H265码流中如何判断NALU中的I帧和P帧以及SPS、PPS帧

H.265/HEVC视频编码标准中，NALU（Network Abstraction Layer Unit）是视频数据传输的最小单元，其中包含了视频编码的各种信息。在NALU中，有几种重要的类型，包括I帧、P帧、SPS和PPS帧。

在H.265/HEVC标准中，I帧通常被称为关键帧，是视频序列中的第一帧或者是关键性转换时的帧。P帧是预测帧，它通过参考前面的I帧或P帧来预测当前的图像。SPS（Sequence Parameter Set）和PPS（Picture Parameter Set）是用于描述视频序列和帧的参数集合。

在H.265/HEVC码流中，可以通过NALU头部的type字段来判断NALU的类型。type字段的值决定了NALU的类型，包括以下几种类型：

- 0x00：未定义
- 0x01：非IDR图像的片
- 0x02：IDR图像的片
- 0x03：SEI
- 0x04：SPS
- 0x05：PPS
- 0x06：分界符
- 0x07：图像的附加增强信息
- 0x08：不可忽略的填充字节
- 0x09：访问单元分界符
- 0x0A：End of Sequence
- 0x0B：End of Stream
- 0x0C：填充

其中，0x01和0x02表示的是P帧和I帧，0x04和0x05表示的是SPS和PPS。因此，通过NALU头部的type字段的值，就可以判断NALU的类型，从而判断出I帧和P帧以及SPS、PPS帧。

相关问题

ffmepg中根据nal数据判断sps\pps\I帧、p帧、b帧

在ffmpeg中，可以使用h264_parser_parse2()函数解析NALU数据，并获取到对应的类型。具体实现可以参考以下代码示例：

AVCodecParserContext *parser_ctx = av_parser_init(AV_CODEC_ID_H264);
AVPacket *pkt = av_packet_alloc();
// 假设nal数据存储在buf中
pkt->data = buf;
pkt->size = buf_size;

int ret = 0;
int nal_type = 0;
while (pkt->size > 0) {
    // 解析NALU数据
    ret = av_parser_parse2(parser_ctx, codec_ctx, &pkt->data, &pkt->size,
                           pkt->data, pkt->size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
    if (ret < 0) {
        // 解析失败
        break;
    }
    if (pkt->size == 0) {
        // 解析完成
        break;
    }

    nal_type = parser_ctx->nal_unit_type;
    switch (nal_type) {
        case H264_NAL_SPS:
            // SPS帧
            break;
        case H264_NAL_PPS:
            // PPS帧
            break;
        case H264_NAL_IDR_SLICE:
        case H264_NAL_SLICE:
            // I帧、P帧或B帧
            break;
        default:
            // 其他类型的NALU
            break;
    }
}
av_packet_free(&pkt);
av_parser_close(parser_ctx);

其中H264_NAL_SPS、H264_NAL_PPS、H264_NAL_IDR_SLICE和H264_NAL_SLICE分别代表SPS帧、PPS帧、I帧和P/B帧。

使用RTMP拉视频流后I帧、P帧、B帧、sps、pps帧等如何判断，请用C++代码举例并表明注释

在使用RTMP拉视频流后，可以通过解析视频流的NALU（Network Abstraction Layer Unit）来判断视频帧类型，以及获取SPS、PPS等信息。下面是一个简单的C++代码示例：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>

using namespace std;

// NALU类型定义
#define NALU_TYPE_SLICE         1   // 非IDR图像的片
#define NALU_TYPE_DPA           2   // 非IDR图像的片
#define NALU_TYPE_DPB           3   // 非IDR图像的片
#define NALU_TYPE_DPC           4   // 非IDR图像的片
#define NALU_TYPE_IDR           5   // IDR图像中的片
#define NALU_TYPE_SEI           6   // 补充增强信息单元
#define NALU_TYPE_SPS           7   // 序列参数集
#define NALU_TYPE_PPS           8   // 图像参数集
#define NALU_TYPE_AUD           9   // 分界符
#define NALU_TYPE_EOSEQ         10  // 序列结束
#define NALU_TYPE_EOSTREAM      11  // 码流结束
#define NALU_TYPE_FILL          12  // 填充

// NALU结构体定义
typedef struct NALU_t {
    int     startcodeprefix_len;    // 码流中开始码的长度，一般为4
    unsigned len;                   // 去掉起始码后，NALU数据部分的长度
    unsigned max_size;              // nalu的最大长度
    int     forbidden_bit;          // 禁止位，始终为0
    int     nal_reference_idc;      // NALU重要性，0~3依次降低
    int     nal_unit_type;          // NALU类型
    char*   buf;                    // NALU数据缓冲区地址
} NALU_t;

int FindStartCode2(unsigned char *Buf)
{
    if(Buf[0]!=0 || Buf[1]!=0 || Buf[2]!=1) return 0; // 检查起始码前三个字节是否为0x000001
    else return 1;
}

int FindStartCode3(unsigned char *Buf)
{
    if(Buf[0]!=0 || Buf[1]!=0 || Buf[2]!=0 || Buf[3]!=1) return 0; // 检查起始码前四个字节是否为0x00000001
    else return 1;
}

int GetAnnexbNALU(NALU_t *nalu)
{
    int pos = 0;
    int StartCodeFound, rewind;
    unsigned char *Buf;

    if ((Buf = (unsigned char*)calloc(nalu->max_size , sizeof(char))) == NULL) return 0;

    nalu->startcodeprefix_len = 3;

    if (3 != fread(Buf, 1, 3, h264stream)) {
        free(Buf);
        return 0;
    }

    if (FindStartCode2(Buf)) { // 找到3字节起始码
        nalu->startcodeprefix_len = 3;
        pos = 3;
    } else { // 找到4字节起始码
        if (1 != fread(Buf+3, 1, 1, h264stream)) {
            free(Buf);
            return 0;
        }

        if (FindStartCode3(Buf)) { // 找到4字节起始码
            nalu->startcodeprefix_len = 4;
            pos = 4;
        } else { // 没有找到起始码
            free(Buf);
            return -1;
        }
    }

    // 查找下一个起始码前的字节数
    StartCodeFound = 0;
    rewind = 0;
    while (!StartCodeFound) {
        if (feof(h264stream)) {
            nalu->len = (pos-1) - nalu->startcodeprefix_len;
            memcpy(nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
            nalu->forbidden_bit = nalu->buf[0] & 0x80; // 禁止位
            nalu->nal_reference_idc = (nalu->buf[0] & 0x60) >> 5; // 重要性
            nalu->nal_unit_type = (nalu->buf[0]) & 0x1f; // 类型
            free(Buf);
            return pos-1;
        }

        Buf[pos++] = fgetc(h264stream);
        if (Buf[pos-1] == 0x00) rewind++;
        else {
            if (Buf[pos-1] == 0x01 && rewind >= 2) StartCodeFound = 1;
            else rewind = 0;
        }
    }

    // 找到下一个起始码前的字节数
    rewind = (rewind == 2) ? 2 : 3;
    if (0 != fseek(h264stream, -rewind, SEEK_CUR)) {
        free(Buf);
        printf("GetAnnexbNALU: Cannot fseek in the bit stream file");
        return 0;
    }

    // 去掉起始码，获取NALU数据部分长度
    nalu->len = (pos-rewind) - nalu->startcodeprefix_len;
    memcpy(nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
    nalu->forbidden_bit = nalu->buf[0] & 0x80; // 禁止位
    nalu->nal_reference_idc = (nalu->buf[0] & 0x60) >> 5; // 重要性
    nalu->nal_unit_type = (nalu->buf[0]) & 0x1f; // 类型

    free(Buf);

    return (pos-rewind);
}

int main()
{
    // 打开视频流
    FILE *h264stream = fopen("test.h264", "rb");
    if (!h264stream) {
        printf("Can't open input video file.\n");
        return 0;
    }

    // 初始化NALU结构体
    NALU_t *nalu = (NALU_t*)calloc(1, sizeof(NALU_t));
    if (!nalu) {
        printf("Alloc NALU_t failed.\n");
        return 0;
    }

    // 设置最大NALU长度
    nalu->max_size = 1024*1024;
    nalu->buf = (char*)calloc(nalu->max_size, sizeof(char));
    if (!nalu->buf) {
        printf("Alloc NALU_t buf failed.\n");
        return 0;
    }

    // 读取NALU数据
    while (!feof(h264stream)) {
        int pos = GetAnnexbNALU(nalu);
        if (pos > 0) {
            // 判断NALU类型
            switch (nalu->nal_unit_type) {
                case NALU_TYPE_SLICE:
                case NALU_TYPE_DPA:
                case NALU_TYPE_DPB:
                case NALU_TYPE_DPC:
                case NALU_TYPE_IDR:
                    // I帧或P帧
                    break;

                case NALU_TYPE_SPS:
                    // SPS帧
                    break;

                case NALU_TYPE_PPS:
                    // PPS帧
                    break;

                default:
                    // 其他帧类型
                    break;
            }
        }
    }

    // 关闭视频流
    fclose(h264stream);

    // 释放内存
    free(nalu->buf);
    free(nalu);

    return 0;
}

该代码打开一个H.264码流文件，然后从中读取NALU数据，并判断NALU类型。其中，`GetAnnexbNALU`函数用于从码流中读取一个NALU，`FindStartCode2`和`FindStartCode3`函数用于查找起始码。在判断NALU类型时，根据NALU类型的不同，可以判断出I帧、P帧、SPS帧、PPS帧等。由于H.264码流中的NALU是以起始码（0x000001或0x00000001）为分割的，因此需要在读取NALU数据时，先查找起始码，并去掉起始码后的数据才是NALU的有效数据。同时，SPS、PPS等信息也是以NALU的形式存在于码流中。