h26l.c

MPEG-4编解码的实现(包括MPEG4视音频编解码)

  for(j=0;j<img->buf_cycle+1;j++)
  {
    memory_size += get_mem3D(&(mcef[j]), 2, img->height_cr, img->width_cr);
  }

  InitRefbuf (Refbuf11, Refbuf11_P);


  // allocate memory for B-frame coding (last upsampled P-frame): mref_P, mcref_P
  // is currently also used in oneforthpix_1() and _2() for coding without B-frames
  //byte mref[1152][1408];  */   /* 1/4 pix luma
  //byte mcef[2][352][288]; */   /* pix chroma
  memory_size += get_mem2D(&mref_P, (img->height+2*IMG_PAD_SIZE)*4, (img->width+2*IMG_PAD_SIZE)*4);
  memory_size += get_mem3D(&mcef_P, 2, img->height_cr, img->width_cr);

  if(input->successive_Bframe!=0)
  {
    // allocate memory for temp B-frame motion vector buffer: tmp_fwMV, tmp_bwMV, dfMV, dbMV
    // int ...MV[2][72][92];  ([2][72][88] should be enough)
    memory_size += get_mem3Dint(&tmp_fwMV, 2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
    memory_size += get_mem3Dint(&tmp_bwMV, 2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
    memory_size += get_mem3Dint(&dfMV,     2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
    memory_size += get_mem3Dint(&dbMV,     2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);

    // allocate memory for temp B-frame motion vector buffer: fw_refFrArr, bw_refFrArr
    // int ...refFrArr[72][88];
    memory_size += get_mem2Dint(&fw_refFrArr, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE);
    memory_size += get_mem2Dint(&bw_refFrArr, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE);
  }

  // allocate memory for temp P and B-frame motion vector buffer: tmp_mv, temp_mv_block
  // int tmp_mv[2][72][92];  ([2][72][88] should be enough)
  memory_size += get_mem3Dint(&tmp_mv, 2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);

  // allocate memory for temp quarter pel luma frame buffer: img4Y_tmp
  // int img4Y_tmp[576][704];  (previously int imgY_tmp in global.h)
  memory_size += get_mem2Dint(&img4Y_tmp, img->height+2*IMG_PAD_SIZE, (img->width+2*IMG_PAD_SIZE)*4);

  // allocate memory for tmp loop filter frame buffers: imgY_tmp, imgUV_tmp
  // byte imgY_tmp[288][352];
  memory_size += get_mem2D(&imgY_tmp, img->height, img->width);
  memory_size += get_mem3D(&imgUV_tmp, 2, img->height_cr, img->width_cr);

  // allocate memory for reference frames of each block: refFrArr
  // int  refFrArr[72][88];
  memory_size += get_mem2Dint(&refFrArr, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE);

  if (input->rdopt==2)
  {
    memory_size += get_mem2Dint(&resY, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
    if ((decref = (byte****) calloc(input->NoOfDecoders,sizeof(byte***))) == NULL) 
      no_mem_exit("get_mem4global_buffers: decref");
    for (j=0 ; j<input->NoOfDecoders; j++)
    {
      memory_size += get_mem3D(&decref[j], img->buf_cycle+1, img->height, img->width);
    }
    memory_size += get_mem2D(&RefBlock, BLOCK_SIZE,BLOCK_SIZE);
    memory_size += get_mem3D(&decY, input->NoOfDecoders, img->height, img->width);
    memory_size += get_mem3D(&decY_best, input->NoOfDecoders, img->height, img->width);
    memory_size += get_mem2D(&status_map, img->height/MB_BLOCK_SIZE,img->width/MB_BLOCK_SIZE);
  }

  return (memory_size);
}

/*!
 ************************************************************************
 * \brief
 *    Free allocated memory of frame size related global buffers
 *    buffers are defined in global.h, allocated memory is allocated in
 *    int get_mem4global_buffers()
 * \par Input:
 *    Input Parameters struct inp_par *inp,                             \n
 *    Image Parameters struct img_par *img
 * \par Output:
 *    none
 ************************************************************************
 */
void free_mem4global_buffers()
{
  int  i,j;

#ifdef _ADAPT_LAST_GROUP_
  extern int *last_P_no;
  free (last_P_no);
#endif

  free(imgY[0]);
  free(imgY);
  free(imgUV[0][0]);
  free(imgUV[1][0]);
  free(imgUV[0]);
  free(imgUV[1]);
  free(imgUV);
  free(imgY_org[0]);    // free ref frame buffers
  free(imgY_org);
  free(imgUV_org[0][0]);
  free(imgUV_org[1][0]);
  free(imgUV_org[0]);
  free(imgUV_org[1]);
  free(imgUV_org);
  free(imgY_pf[0]);  // free post filtering frame buffers
  free(imgY_pf);
  free(imgUV_pf[0][0]);
  free(imgUV_pf[1][0]);
  free(imgUV_pf[0]);
  free(imgUV_pf[1]);
  free(imgUV_pf);

  free(nextP_imgY[0]);    // free next frame buffers (for B frames)
  free(nextP_imgY);
  free(nextP_imgUV[0][0]);
  free(nextP_imgUV[1][0]);
  free(nextP_imgUV[0]);
  free(nextP_imgUV[1]);
  free(nextP_imgUV);


  free (Refbuf11_P);
  for (j=0; j<img->buf_cycle; j++)
    free (Refbuf11[j]);
  free (Refbuf11);

  // free multiple ref frame buffers
  // number of reference frames increased by one for next P-frame
  for(j=0;j<=img->buf_cycle;j++)
  {
    free(mref[j][0]);
    free(mref[j]);
    free(mcef[j][0][0]);
    free(mcef[j][1][0]);
    free(mcef[j][0]);
    free(mcef[j][1]);
    free(mcef[j]);
  }

  free(mref);
  free(mcef);
  free(mref_P[0]);
  free(mref_P);
  free(mcef_P[0][0]);
  free(mcef_P[1][0]);
  free(mcef_P[0]);
  free(mcef_P[1]);
  free(mcef_P);

  if(input->successive_Bframe!=0)
  {
    // free last P-frame buffers for B-frame coding
    for(j=0;j<2;j++)
    {
      free(tmp_fwMV[j][0]);
      free(tmp_bwMV[j][0]);
      free(dfMV[j][0]);
      free(dbMV[j][0]);
      free(tmp_fwMV[j]);
      free(tmp_bwMV[j]);
      free(dfMV[j]);
      free(dbMV[j]);
    }
    free(tmp_fwMV);
    free(tmp_bwMV);
    free(dfMV);
    free(dbMV);
    free(fw_refFrArr[0]);
    free(bw_refFrArr[0]);
    free(fw_refFrArr);
    free(bw_refFrArr);
  } // end if B frame


  free(tmp_mv[0][0]);
  free(tmp_mv[0]);
  free(tmp_mv[1][0]);
  free(tmp_mv[1]);
  free(tmp_mv);
  free(img4Y_tmp[0]);    // free temp quarter pel frame buffer
  free(img4Y_tmp);
  free(imgY_tmp[0]);    // free temp loop filter frame buffer
  free(imgY_tmp);
  free(imgUV_tmp[0][0]);
  free(imgUV_tmp[1][0]);
  free(imgUV_tmp[0]);
  free(imgUV_tmp[1]);
  free(imgUV_tmp);
  free(refFrArr[0]);
  free(refFrArr);

  // free mem, allocated in init_img()
  // free intra pred mode buffer for blocks
  free(img->ipredmode[0]);
  free(img->ipredmode);
  free(img->mb_data);
  free(img->slice_numbers);
  if(input->UseConstrainedIntraPred)
  {
    free(img->intra_mb);
  }

  if (input->rdopt==2)
  {
    free(resY[0]);
    free(resY);
    free(RefBlock[0]);
    free(RefBlock);
    for (j=0; j<input->NoOfDecoders; j++)
    {
      free(decY[j][0]);
      free(decY[j]);
      free(decY_best[j][0]);
      free(decY_best[j]);
      for (i=0; i<img->buf_cycle+1; i++)
      {
        free(decref[j][i][0]);
        free(decref[j][i]);
      }
      free(decref[j]);
    }
    free(decY);
    free(decY_best);
    free(decref);
    free(status_map[0]);
    free(status_map);
  }
}

/*!
 ************************************************************************
 * \brief
 *    Allocate 2D memory array -> unsigned char array2D[rows][columns]
 * \par Input:
 *    none
 * \return memory size in bytes
 ************************************************************************
 */
// Change 9-Aug-2001 P. List: dont allocate independant row arrays anymore
// but one complete array and move row-pointers to array. Now you can step
// to the next line with an offset of img->width
int get_mem2D(byte ***array2D, int rows, int columns)
{
  int i;

  if((*array2D      = (byte**)calloc(rows,        sizeof(byte*))) == NULL)
    no_mem_exit("get_mem2D: array2D");
  if(((*array2D)[0] = (byte* )calloc(columns*rows,sizeof(byte ))) == NULL)
    no_mem_exit("get_mem2D: array2D");

  for(i=1;i<rows;i++)
    (*array2D)[i] = (*array2D)[i-1] + columns ;

  return rows*columns;
}


/*!
 ************************************************************************
 * \brief
 *    Allocate memory for mv
 * \par Input:
 *    Image Parameters struct img_par *img                             \n
 *    int****** mv
 * \return memory size in bytes
 ************************************************************************
 */
int get_mem_mv (int****** mv)
{
  int i, j, k, l;

  if ((*mv = (int*****)calloc(4,sizeof(int****))) == NULL)
    no_mem_exit ("get_mem_mv: mv");
  for (i=0; i<4; i++)
  {
    if (((*mv)[i] = (int****)calloc(4,sizeof(int***))) == NULL)
      no_mem_exit ("get_mem_mv: mv");
    for (j=0; j<4; j++)
    {
      if (((*mv)[i][j] = (int***)calloc(img->buf_cycle,sizeof(int**))) == NULL)
        no_mem_exit ("get_mem_mv: mv");
      for (k=0; k<img->buf_cycle; k++)
      {
        if (((*mv)[i][j][k] = (int**)calloc(9,sizeof(int*))) == NULL)
          no_mem_exit ("get_mem_mv: mv");
        for (l=0; l<9; l++)
          if (((*mv)[i][j][k][l] = (int*)calloc(2,sizeof(int))) == NULL)
            no_mem_exit ("get_mem_mv: mv");
      }
    }
  }
  return 4*4*img->buf_cycle*9*2*sizeof(int);
}

/*!
 ************************************************************************
 * \brief
 *    Free memory from mv
 * \par Input:
 *    int****** mv
 ************************************************************************
 */
void free_mem_mv (int***** mv)
{
  int i, j, k, l;

  for (i=0; i<4; i++)
  {
    for (j=0; j<4; j++)
    {
      for (k=0; k<img->buf_cycle; k++)
      {
        for (l=0; l<9; l++)
          free (mv[i][j][k][l]);
        free (mv[i][j][k]);
      }
      free (mv[i][j]);
    }
    free (mv[i]);
  }
  free (mv);
}

/*!
 ************************************************************************
 * \brief
 *    Allocate 2D memory array -> int array2D[rows][columns]
 * \param rows
 *    number of rows
 * \param columns
 *    number of columns
 * \par Output:
 *    int ***array2D allocated memory
 * \return memory size in bytes
 ************************************************************************
 */
// same change as in get_mem2Dint
int get_mem2Dint(int ***array2D, int rows, int columns)
{
  int i;

  if((*array2D      = (int**)calloc(rows,        sizeof(int*))) == NULL)
    no_mem_exit("get_mem2Dint:array2D");
  if(((*array2D)[0] = (int* )calloc(rows*columns,sizeof(int ))) == NULL)
    no_mem_exit("get_mem2Dint:array2D");

  for(i=1 ; i<rows ; i++)
    (*array2D)[i] =  (*array2D)[i-1] + columns  ;

  return rows*columns*sizeof(int);
}


/*!
 ************************************************************************
 * \brief
 *   Allocate 3D memory array -> unsigned char array3D[frames][rows][columns]
 * \param frames
 *    number of frames
 * \param rows
 *    number of rows
 * \param columns
 *    number of columns
 * \par Output:
 *    byte ****array3D allocated memory
 * \return memory size in bytes
 ************************************************************************
 */
// same change as in get_mem2Dint
int get_mem3D(byte ****array3D, int frames, int rows, int columns)
{
  int  j;

  if(((*array3D) = (byte***)calloc(frames,sizeof(byte**))) == NULL)
    no_mem_exit("get_mem3D: array3D");

  for(j=0;j<frames;j++)
    get_mem2D( (*array3D)+j, rows, columns ) ;

  return frames*rows*columns;
}

/*!
 ************************************************************************
 * \brief
 *    Allocate 3D memory array -> int array3D[frames][rows][columns]
 * \param frames
 *    number of frames
 * \param rows
 *    number of rows
 * \param columns
 *    number of columns
 * \par Output:
 *    int ****array3D allocated memory
 * \return memory size in bytes
 ************************************************************************
 */
// same change as in get_mem2Dint
int get_mem3Dint(int ****array3D, int frames, int rows, int columns)
{
  int  j;

  if(((*array3D) = (int***)calloc(frames,sizeof(int**))) == NULL)
    no_mem_exit("get_mem3Dint: array3D");

  for(j=0;j<frames;j++)
    get_mem2Dint( (*array3D)+j, rows, columns ) ;


  return frames*rows*columns*sizeof(int);
}
/*!
 ************************************************************************
 * \brief
 *    Exit program if memory allocation failed (using error())
 * \param where
 *    string indicating which memory allocation failed
 ************************************************************************
 */
void no_mem_exit(char *where)
{
   snprintf(errortext, ET_SIZE, "Could not allocate memory: %s",where);
   error (errortext, 100);
}