JM8.6解码——帧类型判别

　　h264裸码流，根据nalu_header可以知道类型，例如该帧是I帧，P帧/B帧。

　　例如，常见的0x65代表I帧，0x41代表非关键帧，即P帧或B帧，但是只根据nalu_header是无法区分P帧和B帧的，还需进入到RBSP内部根据语法含义来做判断。

1. JM实现的判别

int FirstPartOfSliceHeader()
{
  Slice *currSlice = img->currentSlice;
  int dP_nr = assignSE2partition[currSlice->dp_mode][SE_HEADER];
  DataPartition *partition = &(currSlice->partArr[dP_nr]);
  Bitstream *currStream = partition->bitstream;
  int tmp;

  UsedBits= partition->bitstream->frame_bitoffset; // was hardcoded to 31 for previous start-code. This is better.

  // Get first_mb_in_slice
  currSlice->start_mb_nr = ue_v ("SH: first_mb_in_slice", currStream);

  tmp = ue_v ("SH: slice_type", currStream);
  
  if (tmp>4) tmp -=5;

  img->type = currSlice->picture_type = (SliceType) tmp;

  currSlice->pic_parameter_set_id = ue_v ("SH: pic_parameter_set_id", currStream);
  
  return UsedBits;
}

　　如上代码，第二次的ue(无符号哥伦布编码)得出了帧类型，但是还需注意到做差："if (tmp>4) tmp -=5;"，才能得到真正的SliceType：

typedef enum {
    P_SLICE = 0,
    B_SLICE,
    I_SLICE,
    SP_SLICE,
    SI_SLICE
} SliceType;

　　例如，一段nalu数据为：0x00 00 01 65 88 80 06 64

　　那么，从0x65后的字节0x88开始算起，

　　第一个ue得到start_mb_nr，即其值为（2^0 - 1 + 0）= 0，0x88使用了最高位，当前bit_offset=1

　　第二个ue得到tmp值，即其值为（2^3 - 1 + 000b）= 7，使用了7bit来计算，当前bit_offset=8，再将tmp-5得到2，那么picture_type为I帧。

　　第三个ue得到pps_id值，从0x80的最高位算起，值为（2^0 - 1 + 0）= 0

2. ffmpeg的实现

　　实现类似，参考文件h264_slice.c，关键代码如下：

static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
                                   const H2645NAL *nal)
{
    const SPS *sps;
    const PPS *pps;
    int ret;
    unsigned int slice_type, tmp, i;
    int field_pic_flag, bottom_field_flag;
    int first_slice = sl == h->slice_ctx && !h->current_slice;
    int picture_structure;

    if (first_slice)
        av_assert0(!h->setup_finished);

    sl->first_mb_addr = get_ue_golomb_long(&sl->gb);

    slice_type = get_ue_golomb_31(&sl->gb);
    if (slice_type > 9) {
        av_log(h->avctx, AV_LOG_ERROR,
               "slice type %d too large at %d
",
               slice_type, sl->first_mb_addr);
        return AVERROR_INVALIDDATA;
    }
    if (slice_type > 4) {
        slice_type -= 5;
        sl->slice_type_fixed = 1;
    } else
        sl->slice_type_fixed = 0;

    slice_type         = ff_h264_golomb_to_pict_type[slice_type];
    sl->slice_type     = slice_type;
    sl->slice_type_nos = slice_type & 3;

    if (nal->type  == H264_NAL_IDR_SLICE &&
        sl->slice_type_nos != AV_PICTURE_TYPE_I) {
        av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.
");
        return AVERROR_INVALIDDATA;
    }

    sl->pps_id = get_ue_golomb(&sl->gb);
...
}

　　同样也是超过4时，再减去5即得到了帧类型。

3. 小工具实现

　　本人曾做了一个小工具，参考核心代码如下：

static int GetFrameType(NALU_t * nal)
{
    bs_t s;
    int frame_type = 0;

    bs_init(&s, nal->buf+1, nal->len - 1);

    if (nal->nal_unit_type == NALU_TYPE_SLICE || nal->nal_unit_type ==  NALU_TYPE_IDR)
    {
        /* i_first_mb */
        bs_read_ue(&s);
        /* picture type */
        frame_type = bs_read_ue(&s);
        switch(frame_type)
        {
        case 0: case 5: /* P */
            nal->frame_type = FRAME_TYPE_P;
            break;
        case 1: case 6: /* B */
            nal->frame_type = FRAME_TYPE_B;
            break;
        case 3: case 8: /* SP */
            nal->frame_type = FRAME_TYPE_P;
            break;
        case 2: case 7: /* I */
            nal->frame_type = FRAME_TYPE_I;
            break;
        case 4: case 9: /* SI */
            nal->frame_type = FRAME_TYPE_I;
            break;
        default:
            printf("unknown frame type! nalu_data[%#x,%#x,%#x,%#x]
", nal->buf[0], nal->buf[1], nal->buf[2], nal->buf[3]);
            break;
        }
    }
    else
    {
        nal->frame_type = nal->nal_unit_type;
    }

    return 0;
}