URL
https://opencores.org/ocsvn/bluespec-h264/bluespec-h264/trunk
Subversion Repositories bluespec-h264
[/] [bluespec-h264/] [trunk/] [test/] [decoder/] [ldecod/] [src/] [erc_do_p.c] - Rev 100
Compare with Previous | Blame | View Log
/*! ************************************************************************************* * \file * erc_do_p.c * * \brief * Inter (P) frame error concealment algorithms for decoder * * \author * - Viktor Varsa <viktor.varsa@nokia.com> * - Ye-Kui Wang <wyk@ieee.org> * - Jill Boyce <jill.boyce@thomson.net> * - Saurav K Bandyopadhyay <saurav@ieee.org> * - Zhenyu Wu <Zhenyu.Wu@thomson.net * - Purvin Pandit <Purvin.Pandit@thomson.net> * ************************************************************************************* */ #include <stdlib.h> #include <assert.h> #include "mbuffer.h" #include "global.h" #include "memalloc.h" #include "erc_do.h" #include "image.h" extern int erc_mvperMB; struct img_par *erc_img; // picture error concealment // concealment_head points to first node in list, concealment_end points to // last node in list. Initialize both to NULL, meaning no nodes in list yet struct concealment_node *concealment_head = NULL; struct concealment_node *concealment_end = NULL; // static function declarations static int concealByCopy(frame *recfr, int currMBNum, objectBuffer_t *object_list, int picSizeX); static int concealByTrial(frame *recfr, imgpel *predMB, int currMBNum, objectBuffer_t *object_list, int predBlocks[], int picSizeX, int picSizeY, int *yCondition); static int edgeDistortion (int predBlocks[], int currYBlockNum, imgpel *predMB, imgpel *recY, int picSizeX, int regionSize); static void copyBetweenFrames (frame *recfr, int currYBlockNum, int picSizeX, int regionSize); static void buildPredRegionYUV(struct img_par *img, int *mv, int x, int y, imgpel *predMB); // picture error concealment static void buildPredblockRegionYUV(struct img_par *img, int *mv, int x, int y, imgpel *predMB, int list); static void CopyImgData(imgpel **inputY, imgpel ***inputUV, imgpel **outputY, imgpel ***outputUV, int img_width, int img_height); static void copyPredMB (int currYBlockNum, imgpel *predMB, frame *recfr, int picSizeX, int regionSize); extern const unsigned char subblk_offset_y[3][8][4]; extern const unsigned char subblk_offset_x[3][8][4]; static int uv_div[2][4] = {{0, 1, 1, 0}, {0, 1, 0, 0}}; //[x/y][yuv_format] /*! ************************************************************************ * \brief * The main function for Inter (P) frame concealment. * \return * 0, if the concealment was not successful and simple concealment should be used * 1, otherwise (even if none of the blocks were concealed) * \param recfr * Reconstructed frame buffer * \param object_list * Motion info for all MBs in the frame * \param picSizeX * Width of the frame in pixels * \param picSizeY * Height of the frame in pixels * \param errorVar * Variables for error concealment * \param chroma_format_idc * Chroma format IDC ************************************************************************ */ int ercConcealInterFrame(frame *recfr, objectBuffer_t *object_list, int picSizeX, int picSizeY, ercVariables_t *errorVar, int chroma_format_idc ) { int lastColumn = 0, lastRow = 0, predBlocks[8]; int lastCorruptedRow = -1, firstCorruptedRow = -1, currRow = 0, row, column, columnInd, areaHeight = 0, i = 0; imgpel *predMB; /* if concealment is on */ if ( errorVar && errorVar->concealment ) { /* if there are segments to be concealed */ if ( errorVar->nOfCorruptedSegments ) { if (chroma_format_idc != YUV400) predMB = (imgpel *) malloc ( (256 + (img->mb_cr_size_x*img->mb_cr_size_y)*2) * sizeof (imgpel)); else predMB = (imgpel *) malloc(256 * sizeof (imgpel)); if ( predMB == NULL ) no_mem_exit("ercConcealInterFrame: predMB"); lastRow = (int) (picSizeY>>4); lastColumn = (int) (picSizeX>>4); for ( columnInd = 0; columnInd < lastColumn; columnInd ++) { column = ((columnInd%2) ? (lastColumn - columnInd/2 -1) : (columnInd/2)); for ( row = 0; row < lastRow; row++) { if ( errorVar->yCondition[MBxy2YBlock(column, row, 0, picSizeX)] <= ERC_BLOCK_CORRUPTED ) { // ERC_BLOCK_CORRUPTED (1) or ERC_BLOCK_EMPTY (0) firstCorruptedRow = row; /* find the last row which has corrupted blocks (in same continuous area) */ for ( lastCorruptedRow = row+1; lastCorruptedRow < lastRow; lastCorruptedRow++) { /* check blocks in the current column */ if (errorVar->yCondition[MBxy2YBlock(column, lastCorruptedRow, 0, picSizeX)] > ERC_BLOCK_CORRUPTED) { /* current one is already OK, so the last was the previous one */ lastCorruptedRow --; break; } } if ( lastCorruptedRow >= lastRow ) { /* correct only from above */ lastCorruptedRow = lastRow-1; for ( currRow = firstCorruptedRow; currRow < lastRow; currRow++ ) { ercCollect8PredBlocks (predBlocks, (currRow<<1), (column<<1), errorVar->yCondition, (lastRow<<1), (lastColumn<<1), 2, 0); if(erc_mvperMB >= MVPERMB_THR) concealByTrial(recfr, predMB, currRow*lastColumn+column, object_list, predBlocks, picSizeX, picSizeY, errorVar->yCondition); else concealByCopy(recfr, currRow*lastColumn+column, object_list, picSizeX); ercMarkCurrMBConcealed (currRow*lastColumn+column, -1, picSizeX, errorVar); } row = lastRow; } else if ( firstCorruptedRow == 0 ) { /* correct only from below */ for ( currRow = lastCorruptedRow; currRow >= 0; currRow-- ) { ercCollect8PredBlocks (predBlocks, (currRow<<1), (column<<1), errorVar->yCondition, (lastRow<<1), (lastColumn<<1), 2, 0); if(erc_mvperMB >= MVPERMB_THR) concealByTrial(recfr, predMB, currRow*lastColumn+column, object_list, predBlocks, picSizeX, picSizeY, errorVar->yCondition); else concealByCopy(recfr, currRow*lastColumn+column, object_list, picSizeX); ercMarkCurrMBConcealed (currRow*lastColumn+column, -1, picSizeX, errorVar); } row = lastCorruptedRow+1; } else { /* correct bi-directionally */ row = lastCorruptedRow+1; areaHeight = lastCorruptedRow-firstCorruptedRow+1; /* * Conceal the corrupted area switching between the up and the bottom rows */ for ( i = 0; i < areaHeight; i++) { if ( i % 2 ) { currRow = lastCorruptedRow; lastCorruptedRow --; } else { currRow = firstCorruptedRow; firstCorruptedRow ++; } ercCollect8PredBlocks (predBlocks, (currRow<<1), (column<<1), errorVar->yCondition, (lastRow<<1), (lastColumn<<1), 2, 0); if(erc_mvperMB >= MVPERMB_THR) concealByTrial(recfr, predMB, currRow*lastColumn+column, object_list, predBlocks, picSizeX, picSizeY, errorVar->yCondition); else concealByCopy(recfr, currRow*lastColumn+column, object_list, picSizeX); ercMarkCurrMBConcealed (currRow*lastColumn+column, -1, picSizeX, errorVar); } } lastCorruptedRow = -1; firstCorruptedRow = -1; } } } free(predMB); } return 1; } else return 0; } /*! ************************************************************************ * \brief * It conceals a given MB by simply copying the pixel area from the reference image * that is at the same location as the macroblock in the current image. This correcponds * to COPY MBs. * \return * Always zero (0). * \param recfr * Reconstructed frame buffer * \param currMBNum * current MB index * \param object_list * Motion info for all MBs in the frame * \param picSizeX * Width of the frame in pixels ************************************************************************ */ static int concealByCopy(frame *recfr, int currMBNum, objectBuffer_t *object_list, int picSizeX) { objectBuffer_t *currRegion; currRegion = object_list+(currMBNum<<2); currRegion->regionMode = REGMODE_INTER_COPY; currRegion->xMin = (xPosMB(currMBNum,picSizeX)<<4); currRegion->yMin = (yPosMB(currMBNum,picSizeX)<<4); copyBetweenFrames (recfr, MBNum2YBlock(currMBNum,0,picSizeX), picSizeX, 16); return 0; } /*! ************************************************************************ * \brief * Copies the co-located pixel values from the reference to the current frame. * Used by concealByCopy * \param recfr * Reconstructed frame buffer * \param currYBlockNum * index of the block (8x8) in the Y plane * \param picSizeX * Width of the frame in pixels * \param regionSize * can be 16 or 8 to tell the dimension of the region to copy ************************************************************************ */ static void copyBetweenFrames (frame *recfr, int currYBlockNum, int picSizeX, int regionSize) { int j, k, location, xmin, ymin; StorablePicture* refPic = listX[0][0]; /* set the position of the region to be copied */ xmin = (xPosYBlock(currYBlockNum,picSizeX)<<3); ymin = (yPosYBlock(currYBlockNum,picSizeX)<<3); for (j = ymin; j < ymin + regionSize; j++) for (k = xmin; k < xmin + regionSize; k++) { location = j * picSizeX + k; //th recfr->yptr[location] = dec_picture->imgY[j][k]; recfr->yptr[location] = refPic->imgY[j][k]; } for (j = ymin >> uv_div[1][dec_picture->chroma_format_idc]; j < (ymin + regionSize) >> uv_div[1][dec_picture->chroma_format_idc]; j++) for (k = xmin >> uv_div[0][dec_picture->chroma_format_idc]; k < (xmin + regionSize) >> uv_div[0][dec_picture->chroma_format_idc]; k++) { // location = j * picSizeX / 2 + k; location = ((j * picSizeX) >> uv_div[0][dec_picture->chroma_format_idc]) + k; //th recfr->uptr[location] = dec_picture->imgUV[0][j][k]; //th recfr->vptr[location] = dec_picture->imgUV[1][j][k]; recfr->uptr[location] = refPic->imgUV[0][j][k]; recfr->vptr[location] = refPic->imgUV[1][j][k]; } } /*! ************************************************************************ * \brief * It conceals a given MB by using the motion vectors of one reliable neighbor. That MV of a * neighbor is selected wich gives the lowest pixel difference at the edges of the MB * (see function edgeDistortion). This corresponds to a spatial smoothness criteria. * \return * Always zero (0). * \param recfr * Reconstructed frame buffer * \param predMB * memory area for storing temporary pixel values for a macroblock * the Y,U,V planes are concatenated y = predMB, u = predMB+256, v = predMB+320 * \param currMBNum * current MB index * \param object_list * array of region structures storing region mode and mv for each region * \param predBlocks * status array of the neighboring blocks (if they are OK, concealed or lost) * \param picSizeX * Width of the frame in pixels * \param picSizeY * Height of the frame in pixels * \param yCondition * array for conditions of Y blocks from ercVariables_t ************************************************************************ */ static int concealByTrial(frame *recfr, imgpel *predMB, int currMBNum, objectBuffer_t *object_list, int predBlocks[], int picSizeX, int picSizeY, int *yCondition) { int predMBNum = 0, numMBPerLine, compSplit1 = 0, compSplit2 = 0, compLeft = 1, comp = 0, compPred, order = 1, fInterNeighborExists, numIntraNeighbours, fZeroMotionChecked, predSplitted = 0, threshold = ERC_BLOCK_OK, minDist, currDist, i, k, bestDir; int regionSize; objectBuffer_t *currRegion; int mvBest[3] , mvPred[3], *mvptr; numMBPerLine = (int) (picSizeX>>4); comp = 0; regionSize = 16; do { /* 4 blocks loop */ currRegion = object_list+(currMBNum<<2)+comp; /* set the position of the region to be concealed */ currRegion->xMin = (xPosYBlock(MBNum2YBlock(currMBNum,comp,picSizeX),picSizeX)<<3); currRegion->yMin = (yPosYBlock(MBNum2YBlock(currMBNum,comp,picSizeX),picSizeX)<<3); do { /* reliability loop */ minDist = 0; fInterNeighborExists = 0; numIntraNeighbours = 0; fZeroMotionChecked = 0; /* loop the 4 neighbours */ for (i = 4; i < 8; i++) { /* if reliable, try it */ if (predBlocks[i] >= threshold) { switch (i) { case 4: predMBNum = currMBNum-numMBPerLine; compSplit1 = 2; compSplit2 = 3; break; case 5: predMBNum = currMBNum-1; compSplit1 = 1; compSplit2 = 3; break; case 6: predMBNum = currMBNum+numMBPerLine; compSplit1 = 0; compSplit2 = 1; break; case 7: predMBNum = currMBNum+1; compSplit1 = 0; compSplit2 = 2; break; } /* try the concealment with the Motion Info of the current neighbour only try if the neighbour is not Intra */ if (isBlock(object_list,predMBNum,compSplit1,INTRA) || isBlock(object_list,predMBNum,compSplit2,INTRA)) { numIntraNeighbours++; } else { /* if neighbour MB is splitted, try both neighbour blocks */ for (predSplitted = isSplitted(object_list, predMBNum), compPred = compSplit1; predSplitted >= 0; compPred = compSplit2, predSplitted -= ((compSplit1 == compSplit2) ? 2 : 1)) { /* if Zero Motion Block, do the copying. This option is tried only once */ if (isBlock(object_list, predMBNum, compPred, INTER_COPY)) { if (fZeroMotionChecked) { continue; } else { fZeroMotionChecked = 1; mvPred[0] = mvPred[1] = 0; mvPred[2] = 0; buildPredRegionYUV(erc_img, mvPred, currRegion->xMin, currRegion->yMin, predMB); } } /* build motion using the neighbour's Motion Parameters */ else if (isBlock(object_list,predMBNum,compPred,INTRA)) { continue; } else { mvptr = getParam(object_list, predMBNum, compPred, mv); mvPred[0] = mvptr[0]; mvPred[1] = mvptr[1]; mvPred[2] = mvptr[2]; buildPredRegionYUV(erc_img, mvPred, currRegion->xMin, currRegion->yMin, predMB); } /* measure absolute boundary pixel difference */ currDist = edgeDistortion(predBlocks, MBNum2YBlock(currMBNum,comp,picSizeX), predMB, recfr->yptr, picSizeX, regionSize); /* if so far best -> store the pixels as the best concealment */ if (currDist < minDist || !fInterNeighborExists) { minDist = currDist; bestDir = i; for (k=0;k<3;k++) mvBest[k] = mvPred[k]; currRegion->regionMode = (isBlock(object_list, predMBNum, compPred, INTER_COPY)) ? ((regionSize == 16) ? REGMODE_INTER_COPY : REGMODE_INTER_COPY_8x8) : ((regionSize == 16) ? REGMODE_INTER_PRED : REGMODE_INTER_PRED_8x8); copyPredMB(MBNum2YBlock(currMBNum,comp,picSizeX), predMB, recfr, picSizeX, regionSize); } fInterNeighborExists = 1; } } } } threshold--; } while ((threshold >= ERC_BLOCK_CONCEALED) && (fInterNeighborExists == 0)); /* always try zero motion */ if (!fZeroMotionChecked) { mvPred[0] = mvPred[1] = 0; mvPred[2] = 0; buildPredRegionYUV(erc_img, mvPred, currRegion->xMin, currRegion->yMin, predMB); currDist = edgeDistortion(predBlocks, MBNum2YBlock(currMBNum,comp,picSizeX), predMB, recfr->yptr, picSizeX, regionSize); if (currDist < minDist || !fInterNeighborExists) { minDist = currDist; for (k=0;k<3;k++) mvBest[k] = mvPred[k]; currRegion->regionMode = ((regionSize == 16) ? REGMODE_INTER_COPY : REGMODE_INTER_COPY_8x8); copyPredMB(MBNum2YBlock(currMBNum,comp,picSizeX), predMB, recfr, picSizeX, regionSize); } } for (i=0; i<3; i++) currRegion->mv[i] = mvBest[i]; yCondition[MBNum2YBlock(currMBNum,comp,picSizeX)] = ERC_BLOCK_CONCEALED; comp = (comp+order+4)%4; compLeft--; } while (compLeft); return 0; } /*! ************************************************************************ * \brief * Builds the motion prediction pixels from the given location (in 1/4 pixel units) * of the reference frame. It not only copies the pixel values but builds the interpolation * when the pixel positions to be copied from is not full pixel (any 1/4 pixel position). * It copies the resulting pixel vlaues into predMB. * \param img * The pointer of img_par struture of current frame * \param mv * The pointer of the predicted MV of the current (being concealed) MB * \param x * The x-coordinate of the above-left corner pixel of the current MB * \param y * The y-coordinate of the above-left corner pixel of the current MB * \param predMB * memory area for storing temporary pixel values for a macroblock * the Y,U,V planes are concatenated y = predMB, u = predMB+256, v = predMB+320 ************************************************************************ */ static void buildPredRegionYUV(struct img_par *img, int *mv, int x, int y, imgpel *predMB) { int tmp_block[BLOCK_SIZE][BLOCK_SIZE]; int i=0,j=0,ii=0,jj=0,i1=0,j1=0,j4=0,i4=0; int jf=0; int uv; int vec1_x=0,vec1_y=0; int ioff,joff; imgpel *pMB = predMB; int ii0,jj0,ii1,jj1,if1,jf1,if0,jf0; int mv_mul; //FRExt int f1_x, f1_y, f2_x, f2_y, f3, f4, ifx; int b8, b4; int yuv = dec_picture->chroma_format_idc - 1; int ref_frame = imax (mv[2], 0); // !!KS: quick fix, we sometimes seem to get negative ref_pic here, so restrict to zero an above /* Update coordinates of the current concealed macroblock */ img->mb_x = x/MB_BLOCK_SIZE; img->mb_y = y/MB_BLOCK_SIZE; img->block_y = img->mb_y * BLOCK_SIZE; img->pix_c_y = img->mb_y * img->mb_cr_size_y; img->block_x = img->mb_x * BLOCK_SIZE; img->pix_c_x = img->mb_x * img->mb_cr_size_x; mv_mul=4; // luma ******************************************************* for(j=0;j<MB_BLOCK_SIZE/BLOCK_SIZE;j++) { joff=j*4; j4=img->block_y+j; for(i=0;i<MB_BLOCK_SIZE/BLOCK_SIZE;i++) { ioff=i*4; i4=img->block_x+i; vec1_x = i4*4*mv_mul + mv[0]; vec1_y = j4*4*mv_mul + mv[1]; get_block(ref_frame, listX[0], vec1_x,vec1_y,img,tmp_block); for(ii=0;ii<BLOCK_SIZE;ii++) for(jj=0;jj<MB_BLOCK_SIZE/BLOCK_SIZE;jj++) img->mpr[jj+joff][ii+ioff]=tmp_block[jj][ii]; } } for (j = 0; j < 16; j++) { for (i = 0; i < 16; i++) { pMB[j*16+i] = img->mpr[j][i]; } } pMB += 256; if (dec_picture->chroma_format_idc != YUV400) { // chroma ******************************************************* f1_x = 64/img->mb_cr_size_x; f2_x=f1_x-1; f1_y = 64/img->mb_cr_size_y; f2_y=f1_y-1; f3=f1_x*f1_y; f4=f3>>1; for(uv=0;uv<2;uv++) { for (b8=0;b8<(img->num_blk8x8_uv/2);b8++) { for(b4=0;b4<4;b4++) { joff = subblk_offset_y[yuv][b8][b4]; j4=img->pix_c_y+joff; ioff = subblk_offset_x[yuv][b8][b4]; i4=img->pix_c_x+ioff; for(jj=0;jj<4;jj++) { jf=(j4+jj)/(img->mb_cr_size_y/4); // jf = Subblock_y-coordinate for(ii=0;ii<4;ii++) { ifx=(i4+ii)/(img->mb_cr_size_x/4); // ifx = Subblock_x-coordinate i1=(i4+ii)*f1_x + mv[0]; j1=(j4+jj)*f1_y + mv[1]; ii0=iClip3 (0, dec_picture->size_x_cr-1, i1/f1_x); jj0=iClip3 (0, dec_picture->size_y_cr-1, j1/f1_y); ii1=iClip3 (0, dec_picture->size_x_cr-1, ((i1+f2_x)/f1_x)); jj1=iClip3 (0, dec_picture->size_y_cr-1, ((j1+f2_y)/f1_y)); if1=(i1 & f2_x); jf1=(j1 & f2_y); if0=f1_x-if1; jf0=f1_y-jf1; img->mpr[jj+joff][ii+ioff]=(if0*jf0*listX[0][ref_frame]->imgUV[uv][jj0][ii0]+ if1*jf0*listX[0][ref_frame]->imgUV[uv][jj0][ii1]+ if0*jf1*listX[0][ref_frame]->imgUV[uv][jj1][ii0]+ if1*jf1*listX[0][ref_frame]->imgUV[uv][jj1][ii1]+f4)/f3; } } } } for (j = 0; j < 8; j++) { for (i = 0; i < 8; i++) { pMB[j*8+i] = img->mpr[j][i]; } } pMB += 64; } } } /*! ************************************************************************ * \brief * Copies pixel values between a YUV frame and the temporary pixel value storage place. This is * used to save some pixel values temporarily before overwriting it, or to copy back to a given * location in a frame the saved pixel values. * \param currYBlockNum * index of the block (8x8) in the Y plane * \param predMB * memory area where the temporary pixel values are stored * the Y,U,V planes are concatenated y = predMB, u = predMB+256, v = predMB+320 * \param recfr * pointer to a YUV frame * \param picSizeX * picture width in pixels * \param regionSize * can be 16 or 8 to tell the dimension of the region to copy ************************************************************************ */ static void copyPredMB (int currYBlockNum, imgpel *predMB, frame *recfr, int picSizeX, int regionSize) { int j, k, xmin, ymin, xmax, ymax; int locationTmp, locationPred; int uv_x = uv_div[0][dec_picture->chroma_format_idc]; int uv_y = uv_div[1][dec_picture->chroma_format_idc]; xmin = (xPosYBlock(currYBlockNum,picSizeX)<<3); ymin = (yPosYBlock(currYBlockNum,picSizeX)<<3); xmax = xmin + regionSize -1; ymax = ymin + regionSize -1; for (j = ymin; j <= ymax; j++) { for (k = xmin; k <= xmax; k++) { locationPred = j * picSizeX + k; locationTmp = (j-ymin) * 16 + (k-xmin); dec_picture->imgY[j][k] = predMB[locationTmp]; } } if (dec_picture->chroma_format_idc != YUV400) { for (j = (ymin>>uv_y); j <= (ymax>>uv_y); j++) { for (k = (xmin>>uv_x); k <= (xmax>>uv_x); k++) { locationPred = ((j * picSizeX) >> uv_x) + k; locationTmp = (j-(ymin>>uv_y)) * img->mb_cr_size_x + (k-(xmin>>1)) + 256; dec_picture->imgUV[0][j][k] = predMB[locationTmp]; locationTmp += 64; dec_picture->imgUV[1][j][k] = predMB[locationTmp]; } } } } /*! ************************************************************************ * \brief * Calculates a weighted pixel difference between edge Y pixels of the macroblock stored in predMB * and the pixels in the given Y plane of a frame (recY) that would become neighbor pixels if * predMB was placed at currYBlockNum block position into the frame. This "edge distortion" value * is used to determine how well the given macroblock in predMB would fit into the frame when * considering spatial smoothness. If there are correctly received neighbor blocks (status stored * in predBlocks) only they are used in calculating the edge distorion; otherwise also the already * concealed neighbor blocks can also be used. * \return * The calculated weighted pixel difference at the edges of the MB. * \param predBlocks * status array of the neighboring blocks (if they are OK, concealed or lost) * \param currYBlockNum * index of the block (8x8) in the Y plane * \param predMB * memory area where the temporary pixel values are stored * the Y,U,V planes are concatenated y = predMB, u = predMB+256, v = predMB+320 * \param recY * pointer to a Y plane of a YUV frame * \param picSizeX * picture width in pixels * \param regionSize * can be 16 or 8 to tell the dimension of the region to copy ************************************************************************ */ static int edgeDistortion (int predBlocks[], int currYBlockNum, imgpel *predMB, imgpel *recY, int picSizeX, int regionSize) { int i, j, distortion, numOfPredBlocks, threshold = ERC_BLOCK_OK; imgpel *currBlock = NULL, *neighbor = NULL; int currBlockOffset = 0; currBlock = recY + (yPosYBlock(currYBlockNum,picSizeX)<<3)*picSizeX + (xPosYBlock(currYBlockNum,picSizeX)<<3); do { distortion = 0; numOfPredBlocks = 0; // loop the 4 neighbors for (j = 4; j < 8; j++) { /* if reliable, count boundary pixel difference */ if (predBlocks[j] >= threshold) { switch (j) { case 4: neighbor = currBlock - picSizeX; for ( i = 0; i < regionSize; i++ ) { distortion += mabs((int)(predMB[i] - neighbor[i])); } break; case 5: neighbor = currBlock - 1; for ( i = 0; i < regionSize; i++ ) { distortion += mabs((int)(predMB[i*16] - neighbor[i*picSizeX])); } break; case 6: neighbor = currBlock + regionSize*picSizeX; currBlockOffset = (regionSize-1)*16; for ( i = 0; i < regionSize; i++ ) { distortion += mabs((int)(predMB[i+currBlockOffset] - neighbor[i])); } break; case 7: neighbor = currBlock + regionSize; currBlockOffset = regionSize-1; for ( i = 0; i < regionSize; i++ ) { distortion += mabs((int)(predMB[i*16+currBlockOffset] - neighbor[i*picSizeX])); } break; } numOfPredBlocks++; } } threshold--; if (threshold < ERC_BLOCK_CONCEALED) break; } while (numOfPredBlocks == 0); if(numOfPredBlocks == 0) { return 0; // assert (numOfPredBlocks != 0); !!!KS hmm, trying to continue... } return (distortion/numOfPredBlocks); } // picture error concealment below /*! ************************************************************************ * \brief * The motion prediction pixels are calculated from the given location (in * 1/4 pixel units) of the referenced frame. It copies the sub block from the * corresponding reference to the frame to be concealed. * ************************************************************************* */ static void buildPredblockRegionYUV(struct img_par *img, int *mv, int x, int y, imgpel *predMB, int list) { int tmp_block[BLOCK_SIZE][BLOCK_SIZE]; int i=0,j=0,ii=0,jj=0,i1=0,j1=0,j4=0,i4=0; int jf=0; int uv; int vec1_x=0,vec1_y=0; int ioff,joff; imgpel *pMB = predMB; int ii0,jj0,ii1,jj1,if1,jf1,if0,jf0; int mv_mul; //FRExt int f1_x, f1_y, f2_x, f2_y, f3, f4, ifx; int yuv = dec_picture->chroma_format_idc - 1; int ref_frame = mv[2]; /* Update coordinates of the current concealed macroblock */ img->mb_x = x/BLOCK_SIZE; img->mb_y = y/BLOCK_SIZE; img->block_y = img->mb_y * BLOCK_SIZE; img->pix_c_y = img->mb_y * img->mb_cr_size_y/4; img->block_x = img->mb_x * BLOCK_SIZE; img->pix_c_x = img->mb_x * img->mb_cr_size_x/4; mv_mul=4; // luma ******************************************************* vec1_x = x*mv_mul + mv[0]; vec1_y = y*mv_mul + mv[1]; get_block(ref_frame, listX[list], vec1_x,vec1_y,img,tmp_block); for(jj=0;jj<MB_BLOCK_SIZE/BLOCK_SIZE;jj++) for(ii=0;ii<BLOCK_SIZE;ii++) img->mpr[jj][ii]=tmp_block[jj][ii]; for (j = 0; j < 4; j++) { for (i = 0; i < 4; i++) { pMB[j*4+i] = img->mpr[j][i]; } } pMB += 16; if (dec_picture->chroma_format_idc != YUV400) { // chroma ******************************************************* f1_x = 64/(img->mb_cr_size_x); f2_x=f1_x-1; f1_y = 64/(img->mb_cr_size_y); f2_y=f1_y-1; f3=f1_x*f1_y; f4=f3>>1; for(uv=0;uv<2;uv++) { joff = subblk_offset_y[yuv][0][0]; j4=img->pix_c_y+joff; ioff = subblk_offset_x[yuv][0][0]; i4=img->pix_c_x+ioff; for(jj=0;jj<2;jj++) { jf=(j4+jj)/(img->mb_cr_size_y/4); // jf = Subblock_y-coordinate for(ii=0;ii<2;ii++) { ifx=(i4+ii)/(img->mb_cr_size_x/4); // ifx = Subblock_x-coordinate i1=(i4+ii)*f1_x + mv[0]; j1=(j4+jj)*f1_y + mv[1]; ii0=iClip3 (0, dec_picture->size_x_cr-1, i1/f1_x); jj0=iClip3 (0, dec_picture->size_y_cr-1, j1/f1_y); ii1=iClip3 (0, dec_picture->size_x_cr-1, ((i1+f2_x)/f1_x)); jj1=iClip3 (0, dec_picture->size_y_cr-1, ((j1+f2_y)/f1_y)); if1=(i1 & f2_x); jf1=(j1 & f2_y); if0=f1_x-if1; jf0=f1_y-jf1; img->mpr[jj][ii]=(if0*jf0*listX[list][ref_frame]->imgUV[uv][jj0][ii0]+ if1*jf0*listX[list][ref_frame]->imgUV[uv][jj0][ii1]+ if0*jf1*listX[list][ref_frame]->imgUV[uv][jj1][ii0]+ if1*jf1*listX[list][ref_frame]->imgUV[uv][jj1][ii1]+f4)/f3; } } for (j = 0; j < 2; j++) { for (i = 0; i < 2; i++) { pMB[j*2+i] = img->mpr[j][i]; } } pMB += 4; } } } /*! ************************************************************************ * \brief * compares two stored pictures by picture number for qsort in descending order * ************************************************************************ */ static int compare_pic_by_pic_num_desc( const void *arg1, const void *arg2 ) { if ( (*(StorablePicture**)arg1)->pic_num < (*(StorablePicture**)arg2)->pic_num) return 1; if ( (*(StorablePicture**)arg1)->pic_num > (*(StorablePicture**)arg2)->pic_num) return -1; else return 0; } /*! ************************************************************************ * \brief * compares two stored pictures by picture number for qsort in descending order * ************************************************************************ */ static int compare_pic_by_lt_pic_num_asc( const void *arg1, const void *arg2 ) { if ( (*(StorablePicture**)arg1)->long_term_pic_num < (*(StorablePicture**)arg2)->long_term_pic_num) return -1; if ( (*(StorablePicture**)arg1)->long_term_pic_num > (*(StorablePicture**)arg2)->long_term_pic_num) return 1; else return 0; } /*! ************************************************************************ * \brief * compares two stored pictures by poc for qsort in ascending order * ************************************************************************ */ static int compare_pic_by_poc_asc( const void *arg1, const void *arg2 ) { if ( (*(StorablePicture**)arg1)->poc < (*(StorablePicture**)arg2)->poc) return -1; if ( (*(StorablePicture**)arg1)->poc > (*(StorablePicture**)arg2)->poc) return 1; else return 0; } /*! ************************************************************************ * \brief * compares two stored pictures by poc for qsort in descending order * ************************************************************************ */ static int compare_pic_by_poc_desc( const void *arg1, const void *arg2 ) { if ( (*(StorablePicture**)arg1)->poc < (*(StorablePicture**)arg2)->poc) return 1; if ( (*(StorablePicture**)arg1)->poc > (*(StorablePicture**)arg2)->poc) return -1; else return 0; } /*! ************************************************************************ * \brief * Copy image data from one array to another array ************************************************************************ */ static void CopyImgData(imgpel **inputY, imgpel ***inputUV, imgpel **outputY, imgpel ***outputUV, int img_width, int img_height) { int x, y; for (y=0; y<img_height; y++) for (x=0; x<img_width; x++) outputY[y][x] = inputY[y][x]; for (y=0; y<img_height/2; y++) for (x=0; x<img_width/2; x++) { outputUV[0][y][x] = inputUV[0][y][x]; outputUV[1][y][x] = inputUV[1][y][x]; } } /*! ************************************************************************ * \brief * Copies the last reference frame for concealing reference frame loss. ************************************************************************ */ static StorablePicture * get_last_ref_pic_from_dpb() { int used_size = dpb.used_size - 1; int i; for(i = used_size; i >= 0; i--) { if (dpb.fs[i]->is_used==3) { if (((dpb.fs[i]->frame->used_for_reference) && (!dpb.fs[i]->frame->is_long_term)) /*|| ((dpb.fs[i]->frame->used_for_reference==0) && (dpb.fs[i]->frame->slice_type == P_SLICE))*/ ) { return dpb.fs[i]->frame; } } } return NULL; } /*! ************************************************************************ * \brief * Conceals the lost reference or non reference frame by either frame copy * or motion vector copy concealment. * ************************************************************************ */ static void copy_to_conceal(StorablePicture *src, StorablePicture *dst, ImageParameters *img) { int i=0; int mv[3]; int multiplier; imgpel *predMB, *storeYUV; int j, y, x, mb_height, mb_width, ii=0, jj=0; int uv; int mm, nn; int scale = 1; // struct inp_par *test; img->current_mb_nr = 0; dst->PicSizeInMbs = src->PicSizeInMbs; dst->slice_type = src->slice_type = img->conceal_slice_type; dst->idr_flag = 0; //since we do not want to clears the ref list dst->no_output_of_prior_pics_flag = src->no_output_of_prior_pics_flag; dst->long_term_reference_flag = src->long_term_reference_flag; dst->adaptive_ref_pic_buffering_flag = src->adaptive_ref_pic_buffering_flag = 0; dst->chroma_format_idc = src->chroma_format_idc; dst->frame_mbs_only_flag = src->frame_mbs_only_flag; dst->frame_cropping_flag = src->frame_cropping_flag; dst->frame_cropping_rect_left_offset = src->frame_cropping_rect_left_offset; dst->frame_cropping_rect_right_offset = src->frame_cropping_rect_right_offset; dst->frame_cropping_rect_bottom_offset = src->frame_cropping_rect_bottom_offset; dst->frame_cropping_rect_top_offset = src->frame_cropping_rect_top_offset; dst->qp = src->qp; dst->slice_qp_delta = src->slice_qp_delta; dec_picture = src; // Conceals the missing frame by frame copy concealment if (img->conceal_mode==1) { // We need these initializations for using deblocking filter for frame copy // concealment as well. dst->PicWidthInMbs = src->PicWidthInMbs; dst->PicSizeInMbs = src->PicSizeInMbs; CopyImgData(src->imgY, src->imgUV, dst->imgY, dst->imgUV, img->width, img->height); } // Conceals the missing frame by motion vector copy concealment if (img->conceal_mode==2) { if (dec_picture->chroma_format_idc != YUV400) { storeYUV = (imgpel *) malloc ( (16 + (img->mb_cr_size_x*img->mb_cr_size_y)*2/16) * sizeof (imgpel)); } else { storeYUV = (imgpel *) malloc (16 * sizeof (imgpel)); } erc_img = img; dst->PicWidthInMbs = src->PicWidthInMbs; dst->PicSizeInMbs = src->PicSizeInMbs; mb_width = dst->PicWidthInMbs; mb_height = (dst->PicSizeInMbs)/(dst->PicWidthInMbs); scale = (img->conceal_slice_type == B_SLICE) ? 2 : 1; if(img->conceal_slice_type == B_SLICE) init_lists_for_non_reference_loss(dst->slice_type, img->currentSlice->structure); else init_lists(dst->slice_type, img->currentSlice->structure); multiplier = BLOCK_SIZE; for(i=0;i<mb_height*4;i++) { mm = i*BLOCK_SIZE; for(j=0;j<mb_width*4;j++) { nn = j*BLOCK_SIZE; mv[0] = src->mv[LIST_0][i][j][0] / scale; mv[1] = src->mv[LIST_0][i][j][1] / scale; mv[2] = src->ref_idx[LIST_0][i][j]; if(mv[2]<0) mv[2]=0; dst->mv[LIST_0][i][j][0] = mv[0]; dst->mv[LIST_0][i][j][1] = mv[1]; dst->ref_idx[LIST_0][i][j] = mv[2]; x = (j)*multiplier; y = (i)*multiplier; if ((mm%16==0) && (nn%16==0)) img->current_mb_nr++; buildPredblockRegionYUV(erc_img, mv, x, y, storeYUV, LIST_0); predMB = storeYUV; for(ii=0;ii<multiplier;ii++) { for(jj=0;jj<multiplier;jj++) { dst->imgY[i*multiplier+ii][j*multiplier+jj] = predMB[ii*(multiplier)+jj]; } } predMB = predMB + (multiplier*multiplier); if (dec_picture->chroma_format_idc != YUV400) { for(uv=0;uv<2;uv++) { for(ii=0;ii< (multiplier/2);ii++) { for(jj=0;jj< (multiplier/2);jj++) { dst->imgUV[uv][i*multiplier/2 +ii][j*multiplier/2 +jj] = predMB[ii*(multiplier/2)+jj]; } } predMB = predMB + (multiplier*multiplier/4); } } } } free(storeYUV); } } /*! ************************************************************************ * \brief * Uses the previous reference pic for concealment of reference frames * ************************************************************************ */ static void copy_prev_pic_to_concealed_pic(StorablePicture *picture, ImageParameters *img) { StorablePicture *ref_pic; /* get the last ref pic in dpb */ ref_pic = get_last_ref_pic_from_dpb(); assert(ref_pic != NULL); /* copy all the struc from this to current concealment pic */ img->conceal_slice_type = P_SLICE; copy_to_conceal(ref_pic, picture, img); } /*! ************************************************************************ * \brief * This function conceals a missing reference frame. The routine is called * based on the difference in frame number. It conceals an IDR frame loss * based on the sudden decrease in frame number. * ************************************************************************ */ void conceal_lost_frames(ImageParameters *img) { int CurrFrameNum; int UnusedShortTermFrameNum; StorablePicture *picture = NULL; int tmp1 = img->delta_pic_order_cnt[0]; int tmp2 = img->delta_pic_order_cnt[1]; int i; img->delta_pic_order_cnt[0] = img->delta_pic_order_cnt[1] = 0; // printf("A gap in frame number is found, try to fill it.\n"); if(img->IDR_concealment_flag == 1) { // Conceals an IDR frame loss. Uses the reference frame in the previous // GOP for concealment. UnusedShortTermFrameNum = 0; img->last_ref_pic_poc = -img->poc_gap; img->earlier_missing_poc = 0; } else UnusedShortTermFrameNum = (img->pre_frame_num + 1) % img->MaxFrameNum; CurrFrameNum = img->frame_num; while (CurrFrameNum != UnusedShortTermFrameNum) { picture = alloc_storable_picture (FRAME, img->width, img->height, img->width_cr, img->height_cr); picture->coded_frame = 1; picture->pic_num = UnusedShortTermFrameNum; picture->frame_num = UnusedShortTermFrameNum; picture->non_existing = 0; picture->is_output = 0; picture->used_for_reference = 1; picture->concealed_pic = 1; picture->adaptive_ref_pic_buffering_flag = 0; img->frame_num = UnusedShortTermFrameNum; picture->top_poc=img->last_ref_pic_poc + img->ref_poc_gap; picture->bottom_poc=picture->top_poc; picture->frame_poc=picture->top_poc; picture->poc=picture->top_poc; img->last_ref_pic_poc = picture->poc; copy_prev_pic_to_concealed_pic(picture, img); //if (UnusedShortTermFrameNum == 0) if(img->IDR_concealment_flag == 1) { picture->slice_type = I_SLICE; picture->idr_flag = 1; flush_dpb(); picture->top_poc= 0; picture->bottom_poc=picture->top_poc; picture->frame_poc=picture->top_poc; picture->poc=picture->top_poc; img->last_ref_pic_poc = picture->poc; } store_picture_in_dpb(picture); picture=NULL; img->pre_frame_num = UnusedShortTermFrameNum; UnusedShortTermFrameNum = (UnusedShortTermFrameNum + 1) % img->MaxFrameNum; // update reference flags and set current flag. for(i=16;i>0;i--) { ref_flag[i] = ref_flag[i-1]; } ref_flag[0] = 0; } img->delta_pic_order_cnt[0] = tmp1; img->delta_pic_order_cnt[1] = tmp2; img->frame_num = CurrFrameNum; } /*! ************************************************************************ * \brief * Updates the reference list for motion vector copy concealment for non- * reference frame loss. * ************************************************************************ */ void update_ref_list_for_concealment() { unsigned i, j; for (i=0, j=0; i<dpb.used_size; i++) { if (dpb.fs[i]->concealment_reference) { dpb.fs_ref[j++]=dpb.fs[i]; } } dpb.ref_frames_in_buffer = active_pps->num_ref_idx_l0_active_minus1; } /*! ************************************************************************ * \brief * Initialize the list based on the B frame or non reference 'p' frame * to be concealed. The function initialize listX[0] and list 1 depending * on current picture type * ************************************************************************ */ void init_lists_for_non_reference_loss(int currSliceType, PictureStructure currPicStructure) { unsigned i; int j; int MaxFrameNum = 1 << (active_sps->log2_max_frame_num_minus4 + 4); int diff; int list0idx = 0; int list0idx_1 = 0; StorablePicture *tmp_s; if (currPicStructure == FRAME) { for(i=0;i<dpb.ref_frames_in_buffer; i++) { if(dpb.fs[i]->concealment_reference == 1) { if(dpb.fs[i]->frame_num > img->frame_to_conceal) dpb.fs_ref[i]->frame_num_wrap = dpb.fs[i]->frame_num - MaxFrameNum; else dpb.fs_ref[i]->frame_num_wrap = dpb.fs[i]->frame_num; dpb.fs_ref[i]->frame->pic_num = dpb.fs_ref[i]->frame_num_wrap; } } } if (currSliceType == P_SLICE) { // Calculate FrameNumWrap and PicNum if (currPicStructure == FRAME) { for(i=0;i<dpb.used_size; i++) { if(dpb.fs[i]->concealment_reference == 1) { listX[0][list0idx++] = dpb.fs[i]->frame; } } // order list 0 by PicNum qsort((void *)listX[0], list0idx, sizeof(StorablePicture*), compare_pic_by_pic_num_desc); listXsize[0] = list0idx; } } if (currSliceType == B_SLICE) { if (currPicStructure == FRAME) { // for(i=0;i<dpb.ref_frames_in_buffer; i++) for(i=0;i<dpb.used_size; i++) { if(dpb.fs[i]->concealment_reference == 1) { if(img->earlier_missing_poc > dpb.fs[i]->frame->poc) listX[0][list0idx++] = dpb.fs[i]->frame; } } qsort((void *)listX[0], list0idx, sizeof(StorablePicture*), compare_pic_by_poc_desc); list0idx_1 = list0idx; // for(i=0;i<dpb.ref_frames_in_buffer; i++) for(i=0;i<dpb.used_size; i++) { if(dpb.fs[i]->concealment_reference == 1) { if(img->earlier_missing_poc < dpb.fs[i]->frame->poc) listX[0][list0idx++] = dpb.fs[i]->frame; } } qsort((void *)&listX[0][list0idx_1], list0idx-list0idx_1, sizeof(StorablePicture*), compare_pic_by_poc_asc); for (j=0; j<list0idx_1; j++) { listX[1][list0idx-list0idx_1+j]=listX[0][j]; } for (j=list0idx_1; j<list0idx; j++) { listX[1][j-list0idx_1]=listX[0][j]; } listXsize[0] = listXsize[1] = list0idx; qsort((void *)&listX[0][listXsize[0]], list0idx-listXsize[0], sizeof(StorablePicture*), compare_pic_by_lt_pic_num_asc); qsort((void *)&listX[1][listXsize[0]], list0idx-listXsize[0], sizeof(StorablePicture*), compare_pic_by_lt_pic_num_asc); listXsize[0] = listXsize[1] = list0idx; } } if ((listXsize[0] == listXsize[1]) && (listXsize[0] > 1)) { // check if lists are identical, if yes swap first two elements of listX[1] diff=0; for (j = 0; j< listXsize[0]; j++) { if (listX[0][j]!=listX[1][j]) diff=1; } if (!diff) { tmp_s = listX[1][0]; listX[1][0]=listX[1][1]; listX[1][1]=tmp_s; } } // set max size listXsize[0] = imin (listXsize[0], (int)active_sps->num_ref_frames); listXsize[1] = imin (listXsize[1], (int)active_sps->num_ref_frames); listXsize[1] = 0; // set the unused list entries to NULL for (i=listXsize[0]; i< (MAX_LIST_SIZE) ; i++) { listX[0][i] = NULL; } for (i=listXsize[1]; i< (MAX_LIST_SIZE) ; i++) { listX[1][i] = NULL; } } /*! ************************************************************************ * \brief * Get from the dpb the picture corresponding to a POC. The POC varies * depending on whether it is a frame copy or motion vector copy concealment. * The frame corresponding to the POC is returned. * ************************************************************************ */ StorablePicture *get_pic_from_dpb(int missingpoc, unsigned int *pos) { int used_size = dpb.used_size - 1; int i, concealfrom = 0; if(img->conceal_mode == 1) concealfrom = missingpoc - img->poc_gap; else if (img->conceal_mode == 2) concealfrom = missingpoc + img->poc_gap; for(i = used_size; i >= 0; i--) { if(dpb.fs[i]->poc == concealfrom) { *pos = i; return dpb.fs[i]->frame; } } return NULL; } /*! ************************************************************************ * \brief * Function to sort the POC and find the lowest number in the POC list * Compare the integers * ************************************************************************ */ int comp(const void *i, const void *j) { return *(int *)i - *(int *)j; } /*! ************************************************************************ * \brief * Initialises a node, allocates memory for the node, and returns * a pointer to the new node. * ************************************************************************ */ struct concealment_node * init_node( StorablePicture* picture, int missingpoc ) { struct concealment_node *ptr; ptr = (struct concealment_node *) calloc( 1, sizeof(struct concealment_node ) ); if( ptr == NULL ) return (struct concealment_node *) NULL; else { ptr->picture = picture; ptr->missingpocs = missingpoc; ptr->next = NULL; return ptr; } } /*! ************************************************************************ * \brief * Prints the details of a node * ************************************************************************ */ void print_node( struct concealment_node *ptr ) { printf("Missing POC=%d\n", ptr->missingpocs ); } /*! ************************************************************************ * \brief * Prints all nodes from the current address passed to it. * ************************************************************************ */ void print_list( struct concealment_node *ptr ) { while( ptr != NULL ) { print_node( ptr ); ptr = ptr->next; } } /*! ************************************************************************ * \brief * Adds a node to the end of the list. * ************************************************************************ */ void add_node( struct concealment_node *concealment_new ) { if( concealment_head == NULL ) { concealment_end = concealment_head = concealment_new; return; } concealment_end->next = concealment_new; concealment_end = concealment_new; } /*! ************************************************************************ * \brief * Deletes the specified node pointed to by 'ptr' from the list * ************************************************************************ */ void delete_node( struct concealment_node *ptr ) { // We only need to delete the first node in the linked list if( ptr == concealment_head ) { concealment_head = concealment_head->next; if( concealment_end == ptr ) concealment_end = concealment_end->next; free(ptr); } } /*! ************************************************************************ * \brief * Deletes all nodes from the place specified by ptr * ************************************************************************ */ void delete_list( struct concealment_node *ptr ) { struct concealment_node *temp; if( concealment_head == NULL ) return; if( ptr == concealment_head ) { concealment_head = NULL; concealment_end = NULL; } else { temp = concealment_head; while( temp->next != ptr ) temp = temp->next; concealment_end = temp; } while( ptr != NULL ) { temp = ptr->next; free( ptr ); ptr = temp; } } /*! ************************************************************************ * \brief * Stores the missing non reference frames in the concealment buffer. The * detection is based on the POC difference in the sorted POC array. A missing * non reference frame is detected when the dpb is full. A singly linked list * is maintained for storing the missing non reference frames. * ************************************************************************ */ void conceal_non_ref_pics(int diff) { int missingpoc = 0; unsigned int i, pos; StorablePicture *conceal_from_picture = NULL; StorablePicture *conceal_to_picture = NULL; struct concealment_node *concealment_ptr = NULL; int temp_used_size = dpb.used_size; if(dpb.used_size == 0 ) return; qsort(pocs_in_dpb, dpb.size, sizeof(int), comp); for(i=0;i<dpb.size-diff;i++) { dpb.used_size = dpb.size; if((pocs_in_dpb[i+1]-pocs_in_dpb[i])>img->poc_gap) { conceal_to_picture = alloc_storable_picture (FRAME, img->width, img->height, img->width_cr, img->height_cr); missingpoc = pocs_in_dpb[i] + img->poc_gap; // Diagnostics // printf("\n missingpoc = %d\n",missingpoc); if(missingpoc > img->earlier_missing_poc) { img->earlier_missing_poc = missingpoc; conceal_to_picture->top_poc= missingpoc; conceal_to_picture->bottom_poc=missingpoc; conceal_to_picture->frame_poc=missingpoc; conceal_to_picture->poc=missingpoc; conceal_from_picture = get_pic_from_dpb(missingpoc, &pos); assert(conceal_from_picture != NULL); dpb.used_size = pos+1; img->frame_to_conceal = conceal_from_picture->frame_num + 1; update_ref_list_for_concealment(); img->conceal_slice_type = B_SLICE; copy_to_conceal(conceal_from_picture, conceal_to_picture, img); concealment_ptr = init_node( conceal_to_picture, missingpoc ); add_node(concealment_ptr); // Diagnostics // print_node(concealment_ptr); } } } //restore the original value //dpb.used_size = dpb.size; dpb.used_size = temp_used_size; } /*! ************************************************************************ * \brief * Perform Sliding window decoded reference picture marking process. It * maintains the POC s stored in the dpb at a specific instance. * ************************************************************************ */ void sliding_window_poc_management(StorablePicture *p) { unsigned int i; if (dpb.used_size == dpb.size) { for(i=0;i<dpb.size-1; i++) pocs_in_dpb[i] = pocs_in_dpb[i+1]; } // pocs_in_dpb[dpb.used_size-1] = p->poc; } /*! ************************************************************************ * \brief * Outputs the non reference frames. The POCs in the concealment buffer are * sorted in ascending order and outputted when the lowest POC in the * concealment buffer is lower than the lowest in the dpb. The linked list * entry corresponding to the outputted POC is immediately deleted. * ************************************************************************ */ void write_lost_non_ref_pic(int poc, int p_out) { FrameStore concealment_fs; if(poc > 0) { if((poc - dpb.last_output_poc) > img->poc_gap) { concealment_fs.frame = concealment_head->picture; concealment_fs.is_output = 0; concealment_fs.is_reference = 0; concealment_fs.is_used = 3; write_stored_frame(&concealment_fs, p_out); delete_node(concealment_head); } } } /*! ************************************************************************ * \brief * Conceals frame loss immediately after the IDR. This special case produces * the same result for either frame copy or motion vector copy concealment. * ************************************************************************ */ void write_lost_ref_after_idr(int pos) { int temp = 1; if(last_out_fs->frame == NULL) { last_out_fs->frame = alloc_storable_picture (FRAME, img->width, img->height, img->width_cr, img->height_cr); last_out_fs->is_used = 3; } if(img->conceal_mode == 2) { temp = 2; img->conceal_mode = 1; } copy_to_conceal(dpb.fs[pos]->frame, last_out_fs->frame, img); img->conceal_mode = temp; }