Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

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

Browse Source 
Signed-off-by: James Almer <jamrial@gmail.com>
pull/389/head
James Almer 1 year ago
parent 2212808a72
commit e5da2ec456
4 changed files with 35 additions and 33 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      libavcodec/evc_frame_merge_bsf.c
  2. 52
      libavcodec/evc_parse.c
  3. 4
      libavcodec/evc_parse.h
  4. 6
      libavcodec/evc_parser.c

6
libavcodec/evc_frame_merge_bsf.c
Unescape View File

@ -145,7 +145,11 @@ static int evc_frame_merge_filter(AVBSFContext *bsf, AVPacket *out)
case EVC_NOIDR_NUT: {
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) {
av_log(bsf, AV_LOG_ERROR, "Slice header parsing error\n");
goto end;

52
libavcodec/evc_parse.c
Unescape 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)
int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps,
enum EVCNALUnitType nalu_type, const uint8_t *bs, int bs_size)
int ff_evc_parse_slice_header(GetBitContext *gb, EVCParserSliceHeader *sh,
const EVCParamSets *ps, enum EVCNALUnitType nalu_type)
{
GetBitContext gb;
const EVCParserPPS *pps;
const EVCParserSPS *sps;
int num_tiles_in_slice = 0;
int slice_pic_parameter_set_id;
int ret;
if ((ret = init_get_bits8(&gb, bs, bs_size)) < 0)
return ret;
slice_pic_parameter_set_id = get_ue_golomb(&gb);
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)
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;
if (!pps->single_tile_in_pic_flag) {
sh->single_tile_in_slice_flag = get_bits1(&gb);
sh->first_tile_id = get_bits(&gb, pps->tile_id_len_minus1 + 1);
sh->single_tile_in_slice_flag = get_bits1(gb);
sh->first_tile_id = get_bits(gb, pps->tile_id_len_minus1 + 1);
} else
sh->single_tile_in_slice_flag = 1;
if (!sh->single_tile_in_slice_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)
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 {
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;
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)
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)))
sh->mmvd_group_enable_flag = get_bits1(&gb);
sh->mmvd_group_enable_flag = get_bits1(gb);
else
sh->mmvd_group_enable_flag = 0;
if (sps->sps_alf_flag) {
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) {
sh->slice_alf_luma_aps_id = get_bits(&gb, 5);
sh->slice_alf_map_flag = get_bits1(&gb);
sh->slice_alf_chroma_idc = get_bits(&gb, 2);
sh->slice_alf_luma_aps_id = get_bits(gb, 5);
sh->slice_alf_map_flag = get_bits1(gb);
sh->slice_alf_chroma_idc = get_bits(gb, 2);
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) {
int sliceChromaAlfEnabledFlag = 0;
@ -136,23 +130,23 @@ int ff_evc_parse_slice_header(EVCParserSliceHeader *sh, const EVCParamSets *ps,
}
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) {
sh->slice_alf_chroma_aps_id = get_bits(&gb, 5);
sh->slice_alf_chroma_map_flag = get_bits1(&gb);
sh->slice_alf_chroma_aps_id = get_bits(gb, 5);
sh->slice_alf_chroma_map_flag = get_bits1(gb);
}
if (sliceChroma2AlfEnabledFlag) {
sh->slice_alf_chroma2_aps_id = get_bits(&gb, 5);
sh->slice_alf_chroma2_map_flag = get_bits1(&gb);
sh->slice_alf_chroma2_aps_id = get_bits(gb, 5);
sh->slice_alf_chroma2_map_flag = get_bits1(gb);
}
}
}
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);
sh->slice_pic_order_cnt_lsb = get_bits(gb, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
}
// @note

4
libavcodec/evc_parse.h
Unescape 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
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,
enum EVCNALUnitType nalu_type, const uint8_t *buf, int buf_size);
int ff_evc_parse_slice_header(GetBitContext *gb, EVCParserSliceHeader *sh,
const EVCParamSets *ps, enum EVCNALUnitType nalu_type);
// 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

6
libavcodec/evc_parser.c
Unescape View File

@ -116,7 +116,11 @@ static int parse_nal_unit(AVCodecParserContext *s, AVCodecContext *avctx,
EVCParserSliceHeader sh;
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) {
av_log(avctx, AV_LOG_ERROR, "Slice header parsing error\n");
return ret;

Write Preview
Loading…
Cancel
Save