lencod.c

我们自己做的JM76向ARM平台移植的ADS版本

/*!
 ***********************************************************************
 *  \mainpage
 *     This is the H.264/AVC encoder reference software. For detailed documentation
 *     see the comments in each file.
 *
 *  \author
 *     The main contributors are listed in contributors.h
 *
 *  \version
 *     JM 7.6
 *
 *  \note
 *     tags are used for document system "doxygen"
 *     available at http://www.doxygen.org
 */
/*!
 *  \file
 *     lencod.c
 *  \brief
 *     H.264/AVC reference encoder project main()
 *  \author
 *   Main contributors (see contributors.h for copyright, address and affiliation details)
 *   - Inge Lille-Lang鴜               <[e-mail]>
 *   - Rickard Sjoberg                 <[e-mail]>
 *   - Stephan Wenger                  <[e-mail]>
 *   - Jani Lainema                    <[e-mail]>
 *   - Byeong-Moon Jeon                <[e-mail]>
 *   - Yoon-Seong Soh                  <[e-mail]>
 *   - Thomas Stockhammer              <[e-mail]>
 *   - Detlev Marpe                    <[e-mail]>
 *   - Guido Heising                   <[e-mail]>
 *   - Karsten Suehring                <[e-mail]>
 ***********************************************************************
 */

#include "contributors.h"

#include <string.h>
#include <math.h>
#include <time.h>
#include <sys/timeb.h>
#include <stdlib.h>
#if defined WIN32
  #include <conio.h>
#endif
#include <assert.h>

#include "global.h"
#include "configfile.h"
#include "leaky_bucket.h"
#include "memalloc.h"
#include "mbuffer.h"
#include "intrarefresh.h"
#include "fmo.h"
#include "encodeiff.h"
#include "sei.h"
#include "parset.h"
#include "image.h"
#include "output.h"
#include "fast_me.h"
#include "ratectl.h"

#define JM      "7"
#define VERSION "7.6"

InputParameters inputs, *input = &inputs;
ImageParameters images, *img   = &images;
StatParameters  stats,  *stat  = &stats;
SNRParameters   snrs,   *snr   = &snrs;
Decoders decoders, *decs=&decoders;


#ifdef _ADAPT_LAST_GROUP_
int initial_Bframes = 0;
#endif

Boolean In2ndIGOP = FALSE;
int    start_frame_no_in_this_IGOP = 0;
int    start_tr_in_this_IGOP = 0;
int    FirstFrameIn2ndIGOP=0;
int    cabac_encoding = 0;


/*!
 ***********************************************************************
 * \brief
 *    Main function for encoder.
 * \param argc
 *    number of command line arguments
 * \param argv
 *    command line arguments
 * \return
 *    exit code
 ***********************************************************************
 */
void Init_Motion_Search_Module ();
void Clear_Motion_Search_Module ();

int main(int argc,char **argv)
{
  int M,N,n,np,nb,i;           //Rate control
  printf("These are the %d  command- line  arguments passed  to main:\n\n", argc);
  for(i=0; i<=argc; i++) 
  printf("argv[%d]:%s\n", i, argv[i]);

  
  p_dec = p_stat = p_log = p_trace = NULL;

  Configure (argc, argv);/*Parse the command line parameters and read the config files.*/

  AllocNalPayloadBuffer();/*Initializes NAL module (allocates NAL_Payload_buffer)为一帧图象分配一块BUFFER*/

  init_poc();/*Initializes the POC structure with appropriate parameters.*/
  GenerateParameterSets();/*generates a sequence and picture parameter set and stores these in global
     active_sps and active_pps*/

  init_img();/*Initializes the Image structure with appropriate parameters.*/

  frame_pic = malloc_picture();/*Allocates the picture structure along with its dependent
 *    data structures*/

  if (input->PicInterlace != FRAME_CODING)
  {
    top_pic = malloc_picture();
    bottom_pic = malloc_picture();
  }
  init_rdopt ();/*create structure for RD-optimized mode decision*/

  init_dpb(input);/*Allocate memory for decoded picture buffer an initialize with sane values.*/
  init_out_buffer();/*Initialize output buffer for direct output*/

  enc_picture = enc_frame_picture = enc_top_picture = enc_bottom_picture = NULL;

  init_global_buffers();/*Dynamic memory allocation of frame size related global buffers
     buffers are defined in global.h, allocated memory must be freed in void free_global_buffers()*/
  create_context_memory ();

  Init_Motion_Search_Module ();/*Initialize the motion search*/

  information_init();/*Prints the header of the protocol.*/

  //Rate control 
  if(input->RCEnable)
    rc_init_seq();/*Initiate rate control parameters*/

#ifdef _Fast_ME_
  DefineThreshold();
#endif

  // B pictures
  Bframe_ctr=0;
  tot_time=0;                 // time for total encoding session

#ifdef _ADAPT_LAST_GROUP_
  if (input->last_frame > 0)
    input->no_frames = 1 + (input->last_frame + input->jumpd) / (input->jumpd + 1);
  initial_Bframes = input->successive_Bframe;
#endif

  PatchInputNoFrames();/*Here we let input->no_frames be the total frame numbers.*/

  // Write sequence header (with parameter sets)
  stat->bit_slice = start_sequence();/*This function opens the output files and generates the appropriate sequence header*/
  start_frame_no_in_this_IGOP = 0;

  for (img->number=0; img->number < input->no_frames; img->number++)
  {
    img->nal_reference_idc = 1;

    //much of this can go in init_frame() or init_field()?
    //poc for this frame or field
    img->toppoc = IMG_NUMBER*img->offset_for_ref_frame[0];
    
    if ((input->PicInterlace==FRAME_CODING)&&(input->MbInterlace==FRAME_CODING))
      img->bottompoc = img->toppoc;     //progressive
    else 
      img->bottompoc = img->toppoc+1;   //hard coded

    push_poc(img->toppoc, img->bottompoc, REFFRAME);               //push poc values into array
    img->framepoc = min (img->toppoc, img->bottompoc);
    
    //frame_num for this frame
    if (input->StoredBPictures == 0 || input->successive_Bframe == 0 || img-> number < 2)
      img->frame_num = IMG_NUMBER % (1 << (LOG2_MAX_FRAME_NUM_MINUS4 + 4));
    else 
      img->frame_num ++;
    
    
    
    //the following is sent in the slice header
    img->delta_pic_order_cnt[0]=0;
    
    SetImgType();

#ifdef _ADAPT_LAST_GROUP_
    if (input->successive_Bframe && input->last_frame && IMG_NUMBER+1 == input->no_frames)
    {                                           
      int bi = (int)((float)(input->jumpd+1)/(input->successive_Bframe+1.0)+0.499999);
      
      input->successive_Bframe = (input->last_frame-(img->number-1)*(input->jumpd+1))/bi-1;

      //about to code the last ref frame, adjust deltapoc         
      img->delta_pic_order_cnt[0]= -2*(initial_Bframes - input->successive_Bframe);
      img->toppoc += img->delta_pic_order_cnt[0];
      img->bottompoc += img->delta_pic_order_cnt[0];
      toprefpoc[0] = img->toppoc;                             //fix array values too
      bottomrefpoc[0] = img->bottompoc;
      
    }
#endif

     //Rate control
    if (img->type == I_SLICE)
    {
      if(input->RCEnable)
      {
        if (input->intra_period == 0)
        {
          n = input->no_frames + (input->no_frames - 1) * input->successive_Bframe;
          
          /* number of P frames */
          np = input->no_frames-1; 
          
          /* number of B frames */
          nb = (input->no_frames - 1) * input->successive_Bframe;
        }else
        {
          N = input->intra_period*(input->successive_Bframe+1);
          M = input->successive_Bframe+1;
          n = (img->number==0) ? N - ( M - 1) : N;
          
          /* last GOP may contain less frames */
          if(img->number/input->intra_period >= input->no_frames / input->intra_period)
          {
            if (img->number != 0)
              n = (input->no_frames - img->number) + (input->no_frames - img->number - 1) * input->successive_Bframe + input->successive_Bframe;
            else
              n = input->no_frames  + (input->no_frames - 1) * input->successive_Bframe;
          }
          
          /* number of P frames */
          if (img->number == 0)
            np = (n + 2 * (M - 1)) / M - 1; /* first GOP */
          else
            np = (n + (M - 1)) / M - 1;
          
          /* number of B frames */
          nb = n - np - 1;
        }
        rc_init_GOP(np,nb);
      }
    }


    // which layer the image belonged to?
    if ( IMG_NUMBER % (input->NumFramesInELSubSeq+1) == 0 )
      img->layer = 0;
    else
      img->layer = 1;

    encode_one_frame(); // encode one I- or P-frame


    img->nb_references += 1;
    img->nb_references = min(img->nb_references, img->buf_cycle); // Tian Dong. PLUS1, +1, June 7, 2002

    /*if ((input->successive_Bframe != 0) && (IMG_NUMBER > 0)) // B-frame(s) to encode
    {
      img->type = B_SLICE;            // set image type to B-frame

      if (input->NumFramesInELSubSeq == 0) 
        img->layer = 0;
      else 
        img->layer = 1;

      if (input->StoredBPictures == 0 )
      {
      img->frame_num++;                 //increment frame_num once for B-frames
      img->frame_num %= (1 << (LOG2_MAX_FRAME_NUM_MINUS4 + 4));
      }
      img->nal_reference_idc = 0;     

      for(img->b_frame_to_code=1; img->b_frame_to_code<=input->successive_Bframe; img->b_frame_to_code++)
      {

        img->nal_reference_idc = 0;     
        if (input->StoredBPictures == 1 )

        {
          img->nal_reference_idc = 1;
          img->frame_num++;                 //increment frame_num once for B-frames
          img->frame_num %= (1 << (LOG2_MAX_FRAME_NUM_MINUS4 + 4));
        }

        //! somewhere here the disposable flag was set -- B frames are always disposable in this encoder.
        //! This happens now in slice.c, terminate_slice, where the nal_reference_idc is set up
        //poc for this B frame
        img->toppoc = (IMG_NUMBER-1)*img->offset_for_ref_frame[0] + 2* img->b_frame_to_code;
        if ((input->PicInterlace==FRAME_CODING)&&(input->MbInterlace==FRAME_CODING))
          img->bottompoc = img->toppoc;     //progressive
        else 
          img->bottompoc = img->toppoc+1;
        
        push_poc(img->toppoc,img->bottompoc, NONREFFRAME);      //push pocs for B frame
        img->framepoc = min (img->toppoc, img->bottompoc);

        //the following is sent in the slice header
        img->delta_pic_order_cnt[0]= 2*(img->b_frame_to_code-1);
        img->delta_pic_order_cnt[1]= 0;   // POC200301
        
        encode_one_frame();  // encode one B-frame
      }
    }*/
    
    process_2nd_IGOP();
  }
  // terminate sequence
  terminate_sequence();

  flush_dpb();

  fclose(p_in);
  if (p_dec)
    fclose(p_dec);
  if (p_trace)
    fclose(p_trace);

  //Clear_Motion_Search_Module ();

  RandomIntraUninit();
  FmoUninit();
  
  // free structure for rd-opt. mode decision
  clear_rdopt ();

#ifdef _LEAKYBUCKET_
  calc_buffer();
#endif

  // report everything
  report();

  free_picture (frame_pic);
  if (top_pic)
    free_picture (top_pic);
  if (bottom_pic)
    free_picture (bottom_pic);

  free_dpb();
  uninit_out_buffer();

  free_global_buffers();

  // free image mem
  free_img ();
  free_context_memory ();
  FreeNalPayloadBuffer();
  FreeParameterSets();