October 2022 - ffmpeg-devel - lists.ffmpeg.org

[PATCH] libavcodec: v4l2m2m: allow lower minimum buffer values
by Lukas Rusak 09 Jan '23

09 Jan '23

There is no reason to enforce a high minimum. In the context of streaming only a few output buffers and capture buffers are even needed for continuous playback. This also helps alleviate memory pressure when decoding 4K media. --- libavcodec/v4l2_m2m.h | 2 +- libavcodec/v4l2_m2m_dec.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libavcodec/v4l2_m2m.h b/libavcodec/v4l2_m2m.h index 61cb919771..feeb162812 100644 --- a/libavcodec/v4l2_m2m.h +++ b/libavcodec/v4l2_m2m.h @@ -38,7 +38,7 @@ #define V4L_M2M_DEFAULT_OPTS \ { "num_output_buffers", "Number of buffers in the output context",\ - OFFSET(num_output_buffers), AV_OPT_TYPE_INT, { .i64 = 16 }, 6, INT_MAX, FLAGS } + OFFSET(num_output_buffers), AV_OPT_TYPE_INT, { .i64 = 16 }, 2, INT_MAX, FLAGS } typedef struct V4L2m2mContext { char devname[PATH_MAX]; diff --git a/libavcodec/v4l2_m2m_dec.c b/libavcodec/v4l2_m2m_dec.c index c6b865fde8..b9725be377 100644 --- a/libavcodec/v4l2_m2m_dec.c +++ b/libavcodec/v4l2_m2m_dec.c @@ -262,7 +262,7 @@ static av_cold int v4l2_decode_close(AVCodecContext *avctx) static const AVOption options[] = { V4L_M2M_DEFAULT_OPTS, { "num_capture_buffers", "Number of buffers in the capture context", - OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 20, INT_MAX, FLAGS }, + OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 2, INT_MAX, FLAGS }, { NULL}, }; -- 2.24.1

3 2

[PATCH v4 1/4] lavc: add standalone cached bitstream reader
by Anton Khirnov 06 Jan '23

06 Jan '23

From: Alexandra Hájková <alexandra.khirnova(a)gmail.com> The cached bitstream reader was originally written by Alexandra Hájková for Libav, with significant input from Kostya Shishkov and Luca Barbato. It was then committed to FFmpeg in ca079b09549, by merging it with the implementation of the current bitstream reader. This merge makes the code of get_bits.h significantly harder to read, since it now contains two different bitstream readers interleaved with #ifdefs. Additionally, the code was committed without proper authorship attribution. This commit re-adds the cached bitstream reader as a standalone header, as it was originally developed. It will be made useful in following commits. Integration by Anton Khirnov. Signed-off-by: Anton Khirnov <anton(a)khirnov.net> --- libavcodec/bitstream.h | 529 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 529 insertions(+) create mode 100644 libavcodec/bitstream.h diff --git a/libavcodec/bitstream.h b/libavcodec/bitstream.h new file mode 100644 index 0000000000..6fd321dba5 --- /dev/null +++ b/libavcodec/bitstream.h @@ -0,0 +1,529 @@ +/* + * Copyright (c) 2016 Alexandra Hájková + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * bitstream reader API header. + */ + +#ifndef AVCODEC_BITSTREAM_H +#define AVCODEC_BITSTREAM_H + +#include <stdint.h> + +#include "config.h" + +#include "libavutil/avassert.h" +#include "libavutil/common.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/log.h" + +#include "mathops.h" +#include "vlc.h" + +#ifndef UNCHECKED_BITSTREAM_READER +#define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER +#endif + +typedef struct BitstreamContext { + uint64_t bits; // stores bits read from the buffer + const uint8_t *buffer, *buffer_end; + const uint8_t *ptr; // pointer to the position inside a buffer + unsigned bits_valid; // number of bits left in bits field + unsigned size_in_bits; +} BitstreamContext; + +/** + * @return + * - 0 on successful refill + * - a negative number when bitstream end is hit + * + * Always succeeds when UNCHECKED_BITSTREAM_READER is enabled. + */ +static inline int bits_priv_refill_64(BitstreamContext *bc) +{ +#if !UNCHECKED_BITSTREAM_READER + if (bc->ptr >= bc->buffer_end) + return -1; +#endif + +#ifdef BITSTREAM_READER_LE + bc->bits = AV_RL64(bc->ptr); +#else + bc->bits = AV_RB64(bc->ptr); +#endif + bc->ptr += 8; + bc->bits_valid = 64; + + return 0; +} + +/** + * @return + * - 0 on successful refill + * - a negative number when bitstream end is hit + * + * Always succeeds when UNCHECKED_BITSTREAM_READER is enabled. + */ +static inline int bits_priv_refill_32(BitstreamContext *bc) +{ +#if !UNCHECKED_BITSTREAM_READER + if (bc->ptr >= bc->buffer_end) + return -1; +#endif + +#ifdef BITSTREAM_READER_LE + bc->bits |= (uint64_t)AV_RL32(bc->ptr) << bc->bits_valid; +#else + bc->bits |= (uint64_t)AV_RB32(bc->ptr) << (32 - bc->bits_valid); +#endif + bc->ptr += 4; + bc->bits_valid += 32; + + return 0; +} + +/** + * Initialize BitstreamContext. + * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes + * larger than the actual read bits because some optimized bitstream + * readers read 32 or 64 bits at once and could read over the end + * @param bit_size the size of the buffer in bits + * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow. + */ +static inline int bits_init(BitstreamContext *bc, const uint8_t *buffer, + unsigned int bit_size) +{ + unsigned int buffer_size; + + if (bit_size > INT_MAX - 7 || !buffer) { + bc->buffer = NULL; + bc->ptr = NULL; + bc->bits_valid = 0; + return AVERROR_INVALIDDATA; + } + + buffer_size = (bit_size + 7) >> 3; + + bc->buffer = buffer; + bc->buffer_end = buffer + buffer_size; + bc->ptr = bc->buffer; + bc->size_in_bits = bit_size; + bc->bits_valid = 0; + bc->bits = 0; + + bits_priv_refill_64(bc); + + return 0; +} + +/** + * Initialize BitstreamContext. + * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes + * larger than the actual read bits because some optimized bitstream + * readers read 32 or 64 bits at once and could read over the end + * @param byte_size the size of the buffer in bytes + * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow + */ +static inline int bits_init8(BitstreamContext *bc, const uint8_t *buffer, + unsigned int byte_size) +{ + if (byte_size > INT_MAX / 8) + return AVERROR_INVALIDDATA; + return bits_init(bc, buffer, byte_size * 8); +} + +/** + * Return number of bits already read. + */ +static inline int bits_tell(const BitstreamContext *bc) +{ + return (bc->ptr - bc->buffer) * 8 - bc->bits_valid; +} + +/** + * Return buffer size in bits. + */ +static inline int bits_size(const BitstreamContext *bc) +{ + return bc->size_in_bits; +} + +/** + * Return the number of the bits left in a buffer. + */ +static inline int bits_left(const BitstreamContext *bc) +{ + return (bc->buffer - bc->ptr) * 8 + bc->size_in_bits + bc->bits_valid; +} + +static inline uint64_t bits_priv_val_show(BitstreamContext *bc, unsigned int n) +{ + av_assert2(n > 0 && n <= 64); + +#ifdef BITSTREAM_READER_LE + return bc->bits & (UINT64_MAX >> (64 - n)); +#else + return bc->bits >> (64 - n); +#endif +} + +static inline void bits_priv_skip_remaining(BitstreamContext *bc, unsigned int n) +{ +#ifdef BITSTREAM_READER_LE + bc->bits >>= n; +#else + bc->bits <<= n; +#endif + bc->bits_valid -= n; +} + +static inline uint64_t bits_priv_val_get(BitstreamContext *bc, unsigned int n) +{ + uint64_t ret; + + av_assert2(n > 0 && n < 64); + + ret = bits_priv_val_show(bc, n); + bits_priv_skip_remaining(bc, n); + + return ret; +} + +/** + * Return one bit from the buffer. + */ +static inline unsigned int bits_read_bit(BitstreamContext *bc) +{ + if (!bc->bits_valid && bits_priv_refill_64(bc) < 0) + return 0; + + return bits_priv_val_get(bc, 1); +} + +/** + * Return n bits from the buffer, n has to be in the 1-32 range. + * May be faster than bits_read() when n is not a compile-time constant and is + * known to be non-zero; + */ +static inline uint32_t bits_read_nz(BitstreamContext *bc, unsigned int n) +{ + av_assert2(n > 0 && n <= 32); + + if (n > bc->bits_valid) { + if (bits_priv_refill_32(bc) < 0) + bc->bits_valid = n; + } + + return bits_priv_val_get(bc, n); +} + +/** + * Return n bits from the buffer, n has to be in the 0-32 range. + */ +static inline uint32_t bits_read(BitstreamContext *bc, unsigned int n) +{ + av_assert2(n <= 32); + + if (!n) + return 0; + + return bits_read_nz(bc, n); +} + +/** + * Return n bits from the buffer, n has to be in the 0-63 range. + */ +static inline uint64_t bits_read_63(BitstreamContext *bc, unsigned int n) +{ + uint64_t ret = 0; + unsigned left = 0; + + av_assert2(n <= 63); + + if (!n) + return 0; + + if (n > bc->bits_valid) { + left = bc->bits_valid; + n -= left; + + if (left) + ret = bits_priv_val_get(bc, left); + + if (bits_priv_refill_64(bc) < 0) + bc->bits_valid = n; + + } + +#ifdef BITSTREAM_READER_LE + ret = bits_priv_val_get(bc, n) << left | ret; +#else + ret = bits_priv_val_get(bc, n) | ret << n; +#endif + + return ret; +} + +/** + * Return n bits from the buffer, n has to be in the 0-64 range. + */ +static inline uint64_t bits_read_64(BitstreamContext *bc, unsigned int n) +{ + av_assert2(n <= 64); + + if (n == 64) { + uint64_t ret = bits_read_63(bc, 63); +#ifdef BITSTREAM_READER_LE + return ret | ((uint64_t)bits_read_bit(bc) << 63); +#else + return (ret << 1) | (uint64_t)bits_read_bit(bc); +#endif + } + return bits_read_63(bc, n); +} + +/** + * Return n bits from the buffer as a signed integer. + * n has to be in the 0-32 range. + */ +static inline int32_t bits_read_signed(BitstreamContext *bc, unsigned int n) +{ + return sign_extend(bits_read(bc, n), n); +} + +/** + * Return n bits from the buffer but do not change the buffer state. + * n has to be in the 1-32 range. May + */ +static inline uint32_t bits_peek_nz(BitstreamContext *bc, unsigned int n) +{ + av_assert2(n > 0 && n <= 32); + + if (n > bc->bits_valid) + bits_priv_refill_32(bc); + + return bits_priv_val_show(bc, n); +} + +/** + * Return n bits from the buffer but do not change the buffer state. + * n has to be in the 0-32 range. + */ +static inline uint32_t bits_peek(BitstreamContext *bc, unsigned int n) +{ + av_assert2(n <= 32); + + if (!n) + return 0; + + return bits_peek_nz(bc, n); +} + +/** + * Return n bits from the buffer as a signed integer, + * do not change the buffer state. + * n has to be in the 0-32 range. + */ +static inline int bits_peek_signed(BitstreamContext *bc, unsigned int n) +{ + return sign_extend(bits_peek(bc, n), n); +} + +/** + * Skip n bits in the buffer. + */ +static inline void bits_skip(BitstreamContext *bc, unsigned int n) +{ + if (n < bc->bits_valid) + bits_priv_skip_remaining(bc, n); + else { + n -= bc->bits_valid; + bc->bits = 0; + bc->bits_valid = 0; + + if (n >= 64) { + unsigned int skip = n / 8; + + n -= skip * 8; + bc->ptr += skip; + } + bits_priv_refill_64(bc); + if (n) + bits_priv_skip_remaining(bc, n); + } +} + +/** + * Seek to the given bit position. + */ +static inline void bits_seek(BitstreamContext *bc, unsigned pos) +{ + bc->ptr = bc->buffer; + bc->bits = 0; + bc->bits_valid = 0; + + bits_skip(bc, pos); +} + +/** + * Skip bits to a byte boundary. + */ +static inline const uint8_t *bits_align(BitstreamContext *bc) +{ + unsigned int n = -bits_tell(bc) & 7; + if (n) + bits_skip(bc, n); + return bc->buffer + (bits_tell(bc) >> 3); +} + +/** + * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB). + * If MSB not set it is negative. + * @param n length in bits + */ +static inline int bits_read_xbits(BitstreamContext *bc, unsigned int n) +{ + int32_t cache = bits_peek(bc, 32); + int sign = ~cache >> 31; + bits_priv_skip_remaining(bc, n); + + return ((((uint32_t)(sign ^ cache)) >> (32 - n)) ^ sign) - sign; +} + +/** + * Return decoded truncated unary code for the values 0, 1, 2. + */ +static inline int bits_decode012(BitstreamContext *bc) +{ + if (!bits_read_bit(bc)) + return 0; + else + return bits_read_bit(bc) + 1; +} + +/** + * Return decoded truncated unary code for the values 2, 1, 0. + */ +static inline int bits_decode210(BitstreamContext *bc) +{ + if (bits_read_bit(bc)) + return 0; + else + return 2 - bits_read_bit(bc); +} + +/* Read sign bit and flip the sign of the provided value accordingly. */ +static inline int bits_apply_sign(BitstreamContext *bc, int val) +{ + int sign = bits_read_signed(bc, 1); + return (val ^ sign) - sign; +} + +static inline int bits_skip_1stop_8data(BitstreamContext *s) +{ + if (bits_left(s) <= 0) + return AVERROR_INVALIDDATA; + + while (bits_read_bit(s)) { + bits_skip(s, 8); + if (bits_left(s) <= 0) + return AVERROR_INVALIDDATA; + } + + return 0; +} + +/** + * Return the LUT element for the given bitstream configuration. + */ +static inline int bits_priv_set_idx(BitstreamContext *bc, int code, int *n, int *nb_bits, + const VLCElem *table) +{ + unsigned idx; + + *nb_bits = -*n; + idx = bits_peek(bc, *nb_bits) + code; + *n = table[idx].len; + + return table[idx].sym; +} + +/** + * Parse a vlc code. + * @param bits is the number of bits which will be read at once, must be + * identical to nb_bits in init_vlc() + * @param max_depth is the number of times bits bits must be read to completely + * read the longest vlc code + * = (max_vlc_length + bits - 1) / bits + * If the vlc code is invalid and max_depth=1, then no bits will be removed. + * If the vlc code is invalid and max_depth>1, then the number of bits removed + * is undefined. + */ +static inline int bits_read_vlc(BitstreamContext *bc, const VLCElem *table, + int bits, int max_depth) +{ + int nb_bits; + unsigned idx = bits_peek(bc, bits); + int code = table[idx].sym; + int n = table[idx].len; + + if (max_depth > 1 && n < 0) { + bits_priv_skip_remaining(bc, bits); + code = bits_priv_set_idx(bc, code, &n, &nb_bits, table); + if (max_depth > 2 && n < 0) { + bits_priv_skip_remaining(bc, nb_bits); + code = bits_priv_set_idx(bc, code, &n, &nb_bits, table); + } + } + bits_priv_skip_remaining(bc, n); + + return code; +} + +#define BITS_RL_VLC(level, run, bc, table, bits, max_depth) \ + do { \ + int n, nb_bits; \ + unsigned int index = bits_peek(bc, bits); \ + level = table[index].level; \ + n = table[index].len; \ + \ + if (max_depth > 1 && n < 0) { \ + bits_skip(bc, bits); \ + \ + nb_bits = -n; \ + \ + index = bits_peek(bc, nb_bits) + level; \ + level = table[index].level; \ + n = table[index].len; \ + if (max_depth > 2 && n < 0) { \ + bits_skip(bc, nb_bits); \ + nb_bits = -n; \ + \ + index = bits_peek(bc, nb_bits) + level; \ + level = table[index].level; \ + n = table[index].len; \ + } \ + } \ + run = table[index].run; \ + bits_skip(bc, n); \ + } while (0) + +#endif /* AVCODEC_BITSTREAM_H */ -- 2.35.1

2 6

[PATCH v7 0/3] 32bps FLAC patches
by Martijn van Beurden 26 Dec '22

26 Dec '22

Recently libFLAC gained the ability (first released in FLAC 1.4.0) to create FLAC files containing 32-bit int PCM samples. To keep complexity reasonable, the choice was made to limit residuals to 32-bit integers, which the encoder must make sure of. In case the encoder cannot find any predictor of which the residuals fit this limit, it must default to using a verbatim subframe. Tests have shown that this does not happen often (<0.1% of subframes on a music corpus of various styles). See also discussion here: https://github.com/ietf-wg-cellar/flac-specification/pull/148 These two patches implement decoding and encoding following this format. Changes since v1: fix copy-paste error in encoder, several invocations of lpc_encode_choose_datapath used wrong parameters, making FATE fail as compression was less than it should be Changes since v2: Rebased decoder part as it didn't apply anymore Changes since v3: Moved put_golomb part to flacenc.c (as it is now quite specific to FLAC) and renamed put_sbits64 to put_sbits63 (and changed assert accordingly) Changes since v4: Fix check of decoded_buffer_33bps malloc. Fix reading of wasted bits for 33bps subframe. Add fate test Changes since v5: Slimmed down 32 bps fate flac test from 2 to 1 input file. Replaced -strict -2 with -strict experimental in fate and encoder warning. Changes since v6: Deduplicated function bodies with preprocessor macros in both encoder and decoder, declared variables in loop body where possible and changed ff_ctz to ff_ctzll where necessary Martijn van Beurden (3): libavcodec/flacdec: Implement decoding of 32 bit-per-sample PCM libavcodec/flacenc: Implement encoding of 32 bit-per-sample PCM fate/flac: Add test of 32 bps encoding/decoding libavcodec/flac.c | 4 +- libavcodec/flacdec.c | 218 ++++++++++++++++-- libavcodec/flacenc.c | 480 +++++++++++++++++++++++++++++++--------- libavcodec/get_bits.h | 12 + libavcodec/mathops.h | 9 + libavcodec/put_bits.h | 7 + libavcodec/put_golomb.h | 14 -- tests/fate/flac.mak | 4 + 8 files changed, 602 insertions(+), 146 deletions(-) -- 2.30.2

2 12

[PATCH 0/2] Print filter input/output formats in help output
by ffmpegagent 26 Dec '22

26 Dec '22

Example out put for command: ffmpeg -h filters=overlay Filter overlay Overlay a video source on top of the input. slice threading supported Inputs: #0: main (video), Formats: Dynamic, Default: [yuv420p, yuvj420p, yuva420p, nv12, nv21] #1: overlay (video), Formats: Dynamic, Default: [yuva420p] Outputs: #0: default (video), Formats: Dynamic, Default: [yuv420p, yuvj420p, yuva420p, nv12, nv21] overlay AVOptions: [...] Examples for what it prints in various cases ============================================ For pass-through filter links ============================= "All (passthrough)" For filters using query_formats =============================== "Dynamic" For filters using query_formats where a call to query_formats succeeds ====================================================================== "Dynamic, Default: [yuv420p, yuvj420p, yuva420p, nv12, nv21]" For all other cases =================== "[s16p, s32p, fltp, dblp]" Except in case when all formats are supported ============================================= (when the number of formats equals the number of available formats) "All" softworkz (2): avfilter/avfilter: add avfilter_print_config_formats() ftools/opt_common: Print filter input/output formats in help output doc/APIchanges | 3 ++ fftools/opt_common.c | 39 +++++++++----- libavfilter/avfilter.c | 102 +++++++++++++++++++++++++++++++++++- libavfilter/avfilter.h | 12 +++++ libavfilter/avfiltergraph.c | 14 +++-- libavfilter/internal.h | 9 ++++ libavfilter/version.h | 4 +- 7 files changed, 163 insertions(+), 20 deletions(-) base-commit: e10e27a2ead8848648b29a1b397cc240206e9c3d Published-As: https://github.com/ffstaging/FFmpeg/releases/tag/pr-ffstaging-43%2Fsoftwork… Fetch-It-Via: git fetch https://github.com/ffstaging/FFmpeg pr-ffstaging-43/softworkz/submit_print_formats-v1 Pull-Request: https://github.com/ffstaging/FFmpeg/pull/43 -- ffmpeg-codebot

4 9

[PATCH]lavc/x86/simple_idct: Fix linking shared libavcodec with MS link.exe
by Carl Eugen Hoyos 13 Dec '22

13 Dec '22

Hi! Attached patch fixes ticket #9909 for me, regression since 4618f36a Please comment, Carl Eugen

4 14

Re: [FFmpeg-devel] [FFmpeg-cvslog] avfilter/framesync: add a new option to set how to sync streams based on secondary input timestamps
by Gyan Doshi 07 Dec '22

07 Dec '22

On 2022-08-10 05:46 pm, James Almer wrote: > ffmpeg | branch: master | James Almer <jamrial(a)gmail.com> | Tue Aug 2 08:28:48 2022 -0300| [0c3e3fd1b478e14692f3b02bb8bf42262ee18af0] | committer: James Almer > > avfilter/framesync: add a new option to set how to sync streams based on secondary input timestamps Needs doc entry in filters.texi http://www.ffmpeg.org/ffmpeg-filters.html#Options-for-filters-with-several-… Regards, Gyan > > Include two values for it, a default one that sets/keeps the current behavior, > where the frame event generated by the primary input will have a timestamp > equal or higher than frames in secondary input, plus a new one where the > secondary input frame will be that with the absolute closest timestamp to that > of the frame event one. > > Addresses ticket #9689, where the new optional behavior produces better frame > syncronization. > > Reviewed-by: Nicolas George <george(a)nsup.org> > Signed-off-by: James Almer <jamrial(a)gmail.com> > >> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=0c3e3fd1b478e1469… > --- > > libavfilter/framesync.c | 19 +++++++++++++++++++ > libavfilter/framesync.h | 23 +++++++++++++++++++++++ > 2 files changed, 42 insertions(+) > > diff --git a/libavfilter/framesync.c b/libavfilter/framesync.c > index 7510550d8e..ee91e4cf68 100644 > --- a/libavfilter/framesync.c > +++ b/libavfilter/framesync.c > @@ -42,6 +42,13 @@ static const AVOption framesync_options[] = { > { "pass", "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS }, .flags = FLAGS, "eof_action" }, > { "shortest", "force termination when the shortest input terminates", OFFSET(opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, > { "repeatlast", "extend last frame of secondary streams beyond EOF", OFFSET(opt_repeatlast), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS }, > + { "ts_sync_mode", "How strictly to sync streams based on secondary input timestamps", > + OFFSET(opt_ts_sync_mode), AV_OPT_TYPE_INT, { .i64 = TS_DEFAULT }, > + TS_DEFAULT, TS_NEAREST, .flags = FLAGS, "ts_sync_mode" }, > + { "default", "Frame from secondary input with the nearest lower or equal timestamp to the primary input frame", > + 0, AV_OPT_TYPE_CONST, { .i64 = TS_DEFAULT }, .flags = FLAGS, "ts_sync_mode" }, > + { "nearest", "Frame from secondary input with the absolute nearest timestamp to the primary input frame", > + 0, AV_OPT_TYPE_CONST, { .i64 = TS_NEAREST }, .flags = FLAGS, "ts_sync_mode" }, > { NULL } > }; > static const AVClass framesync_class = { > @@ -110,6 +117,14 @@ static void framesync_sync_level_update(FFFrameSync *fs) > av_assert0(level <= fs->sync_level); > if (level < fs->sync_level) > av_log(fs, AV_LOG_VERBOSE, "Sync level %u\n", level); > + if (fs->opt_ts_sync_mode > TS_DEFAULT) { > + for (i = 0; i < fs->nb_in; i++) { > + if (fs->in[i].sync < level) > + fs->in[i].ts_mode = fs->opt_ts_sync_mode; > + else > + fs->in[i].ts_mode = TS_DEFAULT; > + } > + } > if (level) > fs->sync_level = level; > else > @@ -187,6 +202,10 @@ static int framesync_advance(FFFrameSync *fs) > } > for (i = 0; i < fs->nb_in; i++) { > if (fs->in[i].pts_next == pts || > + (fs->in[i].ts_mode == TS_NEAREST && > + fs->in[i].have_next && > + fs->in[i].pts_next != INT64_MAX && fs->in[i].pts != AV_NOPTS_VALUE && > + fs->in[i].pts_next - pts < pts - fs->in[i].pts) || > (fs->in[i].before == EXT_INFINITY && > fs->in[i].state == STATE_BOF)) { > av_frame_free(&fs->in[i].frame); > diff --git a/libavfilter/framesync.h b/libavfilter/framesync.h > index a246d2d1e5..233f50a0eb 100644 > --- a/libavfilter/framesync.h > +++ b/libavfilter/framesync.h > @@ -75,6 +75,27 @@ enum FFFrameSyncExtMode { > EXT_INFINITY, > }; > > +/** > + * Timestamp syncronization mode > + * > + * Describe how the frames of a stream are syncronized based on timestamp > + * distance. > + */ > +enum FFFrameTSSyncMode { > + > + /** > + * Sync to frames from secondary input with the nearest, lower or equal > + * timestamp to the frame event one. > + */ > + TS_DEFAULT, > + > + /** > + * Sync to frames from secondary input with the absolute nearest timestamp > + * to the frame event one. > + */ > + TS_NEAREST, > +}; > + > /** > * Input stream structure > */ > @@ -138,6 +159,7 @@ typedef struct FFFrameSyncIn { > */ > unsigned sync; > > + enum FFFrameTSSyncMode ts_mode; > } FFFrameSyncIn; > > /** > @@ -205,6 +227,7 @@ typedef struct FFFrameSync { > int opt_repeatlast; > int opt_shortest; > int opt_eof_action; > + int opt_ts_sync_mode; > > } FFFrameSync; > > > _______________________________________________ > ffmpeg-cvslog mailing list > ffmpeg-cvslog(a)ffmpeg.org > https://ffmpeg.org/mailman/listinfo/ffmpeg-cvslog > > To unsubscribe, visit link above, or email > ffmpeg-cvslog-request(a)ffmpeg.org with subject "unsubscribe".

2 1

[PATCH 1/5] avformat/mxfdec: Avoid some redundant writing to tables in mxf_compute_ptses_fake_index()
by Michael Niedermayer 02 Dec '22

02 Dec '22

Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> --- libavformat/mxfdec.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libavformat/mxfdec.c b/libavformat/mxfdec.c index e63e803aa56..4ceb6cf672f 100644 --- a/libavformat/mxfdec.c +++ b/libavformat/mxfdec.c @@ -1939,10 +1939,10 @@ static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_ta if (index_table->nb_ptses <= 0) return 0; - if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) || + if (!(index_table->ptses = av_malloc_array(index_table->nb_ptses, sizeof(int64_t))) || !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) || !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) || - !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) { + !(flags = av_malloc_array(index_table->nb_ptses, sizeof(uint8_t)))) { av_freep(&index_table->ptses); av_freep(&index_table->fake_index); av_freep(&index_table->offsets); -- 2.17.1

3 14

[PATCH] mpegts: identify and demux DSMCC-B/MHEG streams
by Scott Theisen 28 Nov '22

28 Nov '22

These changes are from MythTV. --- The `AV_CODEC_ID`s are probably in the wrong place since these are data codecs, but that is where they are In MythTV. There was also a related change to libavformat/demux.c's avformat_find_stream_info() trying to optimize it for MHEG streams, but it is unnecessary and was causing FATE to fail. libavcodec/codec_desc.c | 12 +++ libavcodec/codec_id.h | 6 ++ libavformat/avformat.h | 5 + libavformat/mpegts.c | 199 +++++++++++++++++++++++++++++++++++++++- libavformat/mpegts.h | 17 ++++ 5 files changed, 237 insertions(+), 2 deletions(-) diff --git a/libavcodec/codec_desc.c b/libavcodec/codec_desc.c index 648c518b3c..0e54087863 100644 --- a/libavcodec/codec_desc.c +++ b/libavcodec/codec_desc.c @@ -3488,6 +3488,18 @@ static const AVCodecDescriptor codec_descriptors[] = { .props = AV_CODEC_PROP_TEXT_SUB, .profiles = NULL_IF_CONFIG_SMALL(ff_arib_caption_profiles), }, + { + .id = AV_CODEC_ID_DVB_VBI, + .type = AVMEDIA_TYPE_DATA, + .name = "dvb_vbi", + .long_name = NULL_IF_CONFIG_SMALL("dvb teletext"), + }, + { + .id = AV_CODEC_ID_DSMCC_B, + .type = AVMEDIA_TYPE_DATA, + .name = "dsmcc_b", + .long_name = NULL_IF_CONFIG_SMALL("DSMCC B"), + }, /* other kind of codecs and pseudo-codecs */ { diff --git a/libavcodec/codec_id.h b/libavcodec/codec_id.h index bc8226ff07..7e2198a800 100644 --- a/libavcodec/codec_id.h +++ b/libavcodec/codec_id.h @@ -559,6 +559,12 @@ enum AVCodecID { AV_CODEC_ID_TTML, AV_CODEC_ID_ARIB_CAPTION, + /* teletext codecs */ + AV_CODEC_ID_DVB_VBI, + + /* DSMCC codec */ + AV_CODEC_ID_DSMCC_B, + /* other specific kind of codecs (generally used for attachments) */ AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. AV_CODEC_ID_TTF = 0x18000, diff --git a/libavformat/avformat.h b/libavformat/avformat.h index 9d46875cce..664a1afa61 100644 --- a/libavformat/avformat.h +++ b/libavformat/avformat.h @@ -1117,6 +1117,11 @@ typedef struct AVStream { * */ int pts_wrap_bits; + + /* MHEG support */ + int component_tag; ///< Component tag given in PMT + int carousel_id; + int data_id; } AVStream; struct AVCodecParserContext *av_stream_get_parser(const AVStream *s); diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c index 8a3436f2be..be8edd9e62 100644 --- a/libavformat/mpegts.c +++ b/libavformat/mpegts.c @@ -46,6 +46,15 @@ #include <iconv.h> #endif +typedef struct SectionContext { + int pid; + int stream_type; + int new_packet; + MpegTSContext *ts; + AVFormatContext *stream; + AVStream *st; +} SectionContext; + /* maximum size in which we look for synchronization if * synchronization is lost */ #define MAX_RESYNC_SIZE 65536 @@ -412,6 +421,8 @@ static int discard_pid(MpegTSContext *ts, unsigned int pid) return !used && discarded; } +static void mpegts_push_section(MpegTSFilter *filter, const uint8_t *section, int section_len); + /** * Assemble PES packets out of TS packets, and then call the "section_cb" * function when they are complete. @@ -438,6 +449,11 @@ static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1, tss->section_index += len; } + if (tss->section_cb == mpegts_push_section) { + SectionContext *sect = tss->opaque; + sect->new_packet = 1; + } + offset = 0; cur_section_buf = tss->section_buf; while (cur_section_buf - tss->section_buf < MAX_SECTION_SIZE && cur_section_buf[0] != 0xff) { @@ -798,6 +814,7 @@ static const StreamType ISO_types[] = { { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO }, { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, + { 0x0b, AVMEDIA_TYPE_DATA, AV_CODEC_ID_DSMCC_B }, /* DVB_CAROUSEL_ID */ { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC }, { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4 }, /* Makito encoder sets stream type 0x11 for AAC, @@ -882,11 +899,20 @@ static const StreamType DESC_types[] = { { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */ { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */ { 0x7b, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, + { 0x13, AVMEDIA_TYPE_DATA, AV_CODEC_ID_DSMCC_B }, /* DVB_CAROUSEL_ID */ + { 0x45, AVMEDIA_TYPE_DATA, AV_CODEC_ID_DVB_VBI }, /* DVB_VBI_DATA_ID */ + { 0x46, AVMEDIA_TYPE_DATA, AV_CODEC_ID_DVB_VBI }, /* DVB_VBI_TELETEXT_ID */ //FixMe type subtilte { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT }, { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */ { 0 }, }; +/* component tags */ +static const StreamType COMPONENT_TAG_types[] = { + { 0x0a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 }, + { 0x52, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO }, +}; + static void mpegts_find_stream_type(AVStream *st, uint32_t stream_type, const StreamType *types) @@ -1979,7 +2005,13 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */ extradata += 5; - *pp += 4; + { + int comp_page = get16(pp, desc_end); + int anc_page = get16(pp, desc_end); + int sub_id = (anc_page << 16) | comp_page; + if (sub_id && (st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE)) + st->carousel_id = sub_id; + } } language[i * 4 - 1] = 0; @@ -2023,8 +2055,45 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type sti->request_probe = 50; } break; + case DVB_BROADCAST_ID: + st->data_id = get16(pp, desc_end); + break; + case DVB_CAROUSEL_ID: + { + int carId = 0; + carId = get8(pp, desc_end); + carId = (carId << 8) | get8(pp, desc_end); + carId = (carId << 8) | get8(pp, desc_end); + carId = (carId << 8) | get8(pp, desc_end); + st->carousel_id = carId; + } + break; case 0x52: /* stream identifier descriptor */ sti->stream_identifier = 1 + get8(pp, desc_end); + st->component_tag = sti->stream_identifier - 1; + // DVB_DATA_STREAM: + /* Audio and video are sometimes encoded in private streams labelled with + * a component tag. */ +#if 0 + if (st->codecpar->codec_id == AV_CODEC_ID_NONE && + desc_count == 1 && + stream_type == STREAM_TYPE_PRIVATE_DATA) + mpegts_find_stream_type(st, st->component_tag, + COMPONENT_TAG_types); +#endif + break; + case DVB_VBI_TELETEXT_ID: + language[0] = get8(pp, desc_end); + language[1] = get8(pp, desc_end); + language[2] = get8(pp, desc_end); + language[3] = 0; + + /* dvbci->txt_type = */ i = (get8(pp, desc_end)) >> 3; // not exported, defeat compiler -Wunused-value + if (language[0]) + av_dict_set(&st->metadata, "language", language, 0); + break; + case DVB_VBI_DATA_ID: + // dvbci->vbi_data = 1; //not parsing the data service descriptors break; case METADATA_DESCRIPTOR: if (get16(pp, desc_end) == 0xFFFF) @@ -2307,6 +2376,34 @@ static int is_pes_stream(int stream_type, uint32_t prog_reg_desc) (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) ); } +static SectionContext *add_section_stream(MpegTSContext *ts, int pid, int stream_type) +{ + MpegTSFilter *tss = ts->pids[pid]; + SectionContext *sect = 0; + if (tss) { /* filter already exists */ + /* kill it, and start a new stream */ + mpegts_close_filter(ts, tss); + } + + /* create a SECTION context */ + if (!(sect=av_mallocz(sizeof(SectionContext)))) { + av_log(ts, AV_LOG_ERROR, "Error: av_mallocz() failed in add_section_stream"); + return 0; + } + sect->ts = ts; + sect->stream = ts->stream; + sect->pid = pid; + sect->stream_type = stream_type; + tss = mpegts_open_section_filter(ts, pid, mpegts_push_section, sect, 1); + if (!tss) { + av_free(sect); + av_log(ts, AV_LOG_ERROR, "Error: unable to open mpegts Section filter in add_section_stream"); + return 0; + } + + return sect; +} + static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; @@ -2425,7 +2522,56 @@ static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len stream_identifier = parse_stream_identifier_desc(p, p_end) + 1; /* now create stream */ - if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) { + if (stream_type == STREAM_TYPE_DSMCC_B) + { + SectionContext *sect = NULL; + int idx = -1; + + if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_SECTION && + ts->pids[pid]->u.section_filter.section_cb == mpegts_push_section) { + // u.section_filter.opaque may be the MpegTSContext, so test the section_cb + sect = (SectionContext*) ts->pids[pid]->u.section_filter.opaque; + } + if (!sect) { + sect = add_section_stream(ts, pid, stream_type); + } + if (!sect) + { + av_log(ts, AV_LOG_ERROR, "mpegts_add_stream: " + "error creating Section context for pid 0x%x with type %i\n", + pid, stream_type); + goto out; + } + + idx = ff_find_stream_index(ts->stream, pid); + if (idx >= 0) { + st = ts->stream->streams[idx]; + av_log(ts, AV_LOG_DEBUG, "mpegts_add_stream: " + "reusing stream #%d, has id 0x%x and codec %s, type %s at 0x%p\n", + st->index, st->id, avcodec_get_name(st->codecpar->codec_id), + av_get_media_type_string(st->codecpar->codec_type), st); + } + if (!st) { + st = avformat_new_stream(sect->stream, NULL); + } + if (!st) { + goto out; + } + sect->st = st; + sect->st->id = sect->pid; + + avpriv_set_pts_info(sect->st, 33, 1, 90000); + + sect->st->codecpar->codec_type = AVMEDIA_TYPE_DATA; + sect->st->codecpar->codec_id = AV_CODEC_ID_DSMCC_B; + sect->st->priv_data = sect; + ffstream(sect->st)->need_parsing = AVSTREAM_PARSE_NONE; + + av_log(ts, AV_LOG_DEBUG, "mpegts_add_stream: " + "stream #%d, has id 0x%x and codec %s, type %s at 0x%p\n", + st->index, st->id, avcodec_get_name(st->codecpar->codec_id), + av_get_media_type_string(st->codecpar->codec_type), st); + } else if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) { pes = ts->pids[pid]->u.pes_filter.opaque; if (ts->merge_pmt_versions && !pes->st) { st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program); @@ -2527,6 +2673,55 @@ out: av_free(mp4_descr[i].dec_config_descr); } +/* mpegts_push_section: return one or more tables. The tables may not completely fill + the packet and there may be stuffing bytes at the end. + This is complicated because a single TS packet may result in several tables being + produced. We may have a "start" bit indicating, in effect, the end of a table but + the rest of the TS packet after the start may be filled with one or more small tables. +*/ +static void mpegts_push_section(MpegTSFilter *filter, const uint8_t *section, int section_len) +{ + SectionContext *sect = filter->u.section_filter.opaque; + MpegTSContext *ts = sect->ts; + SectionHeader header; + AVPacket *pkt = ts->pkt; + const uint8_t *p = section, *p_end = section + section_len - 4; + + if (parse_section_header(&header, &p, p_end) < 0) + { + av_log(ts, AV_LOG_DEBUG, "Unable to parse header\n"); + return; + } + + if (sect->new_packet && pkt && sect->st && pkt->size == -1) { + int pktLen = section_len + 184; /* Add enough for a complete TS payload. */ + sect->new_packet = 0; + av_packet_unref(pkt); + if (av_new_packet(pkt, pktLen) == 0) { + memcpy(pkt->data, section, section_len); + memset(pkt->data+section_len, 0xff, pktLen-section_len); + pkt->stream_index = sect->st->index; + ts->stop_parse = 1; + } + } else if (pkt->data) { /* We've already added at least one table. */ + uint8_t *data = pkt->data; + int space = pkt->size; + int table_size = 0; + while (space > 3 + table_size) { + table_size = (((data[1] & 0xf) << 8) | data[2]) + 3; + if (table_size < space) { + space -= table_size; + data += table_size; + } /* Otherwise we've got filler. */ + } + if (space < section_len) { + av_log(ts, AV_LOG_DEBUG, "Insufficient space for additional packet\n"); + return; + } + memcpy(data, section, section_len); + } +} + static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; diff --git a/libavformat/mpegts.h b/libavformat/mpegts.h index a48f14e768..6f57af7786 100644 --- a/libavformat/mpegts.h +++ b/libavformat/mpegts.h @@ -122,6 +122,7 @@ #define STREAM_TYPE_AUDIO_MPEG2 0x04 #define STREAM_TYPE_PRIVATE_SECTION 0x05 #define STREAM_TYPE_PRIVATE_DATA 0x06 +#define STREAM_TYPE_DSMCC_B 0x0b #define STREAM_TYPE_AUDIO_AAC 0x0f #define STREAM_TYPE_AUDIO_AAC_LATM 0x11 #define STREAM_TYPE_VIDEO_MPEG4 0x10 @@ -139,6 +140,22 @@ #define STREAM_TYPE_AUDIO_TRUEHD 0x83 #define STREAM_TYPE_AUDIO_EAC3 0x87 +#define STREAM_TYPE_AUDIO_MISC_DTS 0x8a +#define STREAM_TYPE_AUDIO_HDMV_AC3_PLUS 0x84 +#define STREAM_TYPE_AUDIO_HDMV_DTS_HD 0x85 +#define STREAM_TYPE_AUDIO_HDMV_DTS_HD_MASTER 0x86 + +#define STREAM_TYPE_SUBTITLE_DVB 0x100 +#define STREAM_TYPE_VBI_DVB 0x101 + +#define DVB_CAROUSEL_ID 0x13 +#define DVB_VBI_DATA_ID 0x45 +#define DVB_VBI_TELETEXT_ID 0x46 +#define DVB_TELETEXT_ID 0x56 +#define DVB_SUBT_DESCID 0x59 +#define DVB_BROADCAST_ID 0x66 +#define DVB_DATA_STREAM 0x52 + /* ISO/IEC 13818-1 Table 2-22 */ #define STREAM_ID_PROGRAM_STREAM_MAP 0xbc #define STREAM_ID_PRIVATE_STREAM_1 0xbd -- 2.34.1

1 2

[PATCH 0/2] QSV Overlay Filter: Copy side data from input to output frame
by ffmpegagent 28 Nov '22

28 Nov '22

This is split out from my earlier patchset "SEI parsing for QSV decoders" (https://github.com/ffstaging/FFmpeg/pull/31) as it is only logically related but not technically. The first patch had been reviewed and partially authored by Anton (I have indicated this with a signed-off line, please advise in case this wouldn't be right) The second patch performs the copying of side data from input to output frames. softworkz softworkz (2): avutil/frame: Add av_frame_copy_side_data() and av_frame_remove_all_side_data() avcodec/vpp_qsv: Copy side data from input to output frame doc/APIchanges | 4 +++ libavfilter/qsvvpp.c | 6 ++++ libavfilter/vf_overlay_qsv.c | 19 +++++++--- libavutil/frame.c | 67 ++++++++++++++++++++++-------------- libavutil/frame.h | 32 +++++++++++++++++ libavutil/version.h | 4 +-- 6 files changed, 100 insertions(+), 32 deletions(-) base-commit: 882a17068fd8e62c7d38c14e6fb160d7c9fc446a Published-As: https://github.com/ffstaging/FFmpeg/releases/tag/pr-ffstaging-44%2Fsoftwork… Fetch-It-Via: git fetch https://github.com/ffstaging/FFmpeg pr-ffstaging-44/softworkz/submit_copy_sidedata-v1 Pull-Request: https://github.com/ffstaging/FFmpeg/pull/44 -- ffmpeg-codebot

6 11

Ping on help output, logging and VAAPI overlay
by Soft Works 27 Nov '22

27 Nov '22

This is a friendly ping on these recent submissions: Print filter input/output formats in help output https://patchwork.ffmpeg.org/project/ffmpeg/list/?series=7737 Fixes and Enhancements for VAAPI Overlay https://patchwork.ffmpeg.org/project/ffmpeg/list/?series=7722 Add option to log timing https://patchwork.ffmpeg.org/project/ffmpeg/list/?series=7290 Thanks, softworkz

1 1