| |
| /*! |
| ************************************************************************************* |
| * \file decoder.c |
| * |
| * \brief |
| * Contains functions that implement the "decoders in the encoder" concept for the |
| * rate-distortion optimization with losses. |
| * \date |
| * October 22nd, 2001 |
| * |
| * \author |
| * Main contributors (see contributors.h for copyright, address and |
| * affiliation details) |
| * - Dimitrios Kontopodis <dkonto@eikon.tum.de> |
| ************************************************************************************* |
| */ |
| |
| #include <stdlib.h> |
| #include <memory.h> |
| |
| #include "global.h" |
| #include "refbuf.h" |
| #include "image.h" |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * decodes one 8x8 partition |
| * |
| * \note |
| * Gives the expected value in the decoder of one 8x8 block. This is done based on the |
| * stored reconstructed residue decs->resY[][], the reconstructed values imgY[][] |
| * and the motion vectors. The decoded 8x8 block is moved to decs->decY[][]. |
| ************************************************************************************* |
| */ |
| void decode_one_b8block (int decoder, int mbmode, int b8block, int b8mode, int b8ref) |
| { |
| int i,j,block_y,block_x,bx,by; |
| int ref_inx = (IMG_NUMBER-1)%img->num_ref_frames; |
| |
| int mv[2][BLOCK_MULTIPLE][BLOCK_MULTIPLE]; |
| int resY_tmp[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; |
| |
| int i0 = (b8block%2)<<3, i1 = i0+8, bx0 = i0>>2, bx1 = bx0+2; |
| int j0 = (b8block/2)<<3, j1 = j0+8, by0 = j0>>2, by1 = by0+2; |
| |
| if (img->type==I_SLICE) |
| { |
| for(i=i0;i<i1;i++) |
| for(j=j0;j<j1;j++) |
| { |
| decs->decY[decoder][img->pix_y+j][img->pix_x+i]=enc_picture->imgY[img->pix_y+j][img->pix_x+i]; |
| } |
| } |
| else |
| { |
| if (mbmode==0 && (img->type==P_SLICE || (img->type==B_SLICE && img->nal_reference_idc>0))) |
| { |
| for(i=i0;i<i1;i++) |
| for(j=j0;j<j1;j++) |
| { |
| resY_tmp[j][i]=0; |
| } |
| for (by=by0; by<by1; by++) |
| for (bx=bx0; bx<bx1; bx++) |
| { |
| mv[0][by][bx] = mv[1][by][bx] = 0; |
| } |
| } |
| else |
| { |
| if (b8mode>=1 && b8mode<=7) |
| { |
| for (by=by0; by<by1; by++) |
| for (bx=bx0; bx<bx1; bx++) |
| { |
| mv[0][by][bx] = img->all_mv[by][bx][LIST_0][b8ref][b8mode][0]; |
| mv[1][by][bx] = img->all_mv[by][bx][LIST_0][b8ref][b8mode][1]; |
| } |
| } |
| else |
| { |
| for (by=by0; by<by1; by++) |
| for (bx=bx0; bx<bx1; bx++) |
| { |
| mv[0][by][bx] = mv[1][by][bx] = 0; |
| } |
| } |
| |
| for(i=i0;i<i1;i++) |
| for(j=j0;j<j1;j++) |
| { |
| resY_tmp[j][i]=decs->resY[j][i]; |
| } |
| } |
| |
| // Decode Luminance |
| if ((b8mode>=1 && b8mode<=7) || (mbmode==0 && (img->type==P_SLICE || (img->type==B_SLICE && img->nal_reference_idc>0)))) |
| { |
| for (by=by0; by<by1; by++) |
| for (bx=bx0; bx<bx1; bx++) |
| { |
| block_x = img->block_x+bx; |
| block_y = img->block_y+by; |
| if (img->type == B_SLICE && enc_picture != enc_frame_picture) |
| ref_inx = (IMG_NUMBER-b8ref-2)%img->num_ref_frames; |
| |
| Get_Reference_Block (decs->decref[decoder][ref_inx], |
| block_y, block_x, |
| mv[0][by][bx], |
| mv[1][by][bx], |
| decs->RefBlock); |
| for (j=0; j<4; j++) |
| for (i=0; i<4; i++) |
| { |
| decs->decY[decoder][block_y*4+j][block_x*4+i] = resY_tmp[by*4+j][bx*4+i] + decs->RefBlock[j][i]; |
| } |
| } |
| } |
| else |
| { |
| // Intra Refresh - Assume no spatial prediction |
| for(i=i0;i<i1;i++) |
| for(j=j0;j<j1;j++) |
| { |
| decs->decY[decoder][img->pix_y+j][img->pix_x+i] = enc_picture->imgY[img->pix_y+j][img->pix_x+i]; |
| } |
| } |
| } |
| } |
| |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * decodes one macroblock |
| ************************************************************************************* |
| */ |
| void decode_one_mb (int decoder, Macroblock* currMB) |
| { |
| decode_one_b8block (decoder, currMB->mb_type, 0, currMB->b8mode[0], enc_picture->ref_idx[LIST_0][img->block_y+0][img->block_x+0]);//refFrArr[img->block_y+0][img->block_x+0]); |
| decode_one_b8block (decoder, currMB->mb_type, 1, currMB->b8mode[1], enc_picture->ref_idx[LIST_0][img->block_y+0][img->block_x+2]);//refFrArr[img->block_y+0][img->block_x+2]); |
| decode_one_b8block (decoder, currMB->mb_type, 2, currMB->b8mode[2], enc_picture->ref_idx[LIST_0][img->block_y+2][img->block_x+0]);//refFrArr[img->block_y+2][img->block_x+0]); |
| decode_one_b8block (decoder, currMB->mb_type, 3, currMB->b8mode[3], enc_picture->ref_idx[LIST_0][img->block_y+2][img->block_x+2]);//refFrArr[img->block_y+2][img->block_x+2]); |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Finds the reference MB given the decoded reference frame |
| * \note |
| * This is based on the function UnifiedOneForthPix, only it is modified to |
| * be used at the "many decoders in the encoder" RD optimization. In this case |
| * we dont want to keep full upsampled reference frames for all decoders, so |
| * we just upsample when it is necessary. |
| * \param imY |
| * The frame to be upsampled |
| * \param block_y |
| * The row of the block, whose prediction we want to find |
| * \param block_x |
| * The column of the block, whose prediction we want to track |
| * \param mvhor |
| * Motion vector, horizontal part |
| * \param mvver |
| * Motion vector, vertical part |
| * \param out |
| * Output: The prediction for the block (block_y, block_x) |
| ************************************************************************************* |
| */ |
| void Get_Reference_Block(imgpel **imY, |
| int block_y, |
| int block_x, |
| int mvhor, |
| int mvver, |
| imgpel **out) |
| { |
| int i,j,y,x; |
| |
| y = block_y * BLOCK_SIZE * 4 + mvver; |
| x = block_x * BLOCK_SIZE * 4 + mvhor; |
| |
| for (j=0; j<BLOCK_SIZE; j++) |
| for (i=0; i<BLOCK_SIZE; i++) |
| out[j][i] = Get_Reference_Pixel(imY, y+j*4, x+i*4); |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Finds a pixel (y,x) of the upsampled reference frame |
| * \note |
| * This is based on the function UnifiedOneForthPix, only it is modified to |
| * be used at the "many decoders in the encoder" RD optimization. In this case |
| * we dont want to keep full upsampled reference frames for all decoders, so |
| * we just upsample when it is necessary. |
| ************************************************************************************* |
| */ |
| byte Get_Reference_Pixel(imgpel **imY, int y_pos, int x_pos) |
| { |
| |
| int dx, x; |
| int dy, y; |
| int maxold_x,maxold_y; |
| |
| int result = 0, result1, result2; |
| int pres_x; |
| int pres_y; |
| |
| int tmp_res[6]; |
| |
| static const int COEF[6] = { |
| 1, -5, 20, 20, -5, 1 |
| }; |
| |
| |
| dx = x_pos&3; |
| dy = y_pos&3; |
| x_pos = (x_pos-dx)/4; |
| y_pos = (y_pos-dy)/4; |
| maxold_x = img->width-1; |
| maxold_y = img->height-1; |
| |
| if (dx == 0 && dy == 0) { /* fullpel position */ |
| result = imY[iClip3(0,maxold_y,y_pos)][iClip3(0,maxold_x,x_pos)]; |
| } |
| else { /* other positions */ |
| |
| if (dy == 0) { |
| |
| pres_y = iClip3(0,maxold_y,y_pos); |
| for(x=-2;x<4;x++) { |
| pres_x = iClip3(0,maxold_x,x_pos+x); |
| result += imY[pres_y][pres_x]*COEF[x+2]; |
| } |
| |
| result = iClip3(0, img->max_imgpel_value, (result+16)/32); |
| |
| if (dx == 1) { |
| result = (result + imY[pres_y][iClip3(0,maxold_x,x_pos)])/2; |
| } |
| else if (dx == 3) { |
| result = (result + imY[pres_y][iClip3(0,maxold_x,x_pos+1)])/2; |
| } |
| } |
| else if (dx == 0) { |
| |
| pres_x = iClip3(0,maxold_x,x_pos); |
| for(y=-2;y<4;y++) { |
| pres_y = iClip3(0,maxold_y,y_pos+y); |
| result += imY[pres_y][pres_x]*COEF[y+2]; |
| } |
| |
| result = iClip3(0, img->max_imgpel_value, (result+16)/32); |
| |
| if (dy == 1) { |
| result = (result + imY[iClip3(0,maxold_y,y_pos)][pres_x])/2; |
| } |
| else if (dy == 3) { |
| result = (result + imY[iClip3(0,maxold_y,y_pos+1)][pres_x])/2; |
| } |
| } |
| else if (dx == 2) { |
| |
| for(y=-2;y<4;y++) { |
| result = 0; |
| pres_y = iClip3(0,maxold_y,y_pos+y); |
| for(x=-2;x<4;x++) { |
| pres_x = iClip3(0,maxold_x,x_pos+x); |
| result += imY[pres_y][pres_x]*COEF[x+2]; |
| } |
| tmp_res[y+2] = result; |
| } |
| |
| result = 0; |
| for(y=-2;y<4;y++) { |
| result += tmp_res[y+2]*COEF[y+2]; |
| } |
| |
| result = iClip3(0, img->max_imgpel_value, (result+512)/1024); |
| |
| if (dy == 1) { |
| result = (result + iClip3(0, img->max_imgpel_value, (tmp_res[2]+16)/32))/2; |
| } |
| else if (dy == 3) { |
| result = (result + iClip3(0, img->max_imgpel_value, (tmp_res[3]+16)/32))/2; |
| } |
| } |
| else if (dy == 2) { |
| |
| for(x=-2;x<4;x++) { |
| result = 0; |
| pres_x = iClip3(0,maxold_x,x_pos+x); |
| for(y=-2;y<4;y++) { |
| pres_y = iClip3(0,maxold_y,y_pos+y); |
| result += imY[pres_y][pres_x]*COEF[y+2]; |
| } |
| tmp_res[x+2] = result; |
| } |
| |
| result = 0; |
| for(x=-2;x<4;x++) { |
| result += tmp_res[x+2]*COEF[x+2]; |
| } |
| |
| result = iClip3(0, img->max_imgpel_value, (result+512)/1024); |
| |
| if (dx == 1) { |
| result = (result + iClip3(0, img->max_imgpel_value, (tmp_res[2]+16)/32))/2; |
| } |
| else { |
| result = (result + iClip3(0, img->max_imgpel_value, (tmp_res[3]+16)/32))/2; |
| } |
| } |
| else { |
| |
| result = 0; |
| pres_y = dy == 1 ? y_pos : y_pos+1; |
| pres_y = iClip3(0,maxold_y,pres_y); |
| |
| for(x=-2;x<4;x++) { |
| pres_x = iClip3(0,maxold_x,x_pos+x); |
| result += imY[pres_y][pres_x]*COEF[x+2]; |
| } |
| |
| result1 = iClip3(0, img->max_imgpel_value, (result+16)/32); |
| |
| result = 0; |
| pres_x = dx == 1 ? x_pos : x_pos+1; |
| pres_x = iClip3(0,maxold_x,pres_x); |
| |
| for(y=-2;y<4;y++) { |
| pres_y = iClip3(0,maxold_y,y_pos+y); |
| result += imY[pres_y][pres_x]*COEF[y+2]; |
| } |
| |
| result2 = iClip3(0, img->max_imgpel_value, (result+16)/32); |
| result = (result1+result2)/2; |
| } |
| } |
| |
| return result; |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Performs the simulation of the packet losses, calls the error concealment funcs |
| * and copies the decoded images to the reference frame buffers of the decoders |
| * |
| ************************************************************************************* |
| */ |
| void UpdateDecoders() |
| { |
| int k; |
| for (k=0; k<input->NoOfDecoders; k++) |
| { |
| Build_Status_Map(decs->status_map); // simulates the packet losses |
| Error_Concealment(decs->decY_best[k], decs->status_map, decs->decref[k]); // for the moment error concealment is just a "copy" |
| // Move decoded frames to reference buffers: (at the decoders this is done |
| // without interpolation (upsampling) - upsampling is done while decoding |
| DecOneForthPix(decs->decY_best[k], decs->decref[k]); |
| } |
| } |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Copies one (reconstructed) image to the respective reference frame buffer |
| * |
| * \note |
| * This is used at the "many decoders in the encoder" |
| * \param dY |
| * The reconstructed image |
| * \param dref |
| * The reference buffer |
| ************************************************************************************* |
| */ |
| void DecOneForthPix(imgpel **dY, imgpel ***dref) |
| { |
| int j, ref=IMG_NUMBER%img->buf_cycle; |
| |
| for (j=0; j<img->height; j++) |
| memcpy(dref[ref][j], dY[j], img->width*sizeof(imgpel)); |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Gives the prediction residue for a 8x8 block |
| ************************************************************************************* |
| */ |
| void compute_residue_b8block (int b8block, int i16mode) // if not INTRA16x16 it has to be -1 |
| { |
| int i,j; |
| int i0 = (b8block%2)<<3, i1 = i0+8; |
| int j0 = (b8block/2)<<3, j1 = j0+8; |
| |
| if (i16mode>=0) |
| { |
| for (i=i0; i<i1; i++) |
| for (j=j0; j<j1; j++) |
| { |
| decs->resY[j][i] = enc_picture->imgY[img->pix_y+j][img->pix_x+i] - img->mprr_2[i16mode][j][i]; |
| } |
| } |
| else |
| { |
| for (i=i0; i<i1; i++) |
| for (j=j0; j<j1; j++) |
| { |
| decs->resY[j][i] = enc_picture->imgY[img->pix_y+j][img->pix_x+i] - img->mpr[j][i]; |
| } |
| } |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Gives the prediction residue for a macroblock |
| ************************************************************************************* |
| */ |
| void compute_residue_mb (int i16mode) |
| { |
| compute_residue_b8block (0, i16mode); |
| compute_residue_b8block (1, i16mode); |
| compute_residue_b8block (2, i16mode); |
| compute_residue_b8block (3, i16mode); |
| } |
| |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Builds a random status map showing whether each MB is received or lost, based |
| * on the packet loss rate and the slice structure. |
| * |
| * \param s_map |
| * The status map to be filled |
| ************************************************************************************* |
| */ |
| void Build_Status_Map(byte **s_map) |
| { |
| int i,j,slice=-1,mb=0,jj,ii,packet_lost=0; |
| |
| jj = img->height/MB_BLOCK_SIZE; |
| ii = img->width/MB_BLOCK_SIZE; |
| |
| for (j=0 ; j<jj; j++) |
| for (i=0 ; i<ii; i++) |
| { |
| if (!input->slice_mode || img->mb_data[mb].slice_nr != slice) /* new slice */ |
| { |
| packet_lost=0; |
| if ((double)rand()/(double)RAND_MAX*100 < input->LossRateC) packet_lost += 3; |
| if ((double)rand()/(double)RAND_MAX*100 < input->LossRateB) packet_lost += 2; |
| if ((double)rand()/(double)RAND_MAX*100 < input->LossRateA) packet_lost = 1; |
| slice++; |
| } |
| if (!packet_lost) |
| { |
| s_map[j][i]=0; //! Packet OK |
| } |
| else |
| { |
| s_map[j][i]=packet_lost; |
| if(input->partition_mode == 0) s_map[j][i]=1; |
| } |
| mb++; |
| } |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Performs some sort of error concealment for the areas that are lost according |
| * to the status_map |
| * |
| * \param inY |
| * Error concealment is performed on this frame imY[][] |
| * \param s_map |
| * The status map shows which areas are lost. |
| * \param refY |
| * The set of reference frames - may be used for the error concealment. |
| ************************************************************************************* |
| */ |
| void Error_Concealment(imgpel **inY, byte **s_map, imgpel ***refY) |
| { |
| int mb_y, mb_x, mb_h, mb_w; |
| mb_h = img->height/MB_BLOCK_SIZE; |
| mb_w = img->width/MB_BLOCK_SIZE; |
| |
| for (mb_y=0; mb_y < mb_h; mb_y++) |
| for (mb_x=0; mb_x < mb_w; mb_x++) |
| { |
| if (s_map[mb_y][mb_x]) Conceal_Error(inY, mb_y, mb_x, refY, s_map); |
| } |
| } |
| |
| /*! |
| ************************************************************************************* |
| * \brief |
| * Copies a certain MB (mb_y,mb_x) of the frame inY[][] from the previous frame. |
| * For the time there is no better EC... |
| ************************************************************************************* |
| */ |
| void Conceal_Error(imgpel **inY, int mb_y, int mb_x, imgpel ***refY, byte **s_map) |
| { |
| int i,j,block_x, block_y; |
| int ref_inx = (IMG_NUMBER-1)%img->num_ref_frames; |
| int pos_y = mb_y*MB_BLOCK_SIZE, pos_x = mb_x*MB_BLOCK_SIZE; |
| int mv[2][BLOCK_MULTIPLE][BLOCK_MULTIPLE]; |
| int resY[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; |
| int copy = (decs->dec_mb_mode[mb_y][mb_x]==0 && (img->type==P_SLICE || (img->type==B_SLICE && img->nal_reference_idc>0))); |
| int inter = (((decs->dec_mb_mode[mb_y][mb_x]>=1 && decs->dec_mb_mode[mb_y][mb_x]<=3) || decs->dec_mb_mode[mb_y][mb_x]==P8x8) && (img->type==P_SLICE || (img->type==B_SLICE && img->nal_reference_idc>0))); |
| short ***tmp_mv = enc_picture->mv[LIST_0]; |
| |
| switch(s_map[mb_y][mb_x]) |
| { |
| case 1: //! whole slice lost (at least partition A lost) |
| if (img->type!=I_SLICE) |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = refY[ref_inx][pos_y+j][pos_x+i]; |
| } |
| else |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = 127; |
| } |
| break; |
| case 5: //! partition B and partition C lost |
| |
| //! Copy motion vectors |
| for (block_y=0; block_y<BLOCK_MULTIPLE; block_y++) |
| for (block_x=0; block_x<BLOCK_MULTIPLE; block_x++) |
| for (i=0;i<2;i++) |
| mv[i][block_y][block_x]=tmp_mv[mb_y*BLOCK_SIZE+block_y][mb_x*BLOCK_SIZE+block_x+4][i]; |
| |
| //! Residue ist set to zero |
| for(i=0;i<MB_BLOCK_SIZE;i++) |
| for(j=0;j<MB_BLOCK_SIZE;j++) |
| resY[j][i]=0; |
| |
| //! not first frame |
| if (img->type!=I_SLICE) |
| { |
| //! if copy mb |
| if (copy) |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = refY[ref_inx][pos_y+j][pos_x+i]; |
| } |
| //! if inter mb |
| else if (inter) |
| { |
| for (block_y = mb_y*BLOCK_SIZE ; block_y < (mb_y*BLOCK_SIZE + BLOCK_MULTIPLE) ; block_y++) |
| for (block_x = mb_x*BLOCK_SIZE ; block_x < (mb_x*BLOCK_SIZE + BLOCK_MULTIPLE) ; block_x++) |
| { |
| Get_Reference_Block(refY[ref_inx], |
| block_y, block_x, |
| mv[0][block_y - mb_y*BLOCK_SIZE][block_x - mb_x*BLOCK_SIZE], |
| mv[1][block_y - mb_y*BLOCK_SIZE][block_x - mb_x*BLOCK_SIZE], |
| decs->RefBlock); |
| for (j=0;j<BLOCK_SIZE;j++) |
| for (i=0;i<BLOCK_SIZE;i++) |
| { |
| inY[block_y*BLOCK_SIZE + j][block_x*BLOCK_SIZE + i] = decs->RefBlock[j][i]; |
| } |
| } |
| } |
| else //intra; up to now only copy mb, may integrate nokia EC |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = refY[ref_inx][pos_y+j][pos_x+i]; |
| } |
| } |
| else //! first frame; up to now set value to grey, may integrate nokia EC |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = 127; |
| } |
| break; |
| case 3: //! Partition C lost |
| if(img->type!=I_SLICE) |
| { |
| //! Copy motion vectors |
| for (block_y=0; block_y<BLOCK_MULTIPLE; block_y++) |
| for (block_x=0; block_x<BLOCK_MULTIPLE; block_x++) |
| for (i=0;i<2;i++) |
| mv[i][block_y][block_x]=tmp_mv[mb_y*BLOCK_SIZE+block_y][mb_x*BLOCK_SIZE+block_x+4][i]; |
| |
| //! Residue ist set to zero |
| for(i=0;i<MB_BLOCK_SIZE;i++) |
| for(j=0;j<MB_BLOCK_SIZE;j++) |
| resY[j][i]=0; |
| |
| //! if copy mb |
| if (copy) |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = refY[ref_inx][pos_y+j][pos_x+i]; |
| } |
| //! if inter mb |
| else if (inter) |
| { |
| for (block_y = mb_y*BLOCK_SIZE ; block_y < (mb_y*BLOCK_SIZE + BLOCK_MULTIPLE) ; block_y++) |
| for (block_x = mb_x*BLOCK_SIZE ; block_x < (mb_x*BLOCK_SIZE + BLOCK_MULTIPLE) ; block_x++) |
| { |
| Get_Reference_Block(refY[ref_inx], |
| block_y, block_x, |
| mv[0][block_y - mb_y*BLOCK_SIZE][block_x - mb_x*BLOCK_SIZE], |
| mv[1][block_y - mb_y*BLOCK_SIZE][block_x - mb_x*BLOCK_SIZE], |
| decs->RefBlock); |
| for (j=0;j<BLOCK_SIZE;j++) |
| for (i=0;i<BLOCK_SIZE;i++) |
| { |
| inY[block_y*BLOCK_SIZE + j][block_x*BLOCK_SIZE + i] = decs->RefBlock[j][i]; |
| } |
| } |
| } |
| } |
| break; |
| case 2: //! Partition B lost |
| if(img->type!=I_SLICE) |
| { |
| if(!inter) |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = refY[ref_inx][pos_y+j][pos_x+i]; |
| } |
| } |
| else //! first frame; up to now set value to grey, may integrate nokia EC |
| { |
| for (j=0;j<MB_BLOCK_SIZE;j++) |
| for (i=0;i<MB_BLOCK_SIZE;i++) |
| inY[pos_y+j][pos_x+i] = 127; |
| } |
| break; |
| } //! End Switch |
| } |
