image.c

This program can encode the YUV vdieo format to H.264 and decode it.

/*!
 *************************************************************************************
 * \file image.c
 *
 * \brief
 *    Code one image/slice
 *
 * \author
 *    Main contributors (see contributors.h for copyright, address and affiliation details)
 *     - Inge Lille-Langoy               <[e-mail]>
 *     - Rickard Sjoberg                 <[e-mail]>
 *     - Jani Lainema                    <[e-mail]>
 *     - Sebastian Purreiter             <[e-mail]>
 *     - Byeong-Moon Jeon                <[e-mail]>
 *     - Yoon-Seong Soh                  <[e-mail]>
 *     - Thomas Stockhammer              <[e-mail]>
 *     - Detlev Marpe                    <[e-mail]>
 *     - Guido Heising
 *     - Thomas Wedi                     <[e-mail]>
 *     - Ragip Kurceren                  <[e-mail]>
 *     - Antti Hallapuro                 <[e-mail]>
 *     - Alexis Michael Tourapis         <[e-mail]>
 *     - Athanasios Leontaris            <[e-mail]>
 *************************************************************************************
 */
#include "contributors.h"

#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <sys/timeb.h>
#include <string.h>
#include <memory.h>
#include <assert.h>

#include "global.h"

#include "refbuf.h"
#include "mbuffer.h"
#include "img_luma.h"
#include "img_chroma.h"
#include "intrarefresh.h"
#include "fmo.h"
#include "sei.h"
#include "memalloc.h"
#include "nalu.h"
#include "ratectl.h"
#include "mb_access.h"
#include "output.h"
#include "cabac.h"
#include "context_ini.h"

extern pic_parameter_set_rbsp_t *PicParSet[MAXPPS];

void code_a_picture(Picture *pic);
void frame_picture (Picture *frame, int rd_pass);
void field_picture(Picture *top, Picture *bottom);
void prepare_enc_frame_picture (StorablePicture **stored_pic);

static int  writeout_picture(Picture *pic);

static int  picture_structure_decision(Picture *frame, Picture *top, Picture *bot);
static void distortion_fld (float *dis_fld_y, float *dis_fld_u, float *dis_fld_v);
static void find_snr(void);
static void find_distortion(void);
// For 4:4:4 independent mode
static void find_snr_JV();
static void find_distortion_JV();

static void field_mode_buffer(int bit_field, float snr_field_y, float snr_field_u, float snr_field_v);
static void frame_mode_buffer (int bit_frame, float snr_frame_y, float snr_frame_u, float snr_frame_v);

static void init_frame(void);
static void init_field(void);

static void put_buffer_frame(void);
static void put_buffer_top(void);
static void put_buffer_bot(void);

static void copy_motion_vectors_MB(void);

static void PaddAutoCropBorders (int org_size_x, int org_size_y, int img_size_x, int img_size_y,
                                 int org_size_x_cr, int org_size_y_cr, int img_size_x_cr, int img_size_y_cr);
// For 4:4:4 independent mode
static void PaddAutoCropBorders_JV (int org_size_x, int org_size_y, int img_size_x, int img_size_y,
                                 int org_size_x_cr, int org_size_y_cr, int img_size_x_cr, int img_size_y_cr);

static void ReadOneFrame (int FrameNoInFile, int HeaderSize, int xs, int ys, int xs_cr, int ys_cr);

static void writeUnit(Bitstream* currStream ,int partition);
static void rdPictureCoding(void);

#ifdef _ADAPT_LAST_GROUP_
int *last_P_no;
int *last_P_no_frm;
int *last_P_no_fld;
#endif
int FrameNumberInFile;

static void ReportFirstframe(time_t tmp_time, time_t me_time);
static void ReportIntra(time_t tmp_time, time_t me_time);
static void ReportSP(time_t tmp_time, time_t me_time);
static void ReportP(time_t tmp_time, time_t me_time);
static void ReportB(time_t tmp_time, time_t me_time);
static void ReportNALNonVLCBits(time_t tmp_time, time_t me_time);

StorablePicture *enc_picture;
StorablePicture **enc_frame_picture;
StorablePicture **enc_field_picture;
StorablePicture *enc_frame_picture_JV[MAX_PLANE];  //!< enc_frame_picture to be used during 4:4:4 independent mode encoding

//Rate control
//int    QP;

void MbAffPostProc(void)
{
  imgpel temp[32][16];

  imgpel ** imgY  = enc_picture->imgY;
  imgpel ***imgUV = enc_picture->imgUV;
  int i, y, x0, y0, uv;

  if (img->yuv_format != YUV400)
  {
    for (i=0; i<(int)img->PicSizeInMbs; i+=2)
    {
      if (enc_picture->mb_field[i])
      {
        get_mb_pos(i, &x0, &y0, IS_LUMA);
        for (y=0; y<(2*MB_BLOCK_SIZE);y++)
          memcpy(&temp[y],&imgY[y0+y][x0], MB_BLOCK_SIZE * sizeof(imgpel));

        for (y=0; y<MB_BLOCK_SIZE;y++)
        {
          memcpy(&imgY[y0+(2*y)][x0],temp[y], MB_BLOCK_SIZE * sizeof(imgpel));
          memcpy(&imgY[y0+(2*y + 1)][x0],temp[y+ MB_BLOCK_SIZE], MB_BLOCK_SIZE * sizeof(imgpel));
        }

        x0 = x0 / (16/img->mb_cr_size_x);
        y0 = y0 / (16/img->mb_cr_size_y);

        for (uv=0; uv<2; uv++)
        {
          for (y=0; y<(2*img->mb_cr_size_y);y++)
            memcpy(&temp[y],&imgUV[uv][y0+y][x0], img->mb_cr_size_x * sizeof(imgpel));

          for (y=0; y<img->mb_cr_size_y;y++)
          {
            memcpy(&imgUV[uv][y0+(2*y)][x0],temp[y], img->mb_cr_size_x * sizeof(imgpel));
            memcpy(&imgUV[uv][y0+(2*y + 1)][x0],temp[y+ img->mb_cr_size_y], img->mb_cr_size_x * sizeof(imgpel));
          }
        }
      }
    }
  }
  else
  {
    for (i=0; i<(int)img->PicSizeInMbs; i+=2)
    {
      if (enc_picture->mb_field[i])
      {
        get_mb_pos(i, &x0, &y0, IS_LUMA);
        for (y=0; y<(2*MB_BLOCK_SIZE);y++)
          memcpy(&temp[y],&imgY[y0+y][x0], MB_BLOCK_SIZE * sizeof(imgpel));

        for (y=0; y<MB_BLOCK_SIZE;y++)
        {
          memcpy(&imgY[y0+(2*y)][x0],temp[y], MB_BLOCK_SIZE * sizeof(imgpel));
          memcpy(&imgY[y0+(2*y + 1)][x0],temp[y+ MB_BLOCK_SIZE], MB_BLOCK_SIZE * sizeof(imgpel));
        }
      }
    }
  }
}

/*!
 ************************************************************************
 * \brief
 *    Encodes a picture
 *
 *    This is the main picture coding loop.. It is called by all this
 *    frame and field coding stuff after the img-> elements have been
 *    set up.  Not sure whether it is useful for MB-adaptive frame/field
 *    coding
 ************************************************************************
 */
void code_a_picture(Picture *pic)
{
  unsigned int NumberOfCodedMBs = 0;
  int SliceGroup = 0;
  int j;

  int nplane;
  int pl;

  // currently this code only supports fixed enhancement layer distance
  int idr_refresh   = input->idr_period == 0 ? (img->frm_number == 0) : (( ( img->frm_number - img->lastIDRnumber ) % input->idr_period   ) == 0);

  img->currentPicture = pic;

  img->currentPicture->idr_flag = ((!IMG_NUMBER) && (!(img->structure==BOTTOM_FIELD)))
    || (idr_refresh && (img->type == I_SLICE || img->type==SI_SLICE)&& (!(img->structure==BOTTOM_FIELD)));

  pic->no_slices = 0;
  pic->distortion_u = pic->distortion_v = pic->distortion_y = 0.0;

  RandomIntraNewPicture ();     //! Allocates forced INTRA MBs (even for fields!)

  if( IS_INDEPENDENT( input ) )
  {
    for( pl=0; pl<MAX_PLANE; pl++ ){
      img->current_mb_nr = 0;
      img->current_slice_nr = 0;
      img->SumFrameQP = 0;
      SliceGroup = 0;
      NumberOfCodedMBs = 0;
      img->colour_plane_id = pl;

      // The slice_group_change_cycle can be changed here.
      // FmoInit() is called before coding each picture, frame or field
      img->slice_group_change_cycle=1;
      FmoInit(img, active_pps, active_sps);
      FmoStartPicture ();           //! picture level initialization of FMO

      CalculateQuantParam();
      CalculateOffsetParam();

      if(input->Transform8x8Mode)
      {
        CalculateQuant8Param();
        CalculateOffset8Param();
      }

      reset_pic_bin_count();
      img->bytes_in_picture = 0;

      while (NumberOfCodedMBs < img->PicSizeInMbs)       // loop over slices
      {
        // Encode one SLice Group
        while (!FmoSliceGroupCompletelyCoded (SliceGroup))
        {
          // Encode the current slice
          NumberOfCodedMBs += encode_one_slice (SliceGroup, pic, NumberOfCodedMBs);
          FmoSetLastMacroblockInSlice (img->current_mb_nr);
          // Proceed to next slice
          img->current_slice_nr++;
          stats->bit_slice = 0;
        }
        // Proceed to next SliceGroup
        SliceGroup++;
      }
      FmoEndPicture ();
    }
  } 
  else
  {
    // The slice_group_change_cycle can be changed here.
    // FmoInit() is called before coding each picture, frame or field
    img->slice_group_change_cycle=1;
    FmoInit(img, active_pps, active_sps);
    FmoStartPicture ();           //! picture level initialization of FMO

    CalculateQuantParam();
    CalculateOffsetParam();

    if(input->Transform8x8Mode)
    {
      CalculateQuant8Param();
      CalculateOffset8Param();
    }

    reset_pic_bin_count();
    img->bytes_in_picture = 0;

    while (NumberOfCodedMBs < img->PicSizeInMbs)       // loop over slices
    {
      // Encode one SLice Group
      while (!FmoSliceGroupCompletelyCoded (SliceGroup))
      {
        // Encode the current slice
        NumberOfCodedMBs += encode_one_slice (SliceGroup, pic, NumberOfCodedMBs);
        FmoSetLastMacroblockInSlice (img->current_mb_nr);
        // Proceed to next slice
        img->current_slice_nr++;
        stats->bit_slice = 0;
      }
      // Proceed to next SliceGroup
      SliceGroup++;
    }
    FmoEndPicture ();
  }

  if( IS_INDEPENDENT(input) )
  {
    for( nplane=0; nplane<MAX_PLANE; nplane++ )
    {
      change_plane_JV( nplane );
      // Modified for Fast Mode Decision. Inchoon Choi, SungKyunKwan Univ.
      if (input->rdopt == 3 && (img->nal_reference_idc != 0))
        for (j = 0; j < input->NoOfDecoders; j++)
          DeblockFrame (img, decs->decY_best[j], NULL);

      DeblockFrame (img, enc_picture->imgY, enc_picture->imgUV); //comment out to disable loop filter 
    }
  } 
  else
  {
    // Modified for Fast Mode Decision. Inchoon Choi, SungKyunKwan Univ.
    if (input->rdopt == 3 && (img->nal_reference_idc != 0))
      for (j = 0; j < input->NoOfDecoders; j++)
        DeblockFrame (img, decs->decY_best[j], NULL);

    DeblockFrame (img, enc_picture->imgY, enc_picture->imgUV); //comment out to disable loop filter
  }

  if (img->MbaffFrameFlag)
    MbAffPostProc();
}



/*!
 ************************************************************************
 * \brief
 *    Encodes one frame
 ************************************************************************
 */
int encode_one_frame (void)
{
  static int prev_frame_no = 0; // POC200301
  static int consecutive_non_reference_pictures = 0; // POC200301
  int        i, j;
  int   nplane;

  //Rate control
  int bits = 0;
  int bits_frm = 0, bits_fld = 0;

#ifdef _LEAKYBUCKET_
  //extern long Bit_Buffer[20000];
  extern unsigned long total_frame_buffer;
#endif

  time_t ltime1, ltime2, tmp_time;
  struct TIMEB tstruct1, tstruct2;

  float dis_frm = 0.0, dis_frm_y = 0.0, dis_frm_u = 0.0, dis_frm_v = 0.0;
  float dis_fld = 0.0, dis_fld_y = 0.0, dis_fld_u = 0.0, dis_fld_v = 0.0;


  me_time=0;
  img->rd_pass = 0;

  if( IS_INDEPENDENT(input) )
  {
    for( nplane=0; nplane<MAX_PLANE; nplane++ ){
      enc_frame_picture_JV[nplane] = NULL;
    }
  }

  for (i = 0; i < 6; i++)
    enc_frame_picture[i]  = NULL;
  
  ftime (&tstruct1);            // start time ms
  time (&ltime1);               // start time s

  //Rate control
  img->write_macroblock = 0;
/*
  //Shankar Regunathan (Oct 2002)
  //Prepare Panscanrect SEI payload
  UpdatePanScanRectInfo ();
  //Prepare Arbitrarydata SEI Payload
  UpdateUser_data_unregistered ();
  //Prepare Registered data SEI Payload
  UpdateUser_data_registered_itu_t_t35 ();
  //Prepare RandomAccess SEI Payload
  UpdateRandomAccess ();
*/

  if (input->ResendPPS && IMG_NUMBER !=0)
  {
    stats->bit_ctr_parametersets_n=write_PPS(0, 0);
    stats->bit_ctr_parametersets += stats->bit_ctr_parametersets_n;
  }

  put_buffer_frame ();      // sets the pointers to the frame structures
                            // (and not to one of the field structures)
  init_frame ();
  //FrameNumberInFile = CalculateFrameNumber();

  ReadOneFrame (FrameNumberInFile, input->infile_header,
                input->img_width, input->img_height, input->img_width_cr, input->img_height_cr);

  if( IS_INDEPENDENT(input) )
  {
    PaddAutoCropBorders_JV (input->img_width, input->img_height, img->width, img->height,
                       input->img_width_cr, input->img_height_cr, img->width_cr, img->height_cr);
  }
  else
  {
    PaddAutoCropBorders (input->img_width, input->img_height, img->width, img->height,
                       input->img_width_cr, input->img_height_cr, img->width_cr, img->height_cr);
  }

  // set parameters for direct mode and deblocking filter
  img->direct_spatial_mv_pred_flag = input->direct_spatial_mv_pred_flag;
  img->LFDisableIdc                = input->LFDisableIdc;
  img->LFAlphaC0Offset             = input->LFAlphaC0Offset;
  img->LFBetaOffset                = input->LFBetaOffset;
  img->AdaptiveRounding            = input->AdaptiveRounding;