ldecod.c

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

/*!
 ***********************************************************************
 *  \mainpage
 *     This is the H.264/AVC decoder reference software. For detailed documentation
 *     see the comments in each file.
 *
 *     The JM software web site is located at:
 *     http://iphome.hhi.de/suehring/tml
 *
 *     For bug reporting and known issues see:
 *     https://ipbt.hhi.de
 *
 *  \author
 *     The main contributors are listed in contributors.h
 *
 *  \version
 *     JM 15.1 (FRExt)
 *
 *  \note
 *     tags are used for document system "doxygen"
 *     available at http://www.doxygen.org
 */
/*!
 *  \file
 *     ldecod.c
 *  \brief
 *     H.264/AVC reference decoder 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]>
 *     - Sebastian Purreiter     <[e-mail]>
 *     - Byeong-Moon Jeon        <[e-mail]>
 *     - Gabi Blaettermann
 *     - Ye-Kui Wang             <[e-mail]>
 *     - Valeri George           <[e-mail]>
 *     - Karsten Suehring        <[e-mail]>
 *
 ***********************************************************************
 */

#include "contributors.h"

#include <sys/stat.h>

#include "global.h"
#include "image.h"
#include "memalloc.h"
#include "mc_prediction.h"
#include "mbuffer.h"
#include "leaky_bucket.h"
#include "fmo.h"
#include "output.h"
#include "cabac.h"
#include "parset.h"
#include "sei.h"
#include "erc_api.h"
#include "quant.h"
#include "block.h"
#include "nalu.h"

#define JM          "15 (FRExt)"
#define VERSION     "15.1"
#define EXT_VERSION "(FRExt)"

#define LOGFILE     "log.dec"
#define DATADECFILE "dataDec.txt"
#define TRACEFILE   "trace_dec.txt"

extern objectBuffer_t *erc_object_list;
extern ercVariables_t *erc_errorVar;
extern ColocatedParams *Co_located;
extern ColocatedParams *Co_located_JV[MAX_PLANE];  //!< Co_located to be used during 4:4:4 independent mode decoding

// I have started to move the inp and img structures into global variables.
// They are declared in the following lines.  Since inp is defined in conio.h
// and cannot be overridden globally, it is defined here as input
//
// Everywhere, params-> and img-> can now be used either globally or with
// the local override through the formal parameter mechanism

extern StorablePicture* dec_picture;

struct inp_par    *params;       //!< input parameters from input configuration file
struct snr_par    *snr;         //!< statistics
ImageParameters   *img;         //!< image parameters

int global_init_done = 0;

/*!
 ***********************************************************************
 * \brief
 *   print help message and exit
 ***********************************************************************
 */
void JMDecHelpExit (void)
{
  fprintf( stderr, "\n   ldecod [-h] {[defdec.cfg] | {[-p pocScale][-i bitstream.264]...[-o output.yuv] [-r reference.yuv] [-uv]}}\n\n"
    "## Parameters\n\n"

    "## Options\n"
    "   -h  :  prints function usage\n"
    "       :  parse <defdec.cfg> for decoder operation.\n"
    "   -i  :  Input file name. \n"
    "   -o  :  Output file name. If not specified default output is set as test_dec.yuv\n\n"
    "   -r  :  Reference file name. If not specified default output is set as test_rec.yuv\n\n"
    "   -p  :  Poc Scale. \n"
    "   -uv :  write chroma components for monochrome streams(4:2:0)\n"
    "   -lp :  By default the deblocking filter for High Intra-Only profile is off \n\t  regardless of the flags in the bitstream. In the presence of\n\t  this option, the loop filter usage will then be determined \n\t  by the flags and parameters in the bitstream.\n\n" 

    "## Supported video file formats\n"
    "   Input : .264 -> H.264 bitstream files. \n"
    "   Output: .yuv -> RAW file. Format depends on bitstream information. \n\n"

    "## Examples of usage:\n"
    "   ldecod\n"
    "   ldecod  -h\n"
    "   ldecod  default.cfg\n"
    "   ldecod  -i bitstream.264 -o output.yuv -r reference.yuv\n");

  exit(-1);
}


void Configure(int ac, char *av[])
{
  int CLcount;
  char *config_filename=NULL;
  CLcount = 1;


  strcpy(params->infile,"test.264");      //! set default bitstream name
  strcpy(params->outfile,"test_dec.yuv"); //! set default output file name
  strcpy(params->reffile,"test_rec.yuv"); //! set default reference file name
  params->FileFormat = PAR_OF_ANNEXB;
  params->ref_offset=0;
  params->poc_scale=2;
  params->silent = FALSE;
  params->intra_profile_deblocking = 0;

#ifdef _LEAKYBUCKET_
  params->R_decoder=500000;          //! Decoder rate
  params->B_decoder=104000;          //! Decoder buffer size
  params->F_decoder=73000;           //! Decoder initial delay
  strcpy(params->LeakyBucketParamFile,"leakybucketparam.cfg");    // file where Leaky Bucket params (computed by encoder) are stored
#endif

  if (ac==2)
  {
    if (0 == strncmp (av[1], "-h", 2))
    {
      JMDecHelpExit();
    }
    else if (0 == strncmp (av[1], "-s", 2))
    {
      params->silent = TRUE;
    }
    else
    {
      config_filename=av[1];
      init_conf(params, av[1]);
    }
    CLcount=2;
  }

  if (ac>=3)
  {
    if (0 == strncmp (av[1], "-i", 2))
    {
      strcpy(params->infile,av[2]);
      CLcount = 3;
    }
    if (0 == strncmp (av[1], "-h", 2))
    {
      JMDecHelpExit();
    }
    if (0 == strncmp (av[1], "-s", 2))
    {
      params->silent = TRUE;
    }
  }

  // Parse the command line

  while (CLcount < ac)
  {
    if (0 == strncmp (av[CLcount], "-h", 2))
    {
      JMDecHelpExit();
    }
    else if (0 == strncmp (av[CLcount], "-s", 2))
    {
      params->silent = TRUE;
      CLcount ++;
    }
    else if (0 == strncmp (av[CLcount], "-i", 2))  //! Input file
    {
      strcpy(params->infile,av[CLcount+1]);
      CLcount += 2;
    }
    else if (0 == strncmp (av[CLcount], "-o", 2))  //! Output File
    {
      strcpy(params->outfile,av[CLcount+1]);
      CLcount += 2;
    }
    else if (0 == strncmp (av[CLcount], "-r", 2))  //! Reference File
    {
      strcpy(params->reffile,av[CLcount+1]);
      CLcount += 2;
    }
    else if (0 == strncmp (av[CLcount], "-p", 2))  //! Poc Scale
    {
      sscanf (av[CLcount+1], "%d", &params->poc_scale);
      CLcount += 2;
    }
    else if (0 == strncmp (av[CLcount], "-uv", 3))  //! indicate UV writing for 4:0:0
    {
      params->write_uv = 1;
      CLcount ++;
    }
    else if (0 == strncmp (av[CLcount], "-lp", 3))  
    {
      params->intra_profile_deblocking = 1;
      CLcount ++;
    }
    else
    {
      snprintf(errortext, ET_SIZE, "Invalid syntax. Use ldecod -h for proper usage");
      error(errortext, 300);
    }
  }

#if TRACE
  if ((p_trace=fopen(TRACEFILE,"w"))==0)             // append new statistic at the end
  {
    snprintf(errortext, ET_SIZE, "Error open file %s!",TRACEFILE);
    error(errortext,500);
  }
#endif

  if ((p_out=open(params->outfile, OPENFLAGS_WRITE, OPEN_PERMISSIONS))==-1)
  {
    snprintf(errortext, ET_SIZE, "Error open file %s ",params->outfile);
    error(errortext,500);
  }

  fprintf(stdout,"----------------------------- JM %s %s -----------------------------\n", VERSION, EXT_VERSION);
  fprintf(stdout," Decoder config file                    : %s \n",config_filename);
  fprintf(stdout,"--------------------------------------------------------------------------\n");
  fprintf(stdout," Input H.264 bitstream                  : %s \n",params->infile);
  fprintf(stdout," Output decoded YUV                     : %s \n",params->outfile);
  fprintf(stdout," Output status file                     : %s \n",LOGFILE);
  if ((p_ref=open(params->reffile,OPENFLAGS_READ))==-1)
  {
    fprintf(stdout," Input reference file                   : %s does not exist \n",params->reffile);
    fprintf(stdout,"                                          SNR values are not available\n");
  }
  else
    fprintf(stdout," Input reference file                   : %s \n",params->reffile);

  fprintf(stdout,"--------------------------------------------------------------------------\n");
#ifdef _LEAKYBUCKET_
  fprintf(stdout," Rate_decoder        : %8ld \n",params->R_decoder);
  fprintf(stdout," B_decoder           : %8ld \n",params->B_decoder);
  fprintf(stdout," F_decoder           : %8ld \n",params->F_decoder);
  fprintf(stdout," LeakyBucketParamFile: %s \n",params->LeakyBucketParamFile); // Leaky Bucket Param file
  calc_buffer(params);
  fprintf(stdout,"--------------------------------------------------------------------------\n");
#endif
  if (!params->silent)
  {
    fprintf(stdout,"POC must = frame# or field# for SNRs to be correct\n");
    fprintf(stdout,"--------------------------------------------------------------------------\n");
    fprintf(stdout,"  Frame          POC  Pic#   QP    SnrY     SnrU     SnrV   Y:U:V Time(ms)\n");
    fprintf(stdout,"--------------------------------------------------------------------------\n");
  }

}

/*!
 ***********************************************************************
 * \brief
 *    Allocate the Image structure
 * \par  Output:
 *    Image Parameters ImageParameters *img
 ***********************************************************************
 */
static void alloc_img( ImageParameters **img)
{
  if ((*img   =  (ImageParameters *) calloc(1, sizeof(ImageParameters)))==NULL) 
    no_mem_exit("alloc_img: img");

  get_mem3Dpel(&((*img)->mb_pred), MAX_PLANE, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  get_mem3Dpel(&((*img)->mb_rec ), MAX_PLANE, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  get_mem3Dint(&((*img)->mb_rres), MAX_PLANE, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  get_mem3Dint(&((*img)->cof    ), MAX_PLANE, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  //get_mem3Dint(&((*img)->fcf    ), MAX_PLANE, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  
  allocate_block_mem();
  allocate_pred_mem();
}

/*!
 ***********************************************************************
 * \brief
 *    Free the Image structure
 * \par  Input:
 *    Image Parameters ImageParameters *img
 ***********************************************************************
 */
static void free_img( ImageParameters *img)
{
  free_pred_mem();
  free_block_mem();
  //free_mem3Dint(img->fcf    ); 
  free_mem3Dint(img->cof    );
  free_mem3Dint(img->mb_rres);
  free_mem3Dpel(img->mb_rec );
  free_mem3Dpel(img->mb_pred);
  free (img);
}
/*!
 ***********************************************************************
 * \brief
 *    main function for TML decoder
 ***********************************************************************
 */
int main(int argc, char **argv)
{
  int i;
  int nplane;

  // allocate memory for the structures
  if ((params =  (struct inp_par *)calloc(1, sizeof(struct inp_par)))==NULL) no_mem_exit("main: params");
  if ((snr    =  (struct snr_par *)calloc(1, sizeof(struct snr_par)))==NULL) no_mem_exit("main: snr");  

  // Allocate and init image structure memory
  alloc_img(&img);

  Configure (argc, argv);

  initBitsFile(params->FileFormat);

  bitsfile.OpenBitsFile(params->infile);
  
  // Allocate Slice data struct
  malloc_slice(params, img);
  init_old_slice(&old_slice);

  init(img);

  dec_picture = NULL;

  dpb.init_done = 0;