开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
h26l.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：56k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

h26l.c：源码内容
  1. /*
  2. ***********************************************************************
  3. * COPYRIGHT AND WARRANTY INFORMATION
  4. *
  5. * Copyright 2001, International Telecommunications Union, Geneva
  6. *
  7. * DISCLAIMER OF WARRANTY
  8. *
  9. * These software programs are available to the user without any
  10. * license fee or royalty on an "as is" basis. The ITU disclaims
  11. * any and all warranties, whether express, implied, or
  12. * statutory, including any implied warranties of merchantability
  13. * or of fitness for a particular purpose.  In no event shall the
  14. * contributor or the ITU be liable for any incidental, punitive, or
  15. * consequential damages of any kind whatsoever arising from the
  16. * use of these programs.
  17. *
  18. * This disclaimer of warranty extends to the user of these programs
  19. * and user's customers, employees, agents, transferees, successors,
  20. * and assigns.
  21. *
  22. * The ITU does not represent or warrant that the programs furnished
  23. * hereunder are free of infringement of any third-party patents.
  24. * Commercial implementations of ITU-T Recommendations, including
  25. * shareware, may be subject to royalty fees to patent holders.
  26. * Information regarding the ITU-T patent policy is available from
  27. * the ITU Web site at http://www.itu.int.
  28. *
  29. * THIS IS NOT A GRANT OF PATENT RIGHTS - SEE THE ITU-T PATENT POLICY.
  30. ************************************************************************
  31. */
  33. /*
  34.  * Feb 28, 2002
  35.  * dmackie@cisco.com
  36.  * Restructured version of lencod.c that provides a library API to encoder
  37.  */
  39. /*!
  40.  ***********************************************************************
  41.  *  mainpage
  42.  *     This is the H.26L encoder reference software. For detailed documentation
  43.  *     see the comments in each file.
  44.  *
  45.  *  author
  46.  *     The main contributors are listed in contributors.h
  47.  *
  48.  *  version
  49.  *     TML 9.4
  50.  *
  51.  *  note
  52.  *     tags are used for document system "doxygen"
  53.  *     available at http://www.doxygen.org
  54.  */
  55. /*!
  56.  *  file
  57.  *     lencod.c
  58.  *  brief
  59.  *     TML encoder project main
  60.  *  author
  61.  *   Main contributors (see contributors.h for copyright, address and affiliation details)
  62.  *   - Inge Lille-Lang鴜               <inge.lille-langoy@telenor.com>
  63.  *   - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  64.  *   - Stephan Wenger                  <stewe@cs.tu-berlin.de>
  65.  *   - Jani Lainema                    <jani.lainema@nokia.com>
  66.  *   - Byeong-Moon Jeon                <jeonbm@lge.com>
  67.  *   - Yoon-Seong Soh                  <yunsung@lge.com>
  68.  *   - Thomas Stockhammer              <stockhammer@ei.tum.de>
  69.  *   - Detlev Marpe                    <marpe@hhi.de>
  70.  *   - Guido Heising                   <heising@hhi.de>
  71.  *
  72.  ***********************************************************************
  73.  */
  75. #include "contributors.h"
  77. #include <string.h>
  78. #include <math.h>
  79. #include <time.h>
  80. #include <sys/timeb.h>
  81. #include <stdlib.h>
  82. #if defined WIN32
  83.   #include <conio.h>
  84. #endif
  85. #include "global.h"
  86. #include "configfile.h"
  87. #include "leaky_bucket.h"
  89. #define TML     "9"
  90. #define VERSION "9.40"
  92. InputParameters inputs, *input = &inputs;
  93. ImageParameters images, *img   = &images;
  94. StatParameters  stats,  *stat  = &stats;
  95. SNRParameters   snrs,   *snr   = &snrs;
  97. #ifdef H26L_LIB
  98. byte* memout;
  99. int memoutlength;
  100. #endif
  102. #ifdef _ADAPT_LAST_GROUP_
  103. int initial_Bframes = 0;
  104. #endif
  106. int H26L_InUse = 0;
  108. /*!
  109.  ***********************************************************************
  110.  * brief
  111.  *    Main function for encoder.
  112.  * param argc
  113.  *    number of command line arguments
  114.  * param argv
  115.  *    command line arguments
  116.  * return
  117.  *    exit code
  118.  ***********************************************************************
  119.  */
  120. int H26L_Init(char *config)
  121. {
  122.   char* argv[1];
  124.   /* dmackie@cisco.com
  125.    * Since code uses globals everywhere
  126.    * we need to ensure only 1 calling instance
  127.    */
  128.   if (H26L_InUse) {
  129.     return -1;
  130.   }
  131.   H26L_InUse = 1;
  133.   p_dec = p_dec_u = p_dec_v = p_stat = p_log = p_datpart = p_trace = NULL;
  135.   argv[0] = config;
  136.   Configure (1, argv);
  138.   // Initialize Image Parameters
  139.   init_img();
  141.   // Allocate Slice data struct
  142.   malloc_slice();
  144.   // create and init structure for rd-opt. mode decision
  145.   init_rdopt ();
  147. #ifdef _FAST_FULL_ME_
  148.   // create arrays for fast full motion estimation
  149.   InitializeFastFullIntegerSearch (input->search_range);
  150. #endif
  152.   // Initialize Statistic Parameters
  153.   init_stat();
  155.   // allocate memory for frame buffers
  156.   get_mem4global_buffers();
  158.   // Just some information which goes to the standard output
  159.   information_init();
  161.   // Write sequence header; open bitstream files
  162.   stat->bit_slice = start_sequence();
  163.   // B pictures
  164.   Bframe_ctr=0;
  165.   img->refPicID=-1;  //WYK: Oct. 16, 2001
  166.   tot_time=0;                 // time for total encoding session
  168. #ifdef _ADAPT_LAST_GROUP_
  169.   if (input->last_frame > 0)
  170.     input->no_frames = 1 + (input->last_frame + input->jumpd) / (input->jumpd + 1);
  171.   initial_Bframes = input->successive_Bframe;
  172. #endif
  174.   return 0;
  175. }
  177. int H26L_Encode(byte* pY, byte* pU, byte* pV, 
  178. byte* pEncoded, int* pEncodedLength)
  179. {
  180. int image_type;
  182. if (H26L_InUse == 0) {
  183. return -1;
  184. }
  186. memout = pEncoded;
  187. memoutlength = 0;
  188.   
  189.     if (input->intra_period == 0)
  190.     {
  191.       if (img->number == 0)
  192.       {
  193.         img->type = INTRA_IMG;        // set image type for first image to I-frame
  194.       }
  195.       else
  196.       {
  197.         img->type = INTER_IMG;        // P-frame
  198.         if (input->sp_periodicity)
  199.         {
  200.           if ((img->number % input->sp_periodicity) ==0)
  201.           {
  202.             img->types=SP_IMG;
  203.           }
  204.           else img->types=INTER_IMG;
  205.         }
  206.       }
  207.     }
  208.     else
  209.     {
  210.       if ((img->number%input->intra_period) == 0)
  211.       {
  212.         img->type = INTRA_IMG;
  213.       }
  214.       else
  215.       {
  216.         img->type = INTER_IMG;        // P-frame
  217.         if (input->sp_periodicity)
  218.         {
  219.           if ((img->number % input->sp_periodicity) ==0)
  220.               img->types=SP_IMG;
  221.           else img->types=INTER_IMG;
  222.         }
  223.       }
  224.     }
  226. #ifdef _ADAPT_LAST_GROUP_
  227.     if (input->successive_Bframe && input->last_frame && img->number+1 == input->no_frames)
  228.       {
  229.         int bi = (int)((float)(input->jumpd+1)/(input->successive_Bframe+1.0)+0.499999);
  230.         input->successive_Bframe = (input->last_frame-(img->number-1)*(input->jumpd+1))/bi-1;
  231.       }
  232. #endif
  234.     image_type = img->type;
  235.     
  236. /* start of read_one_frame emulation */
  238. if(img->type == B_IMG)
  239. frame_no = (img->number-1)*(input->jumpd+1)+img->b_interval*img->b_frame_to_code;
  240. else {
  241. frame_no = img->number*(input->jumpd+1);
  242. #ifdef _ADAPT_LAST_GROUP_
  243. if (input->last_frame && img->number+1 == input->no_frames)
  244. frame_no=input->last_frame;
  245. #endif
  246. }
  248. memcpy(*imgY_org, pY, img->width * img->height);
  249. memcpy(*(imgUV_org[0]), pU, img->width_cr * img->height_cr);
  250. memcpy(*(imgUV_org[1]), pV, img->width_cr * img->height_cr);
  252. /* end of read_one_frame emulation */
  254.     encode_one_frame(); // encode one I- or P-frame
  255.     if ((input->successive_Bframe != 0) && (img->number > 0)) // B-frame(s) to encode
  256.     {
  257.       img->type = B_IMG;            // set image type to B-frame
  258.       img->types= INTER_IMG;
  259.       for(img->b_frame_to_code=1; img->b_frame_to_code<=input->successive_Bframe; img->b_frame_to_code++)
  260.         encode_one_frame();  // encode one B-frame
  261.     }
  262.     
  263.     if (image_type == INTRA_IMG || img->types==SP_IMG)
  264.     {
  265.         img->nb_references = 1;
  266.     }
  267.     else
  268.     {
  269.        img->nb_references += 1;
  270.        img->nb_references = min(img->nb_references, img->buf_cycle);
  271.     }
  273.   *pEncodedLength = memoutlength;
  274.   img->number++;
  275.   return 0;
  276. }
  278. int H26L_GetReconstructed(byte* pY, byte* pU, byte* pV)
  279. {
  280. memcpy(pY, *imgY, img->width * img->height);
  281. memcpy(pU, *(imgUV[0]), img->width_cr * img->height_cr);
  282. memcpy(pV, *(imgUV[1]), img->width_cr * img->height_cr);
  283. return 0;
  284. }
  286. int H26L_Close()
  287. {
  288.   if (H26L_InUse == 0) {
  289. return -1;
  290.   }
  292.   // terminate sequence
  293.   terminate_sequence();
  295. #ifdef _FAST_FULL_ME_
  296.   // free arrays for fast full motion estimation
  297.   ClearFastFullIntegerSearch ();
  298. #endif
  300.   // free structure for rd-opt. mode decision
  301.   clear_rdopt ();
  303. #ifdef _LEAKYBUCKET_
  304.   calc_buffer();
  305. #endif
  307. #ifndef H26L_LIB
  308.   // report everything
  309.   report();
  310. #endif
  312.   free_slice();
  314.   // free allocated memory for frame buffers
  315.   free_mem4global_buffers();
  317.   // free image mem
  318.   free_img ();
  320.   H26L_InUse = 0;
  322.   return 0;
  323. }
  325. /*!
  326.  ***********************************************************************
  327.  * brief
  328.  *    Initializes the Image structure with appropriate parameters.
  329.  * par Input:
  330.  *    Input Parameters struct inp_par *inp
  331.  * par  Output:
  332.  *    Image Parameters struct img_par *img
  333.  ***********************************************************************
  334.  */
  335. void init_img()
  336. {
  337.   int i,j;
  339.   img->no_multpred=input->no_multpred;
  340. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  341.   img->buf_cycle = max (input->no_multpred, input->add_ref_frame+1);
  342. #else
  343.   img->buf_cycle = input->no_multpred;
  344. #endif
  345.   img->framerate=INIT_FRAME_RATE;   // The basic frame rate (of the original sequence)
  347.   get_mem_mv (&(img->mv));
  348.   get_mem_mv (&(img->p_fwMV));
  349.   get_mem_mv (&(img->p_bwMV));
  350.   get_mem_mv (&(img->all_mv));
  351.   get_mem_mv (&(img->all_bmv));
  353.   img->width    = input->img_width;
  354.   img->height   = input->img_height;
  355.   img->width_cr = input->img_width/2;
  356.   img->height_cr= input->img_height/2;
  358.   if(((img->mb_data) = (Macroblock *) calloc((img->width/MB_BLOCK_SIZE) * (img->height/MB_BLOCK_SIZE),sizeof(Macroblock))) == NULL)
  359.     no_mem_exit("init_img: img->mb_data");
  361.   if(((img->slice_numbers) = (int *) calloc((img->width/MB_BLOCK_SIZE) * (img->height/MB_BLOCK_SIZE),sizeof(int))) == NULL)
  362.     no_mem_exit("init_img: img->slice_numbers");
  364.   if(input->UseConstrainedIntraPred)
  365.   {
  366.     if(((img->intra_mb) = (int *) calloc((img->width/MB_BLOCK_SIZE) * (img->height/MB_BLOCK_SIZE),sizeof(int))) == NULL)
  367.       no_mem_exit("init_img: img->intra_mb");
  368.   }
  370.   init(img);
  372.   // allocate memory for intra pred mode buffer for each block: img->ipredmode
  373.   // int  img->ipredmode[90][74];
  374.   get_mem2Dint(&(img->ipredmode), img->width/BLOCK_SIZE+2, img->height/BLOCK_SIZE+2);
  376.   // Prediction mode is set to -1 outside the frame, indicating that no prediction can be made from this part
  377.   for (i=0; i < img->width/BLOCK_SIZE+1; i++)
  378.   {
  379.     img->ipredmode[i+1][0]=-1;
  380.   }
  381.   for (j=0; j < img->height/BLOCK_SIZE+1; j++)
  382.   {
  383.     img->ipredmode[0][j+1]=-1;
  384.   }
  386.   img->mb_y_upd=0;
  388. }
  390. /*!
  391.  ***********************************************************************
  392.  * brief
  393.  *    Free the Image structures
  394.  * par Input:
  395.  *    Image Parameters struct img_par *img
  396.  ***********************************************************************
  397.  */
  398. void free_img ()
  399. {
  400.   free_mem_mv (img->mv);
  401.   free_mem_mv (img->p_fwMV);
  402.   free_mem_mv (img->p_bwMV);
  403.   free_mem_mv (img->all_mv);
  404.   free_mem_mv (img->all_bmv);
  405. }
  408. /*!
  409.  ************************************************************************
  410.  * brief
  411.  *    Allocates the slice structure along with its dependent
  412.  *    data structures
  413.  * par Input:
  414.  *    Input Parameters struct inp_par *inp,  struct img_par *img
  415.  ************************************************************************
  416.  */
  417. void malloc_slice()
  418. {
  419.   int i;
  420.   DataPartition *dataPart;
  421.   Slice *currSlice;
  422.   const int buffer_size = (img->width * img->height * 3)/2; // DM 070301: The only assumption here is that we
  423.                                 // do not consider the case of data expansion.
  424.                                 // So this is a strictly conservative estimation
  425.                                 // of the size of the bitstream buffer for one frame */                                                       /* ~DM
  427.   switch(input->of_mode) // init depending on NAL mode
  428.   {
  429.     case PAR_OF_26L:
  430.       // Current File Format
  431.       img->currentSlice = (Slice *) calloc(1, sizeof(Slice));
  432.       if ( (currSlice = img->currentSlice) == NULL)
  433.       {
  434.         snprintf (errortext, ET_SIZE, "Memory allocation for Slice datastruct in NAL-mode %d failed", input->of_mode);
  435.         error(errortext, 600);
  436.       }
  437.       if (input->symbol_mode == CABAC)
  438.       {
  439.         // create all context models
  440.         currSlice->mot_ctx = create_contexts_MotionInfo();
  441.         currSlice->tex_ctx = create_contexts_TextureInfo();
  442.       }
  444.       switch(input->partition_mode)
  445.       {
  446.       case PAR_DP_1:
  447.         currSlice->max_part_nr = 1;
  448.         break;
  449.       case PAR_DP_3:
  450.         error("Data Partitioning not supported with bit stream file format",600);
  451.         break;
  452.       default:
  453.         error("Data Partitioning Mode not supported!",600);
  454.         break;
  455.       }
  458.       currSlice->partArr = (DataPartition *) calloc(currSlice->max_part_nr, sizeof(DataPartition));
  459.       if (currSlice->partArr == NULL)
  460.       {
  461.         snprintf(errortext, ET_SIZE, "Memory allocation for Data Partition datastruct in NAL-mode %d failed", input->of_mode);
  462.         error(errortext, 100);
  463.       }
  464.       for (i=0; i<currSlice->max_part_nr; i++) // loop over all data partitions
  465.       {
  466.         dataPart = &(currSlice->partArr[i]);
  467.         dataPart->bitstream = (Bitstream *) calloc(1, sizeof(Bitstream));
  468.         if (dataPart->bitstream == NULL)
  469.         {
  470.           snprintf(errortext, ET_SIZE, "Memory allocation for Bitstream datastruct in NAL-mode %d failed", input->of_mode);
  471.           error (errortext, 100);
  472.         }
  473.         dataPart->bitstream->streamBuffer = (byte *) calloc(buffer_size, sizeof(byte));
  474.         if (dataPart->bitstream->streamBuffer == NULL)
  475.         {
  476.           snprintf(errortext, ET_SIZE, "Memory allocation for bitstream buffer in NAL-mode %d failed", input->of_mode);
  477.           error (errortext, 100);
  478.         }
  479.         // Initialize storage of bitstream parameters
  480.         dataPart->bitstream->stored_bits_to_go = 8;
  481.         dataPart->bitstream->stored_byte_pos = 0;
  482.         dataPart->bitstream->stored_byte_buf = 0;
  483.       }
  484.       return;
  485.     case PAR_OF_RTP:
  486.       // RTP packet file format
  487.       img->currentSlice = (Slice *) calloc(1, sizeof(Slice));
  488.       if ( (currSlice = img->currentSlice) == NULL)
  489.       {
  490.         snprintf(errortext, ET_SIZE, "Memory allocation for Slice datastruct in NAL-mode %d failed", input->of_mode);
  491.         error(errortext, 100);
  492.       }
  493.       if (input->symbol_mode == CABAC)
  494.       {
  495.         // create all context models
  496.         currSlice->mot_ctx = create_contexts_MotionInfo();
  497.         currSlice->tex_ctx = create_contexts_TextureInfo();
  498.       }
  499.       switch(input->partition_mode)
  500.       {
  501.       case PAR_DP_1:
  502.         currSlice->max_part_nr = 1;
  503.         break;
  504.       case PAR_DP_3:
  505.         currSlice->max_part_nr = 3;
  506.         break;
  507.       default:
  508.         error("Data Partitioning Mode not supported!",600);
  509.         break;
  510.       }
  512.       currSlice->partArr = (DataPartition *) calloc(currSlice->max_part_nr, sizeof(DataPartition));
  513.       if (currSlice->partArr == NULL)
  514.       {
  515.         snprintf(errortext, ET_SIZE, "Memory allocation for Data Partition datastruct in NAL-mode %d failed", input->of_mode);
  516.         error(errortext, 100);
  517.       }
  519.       for (i=0; i<currSlice->max_part_nr; i++) // loop over all data partitions
  520.       {
  521.         dataPart = &(currSlice->partArr[i]);
  522.         dataPart->bitstream = (Bitstream *) calloc(1, sizeof(Bitstream));
  523.         if (dataPart->bitstream == NULL)
  524.         {
  525.           snprintf(errortext, ET_SIZE, "Memory allocation for Bitstream datastruct in NAL-mode %d failed", input->of_mode);
  526.           error(errortext, 100);
  527.         }
  528.         dataPart->bitstream->streamBuffer = (byte *) calloc(buffer_size, sizeof(byte));
  529.         if (dataPart->bitstream->streamBuffer == NULL)
  530.         {
  531.           snprintf(errortext, ET_SIZE, "Memory allocation for bitstream buffer in NAL-mode %d failed", input->of_mode);
  532.           error(errortext, 100);
  533.         }
  534.         // Initialize storage of bitstream parameters
  535.         dataPart->bitstream->stored_bits_to_go = 8;
  536.         dataPart->bitstream->stored_byte_pos = 0;
  537.         dataPart->bitstream->stored_byte_buf = 0;
  538.       }
  539.       return;
  541.     default:
  542.       snprintf(errortext, ET_SIZE, "Output File Mode %d not supported", input->of_mode);
  543.       error(errortext, 600);
  544.   }
  546. }
  548. /*!
  549.  ************************************************************************
  550.  * brief
  551.  *    Memory frees of the Slice structure and of its dependent
  552.  *    data structures
  553.  * par Input:
  554.  *    Input Parameters struct inp_par *inp,  struct img_par *img
  555.  ************************************************************************
  556.  */
  557. void free_slice()
  558. {
  559.   int i;
  560.   DataPartition *dataPart;
  561.   Slice *currSlice = img->currentSlice;
  563.   for (i=0; i<currSlice->max_part_nr; i++) // loop over all data partitions
  564.   {
  565.     dataPart = &(currSlice->partArr[i]);
  566.     if (dataPart->bitstream->streamBuffer != NULL)
  567.       free(dataPart->bitstream->streamBuffer);
  568.     if (dataPart->bitstream != NULL)
  569.       free(dataPart->bitstream);
  570.   }
  571.   if (currSlice->partArr != NULL)
  572.     free(currSlice->partArr);
  573.   if (input->symbol_mode == CABAC)
  574.   {
  575.     // delete all context models
  576.     delete_contexts_MotionInfo(currSlice->mot_ctx);
  577.     delete_contexts_TextureInfo(currSlice->tex_ctx);
  578.   }
  579.   if (currSlice != NULL)
  580.     free(img->currentSlice);
  581. }
  584. /*!
  585.  ************************************************************************
  586.  * brief
  587.  *    Initializes the Statistics structure with appropriate parameters
  588.  * par Input:
  589.  *    Statistic Parameters struct stat_par *stat
  590.  * par Output:
  591.  *    Statistic Parameters struct stat_par *stat
  592.  ************************************************************************
  593.  */
  594. void init_stat()
  595. {
  596.   int i;
  597.   if ((stat->mode_use_Bframe = (int *)malloc(sizeof(int)*41))==NULL)
  598.     no_mem_exit("init_stat: stat->mode_use_Bframe");
  599.   if ((stat->bit_use_mode_Bframe =  (int *)malloc(sizeof(int)*41))==NULL)
  600.     no_mem_exit("init_stat: stat->bit_use_mode_Bframe");
  601.   for(i=0; i<41; i++)
  602.     stat->mode_use_Bframe[i]=stat->bit_use_mode_Bframe[i]=0;
  603. }
  605. /*!
  606.  ************************************************************************
  607.  * brief
  608.  *    Reports the gathered information to appropriate outputs
  609.  * par Input:
  610.  *    struct inp_par *inp,                                            n
  611.  *    struct img_par *img,                                            n
  612.  *    struct stat_par *stat,                                          n
  613.  *    struct stat_par *stat                                           n
  614.  *
  615.  * par Output:
  616.  *    None
  617.  ************************************************************************
  618.  */
  619. void report()
  620. {
  621.   int bit_use[2][2] ;
  622.   int i,j;
  623.   char name[20];
  624.   int bit_use_Bframe=0;
  625.   int total_bits;
  626.   float frame_rate;
  628. #ifndef WIN32
  629.   time_t now;
  630.   struct tm *l_time;
  631.   char string[1000];
  632. #else
  633.   char timebuf[128];
  634. #endif
  635.   bit_use[0][0]=1;
  636.   bit_use[1][0]=max(1,input->no_frames-1);
  638.   //  Accumulate bit usage for inter and intra frames
  639.   bit_use[0][1]=bit_use[1][1]=0;
  641.   for (i=0; i < 9; i++)
  642.     bit_use[1][1] += stat->bit_use_mode_inter[i];
  644.   for (j=0;j<2;j++)
  645.   {
  646.     bit_use[j][1]+=stat->bit_use_header[j];
  647.     bit_use[j][1]+=stat->bit_use_mb_type[j];
  648.     bit_use[j][1]+=stat->tmp_bit_use_cbp[j];
  649.     bit_use[j][1]+=stat->bit_use_coeffY[j];
  650.     bit_use[j][1]+=stat->bit_use_coeffC[j];
  651.     bit_use[j][1]+=stat->bit_use_delta_quant[j];
  652.   }
  654.   // B pictures
  655.   if(Bframe_ctr!=0)
  656.   {
  657.     bit_use_Bframe=0;
  658.     for(i=0; i<41; i++)
  659.       bit_use_Bframe += stat->bit_use_mode_Bframe[i]; // fw_predframe_no, blk_size
  660.     bit_use_Bframe += stat->bit_use_header[2];
  661.     bit_use_Bframe += stat->tmp_bit_use_cbp[2];
  662.     bit_use_Bframe += stat->bit_use_coeffY[2];
  663.     bit_use_Bframe += stat->bit_use_coeffC[2];
  664.     bit_use_Bframe += stat->bit_use_delta_quant[2];
  666.     stat->bitrate_P=(stat->bit_ctr_0+stat->bit_ctr_P)*(float)(img->framerate/(input->jumpd+1))/input->no_frames;
  667. #ifdef _ADAPT_LAST_GROUP_
  668.     stat->bitrate_B=(stat->bit_ctr_B)*(float)(img->framerate/(input->jumpd+1))*initial_Bframes/Bframe_ctr;
  669. #else
  670.     stat->bitrate_B=(stat->bit_ctr_B)*(float)(img->framerate/(input->jumpd+1))*input->successive_Bframe/Bframe_ctr;
  671. #endif
  672.   }
  673.   else
  674.   {
  675.     if (input->no_frames > 1)
  676.     {
  677.       stat->bitrate=(bit_use[0][1]+bit_use[1][1])*(float)img->framerate/(input->no_frames*(input->jumpd+1));
  678.     }
  679.   }
  681.   fprintf(stdout,"--------------------------------------------------------------------------n");
  682.   fprintf(stdout,   " Freq. for encoded bitstream       : %1.0fn",(float)img->framerate/(float)(input->jumpd+1));
  683.   if(input->hadamard)
  684.     fprintf(stdout," Hadamard transform                : Usedn");
  685.   else
  686.     fprintf(stdout," Hadamard transform                : Not usedn");
  688.   fprintf(stdout," Image format                      : %dx%dn",input->img_width,input->img_height);
  690.   if(input->intra_upd)
  691.     fprintf(stdout," Error robustness                  : Onn");
  692.   else
  693.     fprintf(stdout," Error robustness                  : Offn");
  694.   fprintf(stdout,    " Search range                      : %dn",input->search_range);
  696.   if(input->mv_res)
  697.     fprintf(stdout," MV resolution                     : 1/8-peln");
  698.   else
  699.     fprintf(stdout," MV resolution                     : 1/4-peln");
  701. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  702.   if (input->add_ref_frame >= input->no_multpred)
  703.   {
  704.       fprintf(stdout,   " No of ref. frames used in P pred  : %d (+ no. %d)n",input->no_multpred,input->add_ref_frame);
  705.       if(input->successive_Bframe != 0)
  706.         fprintf(stdout,   " No of ref. frames used in B pred  : %d (+ no. %d)n",input->no_multpred,input->add_ref_frame);
  707.   }
  708.   else
  709. #endif
  710.   {
  711.     fprintf(stdout,   " No of ref. frames used in P pred  : %dn",input->no_multpred);
  712.     if(input->successive_Bframe != 0)
  713.       fprintf(stdout,   " No of ref. frames used in B pred  : %dn",input->no_multpred);
  714.   }
  715.   fprintf(stdout,   " Total encoding time for the seq.  : %.3f sec n",tot_time*0.001);
  717.   // B pictures
  718.   fprintf(stdout, " Sequence type                     :" );
  719.   if(input->successive_Bframe==1)   fprintf(stdout, " IBPBP (QP: I %d, P %d, B %d) n",
  720.     input->qp0, input->qpN, input->qpB);
  721.   else if(input->successive_Bframe==2) fprintf(stdout, " IBBPBBP (QP: I %d, P %d, B %d) n",
  722.     input->qp0, input->qpN, input->qpB);
  723.   else if(input->successive_Bframe==0 && input->sp_periodicity==0) fprintf(stdout, " IPPP (QP: I %d, P %d) n",   input->qp0, input->qpN);
  724.   else fprintf(stdout, " I-P-P-SP-P (QP: I %d, P %d, SP (%d, %d)) n",  input->qp0, input->qpN, input->qpsp, input->qpsp_pred);
  726.   // report on entropy coding  method
  727.   if (input->symbol_mode == UVLC)
  728.     fprintf(stdout," Entropy coding method             : UVLCn");
  729.   else
  730.     fprintf(stdout," Entropy coding method             : CABACn");
  732. #ifdef _FULL_SEARCH_RANGE_
  733.   if (input->full_search == 2)
  734.     fprintf(stdout," Search range restrictions         : nonen");
  735.   else if (input->full_search == 1)
  736.     fprintf(stdout," Search range restrictions         : older reference framesn");
  737.   else
  738.     fprintf(stdout," Search range restrictions         : smaller blocks and older reference framesn");
  739. #endif
  741.   if (input->rdopt)
  742.     fprintf(stdout," RD-optimized mode decision        : usedn");
  743.   else
  744.     fprintf(stdout," RD-optimized mode decision        : not usedn");
  746.   switch(input->partition_mode)
  747.     {
  748.     case PAR_DP_1:
  749.       fprintf(stdout," Data Partitioning Mode            : 1 partition n");
  750.       break;
  751.     case PAR_DP_3:
  752.       fprintf(stdout," Data Partitioning Mode            : 3 partitions n");
  753.       break;
  754.     default:
  755.       fprintf(stdout," Data Partitioning Mode            : not supportedn");
  756.       break;
  757.     }
  760.     switch(input->of_mode)
  761.     {
  762.     case PAR_OF_26L:
  763.       fprintf(stdout," Output File Format                : H.26L Bit Stream File Format n");
  764.       break;
  765.     case PAR_OF_RTP:
  766.       fprintf(stdout," Output File Format                : RTP Packet File Format n");
  767.       break;
  768.     default:
  769.       fprintf(stdout," Output File Format                : not supportedn");
  770.       break;
  771.     }
  776.   fprintf(stdout,"------------------ Average data all frames  ------------------------------n");
  777.   fprintf(stdout," SNR Y(dB)                         : %5.2fn",snr->snr_ya);
  778.   fprintf(stdout," SNR U(dB)                         : %5.2fn",snr->snr_ua);
  779.   fprintf(stdout," SNR V(dB)                         : %5.2fn",snr->snr_va);
  781.   if(Bframe_ctr!=0)
  782.   {
  784.     fprintf(stdout, " Total bits                        : %d (I %5d, P %5d, B %d) n",
  785.             total_bits=stat->bit_ctr_P + stat->bit_ctr_0 + stat->bit_ctr_B, stat->bit_ctr_0, stat->bit_ctr_P, stat->bit_ctr_B);
  787.     frame_rate = (float)img->framerate / ( (float) (input->jumpd - input->successive_Bframe + 1) );
  788.     stat->bitrate= ((float) total_bits * frame_rate)/((float) (input->no_frames + Bframe_ctr));
  790.     fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2fn", frame_rate, stat->bitrate/1000);
  792.   }
  793.   else if (input->sp_periodicity==0)
  794.   {
  795.     fprintf(stdout, " Total bits                        : %d (I %5d, P %5d) n",
  796.     total_bits=stat->bit_ctr_P + stat->bit_ctr_0 , stat->bit_ctr_0, stat->bit_ctr_P);
  798.     frame_rate = (float)img->framerate / ( (float) (input->jumpd + 1) );
  799.     stat->bitrate= ((float) total_bits * frame_rate)/((float) input->no_frames );
  801.     fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2fn", frame_rate, stat->bitrate/1000);
  802.   }else
  803.   {
  804.     fprintf(stdout, " Total bits                        : %d (I %5d, P %5d) n",
  805.     total_bits=stat->bit_ctr_P + stat->bit_ctr_0 , stat->bit_ctr_0, stat->bit_ctr_P);
  807.     frame_rate = (float)img->framerate / ( (float) (input->jumpd + 1) );
  808.     stat->bitrate= ((float) total_bits * frame_rate)/((float) input->no_frames );
  810.     fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2fn", frame_rate, stat->bitrate/1000);
  811.   }
  813.   fprintf(stdout,"--------------------------------------------------------------------------n");
  814.   fprintf(stdout,"Exit TML %s encoder ver %sn", TML, VERSION);
  816.   // status file
  817.   if ((p_stat=fopen("stat.dat","wb"))==0)
  818.   {
  819.     snprintf(errortext, ET_SIZE, "Error open file %s", "stat.dat");
  820.     error(errortext, 500);
  821.   }
  822.   fprintf(p_stat," -------------------------------------------------------------- n");
  823.   fprintf(p_stat,"  This file contains statistics for the last encoded sequence   n");
  824.   fprintf(p_stat," -------------------------------------------------------------- n");
  825.   fprintf(p_stat,   " Sequence                     : %sn",input->infile);
  826.   fprintf(p_stat,   " No.of coded pictures         : %dn",input->no_frames+Bframe_ctr);
  827.   fprintf(p_stat,   " Freq. for encoded bitstream  : %3.0fn",frame_rate);
  829.   // B pictures
  830.   if(input->successive_Bframe != 0)
  831.   {
  832.     fprintf(p_stat,   " BaseLayer Bitrate(kb/s)      : %6.2fn", stat->bitrate_P/1000);
  833.     fprintf(p_stat,   " EnhancedLyaer Bitrate(kb/s)  : %6.2fn", stat->bitrate_B/1000);
  834.   }
  835.   else
  836.     fprintf(p_stat,   " Bitrate(kb/s)                : %6.2fn", stat->bitrate/1000);
  838.   if(input->hadamard)
  839.     fprintf(p_stat," Hadamard transform           : Usedn");
  840.   else
  841.     fprintf(p_stat," Hadamard transform           : Not usedn");
  843.   fprintf(p_stat," Image format                 : %dx%dn",input->img_width,input->img_height);
  845.   if(input->intra_upd)
  846.     fprintf(p_stat," Error robustness             : Onn");
  847.   else
  848.     fprintf(p_stat," Error robustness             : Offn");
  850.   fprintf(p_stat,    " Search range                 : %dn",input->search_range);
  852.   if(input->mv_res)
  853.     fprintf(p_stat," MV resolution                : 1/8-peln");
  854.   else
  855.     fprintf(p_stat," MV resolution                : 1/4-peln");
  857. #ifdef _ADDITIONAL_REFERENCE_FRAME_
  858.   if (input->add_ref_frame >= input->no_multpred)
  859.     {
  860.       fprintf(p_stat,   " No of frame used in P pred   : %d (+ no. %d)n",input->no_multpred,input->add_ref_frame);
  861.       if(input->successive_Bframe != 0)
  862.         fprintf(p_stat,   " No of frame used in B pred   : %d (+ no. %d)n",input->no_multpred,input->add_ref_frame);
  863.     }
  864.   else
  865. #endif
  866.   {
  867.     fprintf(p_stat,   " No of frame used in P pred   : %dn",input->no_multpred);
  868.     if(input->successive_Bframe != 0)
  869.       fprintf(p_stat,   " No of frame used in B pred   : %dn",input->no_multpred);
  870.   }
  871.   if (input->symbol_mode == UVLC)
  872.     fprintf(p_stat,   " Entropy coding method        : UVLCn");
  873.   else
  874.     fprintf(p_stat,   " Entropy coding method        : CABACn");
  876. #ifdef _FULL_SEARCH_RANGE_
  877.   if (input->full_search == 2)
  878.     fprintf(p_stat," Search range restrictions    : nonen");
  879.   else if (input->full_search == 1)
  880.     fprintf(p_stat," Search range restrictions    : older reference framesn");
  881.   else
  882.     fprintf(p_stat," Search range restrictions    : smaller blocks and older reference framesn");
  883. #endif
  884.   if (input->rdopt)
  885.     fprintf(p_stat," RD-optimized mode decision   : usedn");
  886.   else
  887.     fprintf(p_stat," RD-optimized mode decision   : not usedn");
  889.   fprintf(p_stat," -------------------|---------------|---------------|n");
  890.   fprintf(p_stat,"     Item           |     Intra     |   All frames  |n");
  891.   fprintf(p_stat," -------------------|---------------|---------------|n");
  892.   fprintf(p_stat," SNR Y(dB)          |");
  893.   fprintf(p_stat," %5.2f         |",snr->snr_y1);
  894.   fprintf(p_stat," %5.2f         |n",snr->snr_ya);
  895.   fprintf(p_stat," SNR U/V (dB)       |");
  896.   fprintf(p_stat," %5.2f/%5.2f   |",snr->snr_u1,snr->snr_v1);
  897.   fprintf(p_stat," %5.2f/%5.2f   |n",snr->snr_ua,snr->snr_va);
  899.   // QUANT.
  900.   fprintf(p_stat," Average quant      |");
  901.   fprintf(p_stat," %5d         |",absm(input->qp0));
  902.   fprintf(p_stat," %5.2f         |n",(float)stat->quant1/max(1.0,(float)stat->quant0));
  904.   // MODE
  905.   fprintf(p_stat,"n -------------------|---------------|n");
  906.   fprintf(p_stat,"   Intra            |   Mode used   |n");
  907.   fprintf(p_stat," -------------------|---------------|n");
  909.   fprintf(p_stat," Mode 0  intra oldt| %5d         |n",stat->mode_use_intra[0]);
  910.   for (i=1;i<24;i++)
  911.     fprintf(p_stat," Mode %d intra newt| %5d         |n",i,stat->mode_use_intra[i]);
  913.   fprintf(p_stat,"n -------------------|---------------|---------------|n");
  914.   fprintf(p_stat,"   Inter            |   Mode used   | Vector bit use|n");
  915.   fprintf(p_stat," -------------------|---------------|---------------|");
  917.   fprintf(p_stat,"n Mode 0  (copy)  t| %5d         | %5.0f         |",stat->mode_use_inter[0],(float)stat->bit_use_mode_inter[0]/(float)bit_use[1][0]);
  918.   fprintf(p_stat,"n Mode 1  (16x16) t| %5d         | %5.0f         |",stat->mode_use_inter[1],(float)stat->bit_use_mode_inter[1]/(float)bit_use[1][0]);
  919.   fprintf(p_stat,"n Mode 2  (16x8)  t| %5d         | %5.0f         |",stat->mode_use_inter[2],(float)stat->bit_use_mode_inter[2]/(float)bit_use[1][0]);
  920.   fprintf(p_stat,"n Mode 3  (8x16)  t| %5d         | %5.0f         |",stat->mode_use_inter[3],(float)stat->bit_use_mode_inter[3]/(float)bit_use[1][0]);
  921.   fprintf(p_stat,"n Mode 4  (8x8)   t| %5d         | %5.0f         |",stat->mode_use_inter[4],(float)stat->bit_use_mode_inter[4]/(float)bit_use[1][0]);
  922.   fprintf(p_stat,"n Mode 5  (8x4)   t| %5d         | %5.0f         |",stat->mode_use_inter[5],(float)stat->bit_use_mode_inter[5]/(float)bit_use[1][0]);
  923.   fprintf(p_stat,"n Mode 6  (4x8)   t| %5d         | %5.0f         |",stat->mode_use_inter[6],(float)stat->bit_use_mode_inter[6]/(float)bit_use[1][0]);
  924.   fprintf(p_stat,"n Mode 7  (4x4)   t| %5d         | %5.0f         |",stat->mode_use_inter[7],(float)stat->bit_use_mode_inter[7]/(float)bit_use[1][0]);
  925.   fprintf(p_stat,"n Mode 8 intra oldt| %5d         | --------------|",stat->mode_use_inter[8]);
  926.   for (i=9;i<33;i++)
  927.     fprintf(p_stat,"n Mode %d intr.new t| %5d         |",i,stat->mode_use_inter[i]);
  929.   // B pictures
  930.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  931.   {
  932.     fprintf(p_stat,"nn -------------------|---------------|n");
  933.     fprintf(p_stat,"   B frame          |   Mode used   |n");
  934.     fprintf(p_stat," -------------------|---------------|");
  936.     for(i=0; i<16; i++)
  937.       fprintf(p_stat,"n Mode %d   t| %5d         |", i, stat->mode_use_Bframe[i]);
  938.     fprintf(p_stat,"n Mode %d intra oldt| %5d     |", 16, stat->mode_use_Bframe[16]);
  939.     for (i=17; i<41; i++)
  940.       fprintf(p_stat,"n Mode %d intr.new t| %5d     |",i, stat->mode_use_Bframe[i]);
  941.   }
  943.   fprintf(p_stat,"nn -------------------|---------------|---------------|---------------|n");
  944.   fprintf(p_stat,"  Bit usage:        |     Intra     |    Inter      |   B frame     |n");
  945.   fprintf(p_stat," -------------------|---------------|---------------|---------------|n");
  947.   fprintf(p_stat," Header+modeinfo    |");
  948.   fprintf(p_stat," %7d       |",stat->bit_use_header[0]);
  949.   fprintf(p_stat," %7d       |",stat->bit_use_header[1]/bit_use[1][0]);
  950.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  951.     fprintf(p_stat," %7d       |",stat->bit_use_header[2]/Bframe_ctr);
  952.   else fprintf(p_stat," %7d       |", 0);
  953.   fprintf(p_stat,"n");
  955.   fprintf(p_stat," CBP Y/C            |");
  956.   for (j=0; j < 2; j++)
  957.   {
  958.     fprintf(p_stat," %7.2f       |", (float)stat->tmp_bit_use_cbp[j]/bit_use[j][0]);
  959.   }
  960.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  961.     fprintf(p_stat," %7.2f       |", (float)stat->tmp_bit_use_cbp[2]/Bframe_ctr);
  962.   else fprintf(p_stat," %7.2f       |", 0.);
  963.   fprintf(p_stat,"n");
  965.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  966.     fprintf(p_stat," Coeffs. Y          | %7.2f      | %7.2f       | %7.2f       |n",
  967.       (float)stat->bit_use_coeffY[0]/bit_use[0][0], (float)stat->bit_use_coeffY[1]/bit_use[1][0], (float)stat->bit_use_coeffY[2]/Bframe_ctr);
  968.   else
  969.     fprintf(p_stat," Coeffs. Y          | %7.2f      | %7.2f       | %7.2f       |n",
  970.       (float)stat->bit_use_coeffY[0]/bit_use[0][0], (float)stat->bit_use_coeffY[1]/bit_use[1][0], 0.);
  972.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  973.     fprintf(p_stat," Coeffs. C          | %7.2f       | %7.2f       | %7.2f       |n",
  974.       (float)stat->bit_use_coeffC[0]/bit_use[0][0], (float)stat->bit_use_coeffC[1]/bit_use[1][0], (float)stat->bit_use_coeffC[2]/Bframe_ctr);
  975.   else
  976.     fprintf(p_stat," Coeffs. C          | %7.2f       | %7.2f       | %7.2f       |n",
  977.       (float)stat->bit_use_coeffC[0]/bit_use[0][0], (float)stat->bit_use_coeffC[1]/bit_use[1][0], 0.);
  979.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  980.     fprintf(p_stat," Delta quant        | %7.2f       | %7.2f       | %7.2f       |n",
  981.       (float)stat->bit_use_delta_quant[0]/bit_use[0][0], (float)stat->bit_use_delta_quant[1]/bit_use[1][0], (float)stat->bit_use_delta_quant[2]/Bframe_ctr);
  982.   else
  983.     fprintf(p_stat," Delta quant        | %7.2f       | %7.2f       | %7.2f       |n",
  984.       (float)stat->bit_use_delta_quant[0]/bit_use[0][0], (float)stat->bit_use_delta_quant[1]/bit_use[1][0], 0.);
  987.   fprintf(p_stat," -------------------|---------------|---------------|---------------|n");
  989.   fprintf(p_stat," average bits/frame |");
  990.   for (i=0; i < 2; i++)
  991.   {
  992.     fprintf(p_stat," %7d       |",bit_use[i][1]/bit_use[i][0]);
  993.   }
  994.   if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  995.     fprintf(p_stat," %7d       |", bit_use_Bframe/Bframe_ctr);
  996.   else fprintf(p_stat," %7d       |", 0);
  998.   fprintf(p_stat,"n");
  999.   fprintf(p_stat," -------------------|---------------|---------------|---------------|n");
  1001.   // write to log file
  1002.   if (fopen("log.dat","r")==0)                      // check if file exist
  1003.   {
  1004.     if ((p_log=fopen("log.dat","a"))==NULL)            // append new statistic at the end
  1005.     {
  1006.       snprintf(errortext, ET_SIZE, "Error open file %s  n","log.dat");
  1007.       error(errortext, 500);
  1008.     }
  1009.     else                                            // Create header for new log file
  1010.     {
  1011.       fprintf(p_log," ---------------------------------------------------------------------------------------------------------------------------------------------------------------- n");
  1012.       fprintf(p_log,"|            Encoder statistics. This file is generated during first encoding session, new sessions will be appended                                               |n");
  1013.       fprintf(p_log," ---------------------------------------------------------------------------------------------------------------------------------------------------------------- n");
  1014.       fprintf(p_log,"| Date  | Time  |    Sequence        |#Img|Quant1|QuantN|Format|Hadamard|Search r|#Ref |Freq |Intra upd|SNRY 1|SNRU 1|SNRV 1|SNRY N|SNRU N|SNRV N|#Bitr P|#Bitr B|n");
  1015.       fprintf(p_log," ---------------------------------------------------------------------------------------------------------------------------------------------------------------- n");
  1016.     }
  1017.   }
  1018.   else
  1019.     if ((p_log=fopen("log.dat","a"))==NULL)            // File exist,just open for appending
  1020.     {
  1021.       snprintf(errortext, ET_SIZE, "Error open file %s  n","log.dat");
  1022.       error(errortext, 500);
  1023.     }
  1025. #ifdef WIN32
  1026.   _strdate( timebuf );
  1027.   fprintf(p_log,"| %1.5s |",timebuf );
  1029.   _strtime( timebuf);
  1030.   fprintf(p_log," % 1.5s |",timebuf);
  1031. #else
  1032.   now = time ((time_t *) NULL); // Get the system time and put it into 'now' as 'calender time'
  1033.   time (&now);
  1034.   l_time = localtime (&now);
  1035.   strftime (string, sizeof string, "%d-%b-%Y", l_time);
  1036.   fprintf(p_log,"| %1.5s |",string );
  1038.   strftime (string, sizeof string, "%H:%M:%S", l_time);
  1039.   fprintf(p_log," %1.5s |",string );
  1040. #endif
  1042.   for (i=0;i<20;i++)
  1043.     name[i]=input->infile[i+max(0,strlen(input->infile)-20)]; // write last part of path, max 20 chars
  1044.   fprintf(p_log,"%20.20s|",name);
  1046.   fprintf(p_log,"%3d |",input->no_frames);
  1047.   fprintf(p_log,"  %2d  |",input->qp0);
  1048.   fprintf(p_log,"  %2d  |",input->qpN);
  1051.   fprintf(p_log,"%dx%d|",input->img_width,input->img_height);
  1054.   if (input->hadamard==1)
  1055.     fprintf(p_log,"   ON   |");
  1056.   else
  1057.     fprintf(p_log,"   OFF  |");
  1059.   fprintf(p_log,"   %2d   |",input->search_range );
  1061.   fprintf(p_log," %2d  |",input->no_multpred);
  1063.   fprintf(p_log," %2d  |",img->framerate/(input->jumpd+1));
  1065.   if (input->intra_upd==1)
  1066.     fprintf(p_log,"   ON    |");
  1067.   else
  1068.     fprintf(p_log,"   OFF   |");
  1070.   fprintf(p_log,"%5.3f|",snr->snr_y1);
  1071.   fprintf(p_log,"%5.3f|",snr->snr_u1);
  1072.   fprintf(p_log,"%5.3f|",snr->snr_v1);
  1073.   fprintf(p_log,"%5.3f|",snr->snr_ya);
  1074.   fprintf(p_log,"%5.3f|",snr->snr_ua);
  1075.   fprintf(p_log,"%5.3f|",snr->snr_va);
  1076.   if(input->successive_Bframe != 0)
  1077.   {
  1078.     fprintf(p_log,"%7.0f|",stat->bitrate_P);
  1079.     fprintf(p_log,"%7.0f|n",stat->bitrate_B);
  1080.   }
  1081.   else
  1082.   {
  1083.     fprintf(p_log,"%7.0f|",stat->bitrate);
  1084.     fprintf(p_log,"%7.0f|n",0.0);
  1085.   }
  1087.   fclose(p_log);
  1089.   p_log=fopen("data.txt","a");
  1091.   if(input->successive_Bframe != 0 && Bframe_ctr != 0) // B picture used
  1092.   {
  1093.     fprintf(p_log, "%3d %2d %2d %2.2f %2.2f %2.2f %5d "
  1094.           "%2.2f %2.2f %2.2f %5d "
  1095.         "%2.2f %2.2f %2.2f %5d %5d %.3fn",
  1096.         input->no_frames, input->qp0, input->qpN,
  1097.         snr->snr_y1,
  1098.         snr->snr_u1,
  1099.         snr->snr_v1,
  1100.         stat->bit_ctr_0,
  1101.         0.0,
  1102.         0.0,
  1103.         0.0,
  1104.         0,
  1105.         snr->snr_ya,
  1106.         snr->snr_ua,
  1107.         snr->snr_va,
  1108.         (stat->bit_ctr_0+stat->bit_ctr)/input->no_frames,
  1109.         stat->bit_ctr_B/Bframe_ctr,
  1110.         (double)0.001*tot_time/(input->no_frames+Bframe_ctr));
  1111.   }
  1112.   else
  1113.   {
  1114.     fprintf(p_log, "%3d %2d %2d %2.2f %2.2f %2.2f %5d "
  1115.           "%2.2f %2.2f %2.2f %5d "
  1116.         "%2.2f %2.2f %2.2f %5d %5d %.3fn",
  1117.         input->no_frames, input->qp0, input->qpN,
  1118.         snr->snr_y1,
  1119.         snr->snr_u1,
  1120.         snr->snr_v1,
  1121.         stat->bit_ctr_0,
  1122.         0.0,
  1123.         0.0,
  1124.         0.0,
  1125.         0,
  1126.         snr->snr_ya,
  1127.         snr->snr_ua,
  1128.         snr->snr_va,
  1129.         (stat->bit_ctr_0+stat->bit_ctr)/input->no_frames,
  1130.         0,
  1131.         (double)0.001*tot_time/input->no_frames);
  1132.   }
  1134.   fclose(p_log);
  1136.   // B pictures
  1137.   free(stat->mode_use_Bframe);
  1138.   free(stat->bit_use_mode_Bframe);
  1139. }
  1141. /*!
  1142.  ************************************************************************
  1143.  * brief
  1144.  *    Some matrices are initilized here.
  1145.  * par Input:
  1146.  *    none
  1147.  * par Output:
  1148.  *    none
  1149.  ************************************************************************
  1150.  */
  1151. void init()
  1152. {
  1153.   int i, ii, ind, j, i2;
  1155.   InitMotionVectorSearchModule();
  1157.   /*  img->mv_bituse[] is the number of bits used for motion vectors.
  1158.   It is used to add a portion to the SAD depending on bit usage in the motion search
  1159.   */
  1161.   img->mv_bituse[0]=1;
  1162.   ind=0;
  1163.   for (i=0; i < 9; i++)
  1164.   {
  1165.     ii= 2*i + 3;
  1166.     for (j=1; j <= (int)pow(2,i); j++)
  1167.     {
  1168.       ind++;
  1169.       img->mv_bituse[ind]=ii;
  1170.     }
  1171.   }
  1173.   // quad(0:255) SNR quad array
  1174.   for (i=0; i < 256; ++i) // fix from TML1 / TML2 sw, truncation removed
  1175.   {
  1176.     i2=i*i;
  1177.     img->quad[i]=i2;
  1178.   }
  1180.   // B pictures : img->blk_bitsue[] is used when getting bidirection SAD
  1181.   for (i=0; i < 7; i++)
  1182.   {
  1183.     if(i==0) img->blk_bituse[i]=1;
  1184.     else if(i==1 || i==2) img->blk_bituse[i]=3;
  1185.     else img->blk_bituse[i]=5;
  1186.   }
  1187. }
  1189. /*!
  1190.  ************************************************************************
  1191.  * brief
  1192.  *    Prints the header of the protocol.
  1193.  * par Input:
  1194.  *    struct inp_par *inp
  1195.  * par Output:
  1196.  *    none
  1197.  ************************************************************************
  1198.  */
  1199. void information_init()
  1200. {
  1201.   printf("--------------------------------------------------------------------------n");
  1202.   printf(" Input YUV file                    : %s n",input->infile);
  1203.   printf(" Output H.26L bitstream            : %s n",input->outfile);
  1204.   if (p_dec != NULL)
  1205.     printf(" Output YUV file(debug)            : %s n",input->ReconFile);
  1206.   printf(" Output log file                   : log.dat n");
  1207.   printf(" Output statistics file            : stat.dat n");
  1208.   printf("--------------------------------------------------------------------------n");
  1211.   printf(" Frame   Bit/pic   QP   SnrY    SnrU    SnrV    Time(ms) IntraMBsn");
  1212. }
  1215. /*!
  1216.  ************************************************************************
  1217.  * brief
  1218.  *    Dynamic memory allocation of frame size related global buffers
  1219.  *    buffers are defined in global.h, allocated memory must be freed in
  1220.  *    void free_mem4global_buffers()
  1221.  * par Input:
  1222.  *    Input Parameters struct inp_par *inp,                            n
  1223.  *    Image Parameters struct img_par *img
  1224.  * return Number of allocated bytes
  1225.  ************************************************************************
  1226.  */
  1227. int get_mem4global_buffers()
  1228. {
  1229.   int j,memory_size=0;
  1230. #ifdef _ADAPT_LAST_GROUP_
  1231.   extern int *last_P_no;
  1233.   if ((last_P_no = (int*)malloc(img->buf_cycle*sizeof(int))) == NULL)
  1234.     no_mem_exit("get_mem4global_buffers: last_P_no");
  1235. #endif
  1237.   // allocate memory for encoding frame buffers: imgY, imgUV
  1238.   // byte imgY[288][352];
  1239.   // byte imgUV[2][144][176];
  1240.   memory_size += get_mem2D(&imgY, img->height, img->width);
  1241.   memory_size += get_mem3D(&imgUV, 2, img->height_cr, img->width_cr);
  1243.   // allocate memory for reference frame buffers: imgY_org, imgUV_org
  1244.   // byte imgY_org[288][352];
  1245.   // byte imgUV_org[2][144][176];
  1246.   memory_size += get_mem2D(&imgY_org, img->height, img->width);
  1247.   memory_size += get_mem3D(&imgUV_org, 2, img->height_cr, img->width_cr);
  1249.   // allocate memory for post filter frame buffers: imgY_pf, imgUV_pf
  1250.   // byte imgY_pf[288][352];
  1251.   // byte imgUV_pf[2][144][176];
  1252.   memory_size += get_mem2D(&imgY_pf, img->height, img->width);
  1253.   memory_size += get_mem3D(&imgUV_pf, 2, img->height_cr, img->width_cr);
  1255.   // allocate memory for B frame coding: nextP_imgY, nextP_imgUV
  1256.   // byte nextP_imgY[288][352];
  1257.   // byte nextP_imgUV[2][144][176];
  1258.   memory_size += get_mem2D(&nextP_imgY, img->height, img->width);
  1259.   memory_size += get_mem3D(&nextP_imgUV, 2, img->height_cr, img->width_cr);
  1261.   // allocate memory for multiple ref. frame buffers: mref, mcref
  1262.   //byte mref[MAX_MULT_PRED][1152][1408];  */   /* 1/4 pix luma
  1263.   //byte mcef[MAX_MULT_PRED][2][352][288]; */   /* pix chroma
  1264.   // rows and cols for croma component mcef[ref][croma][4x][4y] are switched
  1265.   // compared to luma mref[ref][4y][4x] for whatever reason
  1266.   // number of reference frames increased by one for next P-frame
  1267.   memory_size += get_mem3D(&mref, img->buf_cycle+1, (img->height+2*IMG_PAD_SIZE)*4, (img->width+2*IMG_PAD_SIZE)*4);
  1268.   if((mcef = (byte****)calloc(img->buf_cycle+1,sizeof(byte***))) == NULL)
  1269.     no_mem_exit("get_mem4global_buffers: mcef");
  1270.   for(j=0;j<img->buf_cycle+1;j++)
  1271.   {
  1272.     memory_size += get_mem3D(&(mcef[j]), 2, img->height_cr, img->width_cr);
  1273.   }
  1275.   InitRefbuf (Refbuf11, Refbuf11_P);
  1278.   // allocate memory for B-frame coding (last upsampled P-frame): mref_P, mcref_P
  1279.   // is currently also used in oneforthpix_1() and _2() for coding without B-frames
  1280.   //byte mref[1152][1408];  */   /* 1/4 pix luma
  1281.   //byte mcef[2][352][288]; */   /* pix chroma
  1282.   memory_size += get_mem2D(&mref_P, (img->height+2*IMG_PAD_SIZE)*4, (img->width+2*IMG_PAD_SIZE)*4);
  1283.   memory_size += get_mem3D(&mcef_P, 2, img->height_cr, img->width_cr);
  1285.   if(input->successive_Bframe!=0)
  1286.   {
  1287.     // allocate memory for temp B-frame motion vector buffer: tmp_fwMV, tmp_bwMV, dfMV, dbMV
  1288.     // int ...MV[2][72][92];  ([2][72][88] should be enough)
  1289.     memory_size += get_mem3Dint(&tmp_fwMV, 2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
  1290.     memory_size += get_mem3Dint(&tmp_bwMV, 2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
  1291.     memory_size += get_mem3Dint(&dfMV,     2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
  1292.     memory_size += get_mem3Dint(&dbMV,     2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
  1294.     // allocate memory for temp B-frame motion vector buffer: fw_refFrArr, bw_refFrArr
  1295.     // int ...refFrArr[72][88];
  1296.     memory_size += get_mem2Dint(&fw_refFrArr, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE);
  1297.     memory_size += get_mem2Dint(&bw_refFrArr, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE);
  1298.   }
  1300.   // allocate memory for temp P and B-frame motion vector buffer: tmp_mv, temp_mv_block
  1301.   // int tmp_mv[2][72][92];  ([2][72][88] should be enough)
  1302.   memory_size += get_mem3Dint(&tmp_mv, 2, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE+4);
  1304.   // allocate memory for temp quarter pel luma frame buffer: img4Y_tmp
  1305.   // int img4Y_tmp[576][704];  (previously int imgY_tmp in global.h)
  1306.   memory_size += get_mem2Dint(&img4Y_tmp, img->height+2*IMG_PAD_SIZE, (img->width+2*IMG_PAD_SIZE)*4);
  1308.   // allocate memory for tmp loop filter frame buffers: imgY_tmp, imgUV_tmp
  1309.   // byte imgY_tmp[288][352];
  1310.   memory_size += get_mem2D(&imgY_tmp, img->height, img->width);
  1311.   memory_size += get_mem3D(&imgUV_tmp, 2, img->height_cr, img->width_cr);
  1313.   // allocate memory for reference frames of each block: refFrArr
  1314.   // int  refFrArr[72][88];
  1315.   memory_size += get_mem2Dint(&refFrArr, img->height/BLOCK_SIZE, img->width/BLOCK_SIZE);
  1317.   if (input->rdopt==2)
  1318.   {
  1319.     memory_size += get_mem2Dint(&resY, MB_BLOCK_SIZE, MB_BLOCK_SIZE);
  1320.     if ((decref = (byte****) calloc(input->NoOfDecoders,sizeof(byte***))) == NULL) 
  1321.       no_mem_exit("get_mem4global_buffers: decref");
  1322.     for (j=0 ; j<input->NoOfDecoders; j++)
  1323.     {
  1324.       memory_size += get_mem3D(&decref[j], img->buf_cycle+1, img->height, img->width);
  1325.     }
  1326.     memory_size += get_mem2D(&RefBlock, BLOCK_SIZE,BLOCK_SIZE);
  1327.     memory_size += get_mem3D(&decY, input->NoOfDecoders, img->height, img->width);
  1328.     memory_size += get_mem3D(&decY_best, input->NoOfDecoders, img->height, img->width);
  1329.     memory_size += get_mem2D(&status_map, img->height/MB_BLOCK_SIZE,img->width/MB_BLOCK_SIZE);
  1330.   }
  1332.   return (memory_size);
  1333. }
  1335. /*!
  1336.  ************************************************************************
  1337.  * brief
  1338.  *    Free allocated memory of frame size related global buffers
  1339.  *    buffers are defined in global.h, allocated memory is allocated in
  1340.  *    int get_mem4global_buffers()
  1341.  * par Input:
  1342.  *    Input Parameters struct inp_par *inp,                             n
  1343.  *    Image Parameters struct img_par *img
  1344.  * par Output:
  1345.  *    none
  1346.  ************************************************************************
  1347.  */
  1348. void free_mem4global_buffers()
  1349. {
  1350.   int  i,j;
  1352. #ifdef _ADAPT_LAST_GROUP_
  1353.   extern int *last_P_no;
  1354.   free (last_P_no);
  1355. #endif
  1357.   free(imgY[0]);
  1358.   free(imgY);
  1359.   free(imgUV[0][0]);
  1360.   free(imgUV[1][0]);
  1361.   free(imgUV[0]);
  1362.   free(imgUV[1]);
  1363.   free(imgUV);
  1364.   free(imgY_org[0]);    // free ref frame buffers
  1365.   free(imgY_org);
  1366.   free(imgUV_org[0][0]);
  1367.   free(imgUV_org[1][0]);
  1368.   free(imgUV_org[0]);
  1369.   free(imgUV_org[1]);
  1370.   free(imgUV_org);
  1371.   free(imgY_pf[0]);  // free post filtering frame buffers
  1372.   free(imgY_pf);
  1373.   free(imgUV_pf[0][0]);
  1374.   free(imgUV_pf[1][0]);
  1375.   free(imgUV_pf[0]);
  1376.   free(imgUV_pf[1]);
  1377.   free(imgUV_pf);
  1379.   free(nextP_imgY[0]);    // free next frame buffers (for B frames)
  1380.   free(nextP_imgY);
  1381.   free(nextP_imgUV[0][0]);
  1382.   free(nextP_imgUV[1][0]);
  1383.   free(nextP_imgUV[0]);
  1384.   free(nextP_imgUV[1]);
  1385.   free(nextP_imgUV);
  1388.   free (Refbuf11_P);
  1389.   for (j=0; j<img->buf_cycle; j++)
  1390.     free (Refbuf11[j]);
  1391.   free (Refbuf11);
  1393.   // free multiple ref frame buffers
  1394.   // number of reference frames increased by one for next P-frame
  1395.   for(j=0;j<=img->buf_cycle;j++)
  1396.   {
  1397.     free(mref[j][0]);
  1398.     free(mref[j]);
  1399.     free(mcef[j][0][0]);
  1400.     free(mcef[j][1][0]);
  1401.     free(mcef[j][0]);
  1402.     free(mcef[j][1]);
  1403.     free(mcef[j]);
  1404.   }
  1406.   free(mref);
  1407.   free(mcef);
  1408.   free(mref_P[0]);
  1409.   free(mref_P);
  1410.   free(mcef_P[0][0]);
  1411.   free(mcef_P[1][0]);
  1412.   free(mcef_P[0]);
  1413.   free(mcef_P[1]);
  1414.   free(mcef_P);
  1416.   if(input->successive_Bframe!=0)
  1417.   {
  1418.     // free last P-frame buffers for B-frame coding
  1419.     for(j=0;j<2;j++)
  1420.     {
  1421.       free(tmp_fwMV[j][0]);
  1422.       free(tmp_bwMV[j][0]);
  1423.       free(dfMV[j][0]);
  1424.       free(dbMV[j][0]);
  1425.       free(tmp_fwMV[j]);
  1426.       free(tmp_bwMV[j]);
  1427.       free(dfMV[j]);
  1428.       free(dbMV[j]);
  1429.     }
  1430.     free(tmp_fwMV);
  1431.     free(tmp_bwMV);
  1432.     free(dfMV);
  1433.     free(dbMV);
  1434.     free(fw_refFrArr[0]);
  1435.     free(bw_refFrArr[0]);
  1436.     free(fw_refFrArr);
  1437.     free(bw_refFrArr);
  1438.   } // end if B frame
  1441.   free(tmp_mv[0][0]);
  1442.   free(tmp_mv[0]);
  1443.   free(tmp_mv[1][0]);
  1444.   free(tmp_mv[1]);
  1445.   free(tmp_mv);
  1446.   free(img4Y_tmp[0]);    // free temp quarter pel frame buffer
  1447.   free(img4Y_tmp);
  1448.   free(imgY_tmp[0]);    // free temp loop filter frame buffer
  1449.   free(imgY_tmp);
  1450.   free(imgUV_tmp[0][0]);
  1451.   free(imgUV_tmp[1][0]);
  1452.   free(imgUV_tmp[0]);
  1453.   free(imgUV_tmp[1]);
  1454.   free(imgUV_tmp);
  1455.   free(refFrArr[0]);
  1456.   free(refFrArr);
  1458.   // free mem, allocated in init_img()
  1459.   // free intra pred mode buffer for blocks
  1460.   free(img->ipredmode[0]);
  1461.   free(img->ipredmode);
  1462.   free(img->mb_data);
  1463.   free(img->slice_numbers);
  1464.   if(input->UseConstrainedIntraPred)
  1465.   {
  1466.     free(img->intra_mb);
  1467.   }
  1469.   if (input->rdopt==2)
  1470.   {
  1471.     free(resY[0]);
  1472.     free(resY);
  1473.     free(RefBlock[0]);
  1474.     free(RefBlock);
  1475.     for (j=0; j<input->NoOfDecoders; j++)
  1476.     {
  1477.       free(decY[j][0]);
  1478.       free(decY[j]);
  1479.       free(decY_best[j][0]);
  1480.       free(decY_best[j]);
  1481.       for (i=0; i<img->buf_cycle+1; i++)
  1482.       {
  1483.         free(decref[j][i][0]);
  1484.         free(decref[j][i]);
  1485.       }
  1486.       free(decref[j]);
  1487.     }
  1488.     free(decY);
  1489.     free(decY_best);
  1490.     free(decref);
  1491.     free(status_map[0]);
  1492.     free(status_map);
  1493.   }
  1494. }
  1496. /*!
  1497.  ************************************************************************
  1498.  * brief
  1499.  *    Allocate 2D memory array -> unsigned char array2D[rows][columns]
  1500.  * par Input:
  1501.  *    none
  1502.  * return memory size in bytes
  1503.  ************************************************************************
  1504.  */
  1505. // Change 9-Aug-2001 P. List: dont allocate independant row arrays anymore
  1506. // but one complete array and move row-pointers to array. Now you can step
  1507. // to the next line with an offset of img->width
  1508. int get_mem2D(byte ***array2D, int rows, int columns)
  1509. {
  1510.   int i;
  1512.   if((*array2D      = (byte**)calloc(rows,        sizeof(byte*))) == NULL)
  1513.     no_mem_exit("get_mem2D: array2D");
  1514.   if(((*array2D)[0] = (byte* )calloc(columns*rows,sizeof(byte ))) == NULL)
  1515.     no_mem_exit("get_mem2D: array2D");
  1517.   for(i=1;i<rows;i++)
  1518.     (*array2D)[i] = (*array2D)[i-1] + columns ;
  1520.   return rows*columns;
  1521. }
  1524. /*!
  1525.  ************************************************************************
  1526.  * brief
  1527.  *    Allocate memory for mv
  1528.  * par Input:
  1529.  *    Image Parameters struct img_par *img                             n
  1530.  *    int****** mv
  1531.  * return memory size in bytes
  1532.  ************************************************************************
  1533.  */
  1534. int get_mem_mv (int****** mv)
  1535. {
  1536.   int i, j, k, l;
  1538.   if ((*mv = (int*****)calloc(4,sizeof(int****))) == NULL)
  1539.     no_mem_exit ("get_mem_mv: mv");
  1540.   for (i=0; i<4; i++)
  1541.   {
  1542.     if (((*mv)[i] = (int****)calloc(4,sizeof(int***))) == NULL)
  1543.       no_mem_exit ("get_mem_mv: mv");
  1544.     for (j=0; j<4; j++)
  1545.     {
  1546.       if (((*mv)[i][j] = (int***)calloc(img->buf_cycle,sizeof(int**))) == NULL)
  1547.         no_mem_exit ("get_mem_mv: mv");
  1548.       for (k=0; k<img->buf_cycle; k++)
  1549.       {
  1550.         if (((*mv)[i][j][k] = (int**)calloc(9,sizeof(int*))) == NULL)
  1551.           no_mem_exit ("get_mem_mv: mv");
  1552.         for (l=0; l<9; l++)
  1553.           if (((*mv)[i][j][k][l] = (int*)calloc(2,sizeof(int))) == NULL)
  1554.             no_mem_exit ("get_mem_mv: mv");
  1555.       }
  1556.     }
  1557.   }
  1558.   return 4*4*img->buf_cycle*9*2*sizeof(int);
  1559. }
  1561. /*!
  1562.  ************************************************************************
  1563.  * brief
  1564.  *    Free memory from mv
  1565.  * par Input:
  1566.  *    int****** mv
  1567.  ************************************************************************
  1568.  */
  1569. void free_mem_mv (int***** mv)
  1570. {
  1571.   int i, j, k, l;
  1573.   for (i=0; i<4; i++)
  1574.   {
  1575.     for (j=0; j<4; j++)
  1576.     {
  1577.       for (k=0; k<img->buf_cycle; k++)
  1578.       {
  1579.         for (l=0; l<9; l++)
  1580.           free (mv[i][j][k][l]);
  1581.         free (mv[i][j][k]);
  1582.       }
  1583.       free (mv[i][j]);
  1584.     }
  1585.     free (mv[i]);
  1586.   }
  1587.   free (mv);
  1588. }
  1590. /*!
  1591.  ************************************************************************
  1592.  * brief
  1593.  *    Allocate 2D memory array -> int array2D[rows][columns]
  1594.  * param rows
  1595.  *    number of rows
  1596.  * param columns
  1597.  *    number of columns
  1598.  * par Output:
  1599.  *    int ***array2D allocated memory
  1600.  * return memory size in bytes
  1601.  ************************************************************************
  1602.  */
  1603. // same change as in get_mem2Dint
  1604. int get_mem2Dint(int ***array2D, int rows, int columns)
  1605. {
  1606.   int i;
  1608.   if((*array2D      = (int**)calloc(rows,        sizeof(int*))) == NULL)
  1609.     no_mem_exit("get_mem2Dint:array2D");
  1610.   if(((*array2D)[0] = (int* )calloc(rows*columns,sizeof(int ))) == NULL)
  1611.     no_mem_exit("get_mem2Dint:array2D");
  1613.   for(i=1 ; i<rows ; i++)
  1614.     (*array2D)[i] =  (*array2D)[i-1] + columns  ;
  1616.   return rows*columns*sizeof(int);
  1617. }
  1620. /*!
  1621.  ************************************************************************
  1622.  * brief
  1623.  *   Allocate 3D memory array -> unsigned char array3D[frames][rows][columns]
  1624.  * param frames
  1625.  *    number of frames
  1626.  * param rows
  1627.  *    number of rows
  1628.  * param columns
  1629.  *    number of columns
  1630.  * par Output:
  1631.  *    byte ****array3D allocated memory
  1632.  * return memory size in bytes
  1633.  ************************************************************************
  1634.  */
  1635. // same change as in get_mem2Dint
  1636. int get_mem3D(byte ****array3D, int frames, int rows, int columns)
  1637. {
  1638.   int  j;
  1640.   if(((*array3D) = (byte***)calloc(frames,sizeof(byte**))) == NULL)
  1641.     no_mem_exit("get_mem3D: array3D");
  1643.   for(j=0;j<frames;j++)
  1644.     get_mem2D( (*array3D)+j, rows, columns ) ;
  1646.   return frames*rows*columns;
  1647. }
  1649. /*!
  1650.  ************************************************************************
  1651.  * brief
  1652.  *    Allocate 3D memory array -> int array3D[frames][rows][columns]
  1653.  * param frames
  1654.  *    number of frames
  1655.  * param rows
  1656.  *    number of rows
  1657.  * param columns
  1658.  *    number of columns
  1659.  * par Output:
  1660.  *    int ****array3D allocated memory
  1661.  * return memory size in bytes
  1662.  ************************************************************************
  1663.  */
  1664. // same change as in get_mem2Dint
  1665. int get_mem3Dint(int ****array3D, int frames, int rows, int columns)
  1666. {
  1667.   int  j;
  1669.   if(((*array3D) = (int***)calloc(frames,sizeof(int**))) == NULL)
  1670.     no_mem_exit("get_mem3Dint: array3D");
  1672.   for(j=0;j<frames;j++)
  1673.     get_mem2Dint( (*array3D)+j, rows, columns ) ;
  1676.   return frames*rows*columns*sizeof(int);
  1677. }
  1678. /*!
  1679.  ************************************************************************
  1680.  * brief
  1681.  *    Exit program if memory allocation failed (using error())
  1682.  * param where
  1683.  *    string indicating which memory allocation failed
  1684.  ************************************************************************
  1685.  */
  1686. void no_mem_exit(char *where)
  1687. {
  1688.    snprintf(errortext, ET_SIZE, "Could not allocate memory: %s",where);
  1689.    error (errortext, 100);
  1690. }