September 2024 - ffmpeg-devel

[PATCH 2/2] lavc/vvc_mc: R-V V dmvr
by uk7b＠foxmail.com 27 Nov '24

27 Nov '24

From: sunyuechi <sunyuechi(a)iscas.ac.cn> k230 banana_f3 dmvr_8_12x20_c: 628.5 ( 1.00x) 624.1 ( 1.00x) dmvr_8_12x20_rvv_i32: 137.5 ( 4.57x) 92.9 ( 6.72x) dmvr_8_20x12_c: 609.7 ( 1.00x) 655.4 ( 1.00x) dmvr_8_20x12_rvv_i32: 146.7 ( 4.16x) 82.4 ( 7.95x) dmvr_8_20x20_c: 998.7 ( 1.00x) 1092.9 ( 1.00x) dmvr_8_20x20_rvv_i32: 221.0 ( 4.52x) 144.9 ( 7.54x) dmvr_h_8_12x20_c: 2008.0 ( 1.00x) 1999.2 ( 1.00x) dmvr_h_8_12x20_rvv_i32: 285.7 ( 7.03x) 207.4 ( 9.64x) dmvr_h_8_20x12_c: 1989.5 ( 1.00x) 2009.7 ( 1.00x) dmvr_h_8_20x12_rvv_i32: 322.7 ( 6.16x) 176.2 (11.41x) dmvr_h_8_20x20_c: 3304.2 ( 1.00x) 3342.9 ( 1.00x) dmvr_h_8_20x20_rvv_i32: 526.5 ( 6.28x) 290.6 (11.50x) dmvr_hv_8_12x20_c: 3609.7 ( 1.00x) 3603.4 ( 1.00x) dmvr_hv_8_12x20_rvv_i32: 554.2 ( 6.51x) 467.9 ( 7.70x) dmvr_hv_8_20x12_c: 3637.5 ( 1.00x) 3624.4 ( 1.00x) dmvr_hv_8_20x12_rvv_i32: 489.5 ( 7.43x) 342.6 (10.58x) dmvr_hv_8_20x20_c: 6794.7 ( 1.00x) 5936.9 ( 1.00x) dmvr_hv_8_20x20_rvv_i32: 785.7 ( 8.65x) 561.4 (10.58x) dmvr_v_8_12x20_c: 2156.0 ( 1.00x) 2155.2 ( 1.00x) dmvr_v_8_12x20_rvv_i32: 295.0 ( 7.31x) 207.4 (10.39x) dmvr_v_8_20x12_c: 2137.5 ( 1.00x) 2165.7 ( 1.00x) dmvr_v_8_20x12_rvv_i32: 322.7 ( 6.62x) 186.7 (11.60x) dmvr_v_8_20x20_c: 3554.2 ( 1.00x) 3593.2 ( 1.00x) dmvr_v_8_20x20_rvv_i32: 535.7 ( 6.63x) 290.6 (12.36x) --- libavcodec/riscv/vvc/vvc_mc_rvv.S | 141 +++++++++++++++++++++++++++++ libavcodec/riscv/vvc/vvcdsp_init.c | 22 +++++ 2 files changed, 163 insertions(+) diff --git a/libavcodec/riscv/vvc/vvc_mc_rvv.S b/libavcodec/riscv/vvc/vvc_mc_rvv.S index 18532616d9..a5e20cbc67 100644 --- a/libavcodec/riscv/vvc/vvc_mc_rvv.S +++ b/libavcodec/riscv/vvc/vvc_mc_rvv.S @@ -285,3 +285,144 @@ endfunc func_w_avg 128 func_w_avg 256 #endif + +func dmvr zve32x, zbb, zba + lpad 0 + li t0, 4 +1: + add t1, a1, a2 + addi t4, a0, 128*2 + add t2, t1, a2 + addi t5, a0, 128*2*2 + add t3, t2, a2 + addi t6, a0, 128*2*3 + vle8.v v0, (a1) + vle8.v v4, (t1) + vle8.v v8, (t2) + vle8.v v12, (t3) + addi a3, a3, -4 + vwmulu.vx v16, v0, t0 + vwmulu.vx v20, v4, t0 + vwmulu.vx v24, v8, t0 + vwmulu.vx v28, v12, t0 + vse16.v v16, (a0) + vse16.v v20, (t4) + vse16.v v24, (t5) + vse16.v v28, (t6) + sh2add a1, a2, a1 + add a0, a0, 128*2*4 + bnez a3, 1b + ret +endfunc + +.macro dmvr_h_v mn, type + lla t4, ff_vvc_inter_luma_dmvr_filters + sh1add t4, \mn, t4 + lbu t5, (t4) + lbu t6, 1(t4) +1: +.ifc \type,h + addi t0, a1, 1 + addi t1, a1, 2 +.else + add t0, a1, a2 + add t1, t0, a2 +.endif + vle8.v v0, (a1) + vle8.v v4, (t0) + vle8.v v8, (t1) + addi a3, a3, -2 + vzext.vf2 v12, v0 + vzext.vf2 v16, v4 + vzext.vf2 v20, v8 + addi t2, a0, 128*2 + vmul.vx v12, v12, t5 + vmul.vx v24, v16, t5 + vmacc.vx v12, t6, v16 + vmacc.vx v24, t6, v20 + vadd.vi v12, v12, 2 + vadd.vi v24, v24, 2 + vsra.vi v12, v12, 2 + vsra.vi v24, v24, 2 + vse16.v v12, (a0) + vse16.v v24, (t2) + add a0, a0, 128*4 + sh1add a1, a2, a1 + bnez a3, 1b + ret +.endm + +func dmvr_h zve32x, zbb, zba + lpad 0 + dmvr_h_v a4, h +endfunc + +func dmvr_v zve32x, zbb, zba + lpad 0 + dmvr_h_v a5, v +endfunc + +.macro dmvr_load_h dst, filter0, filter1 + addi a6, a1, 1 + vle8.v \dst, (a1) + vle8.v v2, (a6) + vzext.vf2 v4, \dst + vzext.vf2 v8, v2 + vmul.vx \dst, v4, \filter0 + vmacc.vx \dst, \filter1, v8 + vadd.vi \dst, \dst, 1 << (2 - 1) + vsra.vi \dst, \dst, 2 +.endm + +func dmvr_hv zve32x, zbb, zba + lpad 0 + lla t0, ff_vvc_inter_luma_dmvr_filters + sh1add t1, a4, t0 + sh1add t2, a5, t0 + lbu t3, (t1) // filter[mx][0] + lbu t4, 1(t1) // filter[mx][1] + lbu t5, (t2) // filter[my][0] + lbu t6, 1(t2) // filter[my][1] + dmvr_load_h v12, t3, t4 + add a1, a1, a2 +1: + vmul.vx v28, v12, t5 + addi a3, a3, -1 + dmvr_load_h v12, t3, t4 + vmacc.vx v28, t6, v12 + vadd.vi v28, v28, 1 << (4 - 1) + vsra.vi v28, v28, 4 + vse16.v v28, (a0) + add a1, a1, a2 + addi a0, a0, 128*2 + bnez a3, 1b + ret +endfunc + +.macro func_dmvr vlen, name +func ff_vvc_\name\()_8_rvv_\vlen\(), zve32x, zbb, zba + lpad 0 + li t0, 20 + beq a6, t0, DMVR20\vlen\name + .ifc \name, dmvr + vsetvlstatic8 12, \vlen + .else + vsetvlstatic16 12, \vlen + .endif + j \name +DMVR20\vlen\name: + .ifc \name, dmvr + vsetvlstatic8 20, \vlen + .else + vsetvlstatic16 20, \vlen + .endif + j \name +endfunc +.endm + +.irp vlen,256,128 +func_dmvr \vlen, dmvr +func_dmvr \vlen, dmvr_h +func_dmvr \vlen, dmvr_v +func_dmvr \vlen, dmvr_hv +.endr diff --git a/libavcodec/riscv/vvc/vvcdsp_init.c b/libavcodec/riscv/vvc/vvcdsp_init.c index ac1e7dda7d..7df3ce58db 100644 --- a/libavcodec/riscv/vvc/vvcdsp_init.c +++ b/libavcodec/riscv/vvc/vvcdsp_init.c @@ -37,6 +37,26 @@ void bf(ff_vvc_w_avg, bd, opt)(uint8_t *dst, ptrdiff_t dst_stride, AVG_PROTOTYPES(8, rvv_128) AVG_PROTOTYPES(8, rvv_256) +#define DMVR_PROTOTYPES(bd, opt) \ +void ff_vvc_dmvr_##bd##_##opt(int16_t *dst, const uint8_t *src, ptrdiff_t src_stride, \ + int height, intptr_t mx, intptr_t my, int width); \ +void ff_vvc_dmvr_h_##bd##_##opt(int16_t *dst, const uint8_t *src, ptrdiff_t src_stride, \ + int height, intptr_t mx, intptr_t my, int width); \ +void ff_vvc_dmvr_v_##bd##_##opt(int16_t *dst, const uint8_t *src, ptrdiff_t src_stride, \ + int height, intptr_t mx, intptr_t my, int width); \ +void ff_vvc_dmvr_hv_##bd##_##opt(int16_t *dst, const uint8_t *src, ptrdiff_t src_stride, \ + int height, intptr_t mx, intptr_t my, int width); \ + +DMVR_PROTOTYPES(8, rvv_128) +DMVR_PROTOTYPES(8, rvv_256) + +#define DMVR_INIT(bd, opt) do { \ + c->inter.dmvr[0][0] = ff_vvc_dmvr_##bd##_##opt; \ + c->inter.dmvr[0][1] = ff_vvc_dmvr_h_##bd##_##opt; \ + c->inter.dmvr[1][0] = ff_vvc_dmvr_v_##bd##_##opt; \ + c->inter.dmvr[1][1] = ff_vvc_dmvr_hv_##bd##_##opt; \ +} while (0) + void ff_vvc_dsp_init_riscv(VVCDSPContext *const c, const int bd) { #if HAVE_RVV @@ -51,6 +71,7 @@ void ff_vvc_dsp_init_riscv(VVCDSPContext *const c, const int bd) # if (__riscv_xlen == 64) c->inter.w_avg = ff_vvc_w_avg_8_rvv_256; # endif + DMVR_INIT(8, rvv_256); break; default: break; @@ -63,6 +84,7 @@ void ff_vvc_dsp_init_riscv(VVCDSPContext *const c, const int bd) # if (__riscv_xlen == 64) c->inter.w_avg = ff_vvc_w_avg_8_rvv_128; # endif + DMVR_INIT(8, rvv_128); break; default: break; -- 2.46.2

3 14

[PATCH v2] avcodec/h2645_vui: Interpret a degenerate SAR as unspecified.
by Giovanni Mascellani 26 Nov '24

26 Nov '24

The specification says that if either the numerator or the denominator is zero then the SAR is to be intended unspecified. Internally ffmpeg represents an unspecified SAR as 0/1, while fractions with a zero denominator are not handled properly; so we bridge the gap by replacing x/0 with 0/1. Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- libavcodec/h2645_vui.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libavcodec/h2645_vui.c b/libavcodec/h2645_vui.c index e5c7bf46f9..c8df733399 100644 --- a/libavcodec/h2645_vui.c +++ b/libavcodec/h2645_vui.c @@ -46,6 +46,8 @@ void ff_h2645_decode_common_vui_params(GetBitContext *gb, H2645VUI *vui, void *l else if (vui->aspect_ratio_idc == EXTENDED_SAR) { vui->sar.num = get_bits(gb, 16); vui->sar.den = get_bits(gb, 16); + if (vui->sar.den == 0) + vui->sar = (AVRational){ 0, 1 }; } else av_log(logctx, AV_LOG_WARNING, "Unknown SAR index: %u.\n", vui->aspect_ratio_idc); -- 2.45.2

1 1

[PATCH 1/2] libavcodec: various: remove empty directories originally for legacy DSP code
by Sean McGovern 26 Nov '24

26 Nov '24

--- libavcodec/bfin/README | 6 ------ libavcodec/sh4/README | 6 ------ libavcodec/sparc/README | 6 ------ 3 files changed, 18 deletions(-) delete mode 100644 libavcodec/bfin/README delete mode 100644 libavcodec/sh4/README delete mode 100644 libavcodec/sparc/README diff --git a/libavcodec/bfin/README b/libavcodec/bfin/README deleted file mode 100644 index afb3461b72..0000000000 --- a/libavcodec/bfin/README +++ /dev/null @@ -1,6 +0,0 @@ -BFIN optimizations have been removed in -commit 880e2aa23645ed9871c66ee1cbd00f93c72d2d73 -The last revission with the optimizations is fa4e17c14035ebf43130fb369e1728cdd98d0b72 - -If you want to maintain these (or other) BFIN optimizations in ffmpeg, then please -contact ffmpeg-devel(a)ffmpeg.org diff --git a/libavcodec/sh4/README b/libavcodec/sh4/README deleted file mode 100644 index 8dd61fe875..0000000000 --- a/libavcodec/sh4/README +++ /dev/null @@ -1,6 +0,0 @@ -SH4 optimizations have been removed in -commit d6096a67422534918405abb46dafbbac4608cbc3 -The last revission with the optimizations is cbfc9046e1c7e295b74f252902ae6f255eef4e78 - -If you want to maintain these (or other) SH4 optimizations in ffmpeg, then please -contact ffmpeg-devel(a)ffmpeg.org diff --git a/libavcodec/sparc/README b/libavcodec/sparc/README deleted file mode 100644 index f9f2349cd4..0000000000 --- a/libavcodec/sparc/README +++ /dev/null @@ -1,6 +0,0 @@ -SPARC optimizations have been removed in -commit b4dd424d96f09f9bafb88e47f37df65dc4529143 -The last revission with the optimizations is fb1b70c1ed50951c5fc1a309c3c446b2eaaf564b - -If you want to maintain these (or other) SPARC optimizations in ffmpeg, then please -contact ffmpeg-devel(a)ffmpeg.org -- 2.39.2

4 6

[PATCH] avcodec: deprecate sonic
by J. Dekker 25 Nov '24

25 Nov '24

This is an experimental and research codec of which ffmpeg is the only encoder and decoder, development has stalled since 2013 and these files don't exist in the wild. Deprecate the encoders to be removed next major bump, decoders to be removed one bump afterwards. We also disable the the encoders by default in configure, the decoders should be disabled by default next bump. Signed-off-by: J. Dekker <jdek(a)itanimul.li> --- Since this codec was added in 2004, there has only been one major non-maintenance, non-bugfix commit in 2013 (6026a5ad4f). That's 1 out of 107 total commits touching this file. This isn't a matter of the codec being unpopular like a niche game codec or some other codec with media found in the wild, it's an experiment which didn't continue and we continue to pay the maintenance cost. Deprecating the codec instead of immediate removal gives a grace period for anyone interested to pick up the format and make it the most advanced audio codec in FFmpeg if they so wish. It encourages an action to be taken whether that be improving the codec, or leaving it to be removed later. configure | 3 +++ libavcodec/version_major.h | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/configure b/configure index bb5e630bad..f11c035796 100755 --- a/configure +++ b/configure @@ -4234,6 +4234,9 @@ do_random(){ $action $(rand_list "$@" | awk "BEGIN { srand($random_seed) } \$1 == \"prob\" { prob = \$2; next } rand() < prob { print }") } +# deprecated components (disabled by default) +disable sonic_encoder sonic_ls_encoder + for opt do optval="${opt#*=}" case "$opt" in diff --git a/libavcodec/version_major.h b/libavcodec/version_major.h index 161442df95..97e4c47d45 100644 --- a/libavcodec/version_major.h +++ b/libavcodec/version_major.h @@ -57,5 +57,9 @@ // reminder to remove CrystalHD decoders on next major bump #define FF_CODEC_CRYSTAL_HD (LIBAVCODEC_VERSION_MAJOR < 61) +// reminder to remove Sonic Lossy/Lossless encoders on next major bump +#define FF_CODEC_SONIC_ENC (LIBAVCODEC_VERSION_MAJOR < 62) +// reminder to remove Sonic decoder on next-next major bump +#define FF_CODEC_SONIC_DEC (LIBAVCODEC_VERSION_MAJOR < 63) #endif /* AVCODEC_VERSION_MAJOR_H */ -- 2.43.2

4 4

[PATCH 1/4] avcodec/ffv1dec: Blow up if user asks for explosion
by Michael Niedermayer 16 Nov '24

16 Nov '24

Fixes: Ticket8403 Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> --- libavcodec/ffv1dec.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libavcodec/ffv1dec.c b/libavcodec/ffv1dec.c index 415c66be636..0afdeabd915 100644 --- a/libavcodec/ffv1dec.c +++ b/libavcodec/ffv1dec.c @@ -354,6 +354,9 @@ static int decode_slice(AVCodecContext *c, void *arg) } } + if (sc->slice_damaged && (f->avctx->err_recognition & AV_EF_EXPLODE)) + return AVERROR_INVALIDDATA; + if ((c->active_thread_type & FF_THREAD_FRAME) && !f->frame_damaged) ff_progress_frame_report(&f->picture, si); -- 2.46.1

1 6

[PATCHv2 1/4] avcodec/mm: set audio pts proportionally to audio offset
by Peter Ross 16 Nov '24

16 Nov '24

--- libavformat/mm.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libavformat/mm.c b/libavformat/mm.c index 23c025d852..a40b5c44bb 100644 --- a/libavformat/mm.c +++ b/libavformat/mm.c @@ -180,7 +180,8 @@ static int read_packet(AVFormatContext *s, if ((ret = av_get_packet(s->pb, pkt, length)) < 0) return ret; pkt->stream_index = 1; - pkt->pts = mm->audio_pts++; + pkt->pts = mm->audio_pts; + mm->audio_pts += length; return 0; default : -- 2.43.0 -- Peter (A907 E02F A6E5 0CD2 34CD 20D2 6760 79C5 AC40 DD6B)

2 5

[PATCH 1/5] compat: add a fallback implementation of C23 stdckdint.h
by James Almer 16 Nov '24

16 Nov '24

From: Justine Tunney <jtunney(a)gmail.com> Header contents taken from https://github.com/jart/jtckdint/commit/62df1fc0966926299253b7af46c777723e3… Signed-off-by: James Almer <jamrial(a)gmail.com> --- compat/stdckdint/stdckdint.h | 663 +++++++++++++++++++++++++++++++++++ tests/ref/fate/source | 1 + 2 files changed, 664 insertions(+) create mode 100644 compat/stdckdint/stdckdint.h diff --git a/compat/stdckdint/stdckdint.h b/compat/stdckdint/stdckdint.h new file mode 100644 index 0000000000..2d36e8ad89 --- /dev/null +++ b/compat/stdckdint/stdckdint.h @@ -0,0 +1,663 @@ +/* + * Copyright 2023 Justine Alexandra Roberts Tunney + * + * Permission to use, copy, modify, and/or distribute this software for + * any purpose with or without fee is hereby granted, provided that the + * above copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE + * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * @fileoverview C23 Checked Arithmetic + * + * This header defines three type generic functions: + * + * - `bool ckd_add(res, a, b)` + * - `bool ckd_sub(res, a, b)` + * - `bool ckd_mul(res, a, b)` + * + * Which allow integer arithmetic errors to be detected. There are many + * kinds of integer errors, e.g. overflow, truncation, etc. These funcs + * catch them all. Here's an example of how it works: + * + * uint32_t c; + * int32_t a = 0x7fffffff; + * int32_t b = 2; + * assert(!ckd_add(&c, a, b)); + * assert(c == 0x80000001u); + * + * Experienced C / C++ users should find this example counter-intuitive + * because the expression `0x7fffffff + 2` not only overflows it's also + * undefined behavior. However here we see it's specified, and does not + * result in an error. That's because C23 checked arithmetic is not the + * arithmetic you're used to. The new standard changes the mathematics. + * + * C23 checked arithmetic is defined as performing the arithmetic using + * infinite precision and then checking if the resulting value will fit + * in the output type. Our example above did not result in an error due + * to `0x80000001` being a legal value for `uint32_t`. + * + * This implementation will use the GNU compiler builtins, when they're + * available, only if you don't use build flags like `-std=c11` because + * they define `__STRICT_ANSI__` and GCC extensions aren't really ANSI. + * Instead, you'll get a pretty good pure C11 and C++11 implementation. + * + * @see https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3096.pdf + * @version 0.1 (2023-07-22) + */ + +#ifndef JTCKDINT_H_ +#define JTCKDINT_H_ + +#ifdef __has_include +#define __ckd_has_include(x) __has_include(x) +#else +#define __ckd_has_include(x) 0 +#endif + +#if __ckd_has_include(<stdckdint.h>) +#include <stdckdint.h> +#else + +#define __STDC_VERSION_STDCKDINT_H__ 202311L + +#if ((defined(__llvm__) || \ + (defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ >= 406)) && \ + !defined(__STRICT_ANSI__)) +#define __ckd_have_int128 +#define __ckd_intmax __int128 +#elif ((defined(__cplusplus) && __cplusplus >= 201103L) || \ + (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)) +#define __ckd_intmax long long +#else +#define __ckd_intmax long +#endif + +typedef signed __ckd_intmax __ckd_intmax_t; +typedef unsigned __ckd_intmax __ckd_uintmax_t; + +#ifdef __has_builtin +#define __ckd_has_builtin(x) __has_builtin(x) +#else +#define __ckd_has_builtin(x) 0 +#endif + +#if (!defined(__STRICT_ANSI__) && \ + ((defined(__GNUC__) && __GNUC__ >= 5 && !defined(__ICC)) || \ + (__ckd_has_builtin(__builtin_add_overflow) && \ + __ckd_has_builtin(__builtin_sub_overflow) && \ + __ckd_has_builtin(__builtin_mul_overflow)))) +#define ckd_add(res, x, y) __builtin_add_overflow((x), (y), (res)) +#define ckd_sub(res, x, y) __builtin_sub_overflow((x), (y), (res)) +#define ckd_mul(res, x, y) __builtin_mul_overflow((x), (y), (res)) + +#elif (defined(__cplusplus) && \ + (__cplusplus >= 201103L || \ + (defined(_MSC_VER) && __cplusplus >= 199711L && \ + __ckd_has_include(<type_traits>) && \ + __ckd_has_include(<limits>)))) +#include <type_traits> +#include <limits> + +template <typename __T, typename __U, typename __V> +inline bool ckd_add(__T *__res, __U __a, __V __b) { + static_assert(std::is_integral<__T>::value && + std::is_integral<__U>::value && + std::is_integral<__V>::value, + "non-integral types not allowed"); + static_assert(!std::is_same<__T, bool>::value && + !std::is_same<__U, bool>::value && + !std::is_same<__V, bool>::value, + "checked booleans not supported"); + static_assert(!std::is_same<__T, char>::value && + !std::is_same<__U, char>::value && + !std::is_same<__V, char>::value, + "unqualified char type is ambiguous"); + __ckd_uintmax_t __x = __a; + __ckd_uintmax_t __y = __b; + __ckd_uintmax_t __z = __x + __y; + *__res = __z; + if (sizeof(__z) > sizeof(__U) && sizeof(__z) > sizeof(__V)) { + if (sizeof(__z) > sizeof(__T) || std::is_signed<__T>::value) { + return static_cast<__ckd_intmax_t>(__z) != static_cast<__T>(__z); + } else if (!std::is_same<__T, __ckd_uintmax_t>::value) { + return (__z != static_cast<__T>(__z) || + ((std::is_signed<__U>::value || + std::is_signed<__V>::value) && + static_cast<__ckd_intmax_t>(__z) < 0)); + } + } + bool __truncated = false; + if (sizeof(__T) < sizeof(__ckd_intmax_t)) { + __truncated = __z != static_cast<__ckd_uintmax_t>(static_cast<__T>(__z)); + } + switch (std::is_signed<__T>::value << 2 | // + std::is_signed<__U>::value << 1 | // + std::is_signed<__V>::value) { + case 0: // u = u + u + return __truncated | (__z < __x); + case 1: // u = u + s + __y ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | + (static_cast<__ckd_intmax_t>((__z ^ __x) & + (__z ^ __y)) < 0); + case 2: // u = s + u + __x ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | + (static_cast<__ckd_intmax_t>((__z ^ __x) & + (__z ^ __y)) < 0); + case 3: // u = s + s + return __truncated | + (static_cast<__ckd_intmax_t>(((__z | __x) & __y) | + ((__z & __x) & ~__y)) < 0); + case 4: // s = u + u + return __truncated | (__z < __x) | (static_cast<__ckd_intmax_t>(__z) < 0); + case 5: // s = u + s + __y ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | (__x + __y < __y); + case 6: // s = s + u + __x ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | (__x + __y < __x); + case 7: // s = s + s + return __truncated | + (static_cast<__ckd_intmax_t>((__z ^ __x) & + (__z ^ __y)) < 0); + default: + for (;;) (void)0; + } +} + +template <typename __T, typename __U, typename __V> +inline bool ckd_sub(__T *__res, __U __a, __V __b) { + static_assert(std::is_integral<__T>::value && + std::is_integral<__U>::value && + std::is_integral<__V>::value, + "non-integral types not allowed"); + static_assert(!std::is_same<__T, bool>::value && + !std::is_same<__U, bool>::value && + !std::is_same<__V, bool>::value, + "checked booleans not supported"); + static_assert(!std::is_same<__T, char>::value && + !std::is_same<__U, char>::value && + !std::is_same<__V, char>::value, + "unqualified char type is ambiguous"); + __ckd_uintmax_t __x = __a; + __ckd_uintmax_t __y = __b; + __ckd_uintmax_t __z = __x - __y; + *__res = __z; + if (sizeof(__z) > sizeof(__U) && sizeof(__z) > sizeof(__V)) { + if (sizeof(__z) > sizeof(__T) || std::is_signed<__T>::value) { + return static_cast<__ckd_intmax_t>(__z) != static_cast<__T>(__z); + } else if (!std::is_same<__T, __ckd_uintmax_t>::value) { + return (__z != static_cast<__T>(__z) || + ((std::is_signed<__U>::value || + std::is_signed<__V>::value) && + static_cast<__ckd_intmax_t>(__z) < 0)); + } + } + bool __truncated = false; + if (sizeof(__T) < sizeof(__ckd_intmax_t)) { + __truncated = __z != static_cast<__ckd_uintmax_t>(static_cast<__T>(__z)); + } + switch (std::is_signed<__T>::value << 2 | // + std::is_signed<__U>::value << 1 | // + std::is_signed<__V>::value) { + case 0: // u = u - u + return __truncated | (__x < __y); + case 1: // u = u - s + __y ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | + (static_cast<__ckd_intmax_t>((__x ^ __y) & + (__z ^ __x)) < 0); + case 2: // u = s - u + return __truncated | (__y > __x) | (static_cast<__ckd_intmax_t>(__x) < 0); + case 3: // u = s - s + return __truncated | + (static_cast<__ckd_intmax_t>(((__z & __x) & __y) | + ((__z | __x) & ~__y)) < 0); + case 4: // s = u - u + return __truncated | + ((__x < __y) ^ (static_cast<__ckd_intmax_t>(__z) < 0)); + case 5: // s = u - s + __y ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | (__x >= __y); + case 6: // s = s - u + __x ^= std::numeric_limits<__ckd_intmax_t>::min(); + return __truncated | (__x < __y); + case 7: // s = s - s + return __truncated | + (static_cast<__ckd_intmax_t>((__x ^ __y) & + (__z ^ __x)) < 0); + default: + for (;;) (void)0; + } +} + +template <typename __T, typename __U, typename __V> +inline bool ckd_mul(__T *__res, __U __a, __V __b) { + static_assert(std::is_integral<__T>::value && + std::is_integral<__U>::value && + std::is_integral<__V>::value, + "non-integral types not allowed"); + static_assert(!std::is_same<__T, bool>::value && + !std::is_same<__U, bool>::value && + !std::is_same<__V, bool>::value, + "checked booleans not supported"); + static_assert(!std::is_same<__T, char>::value && + !std::is_same<__U, char>::value && + !std::is_same<__V, char>::value, + "unqualified char type is ambiguous"); + __ckd_uintmax_t __x = __a; + __ckd_uintmax_t __y = __b; + if ((sizeof(__U) * 8 - std::is_signed<__U>::value) + + (sizeof(__V) * 8 - std::is_signed<__V>::value) <= + (sizeof(__T) * 8 - std::is_signed<__T>::value)) { + if (sizeof(__ckd_uintmax_t) > sizeof(__T) || std::is_signed<__T>::value) { + __ckd_intmax_t __z = __x * __y; + return __z != (*__res = __z); + } else if (!std::is_same<__T, __ckd_uintmax_t>::value) { + __ckd_uintmax_t __z = __x * __y; + *__res = __z; + return (__z != static_cast<__T>(__z) || + ((std::is_signed<__U>::value || + std::is_signed<__V>::value) && + static_cast<__ckd_intmax_t>(__z) < 0)); + } + } + switch (std::is_signed<__T>::value << 2 | // + std::is_signed<__U>::value << 1 | // + std::is_signed<__V>::value) { + case 0: { // u = u * u + __ckd_uintmax_t __z = __x * __y; + int __o = __x && __z / __x != __y; + *__res = __z; + return __o | (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res)); + } + case 1: { // u = u * s + __ckd_uintmax_t __z = __x * __y; + int __o = __x && __z / __x != __y; + *__res = __z; + return (__o | ((static_cast<__ckd_intmax_t>(__y) < 0) & !!__x) | + (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res))); + } + case 2: { // u = s * u + __ckd_uintmax_t __z = __x * __y; + int __o = __x && __z / __x != __y; + *__res = __z; + return (__o | ((static_cast<__ckd_intmax_t>(__x) < 0) & !!__y) | + (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res))); + } + case 3: { // u = s * s + int __o = false; + if (static_cast<__ckd_intmax_t>(__x & __y) < 0) { + __x = -__x; + __y = -__y; + } else if (static_cast<__ckd_intmax_t>(__x ^ __y) < 0) { + __o = __x && __y; + } + __ckd_uintmax_t __z = __x * __y; + __o |= __x && __z / __x != __y; + *__res = __z; + return __o | (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res)); + } + case 4: { // s = u * u + __ckd_uintmax_t __z = __x * __y; + int __o = __x && __z / __x != __y; + *__res = __z; + return (__o | (static_cast<__ckd_intmax_t>(__z) < 0) | + (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res))); + } + case 5: { // s = u * s + __ckd_uintmax_t __t = -__y; + __t = static_cast<__ckd_intmax_t>(__t) < 0 ? __y : __t; + __ckd_uintmax_t __p = __t * __x; + int __o = __t && __p / __t != __x; + int __n = static_cast<__ckd_intmax_t>(__y) < 0; + __ckd_uintmax_t __z = __n ? -__p : __p; + *__res = __z; + __ckd_uintmax_t __m = std::numeric_limits<__ckd_intmax_t>::max(); + return (__o | (__p > __m + __n) | + (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res))); + } + case 6: { // s = s * u + __ckd_uintmax_t __t = -__x; + __t = static_cast<__ckd_intmax_t>(__t) < 0 ? __x : __t; + __ckd_uintmax_t __p = __t * __y; + int __o = __t && __p / __t != __y; + int __n = static_cast<__ckd_intmax_t>(__x) < 0; + __ckd_uintmax_t __z = __n ? -__p : __p; + *__res = __z; + __ckd_uintmax_t __m = std::numeric_limits<__ckd_intmax_t>::max(); + return (__o | (__p > __m + __n) | + (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res))); + } + case 7: { // s = s * s + __ckd_uintmax_t __z = __x * __y; + *__res = __z; + return ((((static_cast<__ckd_intmax_t>(__y) < 0) && + (static_cast<__ckd_intmax_t>(__x) == + std::numeric_limits<__ckd_intmax_t>::min())) || + (__y && ((static_cast<__ckd_intmax_t>(__z) / + static_cast<__ckd_intmax_t>(__y)) != + static_cast<__ckd_intmax_t>(__x)))) | + (sizeof(__T) < sizeof(__z) && + __z != static_cast<__ckd_uintmax_t>(*__res))); + } + default: + for (;;) (void)0; + } +} + +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + +#define ckd_add(res, a, b) __ckd_expr(add, (res), (a), (b)) +#define ckd_sub(res, a, b) __ckd_expr(sub, (res), (a), (b)) +#define ckd_mul(res, a, b) __ckd_expr(mul, (res), (a), (b)) + +#if defined(__GNUC__) || defined(__llvm__) +#define __ckd_inline \ + extern __inline __attribute__((__gnu_inline__, \ + __always_inline__, \ + __artificial__)) +#else +#define __ckd_inline static inline +#endif + +#ifdef __ckd_have_int128 +#define __ckd_generic_int128(x, y) , signed __int128: x, unsigned __int128: y +#else +#define __ckd_generic_int128(x, y) +#endif + +#define __ckd_sign(T) \ + ((T)1 << (sizeof(T) * 8 - 1)) + +#define __ckd_is_signed(x) \ + _Generic(x, \ + signed char: 1, \ + unsigned char: 0, \ + signed short: 1, \ + unsigned short: 0, \ + signed int: 1, \ + unsigned int: 0, \ + signed long: 1, \ + unsigned long: 0, \ + signed long long: 1, \ + unsigned long long: 0 \ + __ckd_generic_int128(1, 0)) + +#define __ckd_expr(op, res, a, b) \ + (_Generic(*res, \ + signed char: __ckd_##op##_schar, \ + unsigned char: __ckd_##op##_uchar, \ + signed short: __ckd_##op##_sshort, \ + unsigned short: __ckd_##op##_ushort, \ + signed int: __ckd_##op##_sint, \ + unsigned int: __ckd_##op##_uint, \ + signed long: __ckd_##op##_slong, \ + unsigned long: __ckd_##op##_ulong, \ + signed long long: __ckd_##op##_slonger, \ + unsigned long long: __ckd_##op##_ulonger \ + __ckd_generic_int128( \ + __ckd_##op##_sint128, \ + __ckd_##op##_uint128))( \ + res, a, b, \ + __ckd_is_signed(a), \ + __ckd_is_signed(b))) + +#define __ckd_declare_add(S, T) \ + __ckd_inline char S(void *__res, \ + __ckd_uintmax_t __x, \ + __ckd_uintmax_t __y, \ + char __a_signed, \ + char __b_signed) { \ + __ckd_uintmax_t __z = __x + __y; \ + *(T *)__res = __z; \ + char __truncated = 0; \ + if (sizeof(T) < sizeof(__ckd_intmax_t)) { \ + __truncated = __z != (__ckd_uintmax_t)(T)__z; \ + } \ + switch (__ckd_is_signed((T)0) << 2 | \ + __a_signed << 1 | __b_signed) { \ + case 0: /* u = u + u */ \ + return __truncated | (__z < __x); \ + case 1: /* u = u + s */ \ + __y ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | \ + ((__ckd_intmax_t)((__z ^ __x) & \ + (__z ^ __y)) < 0); \ + case 2: /* u = s + u */ \ + __x ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | \ + ((__ckd_intmax_t)((__z ^ __x) & \ + (__z ^ __y)) < 0); \ + case 3: /* u = s + s */ \ + return __truncated | \ + ((__ckd_intmax_t)(((__z | __x) & __y) | \ + ((__z & __x) & ~__y)) < 0); \ + case 4: /* s = u + u */ \ + return __truncated | (__z < __x) | ((__ckd_intmax_t)__z < 0); \ + case 5: /* s = u + s */ \ + __y ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | (__x + __y < __y); \ + case 6: /* s = s + u */ \ + __x ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | (__x + __y < __x); \ + case 7: /* s = s + s */ \ + return __truncated | \ + ((__ckd_intmax_t)((__z ^ __x) & \ + (__z ^ __y)) < 0); \ + default: \ + for (;;) (void)0; \ + } \ + } + +__ckd_declare_add(__ckd_add_schar, signed char) +__ckd_declare_add(__ckd_add_uchar, unsigned char) +__ckd_declare_add(__ckd_add_sshort, signed short) +__ckd_declare_add(__ckd_add_ushort, unsigned short) +__ckd_declare_add(__ckd_add_sint, signed int) +__ckd_declare_add(__ckd_add_uint, unsigned int) +__ckd_declare_add(__ckd_add_slong, signed long) +__ckd_declare_add(__ckd_add_ulong, unsigned long) +__ckd_declare_add(__ckd_add_slonger, signed long long) +__ckd_declare_add(__ckd_add_ulonger, unsigned long long) +#ifdef __ckd_have_int128 +__ckd_declare_add(__ckd_add_sint128, signed __int128) +__ckd_declare_add(__ckd_add_uint128, unsigned __int128) +#endif + +#define __ckd_declare_sub(S, T) \ + __ckd_inline char S(void *__res, \ + __ckd_uintmax_t __x, \ + __ckd_uintmax_t __y, \ + char __a_signed, \ + char __b_signed) { \ + __ckd_uintmax_t __z = __x - __y; \ + *(T *)__res = __z; \ + char __truncated = 0; \ + if (sizeof(T) < sizeof(__ckd_intmax_t)) { \ + __truncated = __z != (__ckd_uintmax_t)(T)__z; \ + } \ + switch (__ckd_is_signed((T)0) << 2 | \ + __a_signed << 1 | __b_signed) { \ + case 0: /* u = u - u */ \ + return __truncated | (__x < __y); \ + case 1: /* u = u - s */ \ + __y ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | \ + ((__ckd_intmax_t)((__x ^ __y) & \ + (__z ^ __x)) < 0); \ + case 2: /* u = s - u */ \ + return __truncated | (__y > __x) | ((__ckd_intmax_t)__x < 0); \ + case 3: /* u = s - s */ \ + return __truncated | \ + ((__ckd_intmax_t)(((__z & __x) & __y) | \ + ((__z | __x) & ~__y)) < 0); \ + case 4: /* s = u - u */ \ + return __truncated | ((__x < __y) ^ ((__ckd_intmax_t)__z < 0)); \ + case 5: /* s = u - s */ \ + __y ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | (__x >= __y); \ + case 6: /* s = s - u */ \ + __x ^= __ckd_sign(__ckd_uintmax_t); \ + return __truncated | (__x < __y); \ + case 7: /* s = s - s */ \ + return __truncated | \ + ((__ckd_intmax_t)((__x ^ __y) & \ + (__z ^ __x)) < 0); \ + default: \ + for (;;) (void)0; \ + } \ + } + +__ckd_declare_sub(__ckd_sub_schar, signed char) +__ckd_declare_sub(__ckd_sub_uchar, unsigned char) +__ckd_declare_sub(__ckd_sub_sshort, signed short) +__ckd_declare_sub(__ckd_sub_ushort, unsigned short) +__ckd_declare_sub(__ckd_sub_sint, signed int) +__ckd_declare_sub(__ckd_sub_uint, unsigned int) +__ckd_declare_sub(__ckd_sub_slong, signed long) +__ckd_declare_sub(__ckd_sub_ulong, unsigned long) +__ckd_declare_sub(__ckd_sub_slonger, signed long long) +__ckd_declare_sub(__ckd_sub_ulonger, unsigned long long) +#ifdef __ckd_have_int128 +__ckd_declare_sub(__ckd_sub_sint128, signed __int128) +__ckd_declare_sub(__ckd_sub_uint128, unsigned __int128) +#endif + +#define __ckd_declare_mul(S, T) \ + __ckd_inline char S(void *__res, \ + __ckd_uintmax_t __x, \ + __ckd_uintmax_t __y, \ + char __a_signed, \ + char __b_signed) { \ + switch (__ckd_is_signed((T)0) << 2 | \ + __a_signed << 1 | __b_signed) { \ + case 0: { /* u = u * u */ \ + __ckd_uintmax_t __z = __x * __y; \ + int __o = __x && __z / __x != __y; \ + *(T *)__res = __z; \ + return __o | (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res); \ + } \ + case 1: { /* u = u * s */ \ + __ckd_uintmax_t __z = __x * __y; \ + int __o = __x && __z / __x != __y; \ + *(T *)__res = __z; \ + return (__o | (((__ckd_intmax_t)__y < 0) & !!__x) | \ + (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res)); \ + } \ + case 2: { /* u = s * u */ \ + __ckd_uintmax_t __z = __x * __y; \ + int __o = __x && __z / __x != __y; \ + *(T *)__res = __z; \ + return (__o | (((__ckd_intmax_t)__x < 0) & !!__y) | \ + (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res)); \ + } \ + case 3: { /* u = s * s */ \ + int __o = 0; \ + if ((__ckd_intmax_t)(__x & __y) < 0) { \ + __x = -__x; \ + __y = -__y; \ + } else if ((__ckd_intmax_t)(__x ^ __y) < 0) { \ + __o = __x && __y; \ + } \ + __ckd_uintmax_t __z = __x * __y; \ + __o |= __x && __z / __x != __y; \ + *(T *)__res = __z; \ + return __o | (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res); \ + } \ + case 4: { /* s = u * u */ \ + __ckd_uintmax_t __z = __x * __y; \ + int __o = __x && __z / __x != __y; \ + *(T *)__res = __z; \ + return (__o | ((__ckd_intmax_t)(__z) < 0) | \ + (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res)); \ + } \ + case 5: { /* s = u * s */ \ + __ckd_uintmax_t __t = -__y; \ + __t = (__ckd_intmax_t)(__t) < 0 ? __y : __t; \ + __ckd_uintmax_t __p = __t * __x; \ + int __o = __t && __p / __t != __x; \ + int __n = (__ckd_intmax_t)__y < 0; \ + __ckd_uintmax_t __z = __n ? -__p : __p; \ + *(T *)__res = __z; \ + __ckd_uintmax_t __m = __ckd_sign(__ckd_uintmax_t) - 1; \ + return (__o | (__p > __m + __n) | \ + (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res)); \ + } \ + case 6: { /* s = s * u */ \ + __ckd_uintmax_t __t = -__x; \ + __t = (__ckd_intmax_t)(__t) < 0 ? __x : __t; \ + __ckd_uintmax_t __p = __t * __y; \ + int __o = __t && __p / __t != __y; \ + int __n = (__ckd_intmax_t)__x < 0; \ + __ckd_uintmax_t __z = __n ? -__p : __p; \ + *(T *)__res = __z; \ + __ckd_uintmax_t __m = __ckd_sign(__ckd_uintmax_t) - 1; \ + return (__o | (__p > __m + __n) | \ + (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res)); \ + } \ + case 7: { /* s = s * s */ \ + __ckd_uintmax_t __z = __x * __y; \ + *(T *)__res = __z; \ + return (((((__ckd_intmax_t)__y < 0) && \ + (__x == __ckd_sign(__ckd_uintmax_t))) || \ + (__y && (((__ckd_intmax_t)__z / \ + (__ckd_intmax_t)__y) != \ + (__ckd_intmax_t)__x))) | \ + (sizeof(T) < sizeof(__z) && \ + __z != (__ckd_uintmax_t)*(T *)__res)); \ + } \ + default: \ + for (;;) (void)0; \ + } \ + } + +__ckd_declare_mul(__ckd_mul_schar, signed char) +__ckd_declare_mul(__ckd_mul_uchar, unsigned char) +__ckd_declare_mul(__ckd_mul_sshort, signed short) +__ckd_declare_mul(__ckd_mul_ushort, unsigned short) +__ckd_declare_mul(__ckd_mul_sint, signed int) +__ckd_declare_mul(__ckd_mul_uint, unsigned int) +__ckd_declare_mul(__ckd_mul_slong, signed long) +__ckd_declare_mul(__ckd_mul_ulong, unsigned long) +__ckd_declare_mul(__ckd_mul_slonger, signed long long) +__ckd_declare_mul(__ckd_mul_ulonger, unsigned long long) +#ifdef __ckd_have_int128 +__ckd_declare_mul(__ckd_mul_sint128, signed __int128) +__ckd_declare_mul(__ckd_mul_uint128, unsigned __int128) +#endif + +#else +#pragma message "checked integer arithmetic unsupported in this environment" + +#define ckd_add(res, x, y) (*(res) = (x) + (y), 0) +#define ckd_sub(res, x, y) (*(res) = (x) - (y), 0) +#define ckd_mul(res, x, y) (*(res) = (x) * (y), 0) + +#endif /* GNU */ +#endif /* stdckdint.h */ +#endif /* JTCKDINT_H_ */ diff --git a/tests/ref/fate/source b/tests/ref/fate/source index 78d3a2e0fa..ab6182bf4c 100644 --- a/tests/ref/fate/source +++ b/tests/ref/fate/source @@ -25,6 +25,7 @@ compat/djgpp/math.h compat/float/float.h compat/float/limits.h compat/stdbit/stdbit.h +compat/stdckdint/stdckdint.h libavcodec/bitstream_template.h tools/decode_simple.h Use of av_clip() where av_clip_uintp2() could be used: -- 2.46.1

4 9

[PATCH 01/22] avformat/asfdec_o: Check size of index object
by Michael Niedermayer 15 Nov '24

15 Nov '24

We subtract 24 so it must be at least 24 Fixes: CID1604482 Overflowed constant Sponsored-by: Sovereign Tech Fund Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> --- libavformat/asfdec_o.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libavformat/asfdec_o.c b/libavformat/asfdec_o.c index dfe448e9f7e..dd187e600d0 100644 --- a/libavformat/asfdec_o.c +++ b/libavformat/asfdec_o.c @@ -867,6 +867,9 @@ static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g) int64_t offset; uint64_t size = avio_rl64(pb); + if (size < 24) + return AVERROR_INVALIDDATA; + // simple index objects should be ordered by stream number, this loop tries to find // the first not indexed video stream for (i = 0; i < asf->nb_streams; i++) { -- 2.45.2

3 25

[PATCH] avformat/vpk: fix divide by zero
by Kacper Michajłow 09 Nov '24

09 Nov '24

Can happen after calling avformat_find_stream_info() when the codec fails to open, but return value is 0 and subsequent uses of this context have zero value in channel number. Found by OSS-Fuzz. Signed-off-by: Kacper Michajłow <kasper93(a)gmail.com> --- libavformat/vpk.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libavformat/vpk.c b/libavformat/vpk.c index 001ad33555..aa98ef2dd4 100644 --- a/libavformat/vpk.c +++ b/libavformat/vpk.c @@ -86,6 +86,8 @@ static int vpk_read_packet(AVFormatContext *s, AVPacket *pkt) vpk->current_block++; if (vpk->current_block == vpk->block_count) { + if (par->ch_layout.nb_channels <= 0) + return AVERROR_INVALIDDATA; unsigned size = vpk->last_block_size / par->ch_layout.nb_channels; unsigned skip = (par->block_align - vpk->last_block_size) / par->ch_layout.nb_channels; uint64_t pos = avio_tell(s->pb); -- 2.43.0

4 8

[PATCH] lavc/vvc: Remove experimental flag
by Frank Plowman 08 Nov '24

08 Nov '24

This reverts commit 110d8549d575aae6b2f627cd63e2eb7082ab8926. I have been working through fixing bugs, particularly crashes I've found using a fuzzer, in the VVC decoder for the past few months. While I won't claim it is now bug-free, it is considerably more resilient than it was and I think in a position to have the experimental flag removed for release 7.1. Additionally, most of the Main 10 features of VVC which were missing version of the decoder released in 7.0 have now been implemented. This includes the most major missing features: IBC, subpictures and RPR. Signed-off-by: Frank Plowman <post(a)frankplowman.com> --- libavcodec/vvc/dec.c | 3 +-- tests/fate/vvc.mak | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/libavcodec/vvc/dec.c b/libavcodec/vvc/dec.c index 2c80f0c461..edf2607f50 100644 --- a/libavcodec/vvc/dec.c +++ b/libavcodec/vvc/dec.c @@ -1108,8 +1108,7 @@ const FFCodec ff_vvc_decoder = { .close = vvc_decode_free, FF_CODEC_DECODE_CB(vvc_decode_frame), .flush = vvc_decode_flush, - .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS | - AV_CODEC_CAP_EXPERIMENTAL, + .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS, .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING | FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS, .p.profiles = NULL_IF_CONFIG_SMALL(ff_vvc_profiles), diff --git a/tests/fate/vvc.mak b/tests/fate/vvc.mak index 3e762ec65e..5335460263 100644 --- a/tests/fate/vvc.mak +++ b/tests/fate/vvc.mak @@ -41,7 +41,7 @@ $(foreach VAR,$(FATE_VVC_VARS), $(eval VVC_TESTS_$(VAR) := $(addprefix fate-vvc- $(VVC_TESTS_8BIT): SCALE_OPTS := -pix_fmt yuv420p $(VVC_TESTS_10BIT): SCALE_OPTS := -pix_fmt yuv420p10le -vf scale $(VVC_TESTS_444_10BIT): SCALE_OPTS := -pix_fmt yuv444p10le -vf scale -fate-vvc-conformance-%: CMD = framecrc -c:v vvc -strict experimental -i $(TARGET_SAMPLES)/vvc-conformance/$(subst fate-vvc-conformance-,,$((a))).bit $(SCALE_OPTS) +fate-vvc-conformance-%: CMD = framecrc -c:v vvc -i $(TARGET_SAMPLES)/vvc-conformance/$(subst fate-vvc-conformance-,,$((a))).bit $(SCALE_OPTS) FATE_VVC-$(call FRAMECRC, VVC, VVC, VVC_PARSER) += $(VVC_TESTS_8BIT) FATE_VVC-$(call FRAMECRC, VVC, VVC, VVC_PARSER SCALE_FILTER) += \ -- 2.46.0

4 8