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

avcodec/evc_parse: pass a GetBitContext to the slice header parsing function 

Signed-off-by: James Almer <jamrial@gmail.com>
This commit is contained in:
James Almer 2023-06-20 11:05:38 -03:00
parent 2212808a72
commit e5da2ec456
4 changed files with 35 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libavcodec/evc_frame_merge_bsf.c
View File

@ -145,7 +145,11 @@ static int evc_frame_merge_filter(AVBSFContext *bsf, AVPacket *out)
case EVC_NOIDR_NUT: { case EVC_NOIDR_NUT: {
EVCParserSliceHeader sh; EVCParserSliceHeader sh;
err = ff_evc_parse_slice_header(&sh, &ctx->ps, nalu_type, nalu, nalu_size); err = init_get_bits8(&gb, nalu, nalu_size);
if (err < 0)
return err;
err = ff_evc_parse_slice_header(&gb, &sh, &ctx->ps, nalu_type);
if (err < 0) { if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Slice header parsing error\n"); av_log(bsf, AV_LOG_ERROR, "Slice header parsing error\n");
goto end; goto end;

52
libavcodec/evc_parse.c
View File

@ -44,21 +44,15 @@ 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) // @see ISO_IEC_23094-1 (7.3.2.6 Slice layer RBSP syntax)
int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps, int ff_evc_parse_slice_header(GetBitContext *gb, EVCParserSliceHeader *sh,
enum EVCNALUnitType nalu_type, const uint8_t *bs, int bs_size) const EVCParamSets *ps, enum EVCNALUnitType nalu_type)
{ {
GetBitContext gb;
const EVCParserPPS *pps; const EVCParserPPS *pps;
const EVCParserSPS *sps; const EVCParserSPS *sps;
int num_tiles_in_slice = 0; int num_tiles_in_slice = 0;
int slice_pic_parameter_set_id; int slice_pic_parameter_set_id;
int ret;
if ((ret = init_get_bits8(&gb, bs, bs_size)) < 0) slice_pic_parameter_set_id = get_ue_golomb(gb);
return ret;
slice_pic_parameter_set_id = get_ue_golomb(&gb);
if (slice_pic_parameter_set_id < 0 || slice_pic_parameter_set_id >= EVC_MAX_PPS_COUNT) if (slice_pic_parameter_set_id < 0 || slice_pic_parameter_set_id >= EVC_MAX_PPS_COUNT)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -75,47 +69,47 @@ int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps,
sh->slice_pic_parameter_set_id = slice_pic_parameter_set_id; sh->slice_pic_parameter_set_id = slice_pic_parameter_set_id;
if (!pps->single_tile_in_pic_flag) { if (!pps->single_tile_in_pic_flag) {
sh->single_tile_in_slice_flag = get_bits1(&gb); sh->single_tile_in_slice_flag = get_bits1(gb);
sh->first_tile_id = get_bits(&gb, pps->tile_id_len_minus1 + 1); sh->first_tile_id = get_bits(gb, pps->tile_id_len_minus1 + 1);
} else } else
sh->single_tile_in_slice_flag = 1; sh->single_tile_in_slice_flag = 1;
if (!sh->single_tile_in_slice_flag) { if (!sh->single_tile_in_slice_flag) {
if (pps->arbitrary_slice_present_flag) if (pps->arbitrary_slice_present_flag)
sh->arbitrary_slice_flag = get_bits1(&gb); sh->arbitrary_slice_flag = get_bits1(gb);
if (!sh->arbitrary_slice_flag) if (!sh->arbitrary_slice_flag)
sh->last_tile_id = get_bits(&gb, pps->tile_id_len_minus1 + 1); sh->last_tile_id = get_bits(gb, pps->tile_id_len_minus1 + 1);
else { else {
sh->num_remaining_tiles_in_slice_minus1 = get_ue_golomb(&gb); sh->num_remaining_tiles_in_slice_minus1 = get_ue_golomb(gb);
num_tiles_in_slice = sh->num_remaining_tiles_in_slice_minus1 + 2; num_tiles_in_slice = sh->num_remaining_tiles_in_slice_minus1 + 2;
for (int i = 0; i < num_tiles_in_slice - 1; ++i) for (int i = 0; i < num_tiles_in_slice - 1; ++i)
sh->delta_tile_id_minus1[i] = get_ue_golomb(&gb); sh->delta_tile_id_minus1[i] = get_ue_golomb(gb);
} }
} }
sh->slice_type = get_ue_golomb(&gb); sh->slice_type = get_ue_golomb(gb);
if (nalu_type == EVC_IDR_NUT) if (nalu_type == EVC_IDR_NUT)
sh->no_output_of_prior_pics_flag = get_bits1(&gb); sh->no_output_of_prior_pics_flag = get_bits1(gb);
if (sps->sps_mmvd_flag && ((sh->slice_type == EVC_SLICE_TYPE_B) || (sh->slice_type == EVC_SLICE_TYPE_P))) if (sps->sps_mmvd_flag && ((sh->slice_type == EVC_SLICE_TYPE_B) || (sh->slice_type == EVC_SLICE_TYPE_P)))
sh->mmvd_group_enable_flag = get_bits1(&gb); sh->mmvd_group_enable_flag = get_bits1(gb);
else else
sh->mmvd_group_enable_flag = 0; sh->mmvd_group_enable_flag = 0;
if (sps->sps_alf_flag) { if (sps->sps_alf_flag) {
int ChromaArrayType = sps->chroma_format_idc; int ChromaArrayType = sps->chroma_format_idc;
sh->slice_alf_enabled_flag = get_bits1(&gb); sh->slice_alf_enabled_flag = get_bits1(gb);
if (sh->slice_alf_enabled_flag) { if (sh->slice_alf_enabled_flag) {
sh->slice_alf_luma_aps_id = get_bits(&gb, 5); sh->slice_alf_luma_aps_id = get_bits(gb, 5);
sh->slice_alf_map_flag = get_bits1(&gb); sh->slice_alf_map_flag = get_bits1(gb);
sh->slice_alf_chroma_idc = get_bits(&gb, 2); sh->slice_alf_chroma_idc = get_bits(gb, 2);
if ((ChromaArrayType == 1 || ChromaArrayType == 2) && sh->slice_alf_chroma_idc > 0) if ((ChromaArrayType == 1 || ChromaArrayType == 2) && sh->slice_alf_chroma_idc > 0)
sh->slice_alf_chroma_aps_id = get_bits(&gb, 5); sh->slice_alf_chroma_aps_id = get_bits(gb, 5);
} }
if (ChromaArrayType == 3) { if (ChromaArrayType == 3) {
int sliceChromaAlfEnabledFlag = 0; int sliceChromaAlfEnabledFlag = 0;
@ -136,23 +130,23 @@ int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps,
} }
if (!sh->slice_alf_enabled_flag) if (!sh->slice_alf_enabled_flag)
sh->slice_alf_chroma_idc = get_bits(&gb, 2); sh->slice_alf_chroma_idc = get_bits(gb, 2);
if (sliceChromaAlfEnabledFlag) { if (sliceChromaAlfEnabledFlag) {
sh->slice_alf_chroma_aps_id = get_bits(&gb, 5); sh->slice_alf_chroma_aps_id = get_bits(gb, 5);
sh->slice_alf_chroma_map_flag = get_bits1(&gb); sh->slice_alf_chroma_map_flag = get_bits1(gb);
} }
if (sliceChroma2AlfEnabledFlag) { if (sliceChroma2AlfEnabledFlag) {
sh->slice_alf_chroma2_aps_id = get_bits(&gb, 5); sh->slice_alf_chroma2_aps_id = get_bits(gb, 5);
sh->slice_alf_chroma2_map_flag = get_bits1(&gb); sh->slice_alf_chroma2_map_flag = get_bits1(gb);
} }
} }
} }
if (nalu_type != EVC_IDR_NUT) { if (nalu_type != EVC_IDR_NUT) {
if (sps->sps_pocs_flag) if (sps->sps_pocs_flag)
sh->slice_pic_order_cnt_lsb = get_bits(&gb, sps->log2_max_pic_order_cnt_lsb_minus4 + 4); sh->slice_pic_order_cnt_lsb = get_bits(gb, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
} }
// @note // @note

4
libavcodec/evc_parse.h
View File

@ -117,8 +117,8 @@ static inline uint32_t evc_read_nal_unit_length(const uint8_t *bits, int bits_si
// nuh_temporal_id specifies a temporal identifier for the NAL unit // nuh_temporal_id specifies a temporal identifier for the NAL unit
int ff_evc_get_temporal_id(const uint8_t *bits, int bits_size, void *logctx); int ff_evc_get_temporal_id(const uint8_t *bits, int bits_size, void *logctx);
int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps, int ff_evc_parse_slice_header(GetBitContext *gb, EVCParserSliceHeader *sh,
enum EVCNALUnitType nalu_type, const uint8_t *buf, int buf_size); const EVCParamSets *ps, enum EVCNALUnitType nalu_type);
// POC (picture order count of the current picture) derivation // 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 // @see ISO/IEC 23094-1:2020(E) 8.3.1 Decoding process for picture order count

6
libavcodec/evc_parser.c
View File

@ -116,7 +116,11 @@ static int parse_nal_unit(AVCodecParserContext *s, AVCodecContext *avctx,
EVCParserSliceHeader sh; EVCParserSliceHeader sh;
int bit_depth; int bit_depth;
ret = ff_evc_parse_slice_header(&sh, &ctx->ps, nalu_type, buf, buf_size); ret = init_get_bits8(&gb, buf, buf_size);
if (ret < 0)
return ret;
ret = ff_evc_parse_slice_header(&gb, &sh, &ctx->ps, nalu_type);
if (ret < 0) { if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Slice header parsing error\n"); av_log(avctx, AV_LOG_ERROR, "Slice header parsing error\n");
return ret; return ret;