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

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

Audio

开发平台：

Visual C++

parset.c：源码内容
  2. /*!
  3.  **************************************************************************************
  4.  * file
  5.  *    parset.c
  6.  * brief
  7.  *    Picture and Sequence Parameter set generation and handling
  8.  *  date 25 November 2002
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *      - Stephan Wenger        <stewe@cs.tu-berlin.de>
  12.  *
  13.  **************************************************************************************
  14.  */
  16. #include <time.h>
  17. #include <sys/timeb.h>
  19. #include "global.h"
  21. #include "contributors.h"
  22. #include "nal.h"
  23. #include "mbuffer.h"
  24. #include "parset.h"
  25. #include "vlc.h"
  26. #include "q_matrix.h"
  28. // Local helpers
  29. static int IdentifyProfile(void);
  30. static int IdentifyLevel(void);
  31. static int GenerateVUI_parameters_rbsp(seq_parameter_set_rbsp_t *sps, Bitstream *bitstream);
  33. extern ColocatedParams *Co_located;
  34. extern ColocatedParams *Co_located_JV[MAX_PLANE];  //!< Co_located to be used during 4:4:4 independent mode encoding
  36. pic_parameter_set_rbsp_t *PicParSet[MAXPPS];
  38. static const byte ZZ_SCAN[16]  =
  39. {  0,  1,  4,  8,  5,  2,  3,  6,  9, 12, 13, 10,  7, 11, 14, 15
  40. };
  42. static const byte ZZ_SCAN8[64] =
  43. {  0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
  44.    12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
  45.    35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  46.    58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
  47. };
  50. /*!
  51.  *************************************************************************************
  52.  * brief
  53.  *    generates a sequence and picture parameter set and stores these in global
  54.  *    active_sps and active_pps
  55.  *
  56.  * return
  57.  *    A NALU containing the Sequence ParameterSet
  58.  *
  59.  *************************************************************************************
  60. */
  61. void GenerateParameterSets (void)
  62. {
  63.   int i;
  64.   seq_parameter_set_rbsp_t *sps = NULL;
  66.   sps = AllocSPS();
  68.   for (i=0; i<MAXPPS; i++)
  69.   {
  70.     PicParSet[i] = NULL;
  71.   }
  74.   GenerateSequenceParameterSet(sps, 0);
  76.   if (params->GenerateMultiplePPS)
  77.   {
  78.     PicParSet[0] = AllocPPS();
  79.     PicParSet[1] = AllocPPS();
  80.     PicParSet[2] = AllocPPS();
  82.     if (IS_FREXT_PROFILE(sps->profile_idc))
  83.     {
  84.       GeneratePictureParameterSet( PicParSet[0], sps, 0, 0, 0, params->cb_qp_index_offset, params->cr_qp_index_offset);
  85.       GeneratePictureParameterSet( PicParSet[1], sps, 1, 1, 1, params->cb_qp_index_offset, params->cr_qp_index_offset);
  86.       GeneratePictureParameterSet( PicParSet[2], sps, 2, 1, 2, params->cb_qp_index_offset, params->cr_qp_index_offset);
  88.     }
  89.     else
  90.     {
  91.       GeneratePictureParameterSet( PicParSet[0], sps, 0, 0, 0, params->chroma_qp_index_offset, 0);
  92.       GeneratePictureParameterSet( PicParSet[1], sps, 1, 1, 1, params->chroma_qp_index_offset, 0);
  93.       GeneratePictureParameterSet( PicParSet[2], sps, 2, 1, 2, params->chroma_qp_index_offset, 0);
  94.     }
  95.   }
  96.   else
  97.   {
  98.     PicParSet[0] = AllocPPS();
  99.     if (IS_FREXT_PROFILE(sps->profile_idc))
  100.       GeneratePictureParameterSet( PicParSet[0], sps, 0, params->WeightedPrediction, params->WeightedBiprediction,
  101.                                    params->cb_qp_index_offset, params->cr_qp_index_offset);
  102.     else
  103.       GeneratePictureParameterSet( PicParSet[0], sps, 0, params->WeightedPrediction, params->WeightedBiprediction,
  104.                                    params->chroma_qp_index_offset, 0);
  105.   }
  107.   active_sps = sps;
  108.   active_pps = PicParSet[0];
  109. }
  111. /*!
  112. *************************************************************************************
  113. * brief
  114. *    frees global parameter sets active_sps and active_pps
  115. *
  116. * return
  117. *    A NALU containing the Sequence ParameterSet
  118. *
  119. *************************************************************************************
  120. */
  121. void FreeParameterSets (void)
  122. {
  123.   int i;
  124.   for (i=0; i<MAXPPS; i++)
  125.   {
  126.     if ( NULL != PicParSet[i])
  127.     {
  128.       FreePPS(PicParSet[i]);
  129.       PicParSet[i] = NULL;
  130.     }
  131.   }
  132.   FreeSPS (active_sps);
  133. }
  135. /*!
  136. *************************************************************************************
  137. * brief
  138. *    int GenerateSeq_parameter_set_NALU (void);
  139. *
  140. * note
  141. *    Uses the global variables through GenerateSequenceParameterSet()
  142. *    and GeneratePictureParameterSet
  143. *
  144. * return
  145. *    A NALU containing the Sequence ParameterSet
  146. *
  147. *************************************************************************************
  148. */
  150. NALU_t *GenerateSeq_parameter_set_NALU (void)
  151. {
  152.   NALU_t *n = AllocNALU(64000);
  153.   int RBSPlen = 0;
  154.   int NALUlen;
  155.   byte rbsp[MAXRBSPSIZE];
  157.   RBSPlen = GenerateSeq_parameter_set_rbsp (active_sps, rbsp);
  158.   NALUlen = RBSPtoNALU (rbsp, n, RBSPlen, NALU_TYPE_SPS, NALU_PRIORITY_HIGHEST, 0, 1);
  159.   n->startcodeprefix_len = 4;
  161.   return n;
  162. }
  165. /*!
  166. *************************************************************************************
  167. * brief
  168. *    NALU_t *GeneratePic_parameter_set_NALU (int PPS_id);
  169. *
  170. * note
  171. *    Uses the global variables through GenerateSequenceParameterSet()
  172. *    and GeneratePictureParameterSet
  173. *
  174. * return
  175. *    A NALU containing the Picture Parameter Set
  176. *
  177. *************************************************************************************
  178. */
  180. NALU_t *GeneratePic_parameter_set_NALU(int PPS_id)
  181. {
  182.   NALU_t *n = AllocNALU(64000);
  183.   int RBSPlen = 0;
  184.   int NALUlen;
  185.   byte rbsp[MAXRBSPSIZE];
  187.   RBSPlen = GeneratePic_parameter_set_rbsp (PicParSet[PPS_id], rbsp);
  188.   NALUlen = RBSPtoNALU (rbsp, n, RBSPlen, NALU_TYPE_PPS, NALU_PRIORITY_HIGHEST, 0, 1);
  189.   n->startcodeprefix_len = 4;
  191.   return n;
  192. }
  195. /*!
  196.  ************************************************************************
  197.  * brief
  198.  *    GenerateSequenceParameterSet: extracts info from global variables and
  199.  *    generates sequence parameter set structure
  200.  *
  201.  * par
  202.  *    Function reads all kinds of values from several global variables,
  203.  *    including params-> and image-> and fills in the sps.  Many
  204.  *    values are current hard-coded to defaults.
  205.  *
  206.  ************************************************************************
  207.  */
  209. void GenerateSequenceParameterSet( seq_parameter_set_rbsp_t *sps, //!< Sequence Parameter Set to be filled
  210.                                    int SPS_id                     //!< SPS ID
  211.                                    )
  212. {
  213.   unsigned i;
  214.   unsigned n_ScalingList;
  215.   int SubWidthC  [4]= { 1, 2, 2, 1};
  216.   int SubHeightC [4]= { 1, 2, 1, 1};
  218.   int frext_profile = ((IdentifyProfile()==FREXT_HP) ||
  219.                       (IdentifyProfile()==FREXT_Hi10P) ||
  220.                       (IdentifyProfile()==FREXT_Hi422) ||
  221.                       (IdentifyProfile()==FREXT_Hi444) ||
  222.                       (IdentifyProfile()==FREXT_CAVLC444));
  224.   // *************************************************************************
  225.   // Sequence Parameter Set
  226.   // *************************************************************************
  227.   assert (sps != NULL);
  228.   // Profile and Level should be calculated using the info from the config
  229.   // file.  Calculation is hidden in IndetifyProfile() and IdentifyLevel()
  230.   sps->profile_idc = IdentifyProfile();
  231.   sps->level_idc = IdentifyLevel();
  233.   // needs to be set according to profile
  234.   sps->constrained_set0_flag = FALSE;
  235.   sps->constrained_set1_flag = FALSE;
  236.   sps->constrained_set2_flag = FALSE;
  238.   if ( (sps->level_idc == 9) && !IS_FREXT_PROFILE(sps->profile_idc) ) // Level 1.b
  239.   {
  240.     sps->constrained_set3_flag = TRUE;
  241.     sps->level_idc = 11;
  242.   }
  243.   else if (frext_profile && params->IntraProfile)
  244.   {
  245.     sps->constrained_set3_flag = TRUE;
  246.   }
  247.   else
  248.   {
  249.     sps->constrained_set3_flag = FALSE;
  250.   }
  252.   // Parameter Set ID hard coded to zero
  253.   sps->seq_parameter_set_id = SPS_id;
  255.   // Fidelity Range Extensions stuff
  256.   sps->bit_depth_luma_minus8   = params->output.bit_depth[0] - 8;
  257.   sps->bit_depth_chroma_minus8 = params->output.bit_depth[1] - 8;
  258.   img->lossless_qpprime_flag = params->lossless_qpprime_y_zero_flag & 
  259.       (sps->profile_idc==FREXT_Hi444 || sps->profile_idc==FREXT_CAVLC444);
  261.   //! POC stuff:
  262.   //! The following values are hard-coded in init_poc().  Apparently,
  263.   //! the poc implementation covers only a subset of the poc functionality.
  264.   //! Here, the same subset is implemented.  Changes in the POC stuff have
  265.   //! also to be reflected here
  266.   sps->log2_max_frame_num_minus4 = log2_max_frame_num_minus4;
  267.   sps->log2_max_pic_order_cnt_lsb_minus4 = log2_max_pic_order_cnt_lsb_minus4;
  269.   sps->pic_order_cnt_type = params->pic_order_cnt_type;
  270.   sps->num_ref_frames_in_pic_order_cnt_cycle = img->num_ref_frames_in_pic_order_cnt_cycle;
  271.   sps->delta_pic_order_always_zero_flag = img->delta_pic_order_always_zero_flag;
  272.   sps->offset_for_non_ref_pic = img->offset_for_non_ref_pic;
  273.   sps->offset_for_top_to_bottom_field = img->offset_for_top_to_bottom_field;
  275.   for (i=0; i<img->num_ref_frames_in_pic_order_cnt_cycle; i++)
  276.   {
  277.     sps->offset_for_ref_frame[i] = img->offset_for_ref_frame[i];
  278.   }
  279.   // End of POC stuff
  281.   // Number of Reference Frames
  282.   sps->num_ref_frames = params->num_ref_frames;
  284.   //required_frame_num_update_behaviour_flag hardcoded to zero
  285.   sps->gaps_in_frame_num_value_allowed_flag = FALSE;    // double check
  287.   sps->frame_mbs_only_flag = (Boolean) !(params->PicInterlace || params->MbInterlace);
  289.   // Picture size, finally a simple one :-)
  290.   sps->pic_width_in_mbs_minus1        = (( params->output.width  + img->auto_crop_right)/16) -1;
  291.   sps->pic_height_in_map_units_minus1 = (((params->output.height + img->auto_crop_bottom)/16)/ (2 - sps->frame_mbs_only_flag)) - 1;
  293.   // a couple of flags, simple
  294.   sps->mb_adaptive_frame_field_flag = (Boolean) (FRAME_CODING != params->MbInterlace);
  295.   sps->direct_8x8_inference_flag = (Boolean) params->directInferenceFlag;
  297.   // Sequence VUI not implemented, signalled as not present
  298.   sps->vui_parameters_present_flag = (Boolean) ((params->rgb_input_flag && params->yuv_format==3) || params->EnableVUISupport);
  300.   sps->chroma_format_idc = params->yuv_format;
  301.   sps->separate_colour_plane_flag = ( sps->chroma_format_idc == YUV444 ) ? params->separate_colour_plane_flag : 0;
  303.   if ( sps->vui_parameters_present_flag )
  304.     GenerateVUIParameters(sps);
  306.   // This should be moved somewhere else.
  307.   {
  308.     int PicWidthInMbs, PicHeightInMapUnits, FrameHeightInMbs;
  309.     int width, height;
  310.     int nplane;
  311.     PicWidthInMbs = (sps->pic_width_in_mbs_minus1 +1);
  312.     PicHeightInMapUnits = (sps->pic_height_in_map_units_minus1 +1);
  313.     FrameHeightInMbs = ( 2 - sps->frame_mbs_only_flag ) * PicHeightInMapUnits;
  315.     width = PicWidthInMbs * MB_BLOCK_SIZE;
  316.     height = FrameHeightInMbs * MB_BLOCK_SIZE;
  318.     if( IS_INDEPENDENT(params) )
  319.     {
  320.       for( nplane=0; nplane<MAX_PLANE; nplane++ )
  321.       {
  322.         Co_located_JV[nplane] = alloc_colocated (width, height,sps->mb_adaptive_frame_field_flag);           
  323.       }
  324.     }
  325.     else
  326.     {
  327.       Co_located = alloc_colocated (width, height,sps->mb_adaptive_frame_field_flag);
  328.     }
  329.   }
  331.   // Fidelity Range Extensions stuff
  332.   if(frext_profile)
  333.   {
  335.     sps->seq_scaling_matrix_present_flag = (Boolean) (params->ScalingMatrixPresentFlag&1);
  336.     n_ScalingList = (sps->chroma_format_idc != YUV444) ? 8 : 12;
  337.     for(i=0; i<n_ScalingList; i++)
  338.     {
  339.       if(i<6)
  340.         sps->seq_scaling_list_present_flag[i] = (params->ScalingListPresentFlag[i]&1);
  341.       else
  342.       {
  343.         if(params->Transform8x8Mode)
  344.           sps->seq_scaling_list_present_flag[i] = (params->ScalingListPresentFlag[i]&1);
  345.         else
  346.           sps->seq_scaling_list_present_flag[i] = 0;
  347.       }
  348.       if( sps->seq_scaling_matrix_present_flag == FALSE )
  349.         sps->seq_scaling_list_present_flag[i] = 0;
  350.     }
  351.   }
  352.   else
  353.   {
  354.     sps->seq_scaling_matrix_present_flag = FALSE;
  355.     for(i=0; i<12; i++)
  356.       sps->seq_scaling_list_present_flag[i] = 0;
  358.   }
  361.   if (img->auto_crop_right || img->auto_crop_bottom)
  362.   {
  363.     sps->frame_cropping_flag = TRUE;
  364.     sps->frame_cropping_rect_left_offset=0;
  365.     sps->frame_cropping_rect_top_offset=0;
  366.     sps->frame_cropping_rect_right_offset=  (img->auto_crop_right / SubWidthC[sps->chroma_format_idc]);
  367.     sps->frame_cropping_rect_bottom_offset= (img->auto_crop_bottom / (SubHeightC[sps->chroma_format_idc] * (2 - sps->frame_mbs_only_flag)));
  368.     if (img->auto_crop_right % SubWidthC[sps->chroma_format_idc])
  369.     {
  370.       error("automatic frame cropping (width) not possible",500);
  371.     }
  372.     if (img->auto_crop_bottom % (SubHeightC[sps->chroma_format_idc] * (2 - sps->frame_mbs_only_flag)))
  373.     {
  374.       error("automatic frame cropping (height) not possible",500);
  375.     }
  376.   }
  377.   else
  378.   {
  379.     sps->frame_cropping_flag = FALSE;
  380.   }
  382. }
  384. /*!
  385.  ************************************************************************
  386.  * brief
  387.  *    GeneratePictureParameterSet:
  388.  *    Generates a Picture Parameter Set structure
  389.  *
  390.  * par
  391.  *    Regarding the QP
  392.  *    The previous software versions coded the absolute QP only in the
  393.  *    slice header.  This is kept, and the offset in the PPS is coded
  394.  *    even if we could save bits by intelligently using this field.
  395.  *
  396.  ************************************************************************
  397.  */
  399. void GeneratePictureParameterSet( pic_parameter_set_rbsp_t *pps, //!< Picture Parameter Set to be filled
  400.                                   seq_parameter_set_rbsp_t *sps, //!< used Sequence Parameter Set
  401.                                   int PPS_id,                    //!< PPS ID
  402.                                   int WeightedPrediction,        //!< value of weighted_pred_flag
  403.                                   int WeightedBiprediction,      //!< value of weighted_bipred_idc
  404.                                   int cb_qp_index_offset,        //!< value of cb_qp_index_offset
  405.                                   int cr_qp_index_offset         //!< value of cr_qp_index_offset
  406.                                   )
  407. {
  408.   unsigned i;
  409.   unsigned n_ScalingList;
  411.   int frext_profile = ((IdentifyProfile()==FREXT_HP) ||
  412.                       (IdentifyProfile()==FREXT_Hi10P) ||
  413.                       (IdentifyProfile()==FREXT_Hi422) ||
  414.                       (IdentifyProfile()==FREXT_Hi444) ||
  415.                       (IdentifyProfile()==FREXT_CAVLC444));
  417.   // *************************************************************************
  418.   // Picture Parameter Set
  419.   // *************************************************************************
  421.   pps->seq_parameter_set_id = sps->seq_parameter_set_id;
  422.   pps->pic_parameter_set_id = PPS_id;
  423.   pps->entropy_coding_mode_flag = (params->symbol_mode == CAVLC ? FALSE : TRUE);
  425.   // Fidelity Range Extensions stuff
  426.   if(frext_profile)
  427.   {
  428.     pps->transform_8x8_mode_flag = (params->Transform8x8Mode ? TRUE:FALSE);
  429.     pps->pic_scaling_matrix_present_flag = (Boolean) ((params->ScalingMatrixPresentFlag&2)>>1);
  430.     n_ScalingList = (sps->chroma_format_idc != YUV444) ? 8 : 12;
  431.     for(i=0; i<n_ScalingList; i++)
  432.     {
  433.       if(i<6)
  434.         pps->pic_scaling_list_present_flag[i] = (params->ScalingListPresentFlag[i]&2)>>1;
  435.       else
  436.       {
  437.         if(pps->transform_8x8_mode_flag)
  438.           pps->pic_scaling_list_present_flag[i] = (params->ScalingListPresentFlag[i]&2)>>1;
  439.         else
  440.           pps->pic_scaling_list_present_flag[i] = 0;
  441.       }
  442.       if( pps->pic_scaling_matrix_present_flag == FALSE )
  443.         pps->pic_scaling_list_present_flag[i] = 0;
  444.     }
  445.   }
  446.   else
  447.   {
  448.     pps->pic_scaling_matrix_present_flag = FALSE;
  449.     for(i=0; i<12; i++)
  450.       pps->pic_scaling_list_present_flag[i] = 0;
  452.     pps->transform_8x8_mode_flag = FALSE;
  453.     params->Transform8x8Mode = 0;
  454.   }
  456.   // JVT-Fxxx (by Stephan Wenger, make this flag unconditional
  457.   pps->pic_order_present_flag = img->pic_order_present_flag;
  460.   // Begin FMO stuff
  461.   pps->num_slice_groups_minus1 = params->num_slice_groups_minus1;
  464.   //! Following set the parameter for different slice group types
  465.   if (pps->num_slice_groups_minus1 > 0)
  466.   {
  467.      if ((pps->slice_group_id = calloc ((sps->pic_height_in_map_units_minus1+1)*(sps->pic_width_in_mbs_minus1+1), sizeof(byte))) == NULL)
  468.        no_mem_exit ("GeneratePictureParameterSet: slice_group_id");
  470.     switch (params->slice_group_map_type)
  471.     {
  472.     case 0:
  473.       pps->slice_group_map_type = 0;
  474.       for(i=0; i<=pps->num_slice_groups_minus1; i++)
  475.       {
  476.         pps->run_length_minus1[i]=params->run_length_minus1[i];
  477.       }
  478.       break;
  479.     case 1:
  480.       pps->slice_group_map_type = 1;
  481.       break;
  482.     case 2:
  483.       // i loops from 0 to num_slice_groups_minus1-1, because no info for background needed
  484.       pps->slice_group_map_type = 2;
  485.       for(i=0; i<pps->num_slice_groups_minus1; i++)
  486.       {
  487.         pps->top_left[i] = params->top_left[i];
  488.         pps->bottom_right[i] = params->bottom_right[i];
  489.       }
  490.      break;
  491.     case 3:
  492.     case 4:
  493.     case 5:
  494.       pps->slice_group_map_type = params->slice_group_map_type;
  495.       pps->slice_group_change_direction_flag = (Boolean) params->slice_group_change_direction_flag;
  496.       pps->slice_group_change_rate_minus1 = params->slice_group_change_rate_minus1;
  497.       break;
  498.     case 6:
  499.       pps->slice_group_map_type = 6;
  500.       pps->pic_size_in_map_units_minus1 =
  501.         (((params->output.height + img->auto_crop_bottom)/MB_BLOCK_SIZE)/(2-sps->frame_mbs_only_flag))
  502.         *((params->output.width  + img->auto_crop_right)/MB_BLOCK_SIZE) -1;
  504.       for (i=0;i<=pps->pic_size_in_map_units_minus1; i++)
  505.         pps->slice_group_id[i] = params->slice_group_id[i];
  507.       break;
  508.     default:
  509.       printf ("Parset.c: slice_group_map_type invalid, defaultn");
  510.       assert (0==1);
  511.     }
  512.   }
  513. // End FMO stuff
  515.   pps->num_ref_idx_l0_active_minus1 = sps->frame_mbs_only_flag ? (sps->num_ref_frames-1) : (2 * sps->num_ref_frames - 1) ;   // set defaults
  516.   pps->num_ref_idx_l1_active_minus1 = sps->frame_mbs_only_flag ? (sps->num_ref_frames-1) : (2 * sps->num_ref_frames - 1) ;   // set defaults
  518.   pps->weighted_pred_flag = (Boolean) WeightedPrediction;
  519.   pps->weighted_bipred_idc = WeightedBiprediction;
  521.   pps->pic_init_qp_minus26 = 0;         // hard coded to zero, QP lives in the slice header
  522.   pps->pic_init_qs_minus26 = 0;
  524.   pps->chroma_qp_index_offset = cb_qp_index_offset;
  525.   if (frext_profile)
  526.   {
  527.     pps->cb_qp_index_offset     = cb_qp_index_offset;
  528.     pps->cr_qp_index_offset     = cr_qp_index_offset;
  529.   }
  530.   else
  531.     pps->cb_qp_index_offset = pps->cr_qp_index_offset = pps->chroma_qp_index_offset;
  533.   pps->deblocking_filter_control_present_flag = (Boolean) params->DFSendParameters;
  534.   pps->constrained_intra_pred_flag = (Boolean) params->UseConstrainedIntraPred;
  536.   // if redundant slice is in use.
  537.   pps->redundant_pic_cnt_present_flag = (Boolean) params->redundant_pic_flag;
  538. }
  540. /*!
  541.  *************************************************************************************
  542.  * brief
  543.  *    syntax for scaling list matrix values
  544.  *
  545.  * param scalingListinput
  546.  *    input scaling list
  547.  * param scalingList
  548.  *    scaling list to be used
  549.  * param sizeOfScalingList
  550.  *    size of the scaling list
  551.  * param UseDefaultScalingMatrix
  552.  *    usage of default Scaling Matrix
  553.  * param bitstream
  554.  *    target bitstream for writing syntax
  555.  *
  556.  * return
  557.  *    size of the RBSP in bytes
  558.  *
  559.  *************************************************************************************
  560.  */
  561. int Scaling_List(short *scalingListinput, short *scalingList, int sizeOfScalingList, short *UseDefaultScalingMatrix, Bitstream *bitstream)
  562. {
  563.   int j, scanj;
  564.   int len=0;
  565.   int delta_scale, lastScale, nextScale;
  567.   lastScale = 8;
  568.   nextScale = 8;
  570.   for(j=0; j<sizeOfScalingList; j++)
  571.   {
  572.     scanj = (sizeOfScalingList==16) ? ZZ_SCAN[j]:ZZ_SCAN8[j];
  574.     if(nextScale!=0)
  575.     {
  576.       delta_scale = scalingListinput[scanj]-lastScale; // Calculate delta from the scalingList data from the input file
  577.       if(delta_scale>127)
  578.         delta_scale=delta_scale-256;
  579.       else if(delta_scale<-128)
  580.         delta_scale=delta_scale+256;
  582.       len+=se_v ("   : delta_sl   ",                      delta_scale,                       bitstream);
  583.       nextScale = scalingListinput[scanj];
  584.       *UseDefaultScalingMatrix|=(scanj==0 && nextScale==0); // Check first matrix value for zero
  585.     }
  587.     scalingList[scanj] = (short) ((nextScale==0) ? lastScale:nextScale); // Update the actual scalingList matrix with the correct values
  588.     lastScale = scalingList[scanj];
  589.   }
  591.   return len;
  592. }
  595. /*!
  596.  *************************************************************************************
  597.  * brief
  598.  *    int GenerateSeq_parameter_set_rbsp (seq_parameter_set_rbsp_t *sps, char *rbsp);
  599.  *
  600.  * param sps
  601.  *    sequence parameter structure
  602.  * param rbsp
  603.  *    buffer to be filled with the rbsp, size should be at least MAXIMUMPARSETRBSPSIZE
  604.  *
  605.  * return
  606.  *    size of the RBSP in bytes
  607.  *
  608.  * note
  609.  *    Sequence Parameter VUI function is called, but the function implements
  610.  *    an exit (-1)
  611.  *************************************************************************************
  612.  */
  613. int GenerateSeq_parameter_set_rbsp (seq_parameter_set_rbsp_t *sps, byte *rbsp)
  614. {
  615.   Bitstream *bitstream;
  616.   int len = 0, LenInBytes;
  617.   unsigned i;
  618.   unsigned n_ScalingList;
  620.   assert (rbsp != NULL);
  622.   if ((bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("SeqParameterSet:bitstream");
  624.   // .. and use the rbsp provided (or allocated above) for the data
  625.   bitstream->streamBuffer = rbsp;
  626.   bitstream->bits_to_go = 8;
  628.   len+=u_v  (8, "SPS: profile_idc",                             sps->profile_idc,                               bitstream);
  630.   len+=u_1  ("SPS: constrained_set0_flag",                      sps->constrained_set0_flag,    bitstream);
  631.   len+=u_1  ("SPS: constrained_set1_flag",                      sps->constrained_set1_flag,    bitstream);
  632.   len+=u_1  ("SPS: constrained_set2_flag",                      sps->constrained_set2_flag,    bitstream);
  633.   len+=u_1  ("SPS: constrained_set3_flag",                      sps->constrained_set3_flag,    bitstream);
  634.   len+=u_v  (4, "SPS: reserved_zero_4bits",                     0,                             bitstream);
  636.   len+=u_v  (8, "SPS: level_idc",                               sps->level_idc,                                 bitstream);
  638.   len+=ue_v ("SPS: seq_parameter_set_id",                    sps->seq_parameter_set_id,                      bitstream);
  640.   // Fidelity Range Extensions stuff
  641.   if( IS_FREXT_PROFILE(sps->profile_idc) )
  642.   {
  643.     len+=ue_v ("SPS: chroma_format_idc",                        sps->chroma_format_idc,                          bitstream);
  644.     if(img->yuv_format == YUV444)
  645.       len+=u_1  ("SPS: separate_colour_plane_flag",             sps->separate_colour_plane_flag,                 bitstream);
  646.     len+=ue_v ("SPS: bit_depth_luma_minus8",                    sps->bit_depth_luma_minus8,                      bitstream);
  647.     len+=ue_v ("SPS: bit_depth_chroma_minus8",                  sps->bit_depth_chroma_minus8,                    bitstream);
  648.     len+=u_1  ("SPS: lossless_qpprime_y_zero_flag",             img->lossless_qpprime_flag,                      bitstream);
  649.     //other chroma info to be added in the future
  651.     len+=u_1 ("SPS: seq_scaling_matrix_present_flag",           sps->seq_scaling_matrix_present_flag,            bitstream);
  653.     if(sps->seq_scaling_matrix_present_flag)
  654.     {
  655.       n_ScalingList = (sps->chroma_format_idc != YUV444) ? 8 : 12;
  656.       for(i=0; i<n_ScalingList; i++)
  657.       {
  658.         len+=u_1 ("SPS: seq_scaling_list_present_flag",         sps->seq_scaling_list_present_flag[i],           bitstream);
  659.         if(sps->seq_scaling_list_present_flag[i])
  660.         {
  661.           if(i<6)
  662.             len+=Scaling_List(ScalingList4x4input[i], ScalingList4x4[i], 16, &UseDefaultScalingMatrix4x4Flag[i], bitstream);
  663.           else
  664.             len+=Scaling_List(ScalingList8x8input[i-6], ScalingList8x8[i-6], 64, &UseDefaultScalingMatrix8x8Flag[i-6], bitstream);
  665.         }
  666.       }
  667.     }
  668.   }
  670.   len+=ue_v ("SPS: log2_max_frame_num_minus4",               sps->log2_max_frame_num_minus4,                 bitstream);
  671.   len+=ue_v ("SPS: pic_order_cnt_type",                      sps->pic_order_cnt_type,                        bitstream);
  673.   if (sps->pic_order_cnt_type == 0)
  674.     len+=ue_v ("SPS: log2_max_pic_order_cnt_lsb_minus4",     sps->log2_max_pic_order_cnt_lsb_minus4,         bitstream);
  675.   else if (sps->pic_order_cnt_type == 1)
  676.   {
  677.     len+=u_1  ("SPS: delta_pic_order_always_zero_flag",        sps->delta_pic_order_always_zero_flag,          bitstream);
  678.     len+=se_v ("SPS: offset_for_non_ref_pic",                  sps->offset_for_non_ref_pic,                    bitstream);
  679.     len+=se_v ("SPS: offset_for_top_to_bottom_field",          sps->offset_for_top_to_bottom_field,            bitstream);
  680.     len+=ue_v ("SPS: num_ref_frames_in_pic_order_cnt_cycle",   sps->num_ref_frames_in_pic_order_cnt_cycle,     bitstream);
  681.     for (i=0; i<sps->num_ref_frames_in_pic_order_cnt_cycle; i++)
  682.       len+=se_v ("SPS: offset_for_ref_frame",                  sps->offset_for_ref_frame[i],                      bitstream);
  683.   }
  684.   len+=ue_v ("SPS: num_ref_frames",                          sps->num_ref_frames,                            bitstream);
  685.   len+=u_1  ("SPS: gaps_in_frame_num_value_allowed_flag",    sps->gaps_in_frame_num_value_allowed_flag,      bitstream);
  686.   len+=ue_v ("SPS: pic_width_in_mbs_minus1",                 sps->pic_width_in_mbs_minus1,                   bitstream);
  687.   len+=ue_v ("SPS: pic_height_in_map_units_minus1",          sps->pic_height_in_map_units_minus1,            bitstream);
  688.   len+=u_1  ("SPS: frame_mbs_only_flag",                     sps->frame_mbs_only_flag,                       bitstream);
  689.   if (!sps->frame_mbs_only_flag)
  690.   {
  691.     len+=u_1  ("SPS: mb_adaptive_frame_field_flag",            sps->mb_adaptive_frame_field_flag,              bitstream);
  692.   }
  693.   len+=u_1  ("SPS: direct_8x8_inference_flag",               sps->direct_8x8_inference_flag,                 bitstream);
  695.   len+=u_1  ("SPS: frame_cropping_flag",                      sps->frame_cropping_flag,                       bitstream);
  696.   if (sps->frame_cropping_flag)
  697.   {
  698.     len+=ue_v ("SPS: frame_cropping_rect_left_offset",          sps->frame_cropping_rect_left_offset,           bitstream);
  699.     len+=ue_v ("SPS: frame_cropping_rect_right_offset",         sps->frame_cropping_rect_right_offset,          bitstream);
  700.     len+=ue_v ("SPS: frame_cropping_rect_top_offset",           sps->frame_cropping_rect_top_offset,            bitstream);
  701.     len+=ue_v ("SPS: frame_cropping_rect_bottom_offset",        sps->frame_cropping_rect_bottom_offset,         bitstream);
  702.   }
  704.   len+=u_1  ("SPS: vui_parameters_present_flag",             sps->vui_parameters_present_flag,               bitstream);
  706.   if (sps->vui_parameters_present_flag)
  707.     len+=GenerateVUI_parameters_rbsp(sps, bitstream);    // currently a dummy, asserting
  709.   SODBtoRBSP(bitstream);     // copies the last couple of bits into the byte buffer
  711.   LenInBytes=bitstream->byte_pos;
  713.   free (bitstream);
  715.   return LenInBytes;
  716. }
  719. /*!
  720.  ***********************************************************************************************
  721.  * brief
  722.  *    int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *sps, char *rbsp);
  723.  *
  724.  * param pps
  725.  *    picture parameter structure
  726.  * param rbsp
  727.  *    buffer to be filled with the rbsp, size should be at least MAXIMUMPARSETRBSPSIZE
  728.  *
  729.  * return
  730.  *    size of the RBSP in bytes, negative in case of an error
  731.  *
  732.  * note
  733.  *    Picture Parameter VUI function is called, but the function implements
  734.  *    an exit (-1)
  735.  ************************************************************************************************
  736.  */
  738. int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *pps, byte *rbsp)
  739. {
  740.   Bitstream *bitstream;
  741.   int len = 0, LenInBytes;
  742.   unsigned i;
  743.   unsigned n_ScalingList;
  744.   unsigned NumberBitsPerSliceGroupId;
  745.   int profile_idc;
  747.   assert (rbsp != NULL);
  749.   if ((bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("PicParameterSet:bitstream");
  751.   // .. and use the rbsp provided (or allocated above) for the data
  752.   bitstream->streamBuffer = rbsp;
  753.   bitstream->bits_to_go = 8;
  755.   pps->pic_order_present_flag = img->pic_order_present_flag;
  757.   len+=ue_v ("PPS: pic_parameter_set_id",                    pps->pic_parameter_set_id,                      bitstream);
  758.   len+=ue_v ("PPS: seq_parameter_set_id",                    pps->seq_parameter_set_id,                      bitstream);
  759.   len+=u_1  ("PPS: entropy_coding_mode_flag",                pps->entropy_coding_mode_flag,                  bitstream);
  760.   len+=u_1  ("PPS: pic_order_present_flag",                  pps->pic_order_present_flag,                    bitstream);
  761.   len+=ue_v ("PPS: num_slice_groups_minus1",                 pps->num_slice_groups_minus1,                   bitstream);
  763.   // FMO stuff
  764.   if(pps->num_slice_groups_minus1 > 0 )
  765.   {
  766.     len+=ue_v ("PPS: slice_group_map_type",                 pps->slice_group_map_type,                   bitstream);
  767.     if (pps->slice_group_map_type == 0)
  768.       for (i=0; i<=pps->num_slice_groups_minus1; i++)
  769.         len+=ue_v ("PPS: run_length_minus1[i]",                           pps->run_length_minus1[i],                             bitstream);
  770.     else if (pps->slice_group_map_type==2)
  771.       for (i=0; i<pps->num_slice_groups_minus1; i++)
  772.       {
  774.         len+=ue_v ("PPS: top_left[i]",                          pps->top_left[i],                           bitstream);
  775.         len+=ue_v ("PPS: bottom_right[i]",                      pps->bottom_right[i],                       bitstream);
  776.       }
  777.     else if (pps->slice_group_map_type == 3 ||
  778.              pps->slice_group_map_type == 4 ||
  779.              pps->slice_group_map_type == 5)
  780.     {
  781.       len+=u_1  ("PPS: slice_group_change_direction_flag",         pps->slice_group_change_direction_flag,         bitstream);
  782.       len+=ue_v ("PPS: slice_group_change_rate_minus1",            pps->slice_group_change_rate_minus1,            bitstream);
  783.     }
  784.     else if (pps->slice_group_map_type == 6)
  785.     {
  786.       if (pps->num_slice_groups_minus1>=4)
  787.         NumberBitsPerSliceGroupId=3;
  788.       else if (pps->num_slice_groups_minus1>=2)
  789.         NumberBitsPerSliceGroupId=2;
  790.       else if (pps->num_slice_groups_minus1>=1)
  791.         NumberBitsPerSliceGroupId=1;
  792.       else
  793.         NumberBitsPerSliceGroupId=0;
  795.       len+=ue_v ("PPS: pic_size_in_map_units_minus1",                       pps->pic_size_in_map_units_minus1,             bitstream);
  796.       for(i=0; i<=pps->pic_size_in_map_units_minus1; i++)
  797.         len+= u_v  (NumberBitsPerSliceGroupId, "PPS: >slice_group_id[i]",   pps->slice_group_id[i],                        bitstream);
  798.     }
  799.   }
  800.   // End of FMO stuff
  802.   len+=ue_v ("PPS: num_ref_idx_l0_active_minus1",             pps->num_ref_idx_l0_active_minus1,              bitstream);
  803.   len+=ue_v ("PPS: num_ref_idx_l1_active_minus1",             pps->num_ref_idx_l1_active_minus1,              bitstream);
  804.   len+=u_1  ("PPS: weighted_pred_flag",                       pps->weighted_pred_flag,                        bitstream);
  805.   len+=u_v  (2, "PPS: weighted_bipred_idc",                   pps->weighted_bipred_idc,                       bitstream);
  806.   len+=se_v ("PPS: pic_init_qp_minus26",                      pps->pic_init_qp_minus26,                       bitstream);
  807.   len+=se_v ("PPS: pic_init_qs_minus26",                      pps->pic_init_qs_minus26,                       bitstream);
  809.   profile_idc = IdentifyProfile();
  810.   if( IS_FREXT_PROFILE(profile_idc) )
  811.     len+=se_v ("PPS: chroma_qp_index_offset",                 pps->cb_qp_index_offset,                        bitstream);
  812.   else
  813.     len+=se_v ("PPS: chroma_qp_index_offset",                 pps->chroma_qp_index_offset,                    bitstream);
  815.   len+=u_1  ("PPS: deblocking_filter_control_present_flag",   pps->deblocking_filter_control_present_flag,    bitstream);
  816.   len+=u_1  ("PPS: constrained_intra_pred_flag",              pps->constrained_intra_pred_flag,               bitstream);
  817.   len+=u_1  ("PPS: redundant_pic_cnt_present_flag",           pps->redundant_pic_cnt_present_flag,            bitstream);
  819.   // Fidelity Range Extensions stuff
  820.   if( IS_FREXT_PROFILE(profile_idc) )
  821.   {
  822.     len+=u_1  ("PPS: transform_8x8_mode_flag",                pps->transform_8x8_mode_flag,                   bitstream);
  824.     len+=u_1  ("PPS: pic_scaling_matrix_present_flag",        pps->pic_scaling_matrix_present_flag,           bitstream);
  826.     if(pps->pic_scaling_matrix_present_flag)
  827.     {
  828.       n_ScalingList = 6 + ((active_sps->chroma_format_idc != 3) ? 2 : 6) * pps->transform_8x8_mode_flag;
  829.       for(i=0; i<n_ScalingList; i++)  // SS-70226
  830.       {
  831.         len+=u_1  ("PPS: pic_scaling_list_present_flag",      pps->pic_scaling_list_present_flag[i],          bitstream);
  833.         if(pps->pic_scaling_list_present_flag[i])
  834.         {
  835.           if(i<6)
  836.             len+=Scaling_List(ScalingList4x4input[i], ScalingList4x4[i], 16, &UseDefaultScalingMatrix4x4Flag[i], bitstream);
  837.           else
  838.             len+=Scaling_List(ScalingList8x8input[i-6], ScalingList8x8[i-6], 64, &UseDefaultScalingMatrix8x8Flag[i-6], bitstream);
  839.         }
  840.       }
  841.     }
  842.     len+=se_v ("PPS: second_chroma_qp_index_offset",          pps->cr_qp_index_offset,                        bitstream);
  843.   }
  845.   SODBtoRBSP(bitstream);     // copies the last couple of bits into the byte buffer
  847.   LenInBytes=bitstream->byte_pos;
  849.   // Get rid of the helper structures
  850.   free (bitstream);
  852.   return LenInBytes;
  853. }
  857. /*!
  858.  *************************************************************************************
  859.  * brief
  860.  *    Returns the Profile
  861.  *
  862.  * return
  863.  *    Profile according to Annex A
  864.  *
  865.  * note
  866.  *    Function is currently a dummy.  Should "calculate" the profile from those
  867.  *    config file parameters.  E.g.
  868.  *
  869.  *    Profile = Baseline;
  870.  *    if (CABAC Used || Interlace used) Profile=Main;
  871.  *    if (!Cabac Used) && (Bframes | SPframes) Profile = Streaming;
  872.  *
  873.  *************************************************************************************
  874.  */
  875. int IdentifyProfile(void)
  876. {
  877.   return params->ProfileIDC;
  878. }
  880. /*!
  881.  *************************************************************************************
  882.  * brief
  883.  *    Returns the Level
  884.  *
  885.  * return
  886.  *    Level according to Annex A
  887.  *
  888.  * note
  889.  *    This function is currently a dummy, but should calculate the level out of
  890.  *    the config file parameters (primarily the picture size)
  891.  *************************************************************************************
  892.  */
  893. int IdentifyLevel(void)
  894. {
  895.   return params->LevelIDC;
  896. }
  899. /*!
  900.  *************************************************************************************
  901.  * brief
  902.  *    Function body for VUI Parameter generation (to be done)
  903.  *
  904.  * return
  905.  *    exits with error message
  906.  *************************************************************************************
  907.  */
  908. static int GenerateVUI_parameters_rbsp(seq_parameter_set_rbsp_t *sps, Bitstream *bitstream)
  909. {
  910.   int len=0;
  911.   vui_seq_parameters_t *vui_seq_parameters = &(sps->vui_seq_parameters);
  913.   len+=u_1 ("VUI: aspect_ratio_info_present_flag", vui_seq_parameters->aspect_ratio_info_present_flag, bitstream);
  914.   if (vui_seq_parameters->aspect_ratio_info_present_flag)
  915.   {        
  916.     len+=u_v (8,"VUI: aspect_ratio_idc", vui_seq_parameters->aspect_ratio_idc, bitstream);
  917.     if (vui_seq_parameters->aspect_ratio_idc == 255)
  918.     {
  919.       len+=u_v (16,"VUI: sar_width",  vui_seq_parameters->sar_width,  bitstream);
  920.       len+=u_v (16,"VUI: sar_height", vui_seq_parameters->sar_height, bitstream);
  921.     }
  922.   }  
  924.   len+=u_1 ("VUI: overscan_info_present_flag", vui_seq_parameters->overscan_info_present_flag, bitstream);
  925.   if (vui_seq_parameters->overscan_info_present_flag)
  926.   {
  927.     len+=u_1 ("VUI: overscan_appropriate_flag", vui_seq_parameters->overscan_appropriate_flag, bitstream);
  928.   } 
  930.   len+=u_1 ("VUI: video_signal_type_present_flag", vui_seq_parameters->video_signal_type_present_flag, bitstream);
  931.   if (vui_seq_parameters->video_signal_type_present_flag)
  932.   {
  933.     len+=u_v (3,"VUI: video_format", vui_seq_parameters->video_format, bitstream);
  934.     len+=u_1 ("VUI: video_full_range_flag", vui_seq_parameters->video_full_range_flag, bitstream);
  935.     len+=u_1 ("VUI: colour_description_present_flag", vui_seq_parameters->colour_description_present_flag, bitstream);
  936.     if (vui_seq_parameters->colour_description_present_flag)
  937.     {
  938.       len+=u_v (8,"VUI: colour_primaries", vui_seq_parameters->colour_primaries, bitstream);
  939.       len+=u_v (8,"VUI: transfer_characteristics", vui_seq_parameters->transfer_characteristics, bitstream);
  940.       len+=u_v (8,"VUI: matrix_coefficients", vui_seq_parameters->matrix_coefficients, bitstream);
  941.     }
  942.   }
  944.   len+=u_1 ("VUI: chroma_loc_info_present_flag", vui_seq_parameters->chroma_location_info_present_flag, bitstream);
  945.   if (vui_seq_parameters->chroma_location_info_present_flag)
  946.   {
  947.     len+=ue_v ("VUI: chroma_sample_loc_type_top_field", vui_seq_parameters->chroma_sample_loc_type_top_field, bitstream);
  948.     len+=ue_v ("VUI: chroma_sample_loc_type_bottom_field", vui_seq_parameters->chroma_sample_loc_type_bottom_field, bitstream);
  949.   }
  951.   len+=u_1 ("VUI: timing_info_present_flag", vui_seq_parameters->timing_info_present_flag, bitstream);
  952.   // timing parameters
  953.   if (vui_seq_parameters->timing_info_present_flag)
  954.   {
  955.     len+=u_v (32,"VUI: num_units_in_tick",  vui_seq_parameters->num_units_in_tick, bitstream);
  956.     len+=u_v (32,"VUI: time_scale",         vui_seq_parameters->time_scale, bitstream);
  957.     len+=u_1 ("VUI: fixed_frame_rate_flag", vui_seq_parameters->fixed_frame_rate_flag, bitstream);
  958.   }
  959.   // end of timing parameters
  960.   // nal_hrd_parameters_present_flag
  961.   len+=u_1 ("VUI: nal_hrd_parameters_present_flag", vui_seq_parameters->nal_hrd_parameters_present_flag, bitstream);
  962.   if ( vui_seq_parameters->nal_hrd_parameters_present_flag )
  963.   {
  964.     len += WriteHRDParameters(sps, bitstream);
  965.   }
  966.   // vcl_hrd_parameters_present_flag
  967.   len+=u_1 ("VUI: vcl_hrd_parameters_present_flag", vui_seq_parameters->vcl_hrd_parameters_present_flag, bitstream);
  968.   if ( vui_seq_parameters->vcl_hrd_parameters_present_flag )
  969.   {
  970.     len += WriteHRDParameters(sps, bitstream);
  971.   }
  972.   if ( vui_seq_parameters->nal_hrd_parameters_present_flag || vui_seq_parameters->vcl_hrd_parameters_present_flag )
  973.   {
  974.     len+=u_1 ("VUI: low_delay_hrd_flag", vui_seq_parameters->low_delay_hrd_flag, bitstream );
  975.   }
  976.   len+=u_1 ("VUI: pic_struct_present_flag", vui_seq_parameters->pic_struct_present_flag, bitstream);
  978.   len+=u_1 ("VUI: bitstream_restriction_flag", vui_seq_parameters->bitstream_restriction_flag, bitstream);
  979.   if (vui_seq_parameters->bitstream_restriction_flag)
  980.   {
  981.     len+=u_1  ("VUI: motion_vectors_over_pic_boundaries_flag", vui_seq_parameters->motion_vectors_over_pic_boundaries_flag, bitstream);
  982.     len+=ue_v ("VUI: max_bytes_per_pic_denom", vui_seq_parameters->max_bytes_per_pic_denom, bitstream);
  983.     len+=ue_v ("VUI: max_bits_per_mb_denom", vui_seq_parameters->max_bits_per_mb_denom, bitstream);
  984.     len+=ue_v ("VUI: log2_max_mv_length_horizontal", vui_seq_parameters->log2_max_mv_length_horizontal, bitstream);
  985.     len+=ue_v ("VUI: log2_max_mv_length_vertical", vui_seq_parameters->log2_max_mv_length_vertical, bitstream);
  986.     len+=ue_v ("VUI: num_reorder_frames", vui_seq_parameters->num_reorder_frames, bitstream);
  987.     len+=ue_v ("VUI: max_dec_frame_buffering", vui_seq_parameters->max_dec_frame_buffering, bitstream);
  988.   }
  990.   return len;
  991. }
  993. /*!
  994.  *************************************************************************************
  995.  * brief
  996.  *    Function body for SEI message NALU generation
  997.  *
  998.  * return
  999.  *    A NALU containing the SEI messages
  1000.  *
  1001.  *************************************************************************************
  1002.  */
  1003. NALU_t *GenerateSEImessage_NALU()
  1004. {
  1005.   NALU_t *n = AllocNALU(64000);
  1006.   int RBSPlen = 0;
  1007.   int NALUlen;
  1008.   byte rbsp[MAXRBSPSIZE];
  1010.   RBSPlen = GenerateSEImessage_rbsp (NORMAL_SEI, rbsp);
  1011.   NALUlen = RBSPtoNALU (rbsp, n, RBSPlen, NALU_TYPE_SEI, NALU_PRIORITY_DISPOSABLE, 0, 1);
  1012.   n->startcodeprefix_len = 4;
  1014.   return n;
  1015. }
  1018. /*!
  1019.  *************************************************************************************
  1020.  * brief
  1021.  *    int GenerateSEImessage_rbsp (int, bufferingperiod_information_struct*, char*)
  1022.  *
  1023.  *
  1024.  * return
  1025.  *    size of the RBSP in bytes, negative in case of an error
  1026.  *
  1027.  * note
  1028.  *************************************************************************************
  1029.  */
  1030. int GenerateSEImessage_rbsp (int id, byte *rbsp)
  1031. {
  1032.   Bitstream *bitstream;
  1034.   int len = 0, LenInBytes;
  1035.   assert (rbsp != NULL);
  1037.   if ((bitstream=calloc(1, sizeof(Bitstream)))==NULL) 
  1038.     no_mem_exit("SeqParameterSet:bitstream");
  1040.   // .. and use the rbsp provided (or allocated above) for the data
  1041.   bitstream->streamBuffer = rbsp;
  1042.   bitstream->bits_to_go = 8;
  1044.   {
  1045.     char sei_message[500] = "";
  1046.     char uuid_message[9] = "RandomMSG"; // This is supposed to be Random
  1047.     unsigned int i, message_size = strlen(params->SEIMessageText);
  1048.     struct TIMEB tstruct;
  1049.     ftime( &tstruct);    // start time
  1051.     if (message_size == 0)
  1052.     {
  1053.       message_size = 13;
  1054.       strncpy(sei_message,"Empty Message",message_size);
  1055.     }
  1056.     else
  1057.       strncpy(sei_message,params->SEIMessageText,message_size);
  1059.     len+=u_v (8,"SEI: last_payload_type_byte", 5, bitstream);
  1060.     message_size += 17;
  1061.     while (message_size > 254)
  1062.     {
  1063.       len+=u_v (8,"SEI: ff_byte",255, bitstream);
  1064.       message_size -= 255;
  1065.     }
  1066.     len+=u_v (8,"SEI: last_payload_size_byte",message_size, bitstream);
  1068.     // Lets randomize uuid based on time
  1069.     len+=u_v (32,"SEI: uuid_iso_iec_11578",(int) tstruct.timezone, bitstream);
  1070.     len+=u_v (32,"SEI: uuid_iso_iec_11578",(int) tstruct.time*1000+tstruct.millitm, bitstream);
  1071.     len+=u_v (32,"SEI: uuid_iso_iec_11578",(int) (uuid_message[0] << 24) + (uuid_message[1] << 16)  + (uuid_message[2] << 8) + (uuid_message[3] << 0), bitstream);
  1072.     len+=u_v (32,"SEI: uuid_iso_iec_11578",(int) (uuid_message[4] << 24) + (uuid_message[5] << 16)  + (uuid_message[6] << 8) + (uuid_message[7] << 0), bitstream);
  1073.     for (i = 0; i < strlen(sei_message); i++)
  1074.       len+=u_v (8,"SEI: user_data_payload_byte",sei_message[i], bitstream);
  1076.     len+=u_v (8,"SEI: user_data_payload_byte",   0, bitstream);
  1077.   }
  1078.   SODBtoRBSP(bitstream);     // copies the last couple of bits into the byte buffer
  1080.   LenInBytes=bitstream->byte_pos;
  1082.   free(bitstream);
  1083.   return LenInBytes;
  1084. }
  1086. /*!
  1087.  *************************************************************************************
  1088.  * brief
  1089.  *    int WriteHRDParameters((seq_parameter_set_rbsp_t *sps, Bitstream *bitstream)
  1090.  *
  1091.  *
  1092.  * return
  1093.  *    size of the RBSP in bytes, negative in case of an error
  1094.  *
  1095.  * note
  1096.  *************************************************************************************
  1097.  */
  1099. int WriteHRDParameters(seq_parameter_set_rbsp_t *sps, Bitstream *bitstream)
  1100. {
  1101.   // hrd_parameters()
  1102.   int len = 0;
  1103.   unsigned int SchedSelIdx = 0;
  1104.   hrd_parameters_t *hrd = &(sps->vui_seq_parameters.nal_hrd_parameters);
  1106.   len+=ue_v ("VUI: cpb_cnt_minus1", hrd->cpb_cnt_minus1, bitstream);
  1107.   len+=u_v  (4, "VUI: bit_rate_scale", hrd->bit_rate_scale, bitstream);
  1108.   len+=u_v  (4, "VUI: cpb_size_scale", hrd->cpb_size_scale, bitstream);
  1110.   for( SchedSelIdx = 0; SchedSelIdx <= (hrd->cpb_cnt_minus1); SchedSelIdx++ )
  1111.   {
  1112.     len+=ue_v ("VUI: bit_rate_value_minus1", hrd->bit_rate_value_minus1[SchedSelIdx], bitstream);
  1113.     len+=ue_v ("VUI: cpb_size_value_minus1", hrd->cpb_size_value_minus1[SchedSelIdx], bitstream);
  1114.     len+=u_1  ("VUI: cbr_flag", hrd->cbr_flag[SchedSelIdx], bitstream);
  1115.   }
  1117.   len+=u_v  (5, "VUI: initial_cpb_removal_delay_length_minus1", hrd->initial_cpb_removal_delay_length_minus1, bitstream);
  1118.   len+=u_v  (5, "VUI: cpb_removal_delay_length_minus1", hrd->cpb_removal_delay_length_minus1, bitstream);
  1119.   len+=u_v  (5, "VUI: dpb_output_delay_length_minus1", hrd->dpb_output_delay_length_minus1, bitstream);
  1120.   len+=u_v  (5, "VUI: time_offset_length", hrd->time_offset_length, bitstream);
  1122.   return len;
  1123. }
  1125. /*!
  1126.  *************************************************************************************
  1127.  * brief
  1128.  *    void GenerateVUIParameters(seq_parameter_set_rbsp_t *sps)
  1129.  *
  1130.  *
  1131.  * return
  1132.  *    none
  1133.  *
  1134.  * note
  1135.  *************************************************************************************
  1136.  */
  1138. void GenerateVUIParameters(seq_parameter_set_rbsp_t *sps)
  1139. {
  1140.   unsigned int          SchedSelIdx;
  1141.   hrd_parameters_t     *nal_hrd = &(sps->vui_seq_parameters.nal_hrd_parameters);
  1142.   hrd_parameters_t     *vcl_hrd = &(sps->vui_seq_parameters.vcl_hrd_parameters);
  1143.   vui_seq_parameters_t *vui     = &(sps->vui_seq_parameters);
  1144.   VUIParameters *iVui = &params->VUI;
  1146.   vui->aspect_ratio_info_present_flag      = (Boolean) iVui->aspect_ratio_info_present_flag;
  1147.   vui->aspect_ratio_idc                    = (unsigned int) iVui->aspect_ratio_idc;
  1148.   vui->sar_width                           = (unsigned int) iVui->sar_width;
  1149.   vui->sar_height                          = (unsigned int) iVui->sar_height;
  1150.   vui->overscan_info_present_flag          = (Boolean) iVui->overscan_info_present_flag;
  1151.   vui->overscan_appropriate_flag           = (Boolean) iVui->overscan_appropriate_flag;
  1152.   vui->video_signal_type_present_flag      = (Boolean) iVui->video_signal_type_present_flag;
  1153.   vui->video_format                        = (unsigned int) iVui->video_format;
  1154.   vui->video_full_range_flag               = (Boolean) iVui->video_full_range_flag;
  1155.   vui->colour_description_present_flag     = (Boolean) iVui->colour_description_present_flag;
  1156.   vui->colour_primaries                    = (unsigned int) iVui->colour_primaries;
  1157.   vui->transfer_characteristics            = (unsigned int) iVui->transfer_characteristics;
  1158.   vui->matrix_coefficients                 = (unsigned int) iVui->matrix_coefficients;
  1159.   vui->chroma_location_info_present_flag   = (Boolean) iVui->chroma_location_info_present_flag;
  1160.   vui->chroma_sample_loc_type_top_field    = (unsigned int) iVui->chroma_sample_loc_type_top_field;
  1161.   vui->chroma_sample_loc_type_bottom_field = (unsigned int) iVui->chroma_sample_loc_type_bottom_field;
  1162.   vui->timing_info_present_flag            = (Boolean) iVui->timing_info_present_flag;
  1163.   vui->num_units_in_tick                   = (unsigned int) iVui->num_units_in_tick;
  1164.   vui->time_scale                          = (unsigned int) iVui->time_scale;
  1165.   vui->fixed_frame_rate_flag               = (Boolean) iVui->fixed_frame_rate_flag;  
  1167.   // NAL HRD parameters
  1168.   vui->nal_hrd_parameters_present_flag             = (Boolean) iVui->nal_hrd_parameters_present_flag;  
  1169.   nal_hrd->cpb_cnt_minus1                          = (unsigned int) iVui->nal_cpb_cnt_minus1;
  1170.   nal_hrd->bit_rate_scale                          = (unsigned int) iVui->nal_bit_rate_scale;
  1171.   nal_hrd->cpb_size_scale                          = (unsigned int) iVui->nal_cpb_size_scale;
  1172.   for ( SchedSelIdx = 0; SchedSelIdx <= nal_hrd->cpb_cnt_minus1; SchedSelIdx++ )
  1173.   {
  1174.     nal_hrd->bit_rate_value_minus1[SchedSelIdx]    = (unsigned int) iVui->nal_bit_rate_value_minus1;
  1175.     nal_hrd->cpb_size_value_minus1[SchedSelIdx]    = (unsigned int) iVui->nal_cpb_size_value_minus1;
  1176.     nal_hrd->cbr_flag[SchedSelIdx]                 = (unsigned int) iVui->nal_vbr_cbr_flag;
  1177.   }
  1178.   nal_hrd->initial_cpb_removal_delay_length_minus1 = (unsigned int) iVui->nal_initial_cpb_removal_delay_length_minus1;
  1179.   nal_hrd->cpb_removal_delay_length_minus1         = (unsigned int) iVui->nal_cpb_removal_delay_length_minus1;
  1180.   nal_hrd->dpb_output_delay_length_minus1          = (unsigned int) iVui->nal_dpb_output_delay_length_minus1;
  1181.   nal_hrd->time_offset_length                      = (unsigned int) iVui->nal_time_offset_length;
  1182.   
  1183.   // VCL HRD parameters
  1184.   vui->vcl_hrd_parameters_present_flag             = (Boolean) iVui->vcl_hrd_parameters_present_flag;  
  1185.   vcl_hrd->cpb_cnt_minus1                          = (unsigned int) iVui->vcl_cpb_cnt_minus1;
  1186.   vcl_hrd->bit_rate_scale                          = (unsigned int) iVui->vcl_bit_rate_scale;
  1187.   vcl_hrd->cpb_size_scale                          = (unsigned int) iVui->vcl_cpb_size_scale;
  1188.   for ( SchedSelIdx = 0; SchedSelIdx <= vcl_hrd->cpb_cnt_minus1; SchedSelIdx++ )
  1189.   {
  1190.     vcl_hrd->bit_rate_value_minus1[SchedSelIdx]    = (unsigned int) iVui->vcl_bit_rate_value_minus1;
  1191.     vcl_hrd->cpb_size_value_minus1[SchedSelIdx]    = (unsigned int) iVui->vcl_cpb_size_value_minus1;
  1192.     vcl_hrd->cbr_flag[SchedSelIdx]                 = (unsigned int) iVui->vcl_vbr_cbr_flag;
  1193.   }
  1194.   vcl_hrd->initial_cpb_removal_delay_length_minus1 = (unsigned int) iVui->vcl_initial_cpb_removal_delay_length_minus1;
  1195.   vcl_hrd->cpb_removal_delay_length_minus1         = (unsigned int) iVui->vcl_cpb_removal_delay_length_minus1;
  1196.   vcl_hrd->dpb_output_delay_length_minus1          = (unsigned int) iVui->vcl_dpb_output_delay_length_minus1;
  1197.   vcl_hrd->time_offset_length                      = (unsigned int) iVui->vcl_time_offset_length;
  1199.   vui->low_delay_hrd_flag                      = (Boolean) iVui->low_delay_hrd_flag;
  1200.   vui->pic_struct_present_flag                 = (Boolean) iVui->pic_struct_present_flag;
  1201.   vui->bitstream_restriction_flag              = (Boolean) iVui->bitstream_restriction_flag;
  1202.   vui->motion_vectors_over_pic_boundaries_flag = (Boolean) iVui->motion_vectors_over_pic_boundaries_flag;
  1203.   vui->max_bytes_per_pic_denom                 = (unsigned int) iVui->max_bytes_per_pic_denom;
  1204.   vui->max_bits_per_mb_denom                   = (unsigned int) iVui->max_bits_per_mb_denom;
  1205.   vui->log2_max_mv_length_horizontal           = (unsigned int) iVui->log2_max_mv_length_horizontal;
  1206.   vui->log2_max_mv_length_vertical             = (unsigned int) iVui->log2_max_mv_length_vertical;
  1207.   vui->num_reorder_frames                      = (unsigned int) iVui->num_reorder_frames;
  1208.   vui->max_dec_frame_buffering                 = (unsigned int) iVui->max_dec_frame_buffering;
  1209.   
  1210.   // special case to signal the RGB format
  1211.   if(params->rgb_input_flag && params->yuv_format==3)
  1212.   {
  1213.     printf   ("VUI: writing Sequence Parameter VUI to signal RGB formatn");
  1215.     vui->aspect_ratio_info_present_flag = FALSE;
  1216.     vui->overscan_info_present_flag = FALSE;
  1217.     vui->video_signal_type_present_flag = TRUE;
  1218.     vui->video_format = 2;
  1219.     vui->video_full_range_flag = TRUE;
  1220.     vui->colour_description_present_flag = TRUE;
  1221.     vui->colour_primaries = 2;
  1222.     vui->transfer_characteristics = 2;
  1223.     vui->matrix_coefficients = 0;
  1224.     vui->chroma_location_info_present_flag = FALSE;
  1225.     vui->timing_info_present_flag = FALSE;
  1226.     vui->nal_hrd_parameters_present_flag = FALSE;
  1227.     vui->vcl_hrd_parameters_present_flag = FALSE;
  1228.     vui->pic_struct_present_flag = FALSE;
  1229.     vui->bitstream_restriction_flag = FALSE;
  1230.   } 
  1231. }