diff --git a/libavcodec/evc_parse.c b/libavcodec/evc_parse.c index 262ef5aa39..0ad0d82137 100644 --- a/libavcodec/evc_parse.c +++ b/libavcodec/evc_parse.c @@ -70,11 +70,12 @@ int ff_evc_get_temporal_id(const uint8_t *bits, int bits_size, void *logctx) } // @see ISO_IEC_23094-1 (7.3.2.6 Slice layer RBSP syntax) -static int evc_parse_slice_header(EVCParserContext *ctx, EVCParserSliceHeader *sh, const uint8_t *bs, int bs_size) +int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps, + enum EVCNALUnitType nalu_type, const uint8_t *bs, int bs_size) { GetBitContext gb; - EVCParserPPS *pps; - EVCParserSPS *sps; + const EVCParserPPS *pps; + const EVCParserSPS *sps; int num_tiles_in_slice = 0; int slice_pic_parameter_set_id; @@ -88,11 +89,11 @@ static int evc_parse_slice_header(EVCParserContext *ctx, EVCParserSliceHeader *s if (slice_pic_parameter_set_id < 0 || slice_pic_parameter_set_id >= EVC_MAX_PPS_COUNT) return AVERROR_INVALIDDATA; - pps = ctx->ps.pps[slice_pic_parameter_set_id]; + pps = ps->pps[slice_pic_parameter_set_id]; if(!pps) return AVERROR_INVALIDDATA; - sps = ctx->ps.sps[pps->pps_seq_parameter_set_id]; + sps = ps->sps[pps->pps_seq_parameter_set_id]; if(!sps) return AVERROR_INVALIDDATA; @@ -121,7 +122,7 @@ static int evc_parse_slice_header(EVCParserContext *ctx, EVCParserSliceHeader *s sh->slice_type = get_ue_golomb(&gb); - if (ctx->nalu_type == EVC_IDR_NUT) + if (nalu_type == EVC_IDR_NUT) sh->no_output_of_prior_pics_flag = get_bits(&gb, 1); if (sps->sps_mmvd_flag && ((sh->slice_type == EVC_SLICE_TYPE_B) || (sh->slice_type == EVC_SLICE_TYPE_P))) @@ -175,7 +176,7 @@ static int evc_parse_slice_header(EVCParserContext *ctx, EVCParserSliceHeader *s } } - if (ctx->nalu_type != EVC_IDR_NUT) { + if (nalu_type != EVC_IDR_NUT) { if (sps->sps_pocs_flag) sh->slice_pic_order_cnt_lsb = get_bits(&gb, sps->log2_max_pic_order_cnt_lsb_minus4 + 4); } @@ -372,7 +373,7 @@ int ff_evc_parse_nal_unit(EVCParserContext *ctx, const uint8_t *buf, int buf_siz EVCParserSliceHeader sh; int ret; - ret = evc_parse_slice_header(ctx, &sh, data, nalu_size); + ret = ff_evc_parse_slice_header(&sh, &ctx->ps, nalu_type, data, nalu_size); if (ret < 0) { av_log(logctx, AV_LOG_ERROR, "Slice header parsing error\n"); return ret; diff --git a/libavcodec/evc_parse.h b/libavcodec/evc_parse.h index 97825efcd5..f31075ff9c 100644 --- a/libavcodec/evc_parse.h +++ b/libavcodec/evc_parse.h @@ -159,6 +159,9 @@ int ff_evc_get_temporal_id(const uint8_t *bits, int bits_size, void *logctx); int ff_evc_parse_nal_unit(EVCParserContext *ctx, const uint8_t *buf, int buf_size, void *logctx); +int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps, + enum EVCNALUnitType nalu_type, const uint8_t *buf, int buf_size); + // POC (picture order count of the current picture) derivation // @see ISO/IEC 23094-1:2020(E) 8.3.1 Decoding process for picture order count int ff_evc_derive_poc(const EVCParamSets *ps, const EVCParserSliceHeader *sh, diff --git a/libavcodec/evc_parser.c b/libavcodec/evc_parser.c index 4fd8c49fd4..d22922d1c9 100644 --- a/libavcodec/evc_parser.c +++ b/libavcodec/evc_parser.c @@ -25,6 +25,180 @@ #include "evc.h" #include "evc_parse.h" +#define NUM_CHROMA_FORMATS 4 // @see ISO_IEC_23094-1 section 6.2 table 2 + +static const enum AVPixelFormat pix_fmts_8bit[NUM_CHROMA_FORMATS] = { + AV_PIX_FMT_GRAY8, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P +}; + +static const enum AVPixelFormat pix_fmts_9bit[NUM_CHROMA_FORMATS] = { + AV_PIX_FMT_GRAY9, AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9 +}; + +static const enum AVPixelFormat pix_fmts_10bit[NUM_CHROMA_FORMATS] = { + AV_PIX_FMT_GRAY10, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10 +}; + +static const enum AVPixelFormat pix_fmts_12bit[NUM_CHROMA_FORMATS] = { + AV_PIX_FMT_GRAY12, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12 +}; + +static const enum AVPixelFormat pix_fmts_14bit[NUM_CHROMA_FORMATS] = { + AV_PIX_FMT_GRAY14, AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14 +}; + +static const enum AVPixelFormat pix_fmts_16bit[NUM_CHROMA_FORMATS] = { + AV_PIX_FMT_GRAY16, AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16 +}; + +static int parse_nal_unit(AVCodecParserContext *s, AVCodecContext *avctx, + const uint8_t *buf, int buf_size) +{ + EVCParserContext *ctx = s->priv_data; + int nalu_type, tid; + + if (buf_size <= 0) { + av_log(avctx, AV_LOG_ERROR, "Invalid NAL unit size: (%d)\n", buf_size); + return AVERROR_INVALIDDATA; + } + + // @see ISO_IEC_23094-1_2020, 7.4.2.2 NAL unit header semantic (Table 4 - NAL unit type codes and NAL unit type classes) + // @see enum EVCNALUnitType in evc.h + nalu_type = evc_get_nalu_type(buf, buf_size, avctx); + if (nalu_type < EVC_NOIDR_NUT || nalu_type > EVC_UNSPEC_NUT62) { + av_log(avctx, AV_LOG_ERROR, "Invalid NAL unit type: (%d)\n", nalu_type); + return AVERROR_INVALIDDATA; + } + + tid = ff_evc_get_temporal_id(buf, buf_size, avctx); + if (tid < 0) { + av_log(avctx, AV_LOG_ERROR, "Invalid temporial id: (%d)\n", tid); + return AVERROR_INVALIDDATA; + } + + buf += EVC_NALU_HEADER_SIZE; + buf_size -= EVC_NALU_HEADER_SIZE; + + switch (nalu_type) { + case EVC_SPS_NUT: { + EVCParserSPS *sps = ff_evc_parse_sps(&ctx->ps, buf, buf_size); + if (!sps) { + av_log(avctx, AV_LOG_ERROR, "SPS parsing error\n"); + return AVERROR_INVALIDDATA; + } + break; + } + case EVC_PPS_NUT: { + EVCParserPPS *pps = ff_evc_parse_pps(&ctx->ps, buf, buf_size); + if (!pps) { + av_log(avctx, AV_LOG_ERROR, "PPS parsing error\n"); + return AVERROR_INVALIDDATA; + } + break; + } + case EVC_IDR_NUT: // Coded slice of a IDR or non-IDR picture + case EVC_NOIDR_NUT: { + const EVCParserPPS *pps; + const EVCParserSPS *sps; + EVCParserSliceHeader sh; + int bit_depth; + int ret; + + ret = ff_evc_parse_slice_header(&sh, &ctx->ps, nalu_type, buf, buf_size); + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "Slice header parsing error\n"); + return ret; + } + + pps = ctx->ps.pps[sh.slice_pic_parameter_set_id]; + sps = ctx->ps.sps[pps->pps_seq_parameter_set_id]; + av_assert0(sps && pps); + + s->coded_width = sps->pic_width_in_luma_samples; + s->coded_height = sps->pic_height_in_luma_samples; + + if (sps->picture_cropping_flag) { + s->width = sps->pic_width_in_luma_samples - sps->picture_crop_left_offset - sps->picture_crop_right_offset; + s->height = sps->pic_height_in_luma_samples - sps->picture_crop_top_offset - sps->picture_crop_bottom_offset; + } else { + s->width = sps->pic_width_in_luma_samples; + s->height = sps->pic_height_in_luma_samples; + } + + switch (sh.slice_type) { + case EVC_SLICE_TYPE_B: { + s->pict_type = AV_PICTURE_TYPE_B; + break; + } + case EVC_SLICE_TYPE_P: { + s->pict_type = AV_PICTURE_TYPE_P; + break; + } + case EVC_SLICE_TYPE_I: { + s->pict_type = AV_PICTURE_TYPE_I; + break; + } + default: { + s->pict_type = AV_PICTURE_TYPE_NONE; + } + } + + avctx->profile = sps->profile_idc; + + if (sps->vui_parameters_present_flag && sps->vui_parameters.timing_info_present_flag) { + int64_t num = sps->vui_parameters.num_units_in_tick; + int64_t den = sps->vui_parameters.time_scale; + if (num != 0 && den != 0) + av_reduce(&avctx->framerate.den, &avctx->framerate.num, num, den, 1 << 30); + } else + avctx->framerate = (AVRational) { 0, 1 }; + + bit_depth = sps->bit_depth_chroma_minus8 + 8; + s->format = AV_PIX_FMT_NONE; + + switch (bit_depth) { + case 8: + s->format = pix_fmts_8bit[sps->chroma_format_idc]; + break; + case 9: + s->format = pix_fmts_9bit[sps->chroma_format_idc]; + break; + case 10: + s->format = pix_fmts_10bit[sps->chroma_format_idc]; + break; + case 12: + s->format = pix_fmts_12bit[sps->chroma_format_idc]; + break; + case 14: + s->format = pix_fmts_14bit[sps->chroma_format_idc]; + break; + case 16: + s->format = pix_fmts_16bit[sps->chroma_format_idc]; + break; + } + + s->key_frame = (nalu_type == EVC_IDR_NUT) ? 1 : 0; + + // POC (picture order count of the current picture) derivation + // @see ISO/IEC 23094-1:2020(E) 8.3.1 Decoding process for picture order count + ret = ff_evc_derive_poc(&ctx->ps, &sh, &ctx->poc, nalu_type, tid); + if (ret < 0) + return ret; + + s->output_picture_number = ctx->poc.PicOrderCntVal; + + break; + } + case EVC_SEI_NUT: // Supplemental Enhancement Information + case EVC_APS_NUT: // Adaptation parameter set + case EVC_FD_NUT: // Filler data + default: + break; + } + + return 0; +} + /** * Parse NAL units of found picture and decode some basic information. * @@ -35,13 +209,13 @@ */ static int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t *buf, int buf_size) { - EVCParserContext *ctx = s->priv_data; const uint8_t *data = buf; int data_size = buf_size; int bytes_read = 0; - int nalu_size = 0; while (data_size > 0) { + int nalu_size = 0; + int ret; // Buffer size is not enough for buffer to store NAL unit 4-bytes prefix (length) if (data_size < EVC_NALU_LENGTH_PREFIX_SIZE) @@ -57,31 +231,12 @@ static int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx, const if (data_size < nalu_size) return AVERROR_INVALIDDATA; - if (ff_evc_parse_nal_unit(ctx, data, nalu_size, avctx) != 0) { + ret = parse_nal_unit(s, avctx, data, nalu_size); + if (ret < 0) { av_log(avctx, AV_LOG_ERROR, "Parsing of NAL unit failed\n"); return AVERROR_INVALIDDATA; } - if(ctx->nalu_type == EVC_SPS_NUT) { - - s->coded_width = ctx->coded_width; - s->coded_height = ctx->coded_height; - s->width = ctx->width; - s->height = ctx->height; - - s->format = ctx->format; - - avctx->framerate = ctx->framerate; - avctx->profile = ctx->profile; - - } else if(ctx->nalu_type == EVC_NOIDR_NUT || ctx->nalu_type == EVC_IDR_NUT) { - - s->pict_type = ctx->pict_type; - s->key_frame = ctx->key_frame; - s->output_picture_number = ctx->output_picture_number; - - } - data += nalu_size; data_size -= nalu_size; } @@ -90,8 +245,10 @@ static int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx, const // Decoding nal units from evcC (EVCDecoderConfigurationRecord) // @see @see ISO/IEC 14496-15:2021 Coding of audio-visual objects - Part 15: section 12.3.3.2 -static int decode_extradata(EVCParserContext *ctx, const uint8_t *data, int size, void *logctx) +static int decode_extradata(AVCodecParserContext *s, AVCodecContext *avctx) { + const uint8_t *data = avctx->extradata; + int size = avctx->extradata_size; int ret = 0; GetByteContext gb; @@ -108,7 +265,7 @@ static int decode_extradata(EVCParserContext *ctx, const uint8_t *data, int size // The value of this field shall be one of 0, 1, or 3 corresponding to a length encoded with 1, 2, or 4 bytes, respectively. if (bytestream2_get_bytes_left(&gb) < 18) { - av_log(logctx, AV_LOG_ERROR, "evcC %d too short\n", size); + av_log(avctx, AV_LOG_ERROR, "evcC %d too short\n", size); return AVERROR_INVALIDDATA; } @@ -121,7 +278,7 @@ static int decode_extradata(EVCParserContext *ctx, const uint8_t *data, int size if( nalu_length_field_size != 1 && nalu_length_field_size != 2 && nalu_length_field_size != 4 ) { - av_log(logctx, AV_LOG_ERROR, "The length in bytes of the NALUnitLenght field in a EVC video stream has unsupported value of %d\n", nalu_length_field_size); + av_log(avctx, AV_LOG_ERROR, "The length in bytes of the NALUnitLenght field in a EVC video stream has unsupported value of %d\n", nalu_length_field_size); return AVERROR_INVALIDDATA; } @@ -142,7 +299,7 @@ static int decode_extradata(EVCParserContext *ctx, const uint8_t *data, int size int nal_unit_length = bytestream2_get_be16(&gb); if (bytestream2_get_bytes_left(&gb) < nal_unit_length) { - av_log(logctx, AV_LOG_ERROR, "Invalid NAL unit size in extradata.\n"); + av_log(avctx, AV_LOG_ERROR, "Invalid NAL unit size in extradata.\n"); return AVERROR_INVALIDDATA; } @@ -150,8 +307,8 @@ static int decode_extradata(EVCParserContext *ctx, const uint8_t *data, int size nal_unit_type == EVC_PPS_NUT || nal_unit_type == EVC_APS_NUT || nal_unit_type == EVC_SEI_NUT ) { - if (ff_evc_parse_nal_unit(ctx, gb.buffer, nal_unit_length, logctx) != 0) { - av_log(logctx, AV_LOG_ERROR, "Parsing of NAL unit failed\n"); + if (parse_nal_unit(s, avctx, gb.buffer, nal_unit_length) != 0) { + av_log(avctx, AV_LOG_ERROR, "Parsing of NAL unit failed\n"); return AVERROR_INVALIDDATA; } } @@ -173,8 +330,11 @@ static int evc_parse(AVCodecParserContext *s, AVCodecContext *avctx, int ret; EVCParserContext *ctx = s->priv_data; + s->picture_structure = AV_PICTURE_STRUCTURE_FRAME; + s->key_frame = 0; + if (avctx->extradata && !ctx->parsed_extradata) { - decode_extradata(ctx, avctx->extradata, avctx->extradata_size, avctx); + decode_extradata(s, avctx); ctx->parsed_extradata = 1; } @@ -187,8 +347,6 @@ static int evc_parse(AVCodecParserContext *s, AVCodecContext *avctx, return buf_size; } - s->picture_structure = AV_PICTURE_STRUCTURE_FRAME; - // poutbuf contains just one Access Unit *poutbuf = buf; *poutbuf_size = buf_size;