erc_do_p.c

H.264基于baseline解码器的C++实现源码

    {
      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->mb_pred[uv + 1][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->mb_pred[uv + 1][j][i];
        }
      }
      pMB += 4;

    }
  }
  free_mem2Dpel(tmp_block);
}

/*!
************************************************************************
* \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 img_width_cr, int img_height_cr)
{
  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_cr; y++)
    for (x=0; x<img_width_cr; 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 = FALSE; //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, img->width_cr, img->height_cr);
  }

  // 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->motion.mv[LIST_0][i][j][0] / scale;
        mv[1] = src->motion.mv[LIST_0][i][j][1] / scale;
        mv[2] = src->motion.ref_idx[LIST_0][i][j];

        if(mv[2]<0)
          mv[2]=0;

        dst->motion.mv[LIST_0][i][j][0] = mv[0];
        dst->motion.mv[LIST_0][i][j][1] = mv[1];
        dst->motion.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 = TRUE;
      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)