virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-03 05:10:03 +02:00
Code Issues Releases Activity

lavc/hevcdec: simplify output logic

Browse Source 
Current code is written around the "simple" decode API's limitation that
a single input packet (AU/coded frame) triggers the output of at most
one output frame. However the spec contains two cases where a coded
frame may cause multiple frames to be output (cf. C.5.2.2.2):
* start of a new sequence
* overflowing sps_max_dec_pic_buffering

The decoder currently contains rather convoluted logic to handle these
cases:
* decode/output/per-frame sequence counters,
* HEVC_FRAME_FLAG_BUMPING
* ff_hevc_bump_frame()
* special clauses in ff_hevc_output_frame()

However, with the receive_frame() API none of that is necessary, as we
can just output multiple frames at once. Previously added ContainerFifo
allows that to be done in a straightforward and efficient manner.
This commit is contained in:
Anton Khirnov 2024-06-21 12:03:40 +02:00
parent 79afc45c03
commit 4b9adb35b6
3 changed files with 42 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
libavcodec/hevc/hevcdec.c
View File

@ -2908,6 +2908,7 @@ static int hevc_frame_start(HEVCContext *s)
const HEVCSPS *const sps = pps->sps;
int pic_size_in_ctb = ((sps->width >> sps->log2_min_cb_size) + 1) *
((sps->height >> sps->log2_min_cb_size) + 1);
int new_sequence = IS_IDR(s) || IS_BLA(s) || s->last_eos;
int ret;
ff_refstruct_replace(&s->pps, pps);
@ -2927,7 +2928,7 @@ static int hevc_frame_start(HEVCContext *s)
return pix_fmt;
s->avctx->pix_fmt = pix_fmt;
s->seq_decode = (s->seq_decode + 1) & HEVC_SEQUENCE_COUNTER_MASK;
new_sequence = 1;
}
memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
@ -2936,11 +2937,8 @@ static int hevc_frame_start(HEVCContext *s)
memset(s->is_pcm, 0, (sps->min_pu_width + 1) * (sps->min_pu_height + 1));
memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
if ((IS_IDR(s) || IS_BLA(s))) {
s->seq_decode = (s->seq_decode + 1) & HEVC_SEQUENCE_COUNTER_MASK;
if (IS_IDR(s))
ff_hevc_clear_refs(s);
}
if (IS_IDR(s))
ff_hevc_clear_refs(s);
s->slice_idx = 0;
s->first_nal_type = s->nal_unit_type;
@ -2964,6 +2962,12 @@ static int hevc_frame_start(HEVCContext *s)
if (pps->tiles_enabled_flag)
s->local_ctx[0].end_of_tiles_x = pps->column_width[0] << sps->log2_ctb_size;
if (new_sequence) {
ret = ff_hevc_output_frames(s, 0, 0, s->sh.no_output_of_prior_pics_flag);
if (ret < 0)
return ret;
}
ret = export_stream_params_from_sei(s);
if (ret < 0)
return ret;
@ -3016,10 +3020,8 @@ static int hevc_frame_start(HEVCContext *s)
s->cur_frame->f->pict_type = 3 - s->sh.slice_type;
if (!IS_IRAP(s))
ff_hevc_bump_frame(s);
ret = ff_hevc_output_frame(s, 0);
ret = ff_hevc_output_frames(s, sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics,
sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering, 0);
if (ret < 0)
goto fail;
@ -3267,8 +3269,6 @@ static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
break;
case HEVC_NAL_EOS_NUT:
case HEVC_NAL_EOB_NUT:
s->seq_decode = (s->seq_decode + 1) & HEVC_SEQUENCE_COUNTER_MASK;
break;
case HEVC_NAL_AUD:
case HEVC_NAL_FD_NUT:
case HEVC_NAL_UNSPEC62:
@ -3425,7 +3425,7 @@ static int hevc_receive_frame(AVCodecContext *avctx, AVFrame *frame)
av_packet_unref(avpkt);
ret = ff_decode_get_packet(avctx, avpkt);
if (ret == AVERROR_EOF) {
ret = ff_hevc_output_frame(s, 1);
ret = ff_hevc_output_frames(s, 0, 0, 0);
if (ret < 0)
return ret;
goto do_output;
@ -3487,7 +3487,6 @@ static int hevc_ref_frame(HEVCFrame *dst, const HEVCFrame *src)
dst->poc = src->poc;
dst->ctb_count = src->ctb_count;
dst->flags = src->flags;
dst->sequence = src->sequence;
ff_refstruct_replace(&dst->hwaccel_picture_private,
src->hwaccel_picture_private);
@ -3611,8 +3610,6 @@ static int hevc_update_thread_context(AVCodecContext *dst,
if ((ret = set_sps(s, s0->ps.sps)) < 0)
return ret;
s->seq_decode = s0->seq_decode;
s->seq_output = s0->seq_output;
s->poc_tid0 = s0->poc_tid0;
s->eos = s0->eos;
s->no_rasl_output_flag = s0->no_rasl_output_flag;
@ -3622,10 +3619,6 @@ static int hevc_update_thread_context(AVCodecContext *dst,
s->film_grain_warning_shown = s0->film_grain_warning_shown;
if (s0->eos) {
s->seq_decode = (s->seq_decode + 1) & HEVC_SEQUENCE_COUNTER_MASK;
}
ret = ff_h2645_sei_ctx_replace(&s->sei.common, &s0->sei.common);
if (ret < 0)
return ret;

32
libavcodec/hevc/hevcdec.h
View File

@ -349,10 +349,7 @@ typedef struct DBParams {
#define HEVC_FRAME_FLAG_OUTPUT (1 << 0)
#define HEVC_FRAME_FLAG_SHORT_REF (1 << 1)
#define HEVC_FRAME_FLAG_LONG_REF (1 << 2)
#define HEVC_FRAME_FLAG_BUMPING (1 << 3)
#define HEVC_SEQUENCE_COUNTER_MASK 0xff
#define HEVC_SEQUENCE_COUNTER_INVALID (HEVC_SEQUENCE_COUNTER_MASK + 1)
#define HEVC_FRAME_FLAG_UNAVAILABLE (1 << 3)
typedef struct HEVCFrame {
union {
@ -374,12 +371,6 @@ typedef struct HEVCFrame {
void *hwaccel_picture_private; ///< RefStruct reference
/**
* A sequence counter, so that old frames are output first
* after a POC reset
*/
uint16_t sequence;
/**
* A combination of HEVC_FRAME_FLAG_*
*/
@ -518,13 +509,6 @@ typedef struct HEVCContext {
uint8_t *checksum_buf;
int checksum_buf_size;
/**
* Sequence counters for decoded and output frames, so that old
* frames are output first after a POC reset
*/
uint16_t seq_decode;
uint16_t seq_output;
/** The target for the common_cabac_state of the local contexts. */
HEVCCABACState cabac;
@ -633,12 +617,16 @@ static av_always_inline int ff_hevc_nal_is_nonref(enum HEVCNALUnitType type)
}
/**
* Find next frame in output order and put a reference to it in frame.
* @return 1 if a frame was output, 0 otherwise
* Find frames in the DPB that are ready for output and either write them to the
* output FIFO or drop their output flag, depending on the value of discard.
*
* @param max_output maximum number of output-pending frames that can be
* present in the DPB before output is triggered
* @param max_dpb maximum number of any frames that can be present in the DPB
* before output is triggered
*/
int ff_hevc_output_frame(HEVCContext *s, int flush);
void ff_hevc_bump_frame(HEVCContext *s);
int ff_hevc_output_frames(HEVCContext *s, unsigned max_output,
unsigned max_dpb, int discard);
void ff_hevc_unref_frame(HEVCFrame *frame, int flags);

104
libavcodec/hevc/refs.c
View File

@ -132,8 +132,7 @@ int ff_hevc_set_new_ref(HEVCContext *s, int poc)
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if (frame->f && frame->sequence == s->seq_decode &&
frame->poc == poc) {
if (frame->f && frame->poc == poc) {
av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n",
poc);
return AVERROR_INVALIDDATA;
@ -153,7 +152,6 @@ int ff_hevc_set_new_ref(HEVCContext *s, int poc)
ref->flags = HEVC_FRAME_FLAG_SHORT_REF;
ref->poc = poc;
ref->sequence = s->seq_decode;
ref->f->crop_left = s->ps.sps->output_window.left_offset;
ref->f->crop_right = s->ps.sps->output_window.right_offset;
ref->f->crop_top = s->ps.sps->output_window.top_offset;
@ -166,112 +164,49 @@ static void unref_missing_refs(HEVCContext *s)
{
for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if (frame->sequence == HEVC_SEQUENCE_COUNTER_INVALID) {
if (frame->flags & HEVC_FRAME_FLAG_UNAVAILABLE) {
ff_hevc_unref_frame(frame, ~0);
}
}
}
int ff_hevc_output_frame(HEVCContext *s, int flush)
int ff_hevc_output_frames(HEVCContext *s, unsigned max_output,
unsigned max_dpb, int discard)
{
if (IS_IRAP(s) && s->no_rasl_output_flag == 1) {
const static int mask = HEVC_FRAME_FLAG_BUMPING | HEVC_FRAME_FLAG_OUTPUT;
for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if ((frame->flags & mask) == HEVC_FRAME_FLAG_OUTPUT &&
frame->sequence != s->seq_decode) {
if (s->sh.no_output_of_prior_pics_flag == 1)
ff_hevc_unref_frame(frame, HEVC_FRAME_FLAG_OUTPUT);
else
frame->flags |= HEVC_FRAME_FLAG_BUMPING;
}
}
}
do {
while (1) {
int nb_dpb = 0;
int nb_output = 0;
int min_poc = INT_MAX;
int i, min_idx, ret;
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) &&
frame->sequence == s->seq_output) {
if (frame->flags & HEVC_FRAME_FLAG_OUTPUT) {
nb_output++;
if (frame->poc < min_poc || nb_output == 1) {
min_poc = frame->poc;
min_idx = i;
}
}
nb_dpb += !!frame->flags;
}
/* wait for more frames before output */
if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&
nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)
return 0;
if (nb_output) {
if (nb_output > max_output ||
(nb_output && nb_dpb > max_dpb)) {
HEVCFrame *frame = &s->DPB[min_idx];
ret = ff_container_fifo_write(s->output_fifo,
ret = discard ? 0 :
ff_container_fifo_write(s->output_fifo,
frame->needs_fg ? frame->frame_grain : frame->f);
if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
ff_hevc_unref_frame(frame, HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_BUMPING);
else
ff_hevc_unref_frame(frame, HEVC_FRAME_FLAG_OUTPUT);
ff_hevc_unref_frame(frame, HEVC_FRAME_FLAG_OUTPUT);
if (ret < 0)
return ret;
av_log(s->avctx, AV_LOG_DEBUG,
"Output frame with POC %d.\n", frame->poc);
return 1;
av_log(s->avctx, AV_LOG_DEBUG, "%s frame with POC %d.\n",
discard ? "Discarded" : "Output", frame->poc);
continue;
}
if (s->seq_output != s->seq_decode)
s->seq_output = (s->seq_output + 1) & HEVC_SEQUENCE_COUNTER_MASK;
else
break;
} while (1);
return 0;
}
void ff_hevc_bump_frame(HEVCContext *s)
{
int dpb = 0;
int min_poc = INT_MAX;
int i;
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if ((frame->flags) &&
frame->sequence == s->seq_output &&
frame->poc != s->poc) {
dpb++;
}
}
if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if ((frame->flags) &&
frame->sequence == s->seq_output &&
frame->poc != s->poc) {
if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {
min_poc = frame->poc;
}
}
}
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *frame = &s->DPB[i];
if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&
frame->sequence == s->seq_output &&
frame->poc <= min_poc) {
frame->flags |= HEVC_FRAME_FLAG_BUMPING;
}
}
dpb--;
return 0;
}
}
@ -385,7 +320,7 @@ static HEVCFrame *find_ref_idx(HEVCContext *s, int poc, uint8_t use_msb)
for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
HEVCFrame *ref = &s->DPB[i];
if (ref->f && ref->sequence == s->seq_decode) {
if (ref->f) {
if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))
return ref;
}
@ -428,8 +363,7 @@ static HEVCFrame *generate_missing_ref(HEVCContext *s, int poc)
}
frame->poc = poc;
frame->sequence = HEVC_SEQUENCE_COUNTER_INVALID;
frame->flags = 0;
frame->flags = HEVC_FRAME_FLAG_UNAVAILABLE;
if (s->avctx->active_thread_type == FF_THREAD_FRAME)
ff_progress_frame_report(&frame->tf, INT_MAX);