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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
image.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：61k
源码类别：

Audio

开发平台：

Visual C++

image.c：源码内容
  2. /*!
  3.  ***********************************************************************
  4.  * file image.c
  5.  *
  6.  * brief
  7.  *    Decode a Slice
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *    - Inge Lille-Langoy               <inge.lille-langoy@telenor.com>
  12.  *    - Rickard Sjoberg                 <rickard.sjoberg@era.ericsson.se>
  13.  *    - Jani Lainema                    <jani.lainema@nokia.com>
  14.  *    - Sebastian Purreiter             <sebastian.purreiter@mch.siemens.de>
  15.  *    - Byeong-Moon Jeon                <jeonbm@lge.com>
  16.  *    - Thomas Wedi                     <wedi@tnt.uni-hannover.de>
  17.  *    - Gabi Blaettermann
  18.  *    - Ye-Kui Wang                     <wyk@ieee.org>
  19.  *    - Antti Hallapuro                 <antti.hallapuro@nokia.com>
  20.  *    - Alexis Tourapis                 <alexismt@ieee.org>
  21.  *    - Jill Boyce                      <jill.boyce@thomson.net>
  22.  *    - Saurav K Bandyopadhyay          <saurav@ieee.org>
  23.  *    - Zhenyu Wu                       <Zhenyu.Wu@thomson.net
  24.  *    - Purvin Pandit                   <Purvin.Pandit@thomson.net>
  25.  *
  26.  ***********************************************************************
  27.  */
  29. #include "contributors.h"
  31. #include <math.h>
  32. #include <limits.h>
  34. #include "global.h"
  35. #include "image.h"
  36. #include "fmo.h"
  37. #include "nalu.h"
  38. #include "parset.h"
  39. #include "header.h"
  41. #include "annexb.h"
  42. #include "rtp.h"
  43. #include "sei.h"
  44. #include "output.h"
  45. #include "mb_access.h"
  46. #include "memalloc.h"
  47. #include "macroblock.h"
  49. #include "loopfilter.h"
  51. #include "biaridecod.h"
  52. #include "context_ini.h"
  53. #include "cabac.h"
  54. #include "vlc.h"
  55. #include "quant.h"
  57. #include "errorconcealment.h"
  58. #include "erc_api.h"
  60. extern objectBuffer_t *erc_object_list;
  61. extern ercVariables_t *erc_errorVar;
  62. extern frame erc_recfr;
  63. extern int erc_mvperMB;
  64. extern ImageParameters *erc_img;
  66. //extern FILE *p_out2;
  68. extern StorablePicture **listX[6];
  69. extern ColocatedParams *Co_located;
  71. extern StorablePicture *no_reference_picture;
  72. int non_conforming_stream;
  74. StorablePicture *dec_picture;
  75. StorablePicture *dec_picture_JV[MAX_PLANE];  //!< dec_picture to be used during 4:4:4 independent mode decoding
  77. OldSliceParams old_slice;
  79. void MbAffPostProc(void)
  80. {
  81.   imgpel temp[32][16];
  83.   imgpel ** imgY  = dec_picture->imgY;
  84.   imgpel ***imgUV = dec_picture->imgUV;
  86.   int i, y, x0, y0, uv;
  87.   for (i=0; i<(int)dec_picture->PicSizeInMbs; i+=2)
  88.   {
  89.     if (dec_picture->motion.mb_field[i])
  90.     {
  91.       get_mb_pos(i, img->mb_size[IS_LUMA], &x0, &y0);
  92.       for (y=0; y<(2*MB_BLOCK_SIZE);y++)
  93.         memcpy(temp[y], &imgY[y0+y][x0], MB_BLOCK_SIZE * sizeof(imgpel));
  95.       for (y=0; y<MB_BLOCK_SIZE;y++)
  96.       {
  97.          memcpy(&imgY[y0+(2*y  )][x0], temp[y              ], MB_BLOCK_SIZE * sizeof(imgpel));
  98.          memcpy(&imgY[y0+(2*y+1)][x0], temp[y+MB_BLOCK_SIZE], MB_BLOCK_SIZE * sizeof(imgpel));
  99.       }
  100.        
  102.       if (dec_picture->chroma_format_idc != YUV400)
  103.       {
  104.         x0 = x0 / (16/img->mb_cr_size_x);
  105.         y0 = y0 / (16/img->mb_cr_size_y);
  107.         for (uv=0; uv<2; uv++)
  108.         {
  109.           for (y=0; y<(2*img->mb_cr_size_y);y++)
  110.             memcpy(temp[y], &imgUV[uv][y0+y][x0], img->mb_cr_size_x * sizeof(imgpel));
  112.           for (y=0; y<img->mb_cr_size_y;y++)
  113.           {
  114.             memcpy(&imgUV[uv][y0+(2*y  )][x0], temp[y                  ], img->mb_cr_size_x * sizeof(imgpel));
  115.             memcpy(&imgUV[uv][y0+(2*y+1)][x0], temp[y+img->mb_cr_size_y], img->mb_cr_size_x * sizeof(imgpel));
  116.           }
  117.         }
  118.       }
  119.     }
  120.   }
  121. }
  123. /*!
  124.  ***********************************************************************
  125.  * brief
  126.  *    decodes one I- or P-frame
  127.  *
  128.  ***********************************************************************
  129.  */
  131. int decode_one_frame(ImageParameters *img, struct inp_par *inp, struct snr_par *snr)
  132. {
  133.   int current_header;
  134.   Slice *currSlice = img->currentSlice;
  135.   int i;
  137.   img->current_slice_nr = 0;
  138.   img->current_mb_nr = -4711;     // initialized to an impossible value for debugging -- correct value is taken from slice header
  139.   currSlice->next_header = -8888; // initialized to an impossible value for debugging -- correct value is taken from slice header
  140.   img->num_dec_mb = 0;
  141.   img->newframe = 1;
  143.   while ((currSlice->next_header != EOS && currSlice->next_header != SOP))
  144.   {
  145.     current_header = read_new_slice();
  147.     // error tracking of primary and redundant slices.
  148.     Error_tracking();
  150.     // If primary and redundant are received and primary is correct, discard the redundant
  151.     // else, primary slice will be replaced with redundant slice.
  152.     if(img->frame_num == previous_frame_num && img->redundant_pic_cnt !=0
  153.       && Is_primary_correct !=0 && current_header != EOS)
  154.     {
  155.       continue;
  156.     }
  158.     // update reference flags and set current ref_flag
  159.     if(!(img->redundant_pic_cnt != 0 && previous_frame_num == img->frame_num))
  160.     {
  161.       for(i=16;i>0;i--)
  162.       {
  163.         ref_flag[i] = ref_flag[i-1];
  164.       }
  165.     }
  166.     ref_flag[0] = img->redundant_pic_cnt==0 ? Is_primary_correct : Is_redundant_correct;
  167.     previous_frame_num = img->frame_num;
  169.     if (current_header == EOS)
  170.     {
  171.       exit_picture();
  172.       return EOS;
  173.     }
  175.     decode_slice(img, inp, current_header);
  177.     img->newframe = 0;
  178.     img->current_slice_nr++;
  179.   }
  181.   exit_picture();
  183.   return (SOP);
  184. }
  187. /*!
  188.  ************************************************************************
  189.  * brief
  190.  *    Convert file read buffer to source picture structure
  191.  * param imgX
  192.  *    Pointer to image plane
  193.  * param buf
  194.  *    Buffer for file output
  195.  * param size_x
  196.  *    horizontal image size in pixel
  197.  * param size_y
  198.  *    vertical image size in pixel
  199.  * param symbol_size_in_bytes
  200.  *    number of bytes used per pel
  201.  ************************************************************************
  202.  */
  203. void buf2img (imgpel** imgX, unsigned char* buf, int size_x, int size_y, int symbol_size_in_bytes)
  204. {
  205.   int i,j;
  207.   unsigned short tmp16, ui16;
  208.   unsigned long  tmp32, ui32;
  210.   if (symbol_size_in_bytes> sizeof(imgpel))
  211.   {
  212.     error ("Source picture has higher bit depth than imgpel data type. nPlease recompile with larger data type for imgpel.", 500);
  213.   }
  215.   if (( sizeof(char) == sizeof (imgpel)) && ( sizeof(char) == symbol_size_in_bytes))
  216.   {
  217.     // imgpel == pixel_in_file == 1 byte -> simple copy
  218.     memcpy(&imgX[0][0], buf, size_x * size_y);
  219.     //for(j=0;j<size_y;j++)
  220.       //memcpy(&imgX[j][0], buf+j*size_x, size_x);
  221.   }
  222.   else
  223.   {
  224.     // sizeof (imgpel) > sizeof(char)
  225.     if (testEndian())
  226.     {
  227.       // big endian
  228.       switch (symbol_size_in_bytes)
  229.       {
  230.       case 1:
  231.         {
  232.           for(j=0;j<size_y;j++)
  233.             for(i=0;i<size_x;i++)
  234.             {
  235.               imgX[j][i]= buf[i+j*size_x];
  236.             }
  237.           break;
  238.         }
  239.       case 2:
  240.         {
  241.           for(j=0;j<size_y;j++)
  242.             for(i=0;i<size_x;i++)
  243.             {
  244.               memcpy(&tmp16, buf+((i+j*size_x)*2), 2);
  245.               ui16  = (unsigned short) ((tmp16 >> 8) | ((tmp16&0xFF)<<8));
  246.               imgX[j][i] = (imgpel) ui16;
  247.             }
  248.           break;
  249.         }
  250.       case 4:
  251.         {
  252.           for(j=0;j<size_y;j++)
  253.             for(i=0;i<size_x;i++)
  254.             {
  255.               memcpy(&tmp32, buf+((i+j*size_x)*4), 4);
  256.               ui32  = ((tmp32&0xFF00)<<8) | ((tmp32&0xFF)<<24) | ((tmp32&0xFF0000)>>8) | ((tmp32&0xFF000000)>>24);
  257.               imgX[j][i] = (imgpel) ui32;
  258.             }
  259.         }
  260.       default:
  261.         {
  262.            error ("reading only from formats of 8, 16 or 32 bit allowed on big endian architecture", 500);
  263.            break;
  264.         }
  265.       }
  267.     }
  268.     else
  269.     {
  270.       // little endian
  271.       if (symbol_size_in_bytes == 1)
  272.       {
  273.         for (j=0; j < size_y; j++)
  274.         {
  275.           for (i=0; i < size_x; i++)
  276.           {
  277.             imgX[j][i]=*(buf++);
  278.           }
  279.         }
  280.       }
  281.       else
  282.       {
  283.         for (j=0; j < size_y; j++)
  284.         {
  285.           int jpos = j*size_x;
  286.           for (i=0; i < size_x; i++)
  287.           {
  288.             imgX[j][i]=0;
  289.             memcpy(&(imgX[j][i]), buf +((i+jpos)*symbol_size_in_bytes), symbol_size_in_bytes);
  290.           }
  291.         }
  292.       }
  294.     }
  295.   }
  296. }
  299. /*!
  300.  ************************************************************************
  301.  * brief
  302.  *    Calculate the value of frame_no
  303.  ************************************************************************
  304. */
  305. void calculate_frame_no(StorablePicture *p)
  306. {
  307.   // calculate frame number
  308.   int  psnrPOC = active_sps->mb_adaptive_frame_field_flag ? p->poc /(params->poc_scale) : p->poc/(params->poc_scale);
  310.   if (psnrPOC==0)// && img->psnr_number)
  311.     img->idr_psnr_number = img->number*img->ref_poc_gap/(params->poc_scale);
  313.   img->psnr_number=imax(img->psnr_number,img->idr_psnr_number+psnrPOC);
  315.   frame_no = img->idr_psnr_number + psnrPOC;
  316. }
  319. /*!
  320. ************************************************************************
  321. * brief
  322. *    Find PSNR for all three components.Compare decoded frame with
  323. *    the original sequence. Read inp->jumpd frames to reflect frame skipping.
  324. ************************************************************************
  325. */
  326. void find_snr(
  327.               struct snr_par  *snr,   //!< pointer to snr parameters
  328.               StorablePicture *p,     //!< picture to be compared
  329.               int p_ref)              //!< open reference YUV file
  330. {
  331.   static const int SubWidthC  [4]= { 1, 2, 2, 1};
  332.   static const int SubHeightC [4]= { 1, 2, 1, 1};
  333.   int crop_left, crop_right, crop_top, crop_bottom;
  335.   int i,j, k;
  336.   int64 diff_comp[3] = {0};
  337.   int64  status;
  338.   int symbol_size_in_bytes = img->pic_unit_bitsize_on_disk/8;
  339.   int comp_size_x[3], comp_size_y[3];
  340.   int64 framesize_in_bytes;
  342.   unsigned int max_pix_value_sqd[3] = {iabs2(img->max_imgpel_value_comp[0]),  iabs2(img->max_imgpel_value_comp[1]), iabs2(img->max_imgpel_value_comp[2])};
  344.   Boolean rgb_output = (Boolean) (active_sps->vui_seq_parameters.matrix_coefficients==0);
  345.   unsigned char *buf;
  346.   imgpel **cur_ref[3]  = {imgY_ref, p->chroma_format_idc != YUV400 ? imgUV_ref[0] : NULL, p->chroma_format_idc != YUV400 ? imgUV_ref[1] : NULL};
  347.   imgpel **cur_comp[3] = {p->imgY,  p->chroma_format_idc != YUV400 ? p->imgUV[0]  : NULL , p->chroma_format_idc!= YUV400 ? p->imgUV[1]  : NULL}; 
  348.   // picture error concealment
  349.   char yuv_types[4][6]= {"4:0:0","4:2:0","4:2:2","4:4:4"};
  351.   // cropping for luma
  352.   if (p->frame_cropping_flag)
  353.   {
  354.     crop_left   = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_left_offset;
  355.     crop_right  = SubWidthC[p->chroma_format_idc] * p->frame_cropping_rect_right_offset;
  356.     crop_top    = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) *  p->frame_cropping_rect_top_offset;
  357.     crop_bottom = SubHeightC[p->chroma_format_idc]*( 2 - p->frame_mbs_only_flag ) *  p->frame_cropping_rect_bottom_offset;
  358.   }
  359.   else
  360.   {
  361.     crop_left = crop_right = crop_top = crop_bottom = 0;
  362.   }
  364.   comp_size_x[0] = p->size_x - crop_left - crop_right;
  365.   comp_size_y[0] = p->size_y - crop_top - crop_bottom;
  367.   // cropping for chroma
  368.   if (p->frame_cropping_flag)
  369.   {
  370.     crop_left   = p->frame_cropping_rect_left_offset;
  371.     crop_right  = p->frame_cropping_rect_right_offset;
  372.     crop_top    = ( 2 - p->frame_mbs_only_flag ) *  p->frame_cropping_rect_top_offset;
  373.     crop_bottom = ( 2 - p->frame_mbs_only_flag ) *   p->frame_cropping_rect_bottom_offset;
  374.   }
  375.   else
  376.   {
  377.     crop_left = crop_right = crop_top = crop_bottom = 0;
  378.   }
  380.   if ((p->chroma_format_idc==YUV400) && params->write_uv)
  381.   {
  382.     comp_size_x[1] = comp_size_x[2] = (p->size_x >> 1);
  383.     comp_size_y[1] = comp_size_y[2] = (p->size_y >> 1);
  384.   }
  385.   else
  386.   {
  387.     // These could be computed once and attached to the StorablePicture structure
  388.     comp_size_x[1] = comp_size_x[2] = (p->size_x_cr - crop_left - crop_right); 
  389.     comp_size_y[1] = comp_size_y[2] = (p->size_y_cr - crop_top  - crop_bottom);
  390.   }
  392.   framesize_in_bytes = (((int64) comp_size_x[0] * comp_size_y[0]) + ((int64) comp_size_x[1] * comp_size_y[1] ) * 2) * symbol_size_in_bytes;
  394.   // KS: this buffer should actually be allocated only once, but this is still much faster than the previous version
  395.   buf = malloc ( comp_size_x[0] * comp_size_y[0] * symbol_size_in_bytes );
  397.   if (NULL == buf)
  398.   {
  399.     no_mem_exit("find_snr: buf");
  400.   }
  402.   status = lseek (p_ref, framesize_in_bytes * frame_no, SEEK_SET);
  403.   if (status == -1)
  404.   {
  405.     fprintf(stderr, "Error in seeking frame number: %dn", frame_no);
  406.     free (buf);
  407.     return;
  408.   }
  410.   if(rgb_output)
  411.     lseek (p_ref, framesize_in_bytes/3, SEEK_CUR);
  413.   for (k = 0; k < ((p->chroma_format_idc != YUV400) ? 3 : 1); k++)
  414.   {
  416.     if(rgb_output && k == 2)
  417.       lseek (p_ref, -framesize_in_bytes, SEEK_CUR);
  419.     read(p_ref, buf, comp_size_x[k] * comp_size_y[k] * symbol_size_in_bytes);
  420.     buf2img(cur_ref[k], buf, comp_size_x[k], comp_size_y[k], symbol_size_in_bytes);
  422.     for (j=0; j < comp_size_y[k]; ++j)
  423.     {
  424.       for (i=0; i < comp_size_x[k]; ++i)
  425.       {
  426.         diff_comp[k] += iabs2(cur_comp[k][j][i] - cur_ref[k][j][i]);
  427.       }
  428.     }
  430.     // Collecting SNR statistics
  431.     snr->snr[k] = psnr( max_pix_value_sqd[k], comp_size_x[k] * comp_size_y[k], (float) diff_comp[k]);   
  433.     if (img->number == 0) // first
  434.     {
  435.       snr->snra[k] = snr->snr[k];                                                        // keep luma snr for first frame
  436.     }
  437.     else
  438.     {
  439.       snr->snra[k] = (float)(snr->snra[k]*(snr->frame_ctr)+snr->snr[k])/(snr->frame_ctr + 1); // average snr chroma for all frames
  440.     }
  441.   }
  443.    if(rgb_output)
  444.      lseek (p_ref, framesize_in_bytes*2/3, SEEK_CUR);
  446.   free (buf);
  448.   // picture error concealment
  449.   if(p->concealed_pic)
  450.   {
  451.       fprintf(stdout,"%04d(P)  %8d %5d %5d %7.4f %7.4f %7.4f  %s %5dn",
  452.           frame_no, p->frame_poc, p->pic_num, p->qp,
  453.           snr->snr[0], snr->snr[1], snr->snr[2], yuv_types[p->chroma_format_idc], 0);
  454.   }
  455. }
  458. void reorder_lists(int currSliceType, Slice * currSlice)
  459. {
  461.   if ((currSliceType != I_SLICE)&&(currSliceType != SI_SLICE))
  462.   {
  463.     if (currSlice->ref_pic_list_reordering_flag_l0)
  464.     {
  465.       reorder_ref_pic_list(listX[0], &listXsize[0],
  466.                            img->num_ref_idx_l0_active - 1,
  467.                            currSlice->reordering_of_pic_nums_idc_l0,
  468.                            currSlice->abs_diff_pic_num_minus1_l0,
  469.                            currSlice->long_term_pic_idx_l0);
  470.     }
  471.     if (no_reference_picture == listX[0][img->num_ref_idx_l0_active-1])
  472.     {
  473.       if (non_conforming_stream)
  474.         printf("RefPicList0[ num_ref_idx_l0_active_minus1 ] is equal to 'no reference picture'n");
  475.       else
  476.         error("RefPicList0[ num_ref_idx_l0_active_minus1 ] is equal to 'no reference picture', invalid bitstream",500);
  477.     }
  478.     // that's a definition
  479.     listXsize[0] = img->num_ref_idx_l0_active;
  480.   }
  481.   if (currSliceType == B_SLICE)
  482.   {
  483.     if (currSlice->ref_pic_list_reordering_flag_l1)
  484.     {
  485.       reorder_ref_pic_list(listX[1], &listXsize[1],
  486.                            img->num_ref_idx_l1_active - 1,
  487.                            currSlice->reordering_of_pic_nums_idc_l1,
  488.                            currSlice->abs_diff_pic_num_minus1_l1,
  489.                            currSlice->long_term_pic_idx_l1);
  490.     }
  491.     if (no_reference_picture == listX[1][img->num_ref_idx_l1_active-1])
  492.     {
  493.       if (non_conforming_stream)
  494.         printf("RefPicList1[ num_ref_idx_l1_active_minus1 ] is equal to 'no reference picture'n");
  495.       else
  496.         error("RefPicList1[ num_ref_idx_l1_active_minus1 ] is equal to 'no reference picture', invalid bitstream",500);
  497.     }
  498.     // that's a definition
  499.     listXsize[1] = img->num_ref_idx_l1_active;
  500.   }
  502.   free_ref_pic_list_reordering_buffer(currSlice);
  503. }
  506. /*!
  507.  ************************************************************************
  508.  * brief
  509.  *    initialize ref_pic_num array
  510.  ************************************************************************
  511.  */
  512. void set_ref_pic_num(void)
  513. {
  514.   int i,j;
  516.   int slice_id=img->current_slice_nr;
  518.   for (i=0;i<listXsize[LIST_0];i++)
  519.   {
  520.     dec_picture->ref_pic_num        [slice_id][LIST_0][i] = listX[LIST_0][i]->poc * 2 + ((listX[LIST_0][i]->structure==BOTTOM_FIELD)?1:0) ;
  521.     dec_picture->frm_ref_pic_num    [slice_id][LIST_0][i] = listX[LIST_0][i]->frame_poc * 2;
  522.     dec_picture->top_ref_pic_num    [slice_id][LIST_0][i] = listX[LIST_0][i]->top_poc * 2;
  523.     dec_picture->bottom_ref_pic_num [slice_id][LIST_0][i] = listX[LIST_0][i]->bottom_poc * 2 + 1;
  524.     //printf("POCS %d %d %d %d ",listX[LIST_0][i]->frame_poc,listX[LIST_0][i]->bottom_poc,listX[LIST_0][i]->top_poc,listX[LIST_0][i]->poc);
  525.     //printf("refid %d %d %d %dn",(int) dec_picture->frm_ref_pic_num[LIST_0][i],(int) dec_picture->top_ref_pic_num[LIST_0][i],(int) dec_picture->bottom_ref_pic_num[LIST_0][i],(int) dec_picture->ref_pic_num[LIST_0][i]);
  526.   }
  528.   for (i=0;i<listXsize[LIST_1];i++)
  529.   {
  530.     dec_picture->ref_pic_num        [slice_id][LIST_1][i] = listX[LIST_1][i]->poc  *2 + ((listX[LIST_1][i]->structure==BOTTOM_FIELD)?1:0);
  531.     dec_picture->frm_ref_pic_num    [slice_id][LIST_1][i] = listX[LIST_1][i]->frame_poc * 2;
  532.     dec_picture->top_ref_pic_num    [slice_id][LIST_1][i] = listX[LIST_1][i]->top_poc * 2;
  533.     dec_picture->bottom_ref_pic_num [slice_id][LIST_1][i] = listX[LIST_1][i]->bottom_poc * 2 + 1;
  534.   }
  536.   if (!active_sps->frame_mbs_only_flag)
  537.   {
  538.     if (img->structure==FRAME)
  539.     {
  540.       for (j=2;j<6;j++)
  541.       {
  542.         for (i=0;i<listXsize[j];i++)
  543.         {
  544.           dec_picture->ref_pic_num        [slice_id][j][i] = listX[j][i]->poc * 2 + ((listX[j][i]->structure==BOTTOM_FIELD)?1:0);
  545.           dec_picture->frm_ref_pic_num    [slice_id][j][i] = listX[j][i]->frame_poc * 2 ;
  546.           dec_picture->top_ref_pic_num    [slice_id][j][i] = listX[j][i]->top_poc * 2 ;
  547.           dec_picture->bottom_ref_pic_num [slice_id][j][i] = listX[j][i]->bottom_poc * 2 + 1;
  548.         }
  549.       }
  550.     }
  551.   }
  552. }
  555. /*!
  556.  ************************************************************************
  557.  * brief
  558.  *    Reads new slice from bit_stream
  559.  ************************************************************************
  560.  */
  561. int read_new_slice(void)
  562. {
  563.   NALU_t *nalu = AllocNALU(MAX_CODED_FRAME_SIZE);
  564.   int current_header = 0;
  565.   int BitsUsedByHeader;
  566.   Slice *currSlice = img->currentSlice;
  567.   Bitstream *currStream;
  569.   int slice_id_a, slice_id_b, slice_id_c;
  570.   int redundant_pic_cnt_b, redundant_pic_cnt_c;
  571.   long ftell_position;
  572.   
  573.   while (1)
  574.   {
  575.     ftell_position = ftell(bits);
  577.     if (0 == read_next_nalu(bits, nalu))
  578.       return EOS;
  580.     switch (nalu->nal_unit_type)
  581.     {
  582.       case NALU_TYPE_SLICE:
  583.       case NALU_TYPE_IDR:
  585.         if (img->recovery_point || nalu->nal_unit_type == NALU_TYPE_IDR)
  586.         {
  587.           if (img->recovery_point_found == 0)
  588.           {
  589.             if (nalu->nal_unit_type != NALU_TYPE_IDR)
  590.             {
  591.               printf("Warning: Decoding does not start with an IDR picture.n");
  592.               non_conforming_stream = 1;
  593.             }
  594.             else
  595.               non_conforming_stream = 0;
  596.           }
  597.           img->recovery_point_found = 1;
  598.         }
  600.         if (img->recovery_point_found == 0)
  601.           break;
  603.         img->idr_flag = (nalu->nal_unit_type == NALU_TYPE_IDR);
  604.         img->nal_reference_idc = nalu->nal_reference_idc;
  605.         currSlice->dp_mode = PAR_DP_1;
  606.         currSlice->max_part_nr = 1;
  607.         currSlice->ei_flag = 0;
  608.         currStream = currSlice->partArr[0].bitstream;
  609.         currStream->ei_flag = 0;
  610.         currStream->frame_bitoffset = currStream->read_len = 0;
  611.         memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
  612.         currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
  614.         // Some syntax of the Slice Header depends on the parameter set, which depends on
  615.         // the parameter set ID of the SLice header.  Hence, read the pic_parameter_set_id
  616.         // of the slice header first, then setup the active parameter sets, and then read
  617.         // the rest of the slice header
  618.         BitsUsedByHeader = FirstPartOfSliceHeader();
  619.         UseParameterSet (currSlice->pic_parameter_set_id);
  620.         BitsUsedByHeader+= RestOfSliceHeader ();
  622.         FmoInit (active_pps, active_sps);
  624.         AssignQuantParam (active_pps, active_sps);
  626.         // if primary slice is replaced with redundant slice, set the correct image type
  627.         if(img->redundant_pic_cnt && Is_primary_correct==0 && Is_redundant_correct)
  628.         {
  629.           dec_picture->slice_type=img->type;
  630.         }
  632.         if(is_new_picture())
  633.         {
  634.           init_picture(img, params);
  636.           current_header = SOP;
  637.           //check zero_byte if it is also the first NAL unit in the access unit
  638.           CheckZeroByteVCL(nalu);
  639.         }
  640.         else
  641.           current_header = SOS;
  643.         init_lists(img->type, img->currentSlice->structure);
  644.         reorder_lists (img->type, img->currentSlice);
  646.         if (img->structure==FRAME)
  647.         {
  648.           init_mbaff_lists();
  649.         }
  651.         // From here on, active_sps, active_pps and the slice header are valid
  652.         if (img->MbaffFrameFlag)
  653.           img->current_mb_nr = currSlice->start_mb_nr << 1;
  654.         else
  655.           img->current_mb_nr = currSlice->start_mb_nr;
  657.         if (active_pps->entropy_coding_mode_flag)
  658.         {
  659.           int ByteStartPosition = currStream->frame_bitoffset/8;
  660.           if (currStream->frame_bitoffset%8 != 0)
  661.           {
  662.             ByteStartPosition++;
  663.           }
  664.           arideco_start_decoding (&currSlice->partArr[0].de_cabac, currStream->streamBuffer, ByteStartPosition, &currStream->read_len);
  665.         }
  666. // printf ("read_new_slice: returning %sn", current_header == SOP?"SOP":"SOS");
  667.         FreeNALU(nalu);
  668.         img->recovery_point = 0;
  669.         return current_header;
  670.         break;
  671.       case NALU_TYPE_DPA:
  672.         // read DP_A
  673.         currSlice->dpB_NotPresent =1; 
  674.         currSlice->dpC_NotPresent =1; 
  676.         img->idr_flag          = FALSE;
  677.         img->nal_reference_idc = nalu->nal_reference_idc;
  678.         currSlice->dp_mode     = PAR_DP_3;
  679.         currSlice->max_part_nr = 3;
  680.         currSlice->ei_flag     = 0;
  681.         currStream             = currSlice->partArr[0].bitstream;
  682.         currStream->ei_flag    = 0;
  683.         currStream->frame_bitoffset = currStream->read_len = 0;
  684.         memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
  685.         currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
  687.         BitsUsedByHeader     = FirstPartOfSliceHeader();
  688.         UseParameterSet (currSlice->pic_parameter_set_id);
  689.         BitsUsedByHeader    += RestOfSliceHeader ();
  691.         FmoInit (active_pps, active_sps);
  693.         if(is_new_picture())
  694.         {
  695.           init_picture(img, params);
  696.           current_header = SOP;
  697.           CheckZeroByteVCL(nalu);
  698.         }
  699.         else
  700.           current_header = SOS;
  702.         init_lists(img->type, img->currentSlice->structure);
  703.         reorder_lists (img->type, img->currentSlice);
  705.         if (img->structure==FRAME)
  706.         {
  707.           init_mbaff_lists();
  708.         }
  710.         // From here on, active_sps, active_pps and the slice header are valid
  711.         if (img->MbaffFrameFlag)
  712.           img->current_mb_nr = currSlice->start_mb_nr << 1;
  713.         else
  714.           img->current_mb_nr = currSlice->start_mb_nr;
  716.         // Now I need to read the slice ID, which depends on the value of
  717.         // redundant_pic_cnt_present_flag
  719.         slice_id_a  = ue_v("NALU: DP_A slice_id", currStream);
  721.         if (active_pps->entropy_coding_mode_flag)
  722.           error ("received data partition with CABAC, this is not allowed", 500);
  724.         // continue with reading next DP
  725.         ftell_position = ftell(bits);
  727.         if (0 == read_next_nalu(bits, nalu))
  728.           return current_header;
  729.         
  730.         if ( NALU_TYPE_DPB == nalu->nal_unit_type)
  731.         {
  732.           // we got a DPB
  733.           currStream             = currSlice->partArr[1].bitstream;
  734.           currStream->ei_flag    = 0;
  735.           currStream->frame_bitoffset = currStream->read_len = 0;
  737.           memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
  738.           currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
  740.           slice_id_b  = ue_v("NALU: DP_B slice_id", currStream);
  742.           currSlice->dpB_NotPresent = 0; 
  744.           if ((slice_id_b != slice_id_a) || (nalu->lost_packets))
  745.           {
  746.             printf ("Waning: got a data partition B which does not match DP_A (DP loss!)n");
  747.             currSlice->dpB_NotPresent =1; 
  748.             currSlice->dpC_NotPresent =1; 
  749.           }
  750.           else
  751.           {
  752.             if (active_pps->redundant_pic_cnt_present_flag)
  753.               redundant_pic_cnt_b = ue_v("NALU: DP_B redudant_pic_cnt", currStream);
  754.             else
  755.               redundant_pic_cnt_b = 0;
  757.             // we're finished with DP_B, so let's continue with next DP
  758.             ftell_position = ftell(bits);
  760.             if (0 == read_next_nalu(bits, nalu))
  761.               return current_header;
  762.           }
  763.         }
  764.         else
  765.         {
  766.           currSlice->dpB_NotPresent =1; 
  767.         }
  769.         // check if we got DP_C
  770.         if ( NALU_TYPE_DPC == nalu->nal_unit_type)
  771.         {
  772.           currStream             = currSlice->partArr[2].bitstream;
  773.           currStream->ei_flag    = 0;
  774.           currStream->frame_bitoffset = currStream->read_len = 0;
  776.           memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
  777.           currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
  779.           currSlice->dpC_NotPresent = 0;
  781.           slice_id_c  = ue_v("NALU: DP_C slice_id", currStream);
  782.           if ((slice_id_c != slice_id_a)|| (nalu->lost_packets))
  783.           {
  784.             printf ("Warning: got a data partition C which does not match DP_A(DP loss!)n");
  785.             //currSlice->dpB_NotPresent =1;
  786.             currSlice->dpC_NotPresent =1;
  787.           }
  789.           if (active_pps->redundant_pic_cnt_present_flag)
  790.             redundant_pic_cnt_c = ue_v("NALU:SLICE_C redudand_pic_cnt", currStream);
  791.           else
  792.             redundant_pic_cnt_c = 0;
  793.         }
  794.         else
  795.         {
  796.           currSlice->dpC_NotPresent =1;
  797.         }
  799.         // check if we read anything else than the expected partitions
  800.         if ((nalu->nal_unit_type != NALU_TYPE_DPB) && (nalu->nal_unit_type != NALU_TYPE_DPC))
  801.         {
  802.           // reset bitstream position and read again in next call
  803.           fseek(bits, ftell_position, SEEK_SET);
  804.         }
  806.         FreeNALU(nalu);
  807.         return current_header;
  809.         break;
  810.       case NALU_TYPE_DPB:
  811.         printf ("found data partition B without matching DP A, discardingn");
  812.         break;
  813.       case NALU_TYPE_DPC:
  814.         printf ("found data partition C without matching DP A, discardingn");
  815.         break;
  816.       case NALU_TYPE_SEI:
  817.         //printf ("read_new_slice: Found NALU_TYPE_SEI, len %dn", nalu->len);
  818.         InterpretSEIMessage(nalu->buf,nalu->len,img);
  819.         break;
  820.       case NALU_TYPE_PPS:
  821.         ProcessPPS(nalu);
  822.         break;
  823.       case NALU_TYPE_SPS:
  824.         ProcessSPS(nalu);
  825.         break;
  826.       case NALU_TYPE_AUD:
  827. //        printf ("read_new_slice: Found 'Access Unit Delimiter' NAL unit, len %d, ignoredn", nalu->len);
  828.         break;
  829.       case NALU_TYPE_EOSEQ:
  830. //        printf ("read_new_slice: Found 'End of Sequence' NAL unit, len %d, ignoredn", nalu->len);
  831.         break;
  832.       case NALU_TYPE_EOSTREAM:
  833. //        printf ("read_new_slice: Found 'End of Stream' NAL unit, len %d, ignoredn", nalu->len);
  834.         break;
  835.       case NALU_TYPE_FILL:
  836.         printf ("read_new_slice: Found NALU_TYPE_FILL, len %dn", (int) nalu->len);
  837.         printf ("Skipping these filling bits, proceeding w/ next NALUn");
  838.         break;
  839.       default:
  840.         printf ("Found NALU type %d, len %d undefined, ignore NALU, moving onn", (int) nalu->nal_unit_type, (int) nalu->len);
  841.         break;
  842.     }
  843.   }
  844.   FreeNALU(nalu);
  846.   return  current_header;
  847. }
  850. /*!
  851.  ************************************************************************
  852.  * brief
  853.  *    Initializes the parameters for a new picture
  854.  ************************************************************************
  855.  */
  856. void init_picture(ImageParameters *img, struct inp_par *inp)
  857. {
  858.   int i,j,k,l;
  859.   Slice *currSlice = img->currentSlice;
  860.   int nplane;
  862.   if (dec_picture)
  863.   {
  864.     // this may only happen on slice loss
  865.     exit_picture();
  866.   }
  867.   if (img->recovery_point)
  868.     img->recovery_frame_num = (img->frame_num + img->recovery_frame_cnt) % img->MaxFrameNum;
  870.   if (img->idr_flag)
  871.     img->recovery_frame_num = img->frame_num;
  873.   if (img->recovery_point == 0 &&
  874.     img->frame_num != img->pre_frame_num &&
  875.     img->frame_num != (img->pre_frame_num + 1) % img->MaxFrameNum)
  876.   {
  877.     if (active_sps->gaps_in_frame_num_value_allowed_flag == 0)
  878.     {
  879.       // picture error concealment
  880.       if(inp->conceal_mode !=0)
  881.       {
  882.         if((img->frame_num) < ((img->pre_frame_num + 1) % img->MaxFrameNum))
  883.         {
  884.           /* Conceal lost IDR frames and any frames immediately
  885.              following the IDR. Use frame copy for these since
  886.              lists cannot be formed correctly for motion copy*/
  887.           img->conceal_mode = 1;
  888.           img->IDR_concealment_flag = 1;
  889.           conceal_lost_frames(img);
  890.           //reset to original concealment mode for future drops
  891.           img->conceal_mode = inp->conceal_mode;
  892.         }
  893.         else
  894.         {
  895.           //reset to original concealment mode for future drops
  896.           img->conceal_mode = inp->conceal_mode;
  898.           img->IDR_concealment_flag = 0;
  899.           conceal_lost_frames(img);
  900.         }
  901.       }
  902.       else
  903.       {   /* Advanced Error Concealment would be called here to combat unintentional loss of pictures. */
  904.         error("An unintentional loss of pictures occurs! Exitn", 100);
  905.       }
  906.     }
  907.     if(img->conceal_mode == 0)
  908.       fill_frame_num_gap(img);
  909.   }
  911.   if(img->nal_reference_idc)
  912.   {
  913.     img->pre_frame_num = img->frame_num;
  914.   }
  916.   img->num_dec_mb = 0;
  918.   //calculate POC
  919.   decode_poc(img);
  921.   if (img->recovery_frame_num == img->frame_num &&
  922.     img->recovery_poc == 0x7fffffff)
  923.     img->recovery_poc = img->framepoc;
  925.   if(img->nal_reference_idc)
  926.     img->last_ref_pic_poc = img->framepoc;
  928.   //  dumppoc (img);
  930.   if (img->structure==FRAME ||img->structure==TOP_FIELD)
  931.   {
  932.     gettime (&(img->start_time));             // start time
  933.   }
  935.   dec_picture = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
  936.   dec_picture->top_poc=img->toppoc;
  937.   dec_picture->bottom_poc=img->bottompoc;
  938.   dec_picture->frame_poc=img->framepoc;
  939.   dec_picture->qp = img->qp;
  940.   dec_picture->slice_qp_delta = currSlice->slice_qp_delta;
  941.   dec_picture->chroma_qp_offset[0] = active_pps->chroma_qp_index_offset;
  942.   dec_picture->chroma_qp_offset[1] = active_pps->second_chroma_qp_index_offset;
  944.   // reset all variables of the error concealment instance before decoding of every frame.
  945.   // here the third parameter should, if perfectly, be equal to the number of slices per frame.
  946.   // using little value is ok, the code will allocate more memory if the slice number is larger
  947.   ercReset(erc_errorVar, img->PicSizeInMbs, img->PicSizeInMbs, dec_picture->size_x);
  948.   erc_mvperMB = 0;
  950.   switch (img->structure )
  951.   {
  952.   case TOP_FIELD:
  953.     {
  954.       dec_picture->poc=img->toppoc;
  955.       img->number *= 2;
  956.       break;
  957.     }
  958.   case BOTTOM_FIELD:
  959.     {
  960.       dec_picture->poc=img->bottompoc;
  961.       img->number = img->number * 2 + 1;
  962.       break;
  963.     }
  964.   case FRAME:
  965.     {
  966.       dec_picture->poc=img->framepoc;
  967.       break;
  968.     }
  969.   default:
  970.     error("img->structure not initialized", 235);
  971.   }
  973.   img->current_slice_nr=0;
  975.   if (img->type > SI_SLICE)
  976.   {
  977.     set_ec_flag(SE_PTYPE);
  978.     img->type = P_SLICE;  // concealed element
  979.   }
  981.   // CAVLC init
  982.   if (active_pps->entropy_coding_mode_flag == UVLC)
  983.   {
  984.     for (i=0;i < (int)img->PicSizeInMbs; i++)    
  985.       for (j = 0; j < 3; j++)
  986.         for (l = 0; l < 4; l++)
  987.           for (k = 0; k < 4;k++)
  988.             img->nz_coeff[i][j][l][k]=-1;  // CAVLC
  989.   }
  991.   if(active_pps->constrained_intra_pred_flag)
  992.   {
  993.     for (i=0; i<(int)img->PicSizeInMbs; i++)
  994.     {
  995.       img->intra_block[i] = 1;
  996.     }
  997.   }
  999.   // Set the slice_nr member of each MB to -1, to ensure correct when packet loss occurs
  1000.   // TO set Macroblock Map (mark all MBs as 'have to be concealed')
  1001.   if( IS_INDEPENDENT(img) )
  1002.   {
  1003.     for( nplane=0; nplane<MAX_PLANE; nplane++ )
  1004.     {      
  1005.       for(i=0; i<(int)img->PicSizeInMbs; i++)
  1006.       {
  1007.         img->mb_data_JV[nplane][i].slice_nr = -1; 
  1008.         img->mb_data_JV[nplane][i].ei_flag = 1;
  1009.         img->mb_data_JV[nplane][i].dpl_flag = 0;
  1010.       }
  1011.     }
  1012.   }
  1013.   else
  1014.   {
  1015.     for(i=0; i<(int)img->PicSizeInMbs; i++)
  1016.     {
  1017.       img->mb_data[i].slice_nr = -1; 
  1018.       img->mb_data[i].ei_flag = 1;
  1019.       img->mb_data[i].dpl_flag = 0;
  1020.     }
  1021.   }
  1023.   img->mb_y = img->mb_x = 0;
  1024.   img->block_y_aff = img->block_y = img->pix_y = img->pix_c_y = 0; // define vertical positions
  1025.   img->block_x = img->pix_x = img->pix_c_x = 0; // define horizontal positions
  1027.   dec_picture->slice_type = img->type;
  1028.   dec_picture->used_for_reference = (img->nal_reference_idc != 0);
  1029.   dec_picture->idr_flag = img->idr_flag;
  1030.   dec_picture->no_output_of_prior_pics_flag = img->no_output_of_prior_pics_flag;
  1031.   dec_picture->long_term_reference_flag = img->long_term_reference_flag;
  1032.   dec_picture->adaptive_ref_pic_buffering_flag = img->adaptive_ref_pic_buffering_flag;
  1034.   dec_picture->dec_ref_pic_marking_buffer = img->dec_ref_pic_marking_buffer;
  1035.   img->dec_ref_pic_marking_buffer = NULL;
  1037.   dec_picture->MbaffFrameFlag = img->MbaffFrameFlag;
  1038.   dec_picture->PicWidthInMbs = img->PicWidthInMbs;
  1040.   get_mb_block_pos = dec_picture->MbaffFrameFlag ? get_mb_block_pos_mbaff : get_mb_block_pos_normal;
  1041.   getNeighbour = dec_picture->MbaffFrameFlag ? getAffNeighbour : getNonAffNeighbour;
  1043.   dec_picture->pic_num = img->frame_num;
  1044.   dec_picture->frame_num = img->frame_num;
  1046.   dec_picture->recovery_frame = (img->frame_num == img->recovery_frame_num);
  1048.   dec_picture->coded_frame = (img->structure==FRAME);
  1050.   dec_picture->chroma_format_idc = active_sps->chroma_format_idc;
  1052.   dec_picture->frame_mbs_only_flag = active_sps->frame_mbs_only_flag;
  1053.   dec_picture->frame_cropping_flag = active_sps->frame_cropping_flag;
  1055.   if (dec_picture->frame_cropping_flag)
  1056.   {
  1057.     dec_picture->frame_cropping_rect_left_offset   = active_sps->frame_cropping_rect_left_offset;
  1058.     dec_picture->frame_cropping_rect_right_offset  = active_sps->frame_cropping_rect_right_offset;
  1059.     dec_picture->frame_cropping_rect_top_offset    = active_sps->frame_cropping_rect_top_offset;
  1060.     dec_picture->frame_cropping_rect_bottom_offset = active_sps->frame_cropping_rect_bottom_offset;
  1061.   }
  1063. #if (ENABLE_OUTPUT_TONEMAPPING)
  1064.   // store the necessary tone mapping sei into StorablePicture structure
  1065.   dec_picture->seiHasTone_mapping = 0;
  1066.   if (seiToneMapping.seiHasTone_mapping)
  1067.   {
  1068.     dec_picture->seiHasTone_mapping    = 1;
  1069.     dec_picture->tone_mapping_model_id = seiToneMapping.model_id;
  1070.     dec_picture->tonemapped_bit_depth  = seiToneMapping.sei_bit_depth;
  1071.     dec_picture->tone_mapping_lut      = malloc(sizeof(int)*(1<<seiToneMapping.coded_data_bit_depth));
  1072.     if (NULL == dec_picture->tone_mapping_lut)
  1073.     {
  1074.       no_mem_exit("init_picture: tone_mapping_lut");
  1075.     }
  1076.     memcpy(dec_picture->tone_mapping_lut, seiToneMapping.lut, sizeof(imgpel)*(1<<seiToneMapping.coded_data_bit_depth));
  1077.     update_tone_mapping_sei();
  1078.   }
  1079. #endif
  1081.   if( IS_INDEPENDENT(img) )
  1082.   {
  1083.     dec_picture_JV[0] = dec_picture;
  1084.     dec_picture_JV[1] = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
  1085.     copy_dec_picture_JV( dec_picture_JV[1], dec_picture_JV[0] );
  1086.     dec_picture_JV[2] = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
  1087.     copy_dec_picture_JV( dec_picture_JV[2], dec_picture_JV[0] );
  1088.   }
  1089. }
  1091. /*!
  1092.  ************************************************************************
  1093.  * brief
  1094.  *    finish decoding of a picture, conceal errors and store it
  1095.  *    into the DPB
  1096.  ************************************************************************
  1097.  */
  1098. void exit_picture(void)
  1099. {
  1100.   char yuv_types[4][6]= {"4:0:0","4:2:0","4:2:2","4:4:4"};
  1101.   int ercStartMB;
  1102.   int ercSegment;
  1103.   frame recfr;
  1104.   unsigned int i;
  1105.   int structure, frame_poc, slice_type, refpic, qp, pic_num, chroma_format_idc, is_idr;
  1107.   static char cslice_type[9];  
  1109.   time_t tmp_time;                   // time used by decoding the last frame
  1110.   char   yuvFormat[10];
  1111.   int nplane;
  1113.   // return if the last picture has already been finished
  1114.   if (dec_picture==NULL)
  1115.   {
  1116.     return;
  1117.   }
  1119.   //deblocking for frame or field
  1120.   if( IS_INDEPENDENT(img) )
  1121.   {
  1122.     int colour_plane_id = img->colour_plane_id;
  1123.     for( nplane=0; nplane<MAX_PLANE; nplane++ )
  1124.     {
  1125.       change_plane_JV( nplane );
  1126.       DeblockPicture( img, dec_picture );
  1127.     }
  1128.     img->colour_plane_id = colour_plane_id;
  1129.     make_frame_picture_JV();
  1130.   }
  1131.   else
  1132.   {
  1133.     DeblockPicture( img, dec_picture );
  1134.   }
  1136.   if (dec_picture->MbaffFrameFlag)
  1137.     MbAffPostProc();
  1139.   recfr.yptr = &dec_picture->imgY[0][0];
  1140.   if (dec_picture->chroma_format_idc != YUV400)
  1141.   {
  1142.     recfr.uptr = &dec_picture->imgUV[0][0][0];
  1143.     recfr.vptr = &dec_picture->imgUV[1][0][0];
  1144.   }
  1146.   //! this is always true at the beginning of a picture
  1147.   ercStartMB = 0;
  1148.   ercSegment = 0;
  1150.   //! mark the start of the first segment
  1151.   if (!dec_picture->MbaffFrameFlag)
  1152.   {
  1153.     ercStartSegment(0, ercSegment, 0 , erc_errorVar);
  1154.     //! generate the segments according to the macroblock map
  1155.     for(i = 1; i<dec_picture->PicSizeInMbs; i++)
  1156.     {
  1157.       if(img->mb_data[i].ei_flag != img->mb_data[i-1].ei_flag)
  1158.       {
  1159.         ercStopSegment(i-1, ercSegment, 0, erc_errorVar); //! stop current segment
  1161.         //! mark current segment as lost or OK
  1162.         if(img->mb_data[i-1].ei_flag)
  1163.           ercMarkCurrSegmentLost(dec_picture->size_x, erc_errorVar);
  1164.         else
  1165.           ercMarkCurrSegmentOK(dec_picture->size_x, erc_errorVar);
  1167.         ercSegment++;  //! next segment
  1168.         ercStartSegment(i, ercSegment, 0 , erc_errorVar); //! start new segment
  1169.         ercStartMB = i;//! save start MB for this segment
  1170.       }
  1171.     }
  1172.     //! mark end of the last segment
  1173.     ercStopSegment(dec_picture->PicSizeInMbs-1, ercSegment, 0, erc_errorVar);
  1174.     if(img->mb_data[i-1].ei_flag)
  1175.       ercMarkCurrSegmentLost(dec_picture->size_x, erc_errorVar);
  1176.     else
  1177.       ercMarkCurrSegmentOK(dec_picture->size_x, erc_errorVar);
  1179.     //! call the right error concealment function depending on the frame type.
  1180.     erc_mvperMB /= dec_picture->PicSizeInMbs;
  1182.     erc_img = img;
  1183.     if(dec_picture->slice_type == I_SLICE || dec_picture->slice_type == SI_SLICE) // I-frame
  1184.       ercConcealIntraFrame(&recfr, dec_picture->size_x, dec_picture->size_y, erc_errorVar);
  1185.     else
  1186.       ercConcealInterFrame(&recfr, erc_object_list, dec_picture->size_x, dec_picture->size_y, erc_errorVar, dec_picture->chroma_format_idc);
  1187.   }
  1189.   if (img->structure == FRAME)         // buffer mgt. for frame mode
  1190.     frame_postprocessing(img);
  1191.   else
  1192.     field_postprocessing(img);   // reset all interlaced variables
  1194.   structure  = dec_picture->structure;
  1195.   slice_type = dec_picture->slice_type;
  1196.   frame_poc  = dec_picture->frame_poc;
  1197.   refpic     = dec_picture->used_for_reference;
  1198.   qp         = dec_picture->qp;
  1199.   pic_num    = dec_picture->pic_num;
  1200.   is_idr     = dec_picture->idr_flag;
  1202.   chroma_format_idc= dec_picture->chroma_format_idc;
  1204.   store_picture_in_dpb(dec_picture);
  1205.   dec_picture=NULL;
  1207.   if (img->last_has_mmco_5)
  1208.   {
  1209.     img->pre_frame_num = 0;
  1210.   }
  1212.   if (params->silent == FALSE)
  1213.   {
  1214.     if (structure==TOP_FIELD || structure==FRAME)
  1215.     {
  1216.       if(slice_type == I_SLICE && is_idr) // IDR picture
  1217.         strcpy(cslice_type,"IDR");
  1218.       else if(slice_type == I_SLICE) // I picture
  1219.         strcpy(cslice_type," I ");
  1220.       else if(slice_type == P_SLICE) // P pictures
  1221.         strcpy(cslice_type," P ");
  1222.       else if(slice_type == SP_SLICE) // SP pictures
  1223.         strcpy(cslice_type,"SP ");
  1224.       else if (slice_type == SI_SLICE)
  1225.         strcpy(cslice_type,"SI ");
  1226.       else if(refpic) // stored B pictures
  1227.         strcpy(cslice_type," B ");
  1228.       else // B pictures
  1229.         strcpy(cslice_type," b ");
  1230.       if (structure==FRAME)
  1231.       {
  1232.         strncat(cslice_type,")       ",8-strlen(cslice_type));
  1233.       }
  1234.     }
  1235.     else if (structure==BOTTOM_FIELD)
  1236.     {
  1237.       if(slice_type == I_SLICE && is_idr) // IDR picture
  1238.         strncat(cslice_type,"|IDR)",8-strlen(cslice_type));
  1239.       else if(slice_type == I_SLICE) // I picture
  1240.         strncat(cslice_type,"| I )",8-strlen(cslice_type));
  1241.       else if(slice_type == P_SLICE) // P pictures
  1242.         strncat(cslice_type,"| P )",8-strlen(cslice_type));
  1243.       else if(slice_type == SP_SLICE) // SP pictures
  1244.         strncat(cslice_type,"|SP )",8-strlen(cslice_type));
  1245.       else if (slice_type == SI_SLICE)
  1246.         strncat(cslice_type,"|SI )",8-strlen(cslice_type));
  1247.       else if(refpic) // stored B pictures
  1248.         strncat(cslice_type,"| B )",8-strlen(cslice_type));
  1249.       else // B pictures
  1250.         strncat(cslice_type,"| b )",8-strlen(cslice_type));   
  1251.     }
  1252.   }
  1254.   if ((structure==FRAME)||structure==BOTTOM_FIELD)
  1255.   {
  1256.     gettime (&(img->end_time));              // end time
  1258.     tmp_time= timediff(&(img->start_time), &(img->end_time));
  1259.     tot_time=tot_time + tmp_time;
  1261.     sprintf(yuvFormat,"%s", yuv_types[chroma_format_idc]);
  1262.     
  1263.     if (params->silent == FALSE)
  1264.     {
  1265.       if (p_ref != -1)
  1266.         fprintf(stdout,"%05d(%s%5d %5d %5d %8.4f %8.4f %8.4f  %s %7dn",
  1267.         frame_no, cslice_type, frame_poc, pic_num, qp, snr->snr[0], snr->snr[1], snr->snr[2], yuvFormat, (int)tmp_time);
  1268.     else
  1269.         fprintf(stdout,"%05d(%s%5d %5d %5d                             %s %7dn",
  1270.         frame_no, cslice_type, frame_poc, pic_num, qp, yuvFormat, (int)tmp_time);
  1271.     }
  1272.     else
  1273.       fprintf(stdout,"Completed Decoding frame %05d.r",snr->frame_ctr);
  1275.     fflush(stdout);
  1277.     if(slice_type == I_SLICE || slice_type == SI_SLICE || slice_type == P_SLICE || refpic)   // I or P pictures
  1278.       img->number++;
  1279.     else
  1280.       Bframe_ctr++;    // B pictures
  1281.     snr->frame_ctr++;
  1283.     g_nFrame++;
  1284.   }
  1286.   img->current_mb_nr = -4712;   // impossible value for debugging, StW
  1287.   img->current_slice_nr = 0;
  1289. }
  1291. /*!
  1292.  ************************************************************************
  1293.  * brief
  1294.  *    write the encoding mode and motion vectors of current
  1295.  *    MB to the buffer of the error concealment module.
  1296.  ************************************************************************
  1297.  */
  1299. void ercWriteMBMODEandMV(Macroblock *currMB, ImageParameters *img,struct inp_par *inp)
  1300. {
  1301.   extern objectBuffer_t *erc_object_list;
  1302.   int i, ii, jj, currMBNum = img->current_mb_nr;
  1303.   int mbx = xPosMB(currMBNum,dec_picture->size_x), mby = yPosMB(currMBNum,dec_picture->size_x);
  1304.   objectBuffer_t *currRegion, *pRegion;
  1305.   short***  mv;
  1307.   currRegion = erc_object_list + (currMBNum<<2);
  1309.   if(img->type != B_SLICE) //non-B frame
  1310.   {
  1311.     for (i=0; i<4; i++)
  1312.     {
  1313.       pRegion             = currRegion + i;
  1314.       pRegion->regionMode = (currMB->mb_type  ==I16MB  ? REGMODE_INTRA      :
  1315.                              currMB->b8mode[i]==IBLOCK ? REGMODE_INTRA_8x8  :
  1316.                              currMB->b8mode[i]==0      ? REGMODE_INTER_COPY :
  1317.                              currMB->b8mode[i]==1      ? REGMODE_INTER_PRED : REGMODE_INTER_PRED_8x8);
  1318.       if (currMB->b8mode[i]==0 || currMB->b8mode[i]==IBLOCK)  // INTRA OR COPY
  1319.       {
  1320.         pRegion->mv[0]    = 0;
  1321.         pRegion->mv[1]    = 0;
  1322.         pRegion->mv[2]    = 0;
  1323.       }
  1324.       else
  1325.       {
  1326.         ii              = 4*mbx + (i & 0x01)*2;// + BLOCK_SIZE;
  1327.         jj              = 4*mby + (i >> 1  )*2;
  1328.         if (currMB->b8mode[i]>=5 && currMB->b8mode[i]<=7)  // SMALL BLOCKS
  1329.         {
  1330.           pRegion->mv[0]  = (dec_picture->motion.mv[LIST_0][jj][ii][0] + dec_picture->motion.mv[LIST_0][jj][ii+1][0] + dec_picture->motion.mv[LIST_0][jj+1][ii][0] + dec_picture->motion.mv[LIST_0][jj+1][ii+1][0] + 2)/4;
  1331.           pRegion->mv[1]  = (dec_picture->motion.mv[LIST_0][jj][ii][1] + dec_picture->motion.mv[LIST_0][jj][ii+1][1] + dec_picture->motion.mv[LIST_0][jj+1][ii][1] + dec_picture->motion.mv[LIST_0][jj+1][ii+1][1] + 2)/4;
  1332.         }
  1333.         else // 16x16, 16x8, 8x16, 8x8
  1334.         {
  1335.           pRegion->mv[0]  = dec_picture->motion.mv[LIST_0][jj][ii][0];
  1336.           pRegion->mv[1]  = dec_picture->motion.mv[LIST_0][jj][ii][1];
  1337. //          pRegion->mv[0]  = dec_picture->motion.mv[LIST_0][4*mby+(i/2)*2][4*mbx+(i%2)*2+BLOCK_SIZE][0];
  1338. //          pRegion->mv[1]  = dec_picture->motion.mv[LIST_0][4*mby+(i/2)*2][4*mbx+(i%2)*2+BLOCK_SIZE][1];
  1339.         }
  1340.         erc_mvperMB      += iabs(pRegion->mv[0]) + iabs(pRegion->mv[1]);
  1341.         pRegion->mv[2]    = dec_picture->motion.ref_idx[LIST_0][jj][ii];
  1342.       }
  1343.     }
  1344.   }
  1345.   else  //B-frame
  1346.   {
  1347.     for (i=0; i<4; i++)
  1348.     {
  1349.       ii                  = 4*mbx + (i%2)*2;// + BLOCK_SIZE;
  1350.       jj                  = 4*mby + (i/2)*2;
  1351.       pRegion             = currRegion + i;
  1352.       pRegion->regionMode = (currMB->mb_type  ==I16MB  ? REGMODE_INTRA      :
  1353.                              currMB->b8mode[i]==IBLOCK ? REGMODE_INTRA_8x8  : REGMODE_INTER_PRED_8x8);
  1354.       if (currMB->mb_type==I16MB || currMB->b8mode[i]==IBLOCK)  // INTRA
  1355.       {
  1356.         pRegion->mv[0]    = 0;
  1357.         pRegion->mv[1]    = 0;
  1358.         pRegion->mv[2]    = 0;
  1359.       }
  1360.       else
  1361.       {
  1362.         int idx = (dec_picture->motion.ref_idx[0][jj][ii]<0)?1:0;
  1363. //        int idx = (currMB->b8mode[i]==0 && currMB->b8pdir[i]==2 ? LIST_0 : currMB->b8pdir[i]==1 ? LIST_1 : LIST_0);
  1364. //        int idx = currMB->b8pdir[i]==0 ? LIST_0 : LIST_1;
  1365.         mv                = dec_picture->motion.mv[idx];
  1366.         pRegion->mv[0]    = (mv[jj][ii][0] + mv[jj][ii+1][0] + mv[jj+1][ii][0] + mv[jj+1][ii+1][0] + 2)/4;
  1367.         pRegion->mv[1]    = (mv[jj][ii][1] + mv[jj][ii+1][1] + mv[jj+1][ii][1] + mv[jj+1][ii+1][1] + 2)/4;
  1368.         erc_mvperMB      += iabs(pRegion->mv[0]) + iabs(pRegion->mv[1]);
  1370.         pRegion->mv[2]  = (dec_picture->motion.ref_idx[idx][jj][ii]);
  1371. /*
  1372.         if (currMB->b8pdir[i]==0 || (currMB->b8pdir[i]==2 && currMB->b8mode[i]!=0)) // forward or bidirect
  1373.         {
  1374.           pRegion->mv[2]  = (dec_picture->motion.ref_idx[LIST_0][jj][ii]);
  1375.           ///???? is it right, not only "img->fw_refFrArr[jj][ii-4]"
  1376.         }
  1377.         else
  1378.         {
  1379.           pRegion->mv[2]  = (dec_picture->motion.ref_idx[LIST_1][jj][ii]);
  1380. //          pRegion->mv[2]  = 0;
  1381.         }
  1382.         */
  1383.       }
  1384.     }
  1385.   }
  1386. }
  1388. /*!
  1389.  ************************************************************************
  1390.  * brief
  1391.  *    set defaults for old_slice
  1392.  *    NAL unit of a picture"
  1393.  ************************************************************************
  1394.  */
  1395. void init_old_slice(void)
  1396. {
  1397.   old_slice.field_pic_flag = 0;
  1399.   old_slice.pps_id = INT_MAX;
  1401.   old_slice.frame_num = INT_MAX;
  1403.   old_slice.nal_ref_idc = INT_MAX;
  1405.   old_slice.idr_flag = FALSE;
  1407.   old_slice.pic_oder_cnt_lsb          = UINT_MAX;
  1408.   old_slice.delta_pic_oder_cnt_bottom = INT_MAX;
  1410.   old_slice.delta_pic_order_cnt[0] = INT_MAX;
  1411.   old_slice.delta_pic_order_cnt[1] = INT_MAX;
  1413. }
  1415. /*!
  1416.  ************************************************************************
  1417.  * brief
  1418.  *    save slice parameters that are needed for checking of "first VCL
  1419.  *    NAL unit of a picture"
  1420.  ************************************************************************
  1421.  */
  1422. void exit_slice(void)
  1423. {
  1425.   old_slice.pps_id = img->currentSlice->pic_parameter_set_id;
  1427.   old_slice.frame_num = img->frame_num;
  1429.   old_slice.field_pic_flag = img->field_pic_flag;
  1431.   if(img->field_pic_flag)
  1432.   {
  1433.     old_slice.bottom_field_flag = img->bottom_field_flag;
  1434.   }
  1436.   old_slice.nal_ref_idc   = img->nal_reference_idc;
  1438.   old_slice.idr_flag = img->idr_flag;
  1439.   if (img->idr_flag)
  1440.   {
  1441.     old_slice.idr_pic_id = img->idr_pic_id;
  1442.   }
  1444.   if (active_sps->pic_order_cnt_type == 0)
  1445.   {
  1446.     old_slice.pic_oder_cnt_lsb          = img->pic_order_cnt_lsb;
  1447.     old_slice.delta_pic_oder_cnt_bottom = img->delta_pic_order_cnt_bottom;
  1448.   }
  1450.   if (active_sps->pic_order_cnt_type == 1)
  1451.   {
  1452.     old_slice.delta_pic_order_cnt[0] = img->delta_pic_order_cnt[0];
  1453.     old_slice.delta_pic_order_cnt[1] = img->delta_pic_order_cnt[1];
  1454.   }
  1455. }
  1457. /*!
  1458.  ************************************************************************
  1459.  * brief
  1460.  *    detect if current slice is "first VCL NAL unit of a picture"
  1461.  ************************************************************************
  1462.  */
  1463. int is_new_picture(void)
  1464. {
  1465.   int result=0;
  1467.   result |= (NULL==dec_picture);
  1469.   result |= (old_slice.pps_id != img->currentSlice->pic_parameter_set_id);
  1471.   result |= (old_slice.frame_num != img->frame_num);
  1473.   result |= (old_slice.field_pic_flag != img->field_pic_flag);
  1475.   if(img->field_pic_flag && old_slice.field_pic_flag)
  1476.   {
  1477.     result |= (old_slice.bottom_field_flag != img->bottom_field_flag);
  1478.   }
  1480.   result |= (old_slice.nal_ref_idc != img->nal_reference_idc) && ((old_slice.nal_ref_idc == 0) || (img->nal_reference_idc == 0));
  1482.   result |= ( old_slice.idr_flag != img->idr_flag);
  1484.   if (img->idr_flag && old_slice.idr_flag)
  1485.   {
  1486.     result |= (old_slice.idr_pic_id != img->idr_pic_id);
  1487.   }
  1489.   if (active_sps->pic_order_cnt_type == 0)
  1490.   {
  1491.     result |=  (old_slice.pic_oder_cnt_lsb          != img->pic_order_cnt_lsb);
  1492.     result |=  (old_slice.delta_pic_oder_cnt_bottom != img->delta_pic_order_cnt_bottom);
  1493.   }
  1495.   if (active_sps->pic_order_cnt_type == 1)
  1496.   {
  1497.     result |= (old_slice.delta_pic_order_cnt[0] != img->delta_pic_order_cnt[0]);
  1498.     result |= (old_slice.delta_pic_order_cnt[1] != img->delta_pic_order_cnt[1]);
  1499.   }
  1501.   return result;
  1502. }
  1505. /*!
  1506.  ************************************************************************
  1507.  * brief
  1508.  *    decodes one slice
  1509.  ************************************************************************
  1510.  */
  1511. void decode_one_slice(ImageParameters *img,struct inp_par *inp)
  1512. {
  1513.   Boolean end_of_slice = FALSE;
  1514.   Macroblock *currMB = NULL;
  1515.   img->cod_counter=-1;
  1517.   set_interpret_mb_mode(img->type);
  1519.   if( IS_INDEPENDENT(img) )
  1520.   {
  1521.     change_plane_JV( img->colour_plane_id );
  1522.   }
  1524.   set_ref_pic_num();
  1526.   if (img->type == B_SLICE)
  1527.   {
  1528.     if( IS_INDEPENDENT(img) )
  1529.     {
  1530.       compute_colocated_JV(Co_located, listX);
  1531.     }
  1532.     else
  1533.     {
  1534.       compute_colocated(Co_located, listX);
  1535.     }
  1536.   }
  1538.   //reset_ec_flags();
  1540.   while (end_of_slice == FALSE) // loop over macroblocks
  1541.   {
  1543. #if TRACE
  1544.   fprintf(p_trace,"n*********** POC: %i (I/P) MB: %i Slice: %i Type %d **********n", img->ThisPOC, img->current_mb_nr, img->current_slice_nr, img->type);
  1545. #endif
  1547.     // Initializes the current macroblock
  1548.     start_macroblock(img, &currMB);
  1549.     // Get the syntax elements from the NAL
  1550.     read_one_macroblock(img, currMB);
  1551.     decode_one_macroblock(img, currMB, dec_picture);
  1553.     if(img->MbaffFrameFlag && dec_picture->motion.mb_field[img->current_mb_nr])
  1554.     {
  1555.       img->num_ref_idx_l0_active >>= 1;
  1556.       img->num_ref_idx_l1_active >>= 1;
  1557.     }
  1559.     ercWriteMBMODEandMV(currMB, img,inp);
  1561.     end_of_slice=exit_macroblock(img,(!img->MbaffFrameFlag||img->current_mb_nr%2));
  1562.   }
  1564.   exit_slice();
  1565.   //reset_ec_flags();
  1566. }
  1569. void decode_slice(ImageParameters *img,struct inp_par *inp, int current_header)
  1570. {
  1571.   Slice *currSlice = img->currentSlice;
  1573.   if (active_pps->entropy_coding_mode_flag)
  1574.   {
  1575.     init_contexts (img);
  1576.     cabac_new_slice();
  1577.   }
  1579.   if ( (active_pps->weighted_bipred_idc > 0  && (img->type == B_SLICE)) || (active_pps->weighted_pred_flag && img->type !=I_SLICE))
  1580.     fill_wp_params(img);
  1582.   //printf("frame picture %d %d %dn",img->structure,img->ThisPOC,img->direct_spatial_mv_pred_flag);
  1584.   // decode main slice information
  1585.   if ((current_header == SOP || current_header == SOS) && currSlice->ei_flag == 0)
  1586.     decode_one_slice(img,inp);
  1588.   // setMB-Nr in case this slice was lost
  1589.   // if(currSlice->ei_flag)
  1590.   //   img->current_mb_nr = currSlice->last_mb_nr + 1;
  1591. }
  1594. /*!
  1595.  ************************************************************************
  1596.  * brief
  1597.  *    Prepare field and frame buffer after frame decoding
  1598.  ************************************************************************
  1599.  */
  1600. void frame_postprocessing(ImageParameters *img)
  1601. {
  1602. }
  1604. /*!
  1605.  ************************************************************************
  1606.  * brief
  1607.  *    Prepare field and frame buffer after field decoding
  1608.  ************************************************************************
  1609.  */
  1610. void field_postprocessing(ImageParameters *img)
  1611. {
  1612.   img->number /= 2;
  1613. }
  1617. void reset_wp_params(ImageParameters *img)
  1618. {
  1619.   int i,comp;
  1620.   int log_weight_denom;
  1622.   for (i=0; i<MAX_REFERENCE_PICTURES; i++)
  1623.   {
  1624.     for (comp=0; comp<3; comp++)
  1625.     {
  1626.       log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
  1627.       img->wp_weight[0][i][comp] = 1 << log_weight_denom;
  1628.       img->wp_weight[1][i][comp] = 1 << log_weight_denom;
  1629.     }
  1630.   }
  1631. }
  1634. void fill_wp_params(ImageParameters *img)
  1635. {
  1636.   int i, j, k;
  1637.   int comp;
  1638.   int log_weight_denom;
  1639.   int tb, td;
  1640.   int bframe = (img->type==B_SLICE);
  1641.   int max_bwd_ref, max_fwd_ref;
  1642.   int tx,DistScaleFactor;
  1644.   max_fwd_ref = img->num_ref_idx_l0_active;
  1645.   max_bwd_ref = img->num_ref_idx_l1_active;
  1647.   if (active_pps->weighted_bipred_idc == 2 && bframe)
  1648.   {
  1649.     img->luma_log2_weight_denom = 5;
  1650.     img->chroma_log2_weight_denom = 5;
  1651.     img->wp_round_luma = 16;
  1652.     img->wp_round_chroma = 16;
  1654.     for (i=0; i<MAX_REFERENCE_PICTURES; i++)
  1655.     {
  1656.       for (comp=0; comp<3; comp++)
  1657.       {
  1658.         log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
  1659.         img->wp_weight[0][i][comp] = 1<<log_weight_denom;
  1660.         img->wp_weight[1][i][comp] = 1<<log_weight_denom;
  1661.         img->wp_offset[0][i][comp] = 0;
  1662.         img->wp_offset[1][i][comp] = 0;
  1663.       }
  1664.     }
  1665.   }
  1667.   if (bframe)
  1668.   {
  1669.     for (i=0; i<max_fwd_ref; i++)
  1670.     {
  1671.       for (j=0; j<max_bwd_ref; j++)
  1672.       {
  1673.         for (comp = 0; comp<3; comp++)
  1674.         {
  1675.           log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
  1676.           if (active_pps->weighted_bipred_idc == 1)
  1677.           {
  1678.             img->wbp_weight[0][i][j][comp] =  img->wp_weight[0][i][comp];
  1679.             img->wbp_weight[1][i][j][comp] =  img->wp_weight[1][j][comp];
  1680.           }
  1681.           else if (active_pps->weighted_bipred_idc == 2)
  1682.           {
  1683.             td = iClip3(-128,127,listX[LIST_1][j]->poc - listX[LIST_0][i]->poc);
  1684.             if (td == 0 || listX[LIST_1][j]->is_long_term || listX[LIST_0][i]->is_long_term)
  1685.             {
  1686.               img->wbp_weight[0][i][j][comp] =   32;
  1687.               img->wbp_weight[1][i][j][comp] =   32;
  1688.             }
  1689.             else
  1690.             {
  1691.               tb = iClip3(-128,127,img->ThisPOC - listX[LIST_0][i]->poc);
  1693.               tx = (16384 + iabs(td/2))/td;
  1694.               DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);
  1696.               img->wbp_weight[1][i][j][comp] = DistScaleFactor >> 2;
  1697.               img->wbp_weight[0][i][j][comp] = 64 - img->wbp_weight[1][i][j][comp];
  1698.               if (img->wbp_weight[1][i][j][comp] < -64 || img->wbp_weight[1][i][j][comp] > 128)
  1699.               {
  1700.                 img->wbp_weight[0][i][j][comp] = 32;
  1701.                 img->wbp_weight[1][i][j][comp] = 32;
  1702.                 img->wp_offset[0][i][comp] = 0;
  1703.                 img->wp_offset[1][j][comp] = 0;
  1704.               }
  1705.             }
  1706.           }
  1707.         }
  1708.       }
  1709.    }
  1710.  }
  1712.   if (bframe && img->MbaffFrameFlag)
  1713.   {
  1714.     for (i=0; i<2*max_fwd_ref; i++)
  1715.     {
  1716.       for (j=0; j<2*max_bwd_ref; j++)
  1717.       {
  1718.         for (comp = 0; comp<3; comp++)
  1719.         {
  1720.           for (k=2; k<6; k+=2)
  1721.           {
  1722.             img->wp_offset[k+0][i][comp] = img->wp_offset[0][i>>1][comp];
  1723.             img->wp_offset[k+1][j][comp] = img->wp_offset[1][j>>1][comp];
  1725.             log_weight_denom = (comp == 0) ? img->luma_log2_weight_denom : img->chroma_log2_weight_denom;
  1726.             if (active_pps->weighted_bipred_idc == 1)
  1727.             {
  1728.               img->wbp_weight[k+0][i][j][comp] =  img->wp_weight[0][i>>1][comp];
  1729.               img->wbp_weight[k+1][i][j][comp] =  img->wp_weight[1][j>>1][comp];
  1730.             }
  1731.             else if (active_pps->weighted_bipred_idc == 2)
  1732.             {
  1733.               td = iClip3(-128,127,listX[k+LIST_1][j]->poc - listX[k+LIST_0][i]->poc);
  1734.               if (td == 0 || listX[k+LIST_1][j]->is_long_term || listX[k+LIST_0][i]->is_long_term)
  1735.               {
  1736.                 img->wbp_weight[k+0][i][j][comp] =   32;
  1737.                 img->wbp_weight[k+1][i][j][comp] =   32;
  1738.               }
  1739.               else
  1740.               {
  1741.                 tb = iClip3(-128,127,((k==2)?img->toppoc:img->bottompoc) - listX[k+LIST_0][i]->poc);
  1743.                 tx = (16384 + iabs(td/2))/td;
  1744.                 DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);
  1746.                 img->wbp_weight[k+1][i][j][comp] = DistScaleFactor >> 2;
  1747.                 img->wbp_weight[k+0][i][j][comp] = 64 - img->wbp_weight[k+1][i][j][comp];
  1748.                 if (img->wbp_weight[k+1][i][j][comp] < -64 || img->wbp_weight[k+1][i][j][comp] > 128)
  1749.                 {
  1750.                   img->wbp_weight[k+1][i][j][comp] = 32;
  1751.                   img->wbp_weight[k+0][i][j][comp] = 32;
  1752.                   img->wp_offset[k+0][i][comp] = 0;
  1753.                   img->wp_offset[k+1][j][comp] = 0;
  1754.                 }
  1755.               }
  1756.             }
  1757.           }
  1758.         }
  1759.       }
  1760.     }
  1761.   }
  1762. }
  1764. /*!
  1765.  ************************************************************************
  1766.  * brief
  1767.  *    Error tracking: if current frame is lost or any reference frame of
  1768.  *                    current frame is lost, current frame is incorrect.
  1769.  ************************************************************************
  1770.  */
  1771. void Error_tracking(void)
  1772. {
  1773.   int i;
  1775.   if(img->redundant_pic_cnt == 0)
  1776.     {
  1777.       Is_primary_correct = Is_redundant_correct = 1;
  1778.     }
  1780.   if(img->redundant_pic_cnt == 0 && img->type != I_SLICE)
  1781.   {
  1782.     for(i=0;i<img->num_ref_idx_l0_active;i++)
  1783.     {
  1784.       if(ref_flag[i] == 0)  // any reference of primary slice is incorrect
  1785.       {
  1786.         Is_primary_correct = 0; // primary slice is incorrect
  1787.       }
  1788.     }
  1789.   }
  1790.   else if(img->redundant_pic_cnt != 0 && img->type != I_SLICE)
  1791.   {
  1792.     if(ref_flag[redundant_slice_ref_idx] == 0)  // reference of redundant slice is incorrect
  1793.     {
  1794.       Is_redundant_correct = 0;  // redundant slice is incorrect
  1795.     }
  1796.   }
  1797. }
  1799. /*!
  1800.  ************************************************************************
  1801.  * brief
  1802.  *    copy StorablePicture *src -> StorablePicture *dst
  1803.  *    for 4:4:4 Independent mode
  1804.  ************************************************************************
  1805.  */
  1806. void copy_dec_picture_JV( StorablePicture *dst, StorablePicture *src )
  1807. {
  1808.   dst->top_poc              = src->top_poc;
  1809.   dst->bottom_poc           = src->bottom_poc;
  1810.   dst->frame_poc            = src->frame_poc;
  1811.   dst->qp                   = src->qp;
  1812.   dst->slice_qp_delta       = src->slice_qp_delta;
  1813.   dst->chroma_qp_offset[0]  = src->chroma_qp_offset[0];
  1814.   dst->chroma_qp_offset[1]  = src->chroma_qp_offset[1];
  1816.   dst->poc                  = src->poc;
  1818.   dst->slice_type           = src->slice_type;
  1819.   dst->used_for_reference   = src->used_for_reference;
  1820.   dst->idr_flag             = src->idr_flag;
  1821.   dst->no_output_of_prior_pics_flag = src->no_output_of_prior_pics_flag;
  1822.   dst->long_term_reference_flag = src->long_term_reference_flag;
  1823.   dst->adaptive_ref_pic_buffering_flag = src->adaptive_ref_pic_buffering_flag;
  1825.   dst->dec_ref_pic_marking_buffer = src->dec_ref_pic_marking_buffer;
  1827.   dst->MbaffFrameFlag       = src->MbaffFrameFlag;
  1828.   dst->PicWidthInMbs        = src->PicWidthInMbs;
  1829.   dst->pic_num              = src->pic_num;
  1830.   dst->frame_num            = src->frame_num;
  1831.   dst->recovery_frame       = src->recovery_frame;
  1832.   dst->coded_frame          = src->coded_frame;
  1834.   dst->chroma_format_idc    = src->chroma_format_idc;
  1836.   dst->frame_mbs_only_flag  = src->frame_mbs_only_flag;
  1837.   dst->frame_cropping_flag  = src->frame_cropping_flag;
  1839.   dst->frame_cropping_rect_left_offset   = src->frame_cropping_rect_left_offset;
  1840.   dst->frame_cropping_rect_right_offset  = src->frame_cropping_rect_right_offset;
  1841.   dst->frame_cropping_rect_top_offset    = src->frame_cropping_rect_top_offset;
  1842.   dst->frame_cropping_rect_bottom_offset = src->frame_cropping_rect_bottom_offset;
  1844. #if (ENABLE_OUTPUT_TONEMAPPING)
  1845.   // store the necessary tone mapping sei into StorablePicture structure
  1846.   dst->seiHasTone_mapping = src->seiHasTone_mapping;
  1848.   dst->seiHasTone_mapping    = src->seiHasTone_mapping;
  1849.   dst->tone_mapping_model_id = src->tone_mapping_model_id;
  1850.   dst->tonemapped_bit_depth  = src->tonemapped_bit_depth;
  1851.   if( src->tone_mapping_lut )
  1852.   {
  1853.     dst->tone_mapping_lut      = malloc(sizeof(int)*(1<<seiToneMapping.coded_data_bit_depth));
  1854.     if (NULL == dst->tone_mapping_lut)
  1855.     {
  1856.       no_mem_exit("copy_dec_picture_JV: tone_mapping_lut");
  1857.     }
  1858.     memcpy(dst->tone_mapping_lut, src->tone_mapping_lut, sizeof(imgpel)*(1<<seiToneMapping.coded_data_bit_depth));
  1859.   }
  1860. #endif
  1861. }