image.c

JM 11.0 KTA 2.1 Source Code

      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();

#ifdef MV_COMPETITION // bug fix by AT
#ifdef ADAPTIVE_QUANTIZATION
  if(!input->RDPictureDecision && !input->UseAdaptiveQuantMatrix)
#endif
    // <FTRD Compatibility with AIF
#ifdef ADAPTIVE_FILTER
    if(input->UseAdaptiveFilter==0)
#endif
      // FTRD>
      if((img->type == B_SLICE) && (input->successive_Bframe > 1) && (input->mv_competition > 0))
        Copy_MV_B_frame(enc_picture->mv, enc_picture->ref_idx);
#endif

}



/*!
************************************************************************
* \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        FrameNumberInFile;
  int        i, j;

#ifdef _LEAKYBUCKET_
  //extern long Bit_Buffer[20000];
  extern unsigned long total_frame_buffer;
#endif
#ifdef ADAPTIVE_QUANTIZATION
  int rd_qp=0, AQMS_Skip_flag=0, mincost_flg=0;
  sDefaultInputParam_t defInputParam;
#endif

  time_t ltime1;
  time_t ltime2;

#ifdef WIN32
  struct _timeb tstruct1;
  struct _timeb tstruct2;
#else
  struct timeb tstruct1;
  struct timeb tstruct2;
#endif

  int tmp_time;
  int bits_frm = 0, bits_fld = 0;
  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;

  //Rate control
  int pic_type, bits = 0; 

  me_time=0;
  img->rd_pass = 0;
  enc_frame_picture  = NULL;
  enc_frame_picture2 = NULL;
  enc_frame_picture3 = NULL;
#ifdef ADAPTIVE_FILTER
  enc_frame_picture_aif = NULL;
#endif
#ifdef ADAPTIVE_QUANTIZATION
  enc_frame_picture_aqms = NULL;
#endif
#ifdef WIN32
  _ftime (&tstruct1);           // start time ms
#else
  ftime (&tstruct1);
#endif
  time (&ltime1);               // start time s

#ifdef USE_NEW_OFFSET
  if(input->UseNewOffset)
    img->frameOffsetAvail = 0; 
#endif 

  //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_slice += stats->bit_ctr_parametersets_n;
    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);

  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;

#ifdef ADAPTIVE_QUANTIZATION
  if(input->UseAdaptiveQuantMatrix) // skip consideration
  {
    img->slice_fractional_quant_flag = !(input->UseAdaptiveQuantMatrix==0);
    if(input->ProfileIDC < FREXT_HP)
      img->slice_fractional_quant_flag = (SkipRatio[(img->type)+(img->type==B_SLICE? (img->nal_reference_idc<<2) : 0)] < 90.0);
    AQMS_Skip_flag = (!img->slice_fractional_quant_flag);
  }
#endif
  // Following code should consider optimal coding mode. Currently also does not support
  // multiple slices per frame.
  frame_ctr[img->type]++;
  snr->frame_ctr++;

  if(img->type == SP_SLICE)
  { 
    if(input->sp2_frame_indicator)
    { // switching SP frame encoding
      sp2_frame_indicator=1;
      read_SP_coefficients();
    }
  }
  else
  {
    sp2_frame_indicator=0;
  }

  if (input->PicInterlace == FIELD_CODING)
  {
    //Rate control
    img->FieldControl=1;

    img->field_picture = 1;  // we encode fields
    field_picture (top_pic, bottom_pic);
    img->fld_flag = 1;
  }
  else
  {
    //Rate control
    img->FieldControl=0;

    // For frame coding, turn MB level field/frame coding flag on
    if (input->MbInterlace)
      mb_adaptive = 1;

    img->field_picture = 0; // we encode a frame

    //Rate control
    if(input->RCEnable)
    { 
      /*update the number of MBs in the basic unit for MB adaptive 
      f/f coding*/
      if((input->MbInterlace)&&(input->basicunit<img->Frame_Total_Number_MB)\
        &&(img->type==P_SLICE)&&(img->IFLAG==0))
        img->BasicUnit=input->basicunit*2;
      else
        img->BasicUnit=input->basicunit;

      rc_init_pict(1,0,1); 
      img->qp  = updateQuantizationParameter(0); 


      pic_type = img->type;
      QP =0;
    }

    if( active_sps->frame_mbs_only_flag)
      img->TopFieldFlag=0;

#ifdef ADAPTIVE_QUANTIZATION
    gdwBaseQp = img->qp;
    if (input->UseAdaptiveQuantMatrix )
    {
      SaveInputParam(AQMS_Skip_flag,&defInputParam);
      rd_qp = img->qp;
    }
#endif


    if (input->GenerateMultiplePPS)
      active_pps = PicParSet[0];
#ifdef ADAPTIVE_FILTER
    if(UseAdaptiveFilterForCurrentFrame())
      img->AdaptiveFilterFlag = 0;
    else
      img->AdaptiveFilterFlag = -1;
#endif  
#ifdef DIRECTIONAL_FILTER
    initFilterCustom(input->UseAdaptiveFilter);
#endif
    frame_picture (frame_pic_1, 0);

#ifdef ADAPTIVE_FILTER
    if(img->AdaptiveFilterFlag==0)
    {
      if(input->InterpolationDecision)
      {
        if (input->UseAdaptiveFilter == 2) // separable aif
        {
          UnifiedOneForthPixWithNewFilterHor();
          UnifiedOneForthPixWithNewFilterVer();        
        }
#ifdef DIRECTIONAL_FILTER
        if (input->UseAdaptiveFilter == 3)
        {
          if (input->ImpType == IMP_FLOAT32)
            UnifiedOneForthPixWith_1DAIF_float();
          else if (input->ImpType == IMP_INT16)
            UnifiedOneForthPixWith_1DAIF_int16();        
          else 
            printf("DAIF: wrong implementation type!\n");
        }
#endif  // DIRECTIONAL_FILTER
#ifdef E_DAIF
        else if (input->UseAdaptiveFilter == FILTER_TYPE_EDAIF)
        {
          UnifiedOneForthPixWithNewFilter();
        }
#endif  // E_DAIF
        else 
          UnifiedOneForthPixWithNewFilter();

        if (getDecisionOnAIF_MCP() == 0)
        {
          enc_picture=enc_frame_picture;
          frame_pic = frame_pic_1;
          img->AdaptiveFilterFlag = -1;
          //printf("MCP_De: AVC\n");
        }
        else 
        {
          //printf("MCP_De: AIF\n");
        }
      }
      if(img->AdaptiveFilterFlag==0)
      {
        img->AdaptiveFilterFlag=1;
        frame_picture (frame_pic_aif,3);
        img->AdaptiveFilterFlag=picture_coding_decision(frame_pic_1, frame_pic_aif, img->qp);
        if(img->AdaptiveFilterFlag == 1)
        {
          //printf("RDO_De: AIF\n");
          enc_picture=enc_frame_picture_aif;
          frame_pic = frame_pic_aif;
        }
        else
        {
          //printf("RDO_De: AVC\n");
          enc_picture=enc_frame_picture;
          frame_pic = frame_pic_1;
          img->AdaptiveFilterFlag = -1;
        }
      }      
    }
#endif

#ifdef SWITCHED_FILTERS
    if ((input->RDPictureIntra || img->type != I_SLICE) && input->RDPictureDecision)
    {
      if(input->UseHPFilter == HPF_SIFO)
      {
        if(img->type == P_SLICE)
          rdPictureCodingFilterP();
        else
          rdPictureCodingFilterB();
      }
      else
      {
        rdPictureCoding();
      }
    }
#else
    if ((input->RDPictureIntra || img->type!=I_SLICE) && input->RDPictureDecision)
    {
      rdPictureCoding();
    }
#endif  // SWITCHED_FILTERS

#ifdef ADAPTIVE_QUANTIZATION
    rd_qp = gdwBaseQp = img->qp;
    if(input->UseAdaptiveQuantMatrix)
    {
      rdPictureCodingForIAQMS(AQMS_Skip_flag, &defInputParam, &mincost_flg, rd_qp);
    }
#endif

    // <FTRD Compatibility with AIF
#ifdef MV_COMPETITION // B-slice mv memory override bug fix by AT 2006/11/07
    if( input->RDPictureDecision
#ifdef ADAPTIVE_QUANTIZATION
      || input->UseAdaptiveQuantMatrix 
#endif //ADAPTIV_QUANTIZATION  
#ifdef ADAPTIVE_FILTER
      || (input->UseAdaptiveFilter > 0)
#endif //ADAPTIVE_FILTER 
      )
    {
      if((img->type == B_SLICE) && (input->successive_Bframe > 1))
        Copy_MV_B_frame(enc_picture->mv, enc_picture->ref_idx);
    }
#endif  // MV_COMPETITION
    // FTRD>



    if(img->type==SP_SLICE && si_frame_indicator==0 && input->si_frame_indicator)
    {
      // once the picture has been encoded as a primary SP frame encode as an SI frame
      si_frame_indicator=1;
      frame_picture (frame_pic_2, 0);
    }
    if(img->type==SP_SLICE && input->sp_output_indicator)
    {
      // output the transformed and quantized coefficients (useful for switching SP frames)
      output_SP_coefficients();
    }
    // For field coding, turn MB level field/frame coding flag off
    if (input->MbInterlace)
      mb_adaptive = 0;

    if (input->PicInterlace == ADAPTIVE_CODING)
    {
      //Rate control
      img->FieldControl=1;
      img->write_macroblock = 0;
      img->bot_MB = 0;

      img->field_picture = 1;  // we encode fields
      field_picture (top_pic, bottom_pic);

      //! Note: the distortion for a field coded picture is stored in the top field
      //! the distortion values in the bottom field are dummies
      dis_fld = top_pic->distortion_y + top_pic->distortion_u + top_pic->distortion_v;
      dis_frm = frame_pic_1->distortion_y + frame_pic_1->distortion_u + frame_pic_1->distortion_v;

      if(img->rd_pass==0)
        img->fld_flag = picture_structure_decision (frame_pic_1, top_pic, bottom_pic);
      else if(img->rd_pass==1)
        img->fld_flag = picture_structure_decision (frame_pic_2, top_pic, bottom_pic);
      else
        img->fld_flag = picture_structure_decision (frame_pic_3, top_pic, bottom_pic);

      update_field_frame_contexts (img->fld_flag);

      //Rate control
      if(img->fld_flag==0)
        img->FieldFrame=1;
      /*the current choice is field coding*/
      else
        img->FieldFrame=0;
    }
    else

      img->fld_flag = 0;
  }

  if (img->fld_flag)
    stats->bit_ctr_emulationprevention += stats->em_prev_bits_fld;
  else
    stats->bit_ctr_emulationprevention += stats->em_prev_bits_frm;

  if (img->type != B_SLICE)
  {
    img->pstruct_next_P = img->fld_flag;
  }

#ifdef USE_POST_FILTER
  if(input->UsePostFilter)