January 2024 - ffmpeg-devel - lists.ffmpeg.org

[PATCH 01/31] fftools/ffmpeg_dec: split Decoder into a private and public part
by Anton Khirnov 24 Mar '24

24 Mar '24

Similar to what is currently done for other components, e.g. (de)muxers. There is nothing in the public part currently, but that will change in future commits. --- fftools/ffmpeg.h | 4 +- fftools/ffmpeg_dec.c | 193 ++++++++++++++++++++++--------------------- 2 files changed, 104 insertions(+), 93 deletions(-) diff --git a/fftools/ffmpeg.h b/fftools/ffmpeg.h index 3014a626b4..429c1aba85 100644 --- a/fftools/ffmpeg.h +++ b/fftools/ffmpeg.h @@ -280,7 +280,9 @@ typedef struct FilterGraph { int nb_outputs; } FilterGraph; -typedef struct Decoder Decoder; +typedef struct Decoder { + char dummy; +} Decoder; typedef struct InputStream { const AVClass *class; diff --git a/fftools/ffmpeg_dec.c b/fftools/ffmpeg_dec.c index 5d4ef7909c..fd697c5f1e 100644 --- a/fftools/ffmpeg_dec.c +++ b/fftools/ffmpeg_dec.c @@ -34,7 +34,9 @@ #include "ffmpeg_utils.h" #include "thread_queue.h" -struct Decoder { +typedef struct DecoderPriv { + Decoder dec; + AVFrame *frame; AVPacket *pkt; @@ -55,7 +57,12 @@ struct Decoder { Scheduler *sch; unsigned sch_idx; -}; +} DecoderPriv; + +static DecoderPriv *dp_from_dec(Decoder *d) +{ + return (DecoderPriv*)d; +} // data that is local to the decoder thread and not visible outside of it typedef struct DecThreadContext { @@ -66,61 +73,63 @@ typedef struct DecThreadContext { void dec_free(Decoder **pdec) { Decoder *dec = *pdec; + DecoderPriv *dp; if (!dec) return; + dp = dp_from_dec(dec); - av_frame_free(&dec->frame); - av_packet_free(&dec->pkt); + av_frame_free(&dp->frame); + av_packet_free(&dp->pkt); - for (int i = 0; i < FF_ARRAY_ELEMS(dec->sub_prev); i++) - av_frame_free(&dec->sub_prev[i]); - av_frame_free(&dec->sub_heartbeat); + for (int i = 0; i < FF_ARRAY_ELEMS(dp->sub_prev); i++) + av_frame_free(&dp->sub_prev[i]); + av_frame_free(&dp->sub_heartbeat); av_freep(pdec); } static int dec_alloc(Decoder **pdec) { - Decoder *dec; + DecoderPriv *dp; *pdec = NULL; - dec = av_mallocz(sizeof(*dec)); - if (!dec) + dp = av_mallocz(sizeof(*dp)); + if (!dp) return AVERROR(ENOMEM); - dec->frame = av_frame_alloc(); - if (!dec->frame) + dp->frame = av_frame_alloc(); + if (!dp->frame) goto fail; - dec->pkt = av_packet_alloc(); - if (!dec->pkt) + dp->pkt = av_packet_alloc(); + if (!dp->pkt) goto fail; - dec->last_filter_in_rescale_delta = AV_NOPTS_VALUE; - dec->last_frame_pts = AV_NOPTS_VALUE; - dec->last_frame_tb = (AVRational){ 1, 1 }; - dec->hwaccel_pix_fmt = AV_PIX_FMT_NONE; + dp->last_filter_in_rescale_delta = AV_NOPTS_VALUE; + dp->last_frame_pts = AV_NOPTS_VALUE; + dp->last_frame_tb = (AVRational){ 1, 1 }; + dp->hwaccel_pix_fmt = AV_PIX_FMT_NONE; - *pdec = dec; + *pdec = &dp->dec; return 0; fail: - dec_free(&dec); + dec_free((Decoder**)dp); return AVERROR(ENOMEM); } -static AVRational audio_samplerate_update(void *logctx, Decoder *d, +static AVRational audio_samplerate_update(void *logctx, DecoderPriv *dp, const AVFrame *frame) { - const int prev = d->last_frame_tb.den; + const int prev = dp->last_frame_tb.den; const int sr = frame->sample_rate; AVRational tb_new; int64_t gcd; - if (frame->sample_rate == d->last_frame_sample_rate) + if (frame->sample_rate == dp->last_frame_sample_rate) goto finish; gcd = av_gcd(prev, sr); @@ -141,20 +150,20 @@ static AVRational audio_samplerate_update(void *logctx, Decoder *d, !(frame->time_base.den % tb_new.den)) tb_new = frame->time_base; - if (d->last_frame_pts != AV_NOPTS_VALUE) - d->last_frame_pts = av_rescale_q(d->last_frame_pts, - d->last_frame_tb, tb_new); - d->last_frame_duration_est = av_rescale_q(d->last_frame_duration_est, - d->last_frame_tb, tb_new); + if (dp->last_frame_pts != AV_NOPTS_VALUE) + dp->last_frame_pts = av_rescale_q(dp->last_frame_pts, + dp->last_frame_tb, tb_new); + dp->last_frame_duration_est = av_rescale_q(dp->last_frame_duration_est, + dp->last_frame_tb, tb_new); - d->last_frame_tb = tb_new; - d->last_frame_sample_rate = frame->sample_rate; + dp->last_frame_tb = tb_new; + dp->last_frame_sample_rate = frame->sample_rate; finish: - return d->last_frame_tb; + return dp->last_frame_tb; } -static void audio_ts_process(void *logctx, Decoder *d, AVFrame *frame) +static void audio_ts_process(void *logctx, DecoderPriv *dp, AVFrame *frame) { AVRational tb_filter = (AVRational){1, frame->sample_rate}; AVRational tb; @@ -163,27 +172,27 @@ static void audio_ts_process(void *logctx, Decoder *d, AVFrame *frame) // on samplerate change, choose a new internal timebase for timestamp // generation that can represent timestamps from all the samplerates // seen so far - tb = audio_samplerate_update(logctx, d, frame); - pts_pred = d->last_frame_pts == AV_NOPTS_VALUE ? 0 : - d->last_frame_pts + d->last_frame_duration_est; + tb = audio_samplerate_update(logctx, dp, frame); + pts_pred = dp->last_frame_pts == AV_NOPTS_VALUE ? 0 : + dp->last_frame_pts + dp->last_frame_duration_est; if (frame->pts == AV_NOPTS_VALUE) { frame->pts = pts_pred; frame->time_base = tb; - } else if (d->last_frame_pts != AV_NOPTS_VALUE && + } else if (dp->last_frame_pts != AV_NOPTS_VALUE && frame->pts > av_rescale_q_rnd(pts_pred, tb, frame->time_base, AV_ROUND_UP)) { // there was a gap in timestamps, reset conversion state - d->last_filter_in_rescale_delta = AV_NOPTS_VALUE; + dp->last_filter_in_rescale_delta = AV_NOPTS_VALUE; } frame->pts = av_rescale_delta(frame->time_base, frame->pts, tb, frame->nb_samples, - &d->last_filter_in_rescale_delta, tb); + &dp->last_filter_in_rescale_delta, tb); - d->last_frame_pts = frame->pts; - d->last_frame_duration_est = av_rescale_q(frame->nb_samples, - tb_filter, tb); + dp->last_frame_pts = frame->pts; + dp->last_frame_duration_est = av_rescale_q(frame->nb_samples, + tb_filter, tb); // finally convert to filtering timebase frame->pts = av_rescale_q(frame->pts, tb, tb_filter); @@ -193,7 +202,7 @@ static void audio_ts_process(void *logctx, Decoder *d, AVFrame *frame) static int64_t video_duration_estimate(const InputStream *ist, const AVFrame *frame) { - const Decoder *d = ist->decoder; + const DecoderPriv *dp = dp_from_dec(ist->decoder); const InputFile *ifile = ist->file; int64_t codec_duration = 0; @@ -221,9 +230,9 @@ static int64_t video_duration_estimate(const InputStream *ist, const AVFrame *fr // when timestamps are available, repeat last frame's actual duration // (i.e. pts difference between this and last frame) - if (frame->pts != AV_NOPTS_VALUE && d->last_frame_pts != AV_NOPTS_VALUE && - frame->pts > d->last_frame_pts) - return frame->pts - d->last_frame_pts; + if (frame->pts != AV_NOPTS_VALUE && dp->last_frame_pts != AV_NOPTS_VALUE && + frame->pts > dp->last_frame_pts) + return frame->pts - dp->last_frame_pts; // try frame/codec duration if (frame->duration > 0) @@ -240,12 +249,12 @@ static int64_t video_duration_estimate(const InputStream *ist, const AVFrame *fr } // last resort is last frame's estimated duration, and 1 - return FFMAX(d->last_frame_duration_est, 1); + return FFMAX(dp->last_frame_duration_est, 1); } static int video_frame_process(InputStream *ist, AVFrame *frame) { - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); // The following line may be required in some cases where there is no parser // or the parser does not has_b_frames correctly @@ -281,7 +290,7 @@ static int video_frame_process(InputStream *ist, AVFrame *frame) } #endif - if (frame->format == d->hwaccel_pix_fmt) { + if (frame->format == dp->hwaccel_pix_fmt) { int err = hwaccel_retrieve_data(ist->dec_ctx, frame); if (err < 0) return err; @@ -298,13 +307,13 @@ static int video_frame_process(InputStream *ist, AVFrame *frame) // no timestamp available - extrapolate from previous frame duration if (frame->pts == AV_NOPTS_VALUE) - frame->pts = d->last_frame_pts == AV_NOPTS_VALUE ? 0 : - d->last_frame_pts + d->last_frame_duration_est; + frame->pts = dp->last_frame_pts == AV_NOPTS_VALUE ? 0 : + dp->last_frame_pts + dp->last_frame_duration_est; // update timestamp history - d->last_frame_duration_est = video_duration_estimate(ist, frame); - d->last_frame_pts = frame->pts; - d->last_frame_tb = frame->time_base; + dp->last_frame_duration_est = video_duration_estimate(ist, frame); + dp->last_frame_pts = frame->pts; + dp->last_frame_tb = frame->time_base; if (debug_ts) { av_log(ist, AV_LOG_INFO, @@ -330,13 +339,13 @@ static int video_frame_process(InputStream *ist, AVFrame *frame) static int process_subtitle(InputStream *ist, AVFrame *frame) { - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); const AVSubtitle *subtitle = (AVSubtitle*)frame->buf[0]->data; int ret = 0; if (ist->fix_sub_duration) { - AVSubtitle *sub_prev = d->sub_prev[0]->buf[0] ? - (AVSubtitle*)d->sub_prev[0]->buf[0]->data : NULL; + AVSubtitle *sub_prev = dp->sub_prev[0]->buf[0] ? + (AVSubtitle*)dp->sub_prev[0]->buf[0]->data : NULL; int end = 1; if (sub_prev) { end = av_rescale(subtitle->pts - sub_prev->pts, @@ -350,13 +359,13 @@ static int process_subtitle(InputStream *ist, AVFrame *frame) } } - av_frame_unref(d->sub_prev[1]); - av_frame_move_ref(d->sub_prev[1], frame); + av_frame_unref(dp->sub_prev[1]); + av_frame_move_ref(dp->sub_prev[1], frame); - frame = d->sub_prev[0]; + frame = dp->sub_prev[0]; subtitle = frame->buf[0] ? (AVSubtitle*)frame->buf[0]->data : NULL; - FFSWAP(AVFrame*, d->sub_prev[0], d->sub_prev[1]); + FFSWAP(AVFrame*, dp->sub_prev[0], dp->sub_prev[1]); if (end <= 0) return 0; @@ -365,7 +374,7 @@ static int process_subtitle(InputStream *ist, AVFrame *frame) if (!subtitle) return 0; - ret = sch_dec_send(d->sch, d->sch_idx, frame); + ret = sch_dec_send(dp->sch, dp->sch_idx, frame); if (ret < 0) av_frame_unref(frame); @@ -374,31 +383,31 @@ static int process_subtitle(InputStream *ist, AVFrame *frame) static int fix_sub_duration_heartbeat(InputStream *ist, int64_t signal_pts) { - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); int ret = AVERROR_BUG; - AVSubtitle *prev_subtitle = d->sub_prev[0]->buf[0] ? - (AVSubtitle*)d->sub_prev[0]->buf[0]->data : NULL; + AVSubtitle *prev_subtitle = dp->sub_prev[0]->buf[0] ? + (AVSubtitle*)dp->sub_prev[0]->buf[0]->data : NULL; AVSubtitle *subtitle; if (!ist->fix_sub_duration || !prev_subtitle || !prev_subtitle->num_rects || signal_pts <= prev_subtitle->pts) return 0; - av_frame_unref(d->sub_heartbeat); - ret = subtitle_wrap_frame(d->sub_heartbeat, prev_subtitle, 1); + av_frame_unref(dp->sub_heartbeat); + ret = subtitle_wrap_frame(dp->sub_heartbeat, prev_subtitle, 1); if (ret < 0) return ret; - subtitle = (AVSubtitle*)d->sub_heartbeat->buf[0]->data; + subtitle = (AVSubtitle*)dp->sub_heartbeat->buf[0]->data; subtitle->pts = signal_pts; - return process_subtitle(ist, d->sub_heartbeat); + return process_subtitle(ist, dp->sub_heartbeat); } static int transcode_subtitles(InputStream *ist, const AVPacket *pkt, AVFrame *frame) { - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); AVPacket *flush_pkt = NULL; AVSubtitle subtitle; int got_output; @@ -409,7 +418,7 @@ static int transcode_subtitles(InputStream *ist, const AVPacket *pkt, frame->time_base = pkt->time_base; frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_SUB_HEARTBEAT; - ret = sch_dec_send(d->sch, d->sch_idx, frame); + ret = sch_dec_send(dp->sch, dp->sch_idx, frame); return ret == AVERROR_EOF ? AVERROR_EXIT : ret; } else if (pkt && (intptr_t)pkt->opaque == PKT_OPAQUE_FIX_SUB_DURATION) { return fix_sub_duration_heartbeat(ist, av_rescale_q(pkt->pts, pkt->time_base, @@ -457,7 +466,7 @@ static int transcode_subtitles(InputStream *ist, const AVPacket *pkt, static int packet_decode(InputStream *ist, AVPacket *pkt, AVFrame *frame) { const InputFile *ifile = ist->file; - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); AVCodecContext *dec = ist->dec_ctx; const char *type_desc = av_get_media_type_string(dec->codec_type); int ret; @@ -553,7 +562,7 @@ static int packet_decode(InputStream *ist, AVPacket *pkt, AVFrame *frame) if (dec->codec_type == AVMEDIA_TYPE_AUDIO) { ist->samples_decoded += frame->nb_samples; - audio_ts_process(ist, ist->decoder, frame); + audio_ts_process(ist, dp, frame); } else { ret = video_frame_process(ist, frame); if (ret < 0) { @@ -565,7 +574,7 @@ static int packet_decode(InputStream *ist, AVPacket *pkt, AVFrame *frame) ist->frames_decoded++; - ret = sch_dec_send(d->sch, d->sch_idx, frame); + ret = sch_dec_send(dp->sch, dp->sch_idx, frame); if (ret < 0) { av_frame_unref(frame); return ret == AVERROR_EOF ? AVERROR_EXIT : ret; @@ -611,7 +620,7 @@ fail: void *decoder_thread(void *arg) { InputStream *ist = arg; - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); DecThreadContext dt; int ret = 0, input_status = 0; @@ -624,7 +633,7 @@ void *decoder_thread(void *arg) while (!input_status) { int flush_buffers, have_data; - input_status = sch_dec_receive(d->sch, d->sch_idx, dt.pkt); + input_status = sch_dec_receive(dp->sch, dp->sch_idx, dt.pkt); have_data = input_status >= 0 && (dt.pkt->buf || dt.pkt->side_data_elems || (intptr_t)dt.pkt->opaque == PKT_OPAQUE_SUB_HEARTBEAT || @@ -656,8 +665,8 @@ void *decoder_thread(void *arg) /* report last frame duration to the scheduler */ if (ist->dec->type == AVMEDIA_TYPE_AUDIO) { - dt.pkt->pts = d->last_frame_pts + d->last_frame_duration_est; - dt.pkt->time_base = d->last_frame_tb; + dt.pkt->pts = dp->last_frame_pts + dp->last_frame_duration_est; + dt.pkt->time_base = dp->last_frame_tb; } avcodec_flush_buffers(ist->dec_ctx); @@ -679,11 +688,11 @@ void *decoder_thread(void *arg) av_frame_unref(dt.frame); dt.frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_EOF; - dt.frame->pts = d->last_frame_pts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE : - d->last_frame_pts + d->last_frame_duration_est; - dt.frame->time_base = d->last_frame_tb; + dt.frame->pts = dp->last_frame_pts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE : + dp->last_frame_pts + dp->last_frame_duration_est; + dt.frame->time_base = dp->last_frame_tb; - ret = sch_dec_send(d->sch, d->sch_idx, dt.frame); + ret = sch_dec_send(dp->sch, dp->sch_idx, dt.frame); if (ret < 0 && ret != AVERROR_EOF) { av_log(NULL, AV_LOG_FATAL, "Error signalling EOF timestamp: %s\n", av_err2str(ret)); @@ -710,7 +719,7 @@ finish: static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts) { InputStream *ist = s->opaque; - Decoder *d = ist->decoder; + DecoderPriv *dp = dp_from_dec(ist->decoder); const enum AVPixelFormat *p; for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) { @@ -735,7 +744,7 @@ static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat } } if (config && config->device_type == ist->hwaccel_device_type) { - d->hwaccel_pix_fmt = *p; + dp->hwaccel_pix_fmt = *p; break; } } @@ -890,7 +899,7 @@ static int hw_device_setup_for_decode(InputStream *ist) int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx) { - Decoder *d; + DecoderPriv *dp; const AVCodec *codec = ist->dec; int ret; @@ -904,19 +913,19 @@ int dec_open(InputStream *ist, Scheduler *sch, unsigned sch_idx) ret = dec_alloc(&ist->decoder); if (ret < 0) return ret; - d = ist->decoder; + dp = dp_from_dec(ist->decoder); - d->sch = sch; - d->sch_idx = sch_idx; + dp->sch = sch; + dp->sch_idx = sch_idx; if (codec->type == AVMEDIA_TYPE_SUBTITLE && ist->fix_sub_duration) { - for (int i = 0; i < FF_ARRAY_ELEMS(d->sub_prev); i++) { - d->sub_prev[i] = av_frame_alloc(); - if (!d->sub_prev[i]) + for (int i = 0; i < FF_ARRAY_ELEMS(dp->sub_prev); i++) { + dp->sub_prev[i] = av_frame_alloc(); + if (!dp->sub_prev[i]) return AVERROR(ENOMEM); } - d->sub_heartbeat = av_frame_alloc(); - if (!d->sub_heartbeat) + dp->sub_heartbeat = av_frame_alloc(); + if (!dp->sub_heartbeat) return AVERROR(ENOMEM); } -- 2.42.0

2 33

[PATCH v1] avcodec/cbs_vp8: Improve the bitstream position check
by Dai, Jianhui J 19 Mar '24

19 Mar '24

The VP8 compressed header may not be byte-aligned due to boolean coding. Use bitwise comparison to prevent the potential overread. Signed-off-by: Jianhui Dai <jianhui.j.dai(a)intel.com> --- libavcodec/cbs_vp8.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/libavcodec/cbs_vp8.c b/libavcodec/cbs_vp8.c index 065156c248..13acad3724 100644 --- a/libavcodec/cbs_vp8.c +++ b/libavcodec/cbs_vp8.c @@ -327,9 +327,10 @@ static int cbs_vp8_read_unit(CodedBitstreamContext *ctx, if (err < 0) return err; + // Position may not be byte-aligned after compressed header; using bits + // count comparison for accuracy. pos = get_bits_count(&gbc); - pos /= 8; - av_assert0(pos <= unit->data_size); + av_assert0(pos <= unit->data_size * 8); frame->data_ref = av_buffer_ref(unit->data_ref); if (!frame->data_ref) -- 2.25.1

2 4

[PATCH] avcodec/parser: Check next against buffer index
by Michael Niedermayer 13 Mar '24

13 Mar '24

Fixes: out of array access Fixes: crash-0d640731c7da52415670eb47a2af701cbe2e1a3b Found-by: Catena cyber <contact(a)catenacyber.fr> Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> --- libavcodec/parser.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libavcodec/parser.c b/libavcodec/parser.c index efc28b8918..db39e698ab 100644 --- a/libavcodec/parser.c +++ b/libavcodec/parser.c @@ -214,7 +214,7 @@ int ff_combine_frame(ParseContext *pc, int next, for (; pc->overread > 0; pc->overread--) pc->buffer[pc->index++] = pc->buffer[pc->overread_index++]; - if (next > *buf_size) + if (next > *buf_size || (next < -pc->index && next != END_NOT_FOUND)) return AVERROR(EINVAL); /* flush remaining if EOF */ -- 2.17.1

4 5

Fwd: patch for 44.1/32 khz pcm input in pcm dvd encoder
by Andrew Randrianasulu 11 Mar '24

11 Mar '24

---------- Forwarded message --------- От: Andrew Randrianasulu <randrianasulu(a)gmail.com> Date: вс, 21 янв. 2024 г., 06:49 Subject: patch for 44.1/32 khz pcm input in pcm dvd encoder To: FFmpeg user questions <ffmpeg-user(a)ffmpeg.org>, Cinelerra.GG < cin(a)lists.cinelerra-gg.org> relative to ffmpeg.git commit 6c4388b468bf92c0c1e7733c6cfe4ff3f9ca9723 lightly tested with mpv and mediainfo like this: ./ffmpeg -i ~/f9518976.mp4 -target pal-dvd -ar 44100 -c:a pcm_dvd -f dvd t.mpg mpv plays sound correctly, mediainfo does not know those frequencies and display 0khz. ;) ==== forwarded to ffmpeg-devel as requested.

2 7

[PATCH] libavdevice/decklink: extend available actions on signal loss
by Michael Riedl 05 Mar '24

05 Mar '24

Deprecate the option 'draw_bars' in favor of the new option 'signal_loss_action', which controls the behavior when the input signal is not available (including the behavior previously available through draw_bars). The default behavior remains unchanged to be backwards compatible. The new option is more flexible for extending now and in the future. The new value 'repeat' repeats the last video frame. This is useful for very short dropouts and was not available before. Signed-off-by: Michael Riedl <michael.riedl(a)nativewaves.com> --- doc/indevs.texi | 16 ++++++++++++++++ libavdevice/decklink_common.h | 1 + libavdevice/decklink_common_c.h | 7 +++++++ libavdevice/decklink_dec.cpp | 23 ++++++++++++++++++++++- libavdevice/decklink_dec_c.c | 6 +++++- 5 files changed, 51 insertions(+), 2 deletions(-) diff --git a/doc/indevs.texi b/doc/indevs.texi index 863536a34d5..a985d58ce7f 100644 --- a/doc/indevs.texi +++ b/doc/indevs.texi @@ -395,6 +395,22 @@ Defaults to @samp{audio}. @item draw_bars If set to @samp{true}, color bars are drawn in the event of a signal loss. Defaults to @samp{true}. +This option is deprecated, please use the @code{signal_loss_action} option. + +@item signal_loss_action +Sets the action to take in the event of a signal loss. Accepts one of the +following values: + +@table @option +@item 1, none +Do nothing on signal loss. This usually results in black frames. +@item 2, bars +Draw color bars on signal loss. Only supported for 8-bit input signals. +@item 3, repeat +Repeat the last video frame on signal loss. +@end table + +Defaults to @samp{bars}. @item queue_size Sets maximum input buffer size in bytes. If the buffering reaches this value, diff --git a/libavdevice/decklink_common.h b/libavdevice/decklink_common.h index 34ab1b96700..be666212e6c 100644 --- a/libavdevice/decklink_common.h +++ b/libavdevice/decklink_common.h @@ -146,6 +146,7 @@ struct decklink_ctx { DecklinkPtsSource video_pts_source; int draw_bars; BMDPixelFormat raw_format; + DecklinkSignalLossAction signal_loss_action; int frames_preroll; int frames_buffer; diff --git a/libavdevice/decklink_common_c.h b/libavdevice/decklink_common_c.h index 9c55d891494..53d2c583e7e 100644 --- a/libavdevice/decklink_common_c.h +++ b/libavdevice/decklink_common_c.h @@ -37,6 +37,12 @@ typedef enum DecklinkPtsSource { PTS_SRC_NB } DecklinkPtsSource; +typedef enum DecklinkSignalLossAction { + SIGNAL_LOSS_NONE = 1, + SIGNAL_LOSS_REPEAT = 2, + SIGNAL_LOSS_BARS = 3 +} DecklinkSignalLossAction; + struct decklink_cctx { const AVClass *cclass; @@ -68,6 +74,7 @@ struct decklink_cctx { int64_t timestamp_align; int timing_offset; int wait_for_tc; + DecklinkSignalLossAction signal_loss_action; }; #endif /* AVDEVICE_DECKLINK_COMMON_C_H */ diff --git a/libavdevice/decklink_dec.cpp b/libavdevice/decklink_dec.cpp index 11640f72caa..f6095c72359 100644 --- a/libavdevice/decklink_dec.cpp +++ b/libavdevice/decklink_dec.cpp @@ -593,6 +593,7 @@ private: int no_video; int64_t initial_video_pts; int64_t initial_audio_pts; + IDeckLinkVideoInputFrame* last_video_frame; }; decklink_input_callback::decklink_input_callback(AVFormatContext *_avctx) : _refs(1) @@ -602,10 +603,13 @@ decklink_input_callback::decklink_input_callback(AVFormatContext *_avctx) : _ref ctx = (struct decklink_ctx *)cctx->ctx; no_video = 0; initial_audio_pts = initial_video_pts = AV_NOPTS_VALUE; + last_video_frame = nullptr; } decklink_input_callback::~decklink_input_callback() { + if (last_video_frame) + last_video_frame->Release(); } ULONG decklink_input_callback::AddRef(void) @@ -773,7 +777,7 @@ HRESULT decklink_input_callback::VideoInputFrameArrived( ctx->video_st->time_base.den); if (videoFrame->GetFlags() & bmdFrameHasNoInputSource) { - if (ctx->draw_bars && videoFrame->GetPixelFormat() == bmdFormat8BitYUV) { + if (ctx->signal_loss_action == SIGNAL_LOSS_BARS && videoFrame->GetPixelFormat() == bmdFormat8BitYUV) { unsigned bars[8] = { 0xEA80EA80, 0xD292D210, 0xA910A9A5, 0x90229035, 0x6ADD6ACA, 0x51EF515A, 0x286D28EF, 0x10801080 }; @@ -785,6 +789,8 @@ HRESULT decklink_input_callback::VideoInputFrameArrived( for (int x = 0; x < width; x += 2) *p++ = bars[(x * 8) / width]; } + } else if (ctx->signal_loss_action == SIGNAL_LOSS_REPEAT) { + last_video_frame->GetBytes(&frameBytes); } if (!no_video) { @@ -793,6 +799,12 @@ HRESULT decklink_input_callback::VideoInputFrameArrived( } no_video = 1; } else { + if (ctx->signal_loss_action == SIGNAL_LOSS_REPEAT) { + if (last_video_frame) + last_video_frame->Release(); + last_video_frame = videoFrame; + last_video_frame->AddRef(); + } if (no_video) { av_log(avctx, AV_LOG_WARNING, "Frame received (#%lu) - Input returned " "- Frames dropped %u\n", ctx->frameCount, ++ctx->dropped); @@ -1074,6 +1086,15 @@ av_cold int ff_decklink_read_header(AVFormatContext *avctx) ctx->audio_pts_source = cctx->audio_pts_source; ctx->video_pts_source = cctx->video_pts_source; ctx->draw_bars = cctx->draw_bars; + ctx->signal_loss_action = cctx->signal_loss_action; + if (!ctx->draw_bars && ctx->signal_loss_action == SIGNAL_LOSS_BARS) { + ctx->signal_loss_action = SIGNAL_LOSS_NONE; + av_log(avctx, AV_LOG_WARNING, "Setting signal_loss_action to none because draw_bars is false\n"); + } + if (!ctx->draw_bars && ctx->signal_loss_action != SIGNAL_LOSS_NONE) { + av_log(avctx, AV_LOG_ERROR, "options draw_bars and signal_loss_action are mutually exclusive\n"); + return AVERROR(EINVAL); + } ctx->audio_depth = cctx->audio_depth; if (cctx->raw_format > 0 && (unsigned int)cctx->raw_format < FF_ARRAY_ELEMS(decklink_raw_format_map)) ctx->raw_format = decklink_raw_format_map[cctx->raw_format]; diff --git a/libavdevice/decklink_dec_c.c b/libavdevice/decklink_dec_c.c index 2159702c96b..7c0ef4f8c23 100644 --- a/libavdevice/decklink_dec_c.c +++ b/libavdevice/decklink_dec_c.c @@ -94,12 +94,16 @@ static const AVOption options[] = { { "reference", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PTS_SRC_REFERENCE}, 0, 0, DEC, "pts_source"}, { "wallclock", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PTS_SRC_WALLCLOCK}, 0, 0, DEC, "pts_source"}, { "abs_wallclock", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PTS_SRC_ABS_WALLCLOCK}, 0, 0, DEC, "pts_source"}, - { "draw_bars", "draw bars on signal loss" , OFFSET(draw_bars), AV_OPT_TYPE_BOOL, { .i64 = 1}, 0, 1, DEC }, + { "draw_bars", "use option signal_loss_action instead" , OFFSET(draw_bars), AV_OPT_TYPE_BOOL, { .i64 = 1}, 0, 1, DEC | AV_OPT_FLAG_DEPRECATED }, { "queue_size", "input queue buffer size", OFFSET(queue_size), AV_OPT_TYPE_INT64, { .i64 = (1024 * 1024 * 1024)}, 0, INT64_MAX, DEC }, { "audio_depth", "audio bitdepth (16 or 32)", OFFSET(audio_depth), AV_OPT_TYPE_INT, { .i64 = 16}, 16, 32, DEC }, { "decklink_copyts", "copy timestamps, do not remove the initial offset", OFFSET(copyts), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC }, { "timestamp_align", "capture start time alignment (in seconds)", OFFSET(timestamp_align), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, DEC }, { "wait_for_tc", "drop frames till a frame with timecode is received. TC format must be set", OFFSET(wait_for_tc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC }, + { "signal_loss_action", "action on signal loss", OFFSET(signal_loss_action), AV_OPT_TYPE_INT, { .i64 = SIGNAL_LOSS_BARS }, SIGNAL_LOSS_NONE, SIGNAL_LOSS_BARS, DEC, "signal_loss_action" }, + { "none", "do not do anything (usually leads to black frames)", 0, AV_OPT_TYPE_CONST, { .i64 = SIGNAL_LOSS_NONE }, 0, 0, DEC, "signal_loss_action"}, + { "bars", "draw color bars (only supported for 8-bit signals)", 0, AV_OPT_TYPE_CONST, { .i64 = SIGNAL_LOSS_BARS }, 0, 0, DEC, "signal_loss_action"}, + { "repeat", "repeat the last video frame", 0, AV_OPT_TYPE_CONST, { .i64 = SIGNAL_LOSS_REPEAT }, 0, 0, DEC, "signal_loss_action"}, { NULL }, }; -- 2.39.2

2 7

[PATCH 00/24] Major library version bump
by James Almer 04 Mar '24

04 Mar '24

6 59

[PATCH 2/2] avformat/flvdec: support enhanced flv PacketTypeMetadata
by 411294962＠qq.com 03 Mar '24

03 Mar '24

From: Zhu Pengfei <411294962(a)qq.com> Signed-off-by: Zhu Pengfei <411294962(a)qq.com> --- libavformat/flvdec.c | 171 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 170 insertions(+), 1 deletion(-) diff --git a/libavformat/flvdec.c b/libavformat/flvdec.c index e25b5bd163..46bb0825ca 100644 --- a/libavformat/flvdec.c +++ b/libavformat/flvdec.c @@ -34,6 +34,7 @@ #include "libavutil/intfloat.h" #include "libavutil/intreadwrite.h" #include "libavutil/mathematics.h" +#include "libavutil/mastering_display_metadata.h" #include "avformat.h" #include "demux.h" #include "internal.h" @@ -45,6 +46,28 @@ #define MAX_DEPTH 16 ///< arbitrary limit to prevent unbounded recursion +typedef struct FLVMasteringMeta { + double r_x; + double r_y; + double g_x; + double g_y; + double b_x; + double b_y; + double white_x; + double white_y; + double max_luminance; + double min_luminance; +} FLVMasteringMeta; + +typedef struct FLVMetaVideoColor { + uint64_t matrix_coefficients; + uint64_t transfer_characteristics; + uint64_t primaries; + uint64_t max_cll; + uint64_t max_fall; + FLVMasteringMeta mastering_meta; +} FLVMetaVideoColor; + typedef struct FLVContext { const AVClass *class; ///< Class for private options. int trust_metadata; ///< configure streams according onMetaData @@ -80,6 +103,8 @@ typedef struct FLVContext { int64_t time_offset; int64_t time_pos; + FLVMetaVideoColor *metaVideoColor; + int meta_color_info_flag; } FLVContext; /* AMF date type */ @@ -524,6 +549,7 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, FLVContext *flv = s->priv_data; AVIOContext *ioc; AMFDataType amf_type; + FLVMetaVideoColor *meta_video_color = flv->metaVideoColor; char str_val[1024]; double num_val; amf_date date; @@ -655,6 +681,36 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, } else if (!strcmp(key, "height") && vpar) { vpar->height = num_val; } + } else if (!strcmp(key, "colorPrimaries") && meta_video_color) { + meta_video_color->primaries = num_val; + } else if (!strcmp(key, "transferCharacteristics") && meta_video_color) { + meta_video_color->transfer_characteristics = num_val; + } else if (!strcmp(key, "matrixCoefficients") && meta_video_color) { + meta_video_color->matrix_coefficients = num_val; + } else if (!strcmp(key, "maxFall") && meta_video_color) { + meta_video_color->max_fall = num_val; + } else if (!strcmp(key, "maxCLL") && meta_video_color) { + meta_video_color->max_cll = num_val; + } else if (!strcmp(key, "redX") && meta_video_color) { + meta_video_color->mastering_meta.r_x = num_val; + } else if (!strcmp(key, "redY") && meta_video_color) { + meta_video_color->mastering_meta.r_y = num_val; + } else if (!strcmp(key, "greenX") && meta_video_color) { + meta_video_color->mastering_meta.g_x = num_val; + } else if (!strcmp(key, "greenY") && meta_video_color) { + meta_video_color->mastering_meta.g_y = num_val; + } else if (!strcmp(key, "blueX") && meta_video_color) { + meta_video_color->mastering_meta.b_x = num_val; + } else if (!strcmp(key, "blueY") && meta_video_color) { + meta_video_color->mastering_meta.b_y = num_val; + } else if (!strcmp(key, "whitePointX") && meta_video_color) { + meta_video_color->mastering_meta.white_x = num_val; + } else if (!strcmp(key, "whitePointY") && meta_video_color) { + meta_video_color->mastering_meta.white_y = num_val; + } else if (!strcmp(key, "maxLuminance") && meta_video_color) { + meta_video_color->mastering_meta.max_luminance = num_val; + } else if (!strcmp(key, "minLuminance") && meta_video_color) { + meta_video_color->mastering_meta.min_luminance = num_val; } } if (amf_type == AMF_DATA_TYPE_STRING) { @@ -824,6 +880,7 @@ static int flv_read_close(AVFormatContext *s) av_freep(&flv->new_extradata[i]); av_freep(&flv->keyframe_times); av_freep(&flv->keyframe_filepositions); + av_freep(&flv->metaVideoColor); return 0; } @@ -1028,6 +1085,104 @@ static int resync(AVFormatContext *s) return AVERROR_EOF; } +static int flv_parse_video_color_info(AVFormatContext *s, AVStream *st, int64_t next_pos) +{ + FLVContext *flv = s->priv_data; + AMFDataType type; + AVIOContext *ioc; + char buffer[32]; + ioc = s->pb; + + // first object needs to be "colorInfo" string + type = avio_r8(ioc); + if (type != AMF_DATA_TYPE_STRING || + amf_get_string(ioc, buffer, sizeof(buffer)) < 0) + return TYPE_UNKNOWN; + + if (strcmp(buffer, "colorInfo")) { + av_log(s, AV_LOG_DEBUG, "Unknown type %s\n", buffer); + return TYPE_UNKNOWN; + } + + flv->metaVideoColor = av_mallocz(sizeof(FLVMetaVideoColor)); + if (!flv->metaVideoColor) { + return AVERROR(ENOMEM); + } + flv->meta_color_info_flag = 1; + amf_parse_object(s, NULL, NULL, buffer, next_pos, 0); // parse metadata + return 0; +} + +static int flv_update_video_color_info(AVFormatContext *s, AVStream *st) +{ + FLVContext *flv = s->priv_data; + const FLVMetaVideoColor* meta_video_color = flv->metaVideoColor; + const FLVMasteringMeta *mastering_meta = &meta_video_color->mastering_meta; + + int has_mastering_primaries, has_mastering_luminance; + // Mastering primaries are CIE 1931 coords, and must be > 0. + has_mastering_primaries = + mastering_meta->r_x > 0 && mastering_meta->r_y > 0 && + mastering_meta->g_x > 0 && mastering_meta->g_y > 0 && + mastering_meta->b_x > 0 && mastering_meta->b_y > 0 && + mastering_meta->white_x > 0 && mastering_meta->white_y > 0; + has_mastering_luminance = mastering_meta->max_luminance >= 0 && mastering_meta->min_luminance >= 0; + + if (meta_video_color->matrix_coefficients != AVCOL_SPC_RESERVED) + st->codecpar->color_space = meta_video_color->matrix_coefficients; + if (meta_video_color->primaries != AVCOL_PRI_RESERVED && + meta_video_color->primaries != AVCOL_PRI_RESERVED0) + st->codecpar->color_primaries = meta_video_color->primaries; + if (meta_video_color->transfer_characteristics != AVCOL_TRC_RESERVED && + meta_video_color->transfer_characteristics != AVCOL_TRC_RESERVED0) + st->codecpar->color_trc = meta_video_color->transfer_characteristics; + + if (meta_video_color->max_cll && meta_video_color->max_fall) { + size_t size = 0; + AVContentLightMetadata *metadata = av_content_light_metadata_alloc(&size); + if (!metadata) + return AVERROR(ENOMEM); + if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data, + AV_PKT_DATA_CONTENT_LIGHT_LEVEL, metadata, size, 0)) { + av_freep(&metadata); + return AVERROR(ENOMEM); + } + metadata->MaxCLL = meta_video_color->max_cll; + metadata->MaxFALL = meta_video_color->max_fall; + } + + if (has_mastering_primaries || has_mastering_luminance) { + AVMasteringDisplayMetadata *metadata; + AVPacketSideData *sd = av_packet_side_data_new(&st->codecpar->coded_side_data, + &st->codecpar->nb_coded_side_data, + AV_PKT_DATA_MASTERING_DISPLAY_METADATA, + sizeof(AVMasteringDisplayMetadata), 0); + if (!sd) + return AVERROR(ENOMEM); + metadata = (AVMasteringDisplayMetadata*)sd->data; + memset(metadata, 0, sizeof(AVMasteringDisplayMetadata)); + // hdrCll + if (has_mastering_luminance) { + metadata->max_luminance = av_d2q(mastering_meta->max_luminance, INT_MAX); + metadata->min_luminance = av_d2q(mastering_meta->min_luminance, INT_MAX); + metadata->has_luminance = 1; + } + // hdrMdcv + if (has_mastering_primaries) { + metadata->display_primaries[0][0] = av_d2q(mastering_meta->r_x, INT_MAX); + metadata->display_primaries[0][1] = av_d2q(mastering_meta->r_y, INT_MAX); + metadata->display_primaries[1][0] = av_d2q(mastering_meta->g_x, INT_MAX); + metadata->display_primaries[1][1] = av_d2q(mastering_meta->g_y, INT_MAX); + metadata->display_primaries[2][0] = av_d2q(mastering_meta->b_x, INT_MAX); + metadata->display_primaries[2][1] = av_d2q(mastering_meta->b_y, INT_MAX); + metadata->white_point[0] = av_d2q(mastering_meta->white_x, INT_MAX); + metadata->white_point[1] = av_d2q(mastering_meta->white_y, INT_MAX); + metadata->has_primaries = 1; + } + } + return 0; +} + static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) { FLVContext *flv = s->priv_data; @@ -1100,8 +1255,17 @@ retry: video_codec_id = avio_rb32(s->pb); size -= 4; } - if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD) + + if (enhanced_flv && stream_type == FLV_STREAM_TYPE_VIDEO && (flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD) { + type = flags & 0x0F; + if (type == PacketTypeMetadata) { + int ret = flv_parse_video_color_info(s, st, next); + av_log(s, AV_LOG_INFO, "enhanced flv parse metadata ret %d and skip\n", ret); + } + goto skip; + } else if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD) { goto skip; + } } else if (type == FLV_TAG_TYPE_META) { stream_type=FLV_STREAM_TYPE_SUBTITLE; if (size > 13 + 1 + 4) { // Header-type metadata stuff @@ -1287,6 +1451,11 @@ retry_duration: goto leave; } + if (enhanced_flv && stream_type == FLV_STREAM_TYPE_VIDEO && flv->meta_color_info_flag) { + flv_update_video_color_info(s, st); // update av packet side data + flv->meta_color_info_flag = 0; + } + if (st->codecpar->codec_id == AV_CODEC_ID_H264 || st->codecpar->codec_id == AV_CODEC_ID_MPEG4 || (st->codecpar->codec_id == AV_CODEC_ID_HEVC && type == PacketTypeCodedFrames)) { // sign extension -- 2.42.1

5 16

[PATCH] avutil/mem: always align by at least 32 bytes
by Timo Rothenpieler 27 Feb '24

27 Feb '24

FFmpeg has instances of DECLARE_ALIGNED(32, ...) in a lot of structs, which then end up heap-allocated. By declaring any variable in a struct, or tree of structs, to be 32 byte aligned, it allows the compiler to safely assume the entire struct itself is also 32 byte aligned. This might make the compiler emit code which straight up crashes or misbehaves in other ways, and at least in one instances is now documented to actually do (see ticket 10549 on trac). The issue there is that an unrelated variable in SingleChannelElement is declared to have an alignment of 32 bytes. So if the compiler does a copy in decode_cpe() with avx instructions, but ffmpeg is built with --disable-avx, this results in a crash, since the memory is only 16 byte aligned. Mind you, even if the compiler does not emit avx instructions, the code is still invalid and could misbehave. It just happens not to. Declaring any variable in a struct with a 32 byte alignment promises 32 byte alignment of the whole struct to the compiler. Instead of now going through all instances of variables in structs being declared as 32 byte aligned, this patch bumps the minimum alignment to 32 bytes. --- libavutil/mem.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libavutil/mem.c b/libavutil/mem.c index 36b8940a0c..26a9b9753b 100644 --- a/libavutil/mem.c +++ b/libavutil/mem.c @@ -62,7 +62,7 @@ void free(void *ptr); #endif /* MALLOC_PREFIX */ -#define ALIGN (HAVE_AVX512 ? 64 : (HAVE_AVX ? 32 : 16)) +#define ALIGN (HAVE_AVX512 ? 64 : 32) /* NOTE: if you want to override these functions with your own * implementations (not recommended) you have to link libav* as -- 2.34.1

8 28

[PATCH] avformat/mov: avoid seeking back to 0 on HEVC open GOP files
by llyyr 26 Feb '24

26 Feb '24

ab77b878f1 attempted to fix the issue of broken packets being sent to the decoder by implementing logic that kept attempting to PTS-step backwards until it reached a valid point, however applying this heuristic meant that in files that had no valid points (such as HEVC videos shot on iPhones), we'd seek back to sample 0 on every seek attempt. This meant that files that were previously seekable, albeit with some skipped frames, were not seekable at all now. Relax this heuristic a bit by giving up on seeking to a valid point if we've tried a different sample and we still don't have a valid point to seek to. This may some frames to be skipped on seeking but it's better than not being able to seek at all in such files. Fixes: ab77b878f1 ("avformat/mov: fix seeking with HEVC open GOP files") --- libavformat/mov.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/libavformat/mov.c b/libavformat/mov.c index 1996e0028c..60a4d581d9 100644 --- a/libavformat/mov.c +++ b/libavformat/mov.c @@ -9108,7 +9108,7 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, { MOVStreamContext *sc = st->priv_data; FFStream *const sti = ffstream(st); - int sample, time_sample, ret; + int sample, time_sample, ret, next_ts, requested_sample; unsigned int i; // Here we consider timestamp to be PTS, hence try to offset it so that we @@ -9129,7 +9129,17 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, if (!sample || can_seek_to_key_sample(st, sample, timestamp)) break; - timestamp -= FFMAX(sc->min_sample_duration, 1); + + next_ts = timestamp - FFMAX(sc->min_sample_duration, 1); + requested_sample = av_index_search_timestamp(st, next_ts, flags); + + // If we can't seek to the next pts either and it's a different sample, + // give up trying to find a good pts to seek to, otherwise we'll end up + // seeking back to sample 0 on every seek. + if (!can_seek_to_key_sample(st, requested_sample, next_ts) && sample != requested_sample) + break; + + timestamp = next_ts; } mov_current_sample_set(sc, sample); -- 2.42.0

1 1

[PATCH v2 1/2] avcodec/av1dec: Move message of OBU info back to the beginning
by fei.w.wang＠intel.com 26 Feb '24

26 Feb '24

From: Fei Wang <fei.w.wang(a)intel.com> So that can show OBU info even it doesn't have decomposed content. And add OBU content status into the message. Signed-off-by: Fei Wang <fei.w.wang(a)intel.com> --- libavcodec/av1dec.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libavcodec/av1dec.c b/libavcodec/av1dec.c index da05a0f039..198fe75aa0 100644 --- a/libavcodec/av1dec.c +++ b/libavcodec/av1dec.c @@ -1200,11 +1200,12 @@ static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame) AV1RawOBU *obu = unit->content; const AV1RawOBUHeader *header; + av_log(avctx, AV_LOG_DEBUG, "OBU idx:%d, type:%d, content available:%d.\n", i, unit->type, !!obu); + if (!obu) continue; header = &obu->header; - av_log(avctx, AV_LOG_DEBUG, "Obu idx:%d, obu type:%d.\n", i, unit->type); switch (unit->type) { case AV1_OBU_SEQUENCE_HEADER: -- 2.25.1

2 2