JM ldecod分析：获取slice

已于 2022-05-30 15:50:27 修改
阅读量372 收藏 1
点赞数
分类专栏： H264&H265 文章标签： JM
于 2021-07-15 20:27:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongkun152/article/details/115418661
版权

JM ldecod分析：解码slice

承接上节 JM ldecod分析
read_new_slice()从h264数据流中获取一个slice。
slice结构参见关键数据结构
（后边提到的数据结构均在该链接中）

  1. read_next_nalu()

NALU_t结构是nalu的描述头，用来保存nalu的头信息和nalu body的buf指针。

read_new_slice

从bitstream中读取到slice之后，slice分为slice_header和slice_data两部分。读取slice_header 的部分字段的时候，需要首先获取pps 和sps。所以读取slice_header时，代码分成两部分。slice_header字段使用的是哥伦布编码进行编码的。
slice_data字段主要使用熵编码，CAVLC和CABAC。

/*!
 ************************************************************************
 * \brief
 *    Reads new slice from bit_stream_dec
 ************************************************************************
 */
int read_new_slice(Slice *currSlice)
{
  VideoParameters *p_Vid = currSlice->p_Vid;
  InputParameters *p_Inp = currSlice->p_Inp;

  NALU_t *nalu = p_Vid->nalu; 
  int current_header = 0;
  int BitsUsedByHeader;
  Bitstream *currStream = NULL;

  static NALU_t *pending_nalu = NULL;

  int slice_id_a, slice_id_b, slice_id_c;

  for (;;)
  {
#if (MVC_EXTENSION_ENABLE)
    currSlice->svc_extension_flag = -1;
#endif
    if (!pending_nalu)
    {
      读取一个nalu（ebsp已经被转化为rbsp）
      if (0 == read_next_nalu(p_Vid, nalu))
        return EOS;
    }
    else
    {
      nalu = pending_nalu;
      pending_nalu = NULL;
    }

#if (MVC_EXTENSION_ENABLE)
    if(p_Inp->DecodeAllLayers == 1 && (nalu->nal_unit_type == NALU_TYPE_PREFIX || nalu->nal_unit_type == NALU_TYPE_SLC_EXT))
    {
      currStream = currSlice->partArr[0].bitstream;
      currStream->ei_flag = 0;
      currStream->frame_bitoffset = currStream->read_len = 0;
      fast_memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
      currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

      currSlice->svc_extension_flag = read_u_1 ("svc_extension_flag"        , currStream, &p_Dec->UsedBits);

      if(currSlice->svc_extension_flag)
      {
        nal_unit_header_svc_extension();
      }
      else
      {
        nal_unit_header_mvc_extension(&currSlice->NaluHeaderMVCExt, currStream);
        currSlice->NaluHeaderMVCExt.iPrefixNALU = (nalu->nal_unit_type == NALU_TYPE_PREFIX);
      }

      if(nalu->nal_unit_type == NALU_TYPE_SLC_EXT)
      {        
        if(currSlice->svc_extension_flag)
        {
          //to be implemented for Annex G;
        }
        else 
        {
          nalu->nal_unit_type = NALU_TYPE_SLICE; //currSlice->NaluHeaderMVCExt.non_idr_flag==0? NALU_TYPE_IDR: NALU_TYPE_SLICE; 
        }
      }
    }
#endif
根据nalu类型进行处理
process_nalu:
    switch (nalu->nal_unit_type)
    {
    case NALU_TYPE_SLICE:
    case NALU_TYPE_IDR:

      if (p_Vid->recovery_point || nalu->nal_unit_type == NALU_TYPE_IDR)
      {
        if (p_Vid->recovery_point_found == 0)
        {
          if (nalu->nal_unit_type != NALU_TYPE_IDR)
          {
            printf("Warning: Decoding does not start with an IDR picture.\n");
            p_Vid->non_conforming_stream = 1;
          }
          else
            p_Vid->non_conforming_stream = 0;
        }
        p_Vid->recovery_point_found = 1;
      }

      if (p_Vid->recovery_point_found == 0)
        break;

      currSlice->idr_flag = (nalu->nal_unit_type == NALU_TYPE_IDR);
      currSlice->nal_reference_idc = nalu->nal_reference_idc;
      currSlice->dp_mode = PAR_DP_1;
      currSlice->max_part_nr = 1;
#if (MVC_EXTENSION_ENABLE)
      if (currSlice->svc_extension_flag != 0)
      {
        currStream = currSlice->partArr[0].bitstream;
        currStream->ei_flag = 0;
        currStream->frame_bitoffset = currStream->read_len = 0;
        fast_memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
      }
#else   
      currStream = currSlice->partArr[0].bitstream;
      currStream->ei_flag = 0;
      currStream->frame_bitoffset = currStream->read_len = 0;
      保存解码原数据
      memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
      将最后的填充0 bit删掉，获得code_len 编码后数据长度
      currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
#endif

#if (MVC_EXTENSION_ENABLE)
      if(currSlice->svc_extension_flag == 0)
      {  //MVC
        //if(is_MVC_profile(p_Vid->active_sps->profile_idc))
        //{
          currSlice->view_id = currSlice->NaluHeaderMVCExt.view_id;
          currSlice->inter_view_flag = currSlice->NaluHeaderMVCExt.inter_view_flag;
          currSlice->anchor_pic_flag = currSlice->NaluHeaderMVCExt.anchor_pic_flag;
        //}
      }
      else if(currSlice->svc_extension_flag == -1) //SVC and the normal AVC;
      {
        if(p_Vid->active_subset_sps == NULL)
        {
          currSlice->view_id = GetBaseViewId(p_Vid, &p_Vid->active_subset_sps);
          if(currSlice->NaluHeaderMVCExt.iPrefixNALU >0)
          {
            assert(currSlice->view_id == currSlice->NaluHeaderMVCExt.view_id);
            currSlice->inter_view_flag = currSlice->NaluHeaderMVCExt.inter_view_flag;
            currSlice->anchor_pic_flag = currSlice->NaluHeaderMVCExt.anchor_pic_flag;
          }
          else
          {
            currSlice->inter_view_flag = 1;
            currSlice->anchor_pic_flag = currSlice->idr_flag;
          }
        }
        else
        {
          assert(p_Vid->active_subset_sps->num_views_minus1 >=0);
          // prefix NALU available
          if(currSlice->NaluHeaderMVCExt.iPrefixNALU >0)
          {
            currSlice->view_id = currSlice->NaluHeaderMVCExt.view_id;
            currSlice->inter_view_flag = currSlice->NaluHeaderMVCExt.inter_view_flag;
            currSlice->anchor_pic_flag = currSlice->NaluHeaderMVCExt.anchor_pic_flag;
          }
          else
          { //no prefix NALU;
            currSlice->view_id = p_Vid->active_subset_sps->view_id[0];
            currSlice->inter_view_flag = 1;
            currSlice->anchor_pic_flag = currSlice->idr_flag;
          }
        }
      }
     currSlice->layer_id = currSlice->view_id = GetVOIdx( p_Vid, currSlice->view_id );
#endif

      // Some syntax of the Slice Header depends on the parameter set, which depends on
      // the parameter set ID of the SLice header.  Hence, read the pic_parameter_set_id
      // of the slice header first, then setup the active parameter sets, and then read
      // the rest of the slice header
      BitsUsedByHeader = FirstPartOfSliceHeader(currSlice);
      UseParameterSet (currSlice);
      currSlice->active_sps = p_Vid->active_sps;
      currSlice->active_pps = p_Vid->active_pps;
      currSlice->Transform8x8Mode = p_Vid->active_pps->transform_8x8_mode_flag;
      currSlice->chroma444_not_separate = (p_Vid->active_sps->chroma_format_idc==YUV444)&&((p_Vid->separate_colour_plane_flag == 0));

      BitsUsedByHeader += RestOfSliceHeader (currSlice);
#if (MVC_EXTENSION_ENABLE)
      if(currSlice->view_id >=0)
      {
        currSlice->p_Dpb = p_Vid->p_Dpb_layer[currSlice->view_id];
      }
#endif

      assign_quant_params (currSlice);        

      // if primary slice is replaced with redundant slice, set the correct image type
      if(currSlice->redundant_pic_cnt && p_Vid->Is_primary_correct==0 && p_Vid->Is_redundant_correct)
      {
        p_Vid->dec_picture->slice_type = p_Vid->type;
      }

      if(is_new_picture(p_Vid->dec_picture, currSlice, p_Vid->old_slice))
      {
        if(p_Vid->iSliceNumOfCurrPic==0)
          init_picture(p_Vid, currSlice, p_Inp);

        current_header = SOP;
        //check zero_byte if it is also the first NAL unit in the access unit
        CheckZeroByteVCL(p_Vid, nalu);
      }
      else
        current_header = SOS;

      setup_slice_methods(currSlice);

      // From here on, p_Vid->active_sps, p_Vid->active_pps and the slice header are valid
      if (currSlice->mb_aff_frame_flag)
        currSlice->current_mb_nr = currSlice->start_mb_nr << 1;
      else
        currSlice->current_mb_nr = currSlice->start_mb_nr;

      if (p_Vid->active_pps->entropy_coding_mode_flag)
      {
        int ByteStartPosition = currStream->frame_bitoffset/8;
        if (currStream->frame_bitoffset%8 != 0)
        {
          ++ByteStartPosition;
        }
        arideco_start_decoding (&currSlice->partArr[0].de_cabac, currStream->streamBuffer, ByteStartPosition, &currStream->read_len);
      }
      // printf ("read_new_slice: returning %s\n", current_header == SOP?"SOP":"SOS");
      //FreeNALU(nalu);
      p_Vid->recovery_point = 0;
      return current_header;
      break;
    case NALU_TYPE_DPA:
      if (p_Vid->recovery_point_found == 0)
        break;

      // read DP_A
      currSlice->dpB_NotPresent =1; 
      currSlice->dpC_NotPresent =1; 

      currSlice->idr_flag          = FALSE;
      currSlice->nal_reference_idc = nalu->nal_reference_idc;
      currSlice->dp_mode     = PAR_DP_3;
      currSlice->max_part_nr = 3;
      currSlice->ei_flag     = 0;
#if MVC_EXTENSION_ENABLE
      currSlice->p_Dpb = p_Vid->p_Dpb_layer[0];
#endif
      currStream             = currSlice->partArr[0].bitstream;
      currStream->ei_flag    = 0;
      currStream->frame_bitoffset = currStream->read_len = 0;
      memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
      currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
#if MVC_EXTENSION_ENABLE
      currSlice->view_id = GetBaseViewId(p_Vid, &p_Vid->active_subset_sps);
      currSlice->inter_view_flag = 1;
      currSlice->layer_id = currSlice->view_id = GetVOIdx( p_Vid, currSlice->view_id );
      currSlice->anchor_pic_flag = currSlice->idr_flag;
#endif

      BitsUsedByHeader = FirstPartOfSliceHeader(currSlice);
      UseParameterSet (currSlice);
      currSlice->active_sps = p_Vid->active_sps;
      currSlice->active_pps = p_Vid->active_pps;
      currSlice->Transform8x8Mode = p_Vid->active_pps->transform_8x8_mode_flag;
      currSlice->chroma444_not_separate = (p_Vid->active_sps->chroma_format_idc==YUV444)&&((p_Vid->separate_colour_plane_flag == 0));

      BitsUsedByHeader += RestOfSliceHeader (currSlice);
#if MVC_EXTENSION_ENABLE
      currSlice->p_Dpb = p_Vid->p_Dpb_layer[currSlice->view_id];
#endif

      assign_quant_params (currSlice);        


      if(is_new_picture(p_Vid->dec_picture, currSlice, p_Vid->old_slice))
      {
        if(p_Vid->iSliceNumOfCurrPic==0)
          init_picture(p_Vid, currSlice, p_Inp);

        current_header = SOP;
        //check zero_byte if it is also the first NAL unit in the access unit
        CheckZeroByteVCL(p_Vid, nalu);
      }
      else
        current_header = SOS;

      setup_slice_methods(currSlice);

      // From here on, p_Vid->active_sps, p_Vid->active_pps and the slice header are valid
      if (currSlice->mb_aff_frame_flag)
        currSlice->current_mb_nr = currSlice->start_mb_nr << 1;
      else
        currSlice->current_mb_nr = currSlice->start_mb_nr;

      // Now I need to read the slice ID, which depends on the value of
      // redundant_pic_cnt_present_flag

      slice_id_a  = read_ue_v("NALU: DP_A slice_id", currStream, &p_Dec->UsedBits);

      if (p_Vid->active_pps->entropy_coding_mode_flag)
        error ("received data partition with CABAC, this is not allowed", 500);

      // continue with reading next DP
      if (0 == read_next_nalu(p_Vid, nalu))
        return current_header;

      if ( NALU_TYPE_DPB == nalu->nal_unit_type)
      {
        // we got a DPB
        currStream             = currSlice->partArr[1].bitstream;
        currStream->ei_flag    = 0;
        currStream->frame_bitoffset = currStream->read_len = 0;

        memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

        slice_id_b  = read_ue_v("NALU: DP_B slice_id", currStream, &p_Dec->UsedBits);

        currSlice->dpB_NotPresent = 0; 

        if ((slice_id_b != slice_id_a) || (nalu->lost_packets))
        {
          printf ("Waning: got a data partition B which does not match DP_A (DP loss!)\n");
          currSlice->dpB_NotPresent =1; 
          currSlice->dpC_NotPresent =1; 
        }
        else
        {
          if (p_Vid->active_pps->redundant_pic_cnt_present_flag)
            read_ue_v("NALU: DP_B redundant_pic_cnt", currStream, &p_Dec->UsedBits);

          // we're finished with DP_B, so let's continue with next DP
          if (0 == read_next_nalu(p_Vid, nalu))
            return current_header;
        }
      }
      else
      {
        currSlice->dpB_NotPresent =1; 
      }

      // check if we got DP_C
      if ( NALU_TYPE_DPC == nalu->nal_unit_type)
      {
        currStream             = currSlice->partArr[2].bitstream;
        currStream->ei_flag    = 0;
        currStream->frame_bitoffset = currStream->read_len = 0;

        memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

        currSlice->dpC_NotPresent = 0;

        slice_id_c  = read_ue_v("NALU: DP_C slice_id", currStream, &p_Dec->UsedBits);
        if ((slice_id_c != slice_id_a)|| (nalu->lost_packets))
        {
          printf ("Warning: got a data partition C which does not match DP_A(DP loss!)\n");
          //currSlice->dpB_NotPresent =1;
          currSlice->dpC_NotPresent =1;
        }

        if (p_Vid->active_pps->redundant_pic_cnt_present_flag)
          read_ue_v("NALU:SLICE_C redudand_pic_cnt", currStream, &p_Dec->UsedBits);
      }
      else
      {
        currSlice->dpC_NotPresent =1;
        pending_nalu = nalu;
      }

      // check if we read anything else than the expected partitions
      if ((nalu->nal_unit_type != NALU_TYPE_DPB) && (nalu->nal_unit_type != NALU_TYPE_DPC) && (!currSlice->dpC_NotPresent))
      {
        // we have a NALI that we can't process here, so restart processing
        goto process_nalu;
        // yes, "goto" should not be used, but it's really the best way here before we restructure the decoding loop
        // (which should be taken care of anyway)
      }

      //FreeNALU(nalu);
      return current_header;
      break;
    case NALU_TYPE_DPB:
      if (p_Inp->silent == FALSE)
      {
        printf ("found data partition B without matching DP A, discarding\n");
      }
      break;
    case NALU_TYPE_DPC:
      if (p_Inp->silent == FALSE)
      {
        printf ("found data partition C without matching DP A, discarding\n");
      }
      break;
    case NALU_TYPE_SEI:
      //printf ("read_new_slice: Found NALU_TYPE_SEI, len %d\n", nalu->len);
      InterpretSEIMessage(nalu->buf,nalu->len,p_Vid, currSlice);
      break;
    case NALU_TYPE_PPS:
      //printf ("Found NALU_TYPE_PPS\n");
      ProcessPPS(p_Vid, nalu);
      break;
    case NALU_TYPE_SPS:
      //printf ("Found NALU_TYPE_SPS\n");
      ProcessSPS(p_Vid, nalu);
      break;
    case NALU_TYPE_AUD:
      //printf ("Found NALU_TYPE_AUD\n");
      //        printf ("read_new_slice: Found 'Access Unit Delimiter' NAL unit, len %d, ignored\n", nalu->len);
      break;
    case NALU_TYPE_EOSEQ:
      //        printf ("read_new_slice: Found 'End of Sequence' NAL unit, len %d, ignored\n", nalu->len);
      break;
    case NALU_TYPE_EOSTREAM:
      //        printf ("read_new_slice: Found 'End of Stream' NAL unit, len %d, ignored\n", nalu->len);
      break;
    case NALU_TYPE_FILL:
      if (p_Inp->silent == FALSE)
      {
        //printf ("read_new_slice: Found NALU_TYPE_FILL, len %d\n", (int) nalu->len);
        //printf ("Skipping these filling bits, proceeding w/ next NALU\n");
      }
      break;
#if (MVC_EXTENSION_ENABLE)
    case NALU_TYPE_VDRD:
      //printf ("Found NALU_TYPE_VDRD\n");
      //        printf ("read_new_slice: Found 'View and Dependency Representation Delimiter' NAL unit, len %d, ignored\n", nalu->len);
      break;
    case NALU_TYPE_PREFIX:
      //printf ("Found NALU_TYPE_PREFIX\n");
      if(currSlice->svc_extension_flag==1)
        prefix_nal_unit_svc();
      break;
    case NALU_TYPE_SUB_SPS:
      //printf ("Found NALU_TYPE_SUB_SPS\n");
      if (p_Inp->DecodeAllLayers== 1)
      {
        ProcessSubsetSPS(p_Vid, nalu);
      }
      else
      {
        if (p_Inp->silent == FALSE)
          printf ("Found Subsequence SPS NALU. Ignoring.\n");
      }
      break;
    case NALU_TYPE_SLC_EXT:
      //printf ("Found NALU_TYPE_SLC_EXT\n");
      if (p_Inp->DecodeAllLayers == 0 &&  (p_Inp->silent == FALSE))
        printf ("Found SVC extension NALU (%d). Ignoring.\n", (int) nalu->nal_unit_type);
      break;
#endif
    default:
      {
        if (p_Inp->silent == FALSE)
          printf ("Found NALU type %d, len %d undefined, ignore NALU, moving on\n", (int) nalu->nal_unit_type, (int) nalu->len);
      }
      break;
    }
  }
}

read_new_slice() 中首先分割bit流通过read_next_nalu()获取到下一个Nalu，根据Nalu的类型进行处理：

参见 JM ldecod分析: 分帧处理

LUCKY-LIVING
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
视频编解码-H.264编码技术 三 JM 源码剖析 一
芒果木有籽
04-08 549
1码流结构 H.264 码流是由一个个 NALU 组成的而 NALU 又是由 NALU 头和 RBSP 数据组成 NAL单元语法 forbidden_zero_bit f(1) 表示 1 比特定长编码 nal_ref_idc，该行最后一列是 u(2)，元素采用 u(2) 方式编码 规定NAL 单元的内容包含一个序列参数集，或一个图像参数集，或一个参考图像 条带，或一个参...
如何利用unsafe获取slice&map的长度
Mreden的博客
04-17 462
获取 slice 长度 通过前面关于 slice 的文章，我们知道了 slice header 的结构体定义： // runtime/slice.go type slice struct { array unsafe.Pointer // 元素指针 len int // 长度 cap int // 容量 } 调用 make 函数新建一个 slice，底层调用的是...
golang 获取切片 slice 第一个 最后一个 元素
whatday的专栏
01-04 3万+
复合数据类型切片通常用作Go中索引数据的口语结构。 该类型[]intSlice是具有类型为integer的元素的切片。 len函数用于获取切片的最后一个元素，并从切片中删除最后一个元素。 示例如下： package main import "fmt" func main() { intSlice := []int{1, 2, 3, 4, 5} fmt.Printf("Slice: %vn", intSlice) last := intSlice[
【H.264/AVC 句法和语义详解】(十一)：Slice_Header的句法和语义
houxiaoni01的博客
08-21 1619
前面我们根据SPS和PPS的句法和语义，已经能够解析出h264码流文件中的前两个NALU。现在我们就开始解析第三个NALU，它同码流中的后面几个NALU一样，它们的nal_unit_type不是等于5，就是等于1。 因此它们不是IDR的slice，就是非IDR的slice，总之后面的几个NALU，都代表了片层的数据。而它们的句法元素，都包含在slice_layer_without_partitio...
H264/AVC-slice header解析
qq_42139383的博客
05-27 2036
一个slice语法由slice header和slice data构成，slice header表示该slice的基本语法，slice data则存放了该slice中所有宏块的数据。 slice header语法结构 first_mb_in_slice: 表示该slice的第一个宏块在图像中的位置。一个图像可能分为多个slice单独编码，因此可以通过first_mb_in_slice确定该slice是否为一个完整的图像。 1）如果MbaffFrameFlag 等于 0, 也就是该slice不是mbaff，
JM ldecod分析：关键数据结构
最新发布
dongkun152的专栏
05-07 587
JM ldecod分析：关键数据结构 slice //! Slice typedef struct slice { struct video_par *p_Vid; struct inp_par *p_Inp; pic_parameter_set_rbsp_t *active_pps; seq_parameter_set_rbsp_t *active_sps; int svc_extension_flag; //svc 扩展 // dpb pointer str
JM ldecod分析: 分帧处理
dongkun152的专栏
10-09 627
JM ldecod分析: 分帧处理 slice 和IDR case NALU_TYPE_SLICE: case NALU_TYPE_IDR: if (p_Vid->recovery_point || nalu->nal_unit_type == NALU_TYPE_IDR) { if (p_Vid->recovery_point_found == 0) { if (nalu->nal_unit_t
Netty-源码分析ByteBuf-readSlice和readRetainedSlice使用细节
大新博客
12-09 3952
返回从当前readerIndex开始的此缓冲区的子区域的新分片，并将readerIndex增加新分片的大小（=长度）。 另请注意，此方法将不会调用retain（），因此不会增加引用计数。 跟slice极为相似，只是把原始缓冲区的readerIndex进行了增加 @Override public ByteBuf readSlice(int length) { ch...
JM-master.zip
06-24
jm/h264 M编解码H.264的速度相对于FFmpeg来说是非常慢的，但是它的代码写得清晰易懂，更适合做学术方面的研究。JM包含了视频解码器ldecod和视频编码器lencod。本文记录视频解码器ldecod的结构。
H.264 JM86.RAR
01-05
JM86代码，可在VS2013上运行，也可以直接通过命令执行。 使用说明： 1. 使用VS2013打开tml.sln，可直接编译 2. 在bin目录中有生成的lencod.exe和ldecod.exe执行文件，也在备份目录bin_bak中找到 3. 可在cmd窗口中...
JM86 编码流程图
05-01
JM编码流程图 JM86 ....\jm86 ....\....\JM ....\....\..\bin ....\....\..\...\decoder.cfg ....\....\..\...\encoder_baseline.cfg ....\....\..\...\encoder_extended.cfg ....\....\..\...\encoder_main....
h264-tools:H.264码流解析分析
07-07
h264-工具mkv2mkv : Usage: ... Usage: ldecod <lot>Decodes 3D H.264 video streams, which ffmpeg cannot do directlynaluparser ： Usage: naluparser [-stat] [-v] [-nalucount #] [-mkv] [-annexb] < inputFil
JM测试代码86版和10.1版
05-01
我在VC60上验证通过了的 Doxygen usage information ------------------------- ...doxygen ldecod.dox in this directory. The documentation will be genrated into the directories lenc/ and ldec/
H.264官方软件JM源代码简单分析-解码器ldecod
热门推荐
雷霄骅(leixiaohua1020)的专栏
11-17 5万+
最近看了一下H.264官方参考软件JM的源代码，在这里总结一下它的结构。JM编解码H.264的速度相对于FFmpeg来说是非常慢的，但是它的代码写得清晰易懂，更适合做学术方面的研究。JM包含了视频解码器ldecod和视频编码器lencod。本文记录视频解码器ldecod的结构。函数调用关系图JM中的H.264视频解码器ldecod的函数调用关系图如下所示。 单击查看更清晰的大图下面解释一下图中关键
H264参数语法文档： SPS、PPS、IDR
01-11 5475
H264参数语法文档： SPS、PPS、IDR 分类： H264图像图形系列2011-02-24 16:05 4347人阅读 评论(1) 收藏 举报 H.264码流第一个 NALU 是 SPS（序列参数集Sequence Parameter Set） 对应H264标准文档 7.3.2.1 序列参数集的语法进行解析 SPS参数解析// fill sps with cont
【H.264/AVC视频编解码技术详解】十一、H.264的Slice Header解析
Workshop of Wenjie.Yin
11-18 1万+
《H.264/AVC视频编解码技术详解》视频教程已经在“CSDN学院”上线，视频中详述了H.264的背景、标准协议和实现，并通过一个实战工程的形式对H.264的标准进行解析和实现，欢迎观看！“纸上得来终觉浅，绝知此事要躬行”，只有自己按照标准文档以代码的形式操作一遍，才能对视频压缩编码标准的思想和方法有足够深刻的理解和体会！链接地址：H.264/AVC视频编解码技术详解GitHub代码地址：点击这里
信源编码（六）h264 jm源码简析
hehehetanchaow的博客
07-15 3015
注：此贴参考了众多文章，其中雷霄骅大神写的最为详细。这里就重点介绍下jm的lencode.c 参考博客：  H.264官方软件JM源代码简单分析-编码器lencod                       H.264官方软件JM源代码简单分析-解码器ldecod 1.int main(int argc,char **argv) argc为参数的个数，*ar
【从零实现一个H.264码流解析器】(六)：解析片头部Slice_Header的句法元素
houxiaoni01的博客
08-22 2365
在之前我们已经解析出码流文件中的前两个NALU，分别为SPS和PPS，下面我们就开始解析第三个NALU。在【最简单的H264编解码器】里已经说过，我们接下来会首先按照最简的方式来考虑问题，因此接下来我们遇到的都是I_Slice。 解析Slice总的来说分成两大块，第一步先解析Slice_Header，然后解析Slice_Data。解析Slice_Header较为简单，而解析Slice_Data则至...
H264-变换和量化
dongkun152的专栏
08-06 3341
H264-变换和量化 在早期的标准中，不同的处理步骤之间有明显的边界，对原始数据（或者残差）进行域变换，然后进行量化降低系数的精度，但是在H264中边界却不明显。为了消除浮点数DCT变换造成的误差累计，使用整数DCT变换，并且将放大系数移到量化阶段进行。 在DCT变换当中，存在有无理数系数。在不同精度的机器上的编码图像和解码图像之间，或者在同一个编码器的重建图像之间，会出现误差漂移和累计。h264通过下面的两个方法解决这个问题： 使用核变换，是整数DCT变换，只需要使用整数和定点数运算 使用最少的乘法优化
H264-解码顺序 显示顺序 参考顺序
dongkun152的专栏
09-22 1956
H264-解码顺序 显示顺序 参考顺序 DPB解码图像缓冲区，片被解码后生成的数据保存在DPB中。DPB中的图像数据可用于后边图像编码时的帧间预测，或者输出到显示。 解码顺序 显示顺序 参考顺序

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值