RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

avcodec/evc_parser: make ff_evc_parse_nal_unit() local to the parser 

This is in preparation for the following commits.

Signed-off-by: James Almer <jamrial@gmail.com>
This commit is contained in:
James Almer 2023-06-17 18:02:26 -03:00
parent ff7a4cdf04
commit a5663f2d9a
3 changed files with 202 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
libavcodec/evc_parse.c
View File

@ -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;

3
libavcodec/evc_parse.h
View File

@ -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,

222
libavcodec/evc_parser.c
View File

@ -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;