June 2022 - ffmpeg-cvslog - lists.ffmpeg.org

checkasm: Provide enough alignment in the new motion test
by Martin Storsjö 28 Jun '22

28 Jun '22

ffmpeg | branch: master | Martin Storsjö <martin(a)martin.st> | Tue Jun 28 13:16:44 2022 +0300| [900424cda97082a0f0a4ed9ae6b081d2cef557d7] | committer: Martin Storsjö checkasm: Provide enough alignment in the new motion test This fixes the checkasm test in some setups on x86. Signed-off-by: Martin Storsjö <martin(a)martin.st> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=900424cda97082a0f… --- tests/checkasm/motion.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/checkasm/motion.c b/tests/checkasm/motion.c index f337dd6f95..0112822174 100644 --- a/tests/checkasm/motion.c +++ b/tests/checkasm/motion.c @@ -48,8 +48,8 @@ static void test_motion(const char *name, me_cmp_func test_func) int i, x, y, d1, d2; uint8_t *ptr; - LOCAL_ALIGNED_8(uint8_t, img1, [WIDTH * HEIGHT]); - LOCAL_ALIGNED_8(uint8_t, img2, [WIDTH * HEIGHT]); + LOCAL_ALIGNED_16(uint8_t, img1, [WIDTH * HEIGHT]); + LOCAL_ALIGNED_16(uint8_t, img2, [WIDTH * HEIGHT]); declare_func_emms(AV_CPU_FLAG_MMX, int, struct MpegEncContext *c, uint8_t *blk1 /* align width (8 or 16) */,

1 0

avutil/wchar_filename: Make the header C++ compatible
by Andreas Rheinhardt 28 Jun '22

28 Jun '22

ffmpeg | branch: master | Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> | Tue Jun 28 06:24:17 2022 +0200| [4454142782bd3db769939e63ea0f2e5e917dc29d] | committer: Andreas Rheinhardt avutil/wchar_filename: Make the header C++ compatible When compiling decklink, this header is included from a C++ file (albeit inside 'extern "C"') and this causes compilation failures because of an implicit void* -> char* conversion. So add an explicit cast. Fixes ticket #9819. Reviewed-by: Martin Storsjö <martin(a)martin.st> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt(a)outlook.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=4454142782bd3db76… --- libavutil/wchar_filename.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libavutil/wchar_filename.h b/libavutil/wchar_filename.h index 08de073ed7..9a04a069f1 100644 --- a/libavutil/wchar_filename.h +++ b/libavutil/wchar_filename.h @@ -54,7 +54,7 @@ static inline int wchartocp(unsigned int code_page, const wchar_t *filename_w, *filename = NULL; return 0; } - *filename = av_malloc_array(num_chars, sizeof *filename); + *filename = (char*)av_malloc_array(num_chars, sizeof *filename); if (!*filename) { errno = ENOMEM; return -1;

1 0

lavc/aarch64: motion estimation functions in neon
by Swinney, Jonathan 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Swinney, Jonathan <jswinney(a)amazon.com> | Sun Jun 26 20:58:09 2022 +0000| [c471cc74747461ca166559c7b7fdfe030c3e3712] | committer: Martin Storsjö lavc/aarch64: motion estimation functions in neon - ff_pix_abs16_neon - ff_pix_abs16_xy2_neon In direct micro benchmarks of these ff functions verses their C implementations, these functions performed as follows on AWS Graviton 3. ff_pix_abs16_neon: pix_abs_0_0_c: 141.1 pix_abs_0_0_neon: 19.6 ff_pix_abs16_xy2_neon: pix_abs_0_3_c: 269.1 pix_abs_0_3_neon: 39.3 Tested with: ./tests/checkasm/checkasm --test=motion --bench --disable-linux-perf Signed-off-by: Jonathan Swinney <jswinney(a)amazon.com> Signed-off-by: Martin Storsjö <martin(a)martin.st> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=c471cc74747461ca1… --- libavcodec/aarch64/Makefile | 2 + libavcodec/aarch64/me_cmp_init_aarch64.c | 39 ++++++ libavcodec/aarch64/me_cmp_neon.S | 205 +++++++++++++++++++++++++++++++ libavcodec/me_cmp.c | 4 +- libavcodec/me_cmp.h | 1 + tests/checkasm/Makefile | 1 + tests/checkasm/checkasm.c | 3 + tests/checkasm/checkasm.h | 1 + tests/checkasm/motion.c | 151 +++++++++++++++++++++++ tests/fate/checkasm.mak | 1 + 10 files changed, 407 insertions(+), 1 deletion(-) diff --git a/libavcodec/aarch64/Makefile b/libavcodec/aarch64/Makefile index c8935f205e..9ce21566c6 100644 --- a/libavcodec/aarch64/Makefile +++ b/libavcodec/aarch64/Makefile @@ -7,6 +7,7 @@ OBJS-$(CONFIG_H264PRED) += aarch64/h264pred_init.o OBJS-$(CONFIG_H264QPEL) += aarch64/h264qpel_init_aarch64.o OBJS-$(CONFIG_HPELDSP) += aarch64/hpeldsp_init_aarch64.o OBJS-$(CONFIG_IDCTDSP) += aarch64/idctdsp_init_aarch64.o +OBJS-$(CONFIG_ME_CMP) += aarch64/me_cmp_init_aarch64.o OBJS-$(CONFIG_MPEGAUDIODSP) += aarch64/mpegaudiodsp_init.o OBJS-$(CONFIG_NEON_CLOBBER_TEST) += aarch64/neontest.o OBJS-$(CONFIG_PIXBLOCKDSP) += aarch64/pixblockdsp_init_aarch64.o @@ -47,6 +48,7 @@ NEON-OBJS-$(CONFIG_HPELDSP) += aarch64/hpeldsp_neon.o NEON-OBJS-$(CONFIG_IDCTDSP) += aarch64/idctdsp_neon.o \ aarch64/simple_idct_neon.o NEON-OBJS-$(CONFIG_MDCT) += aarch64/mdct_neon.o +NEON-OBJS-$(CONFIG_ME_CMP) += aarch64/me_cmp_neon.o NEON-OBJS-$(CONFIG_MPEGAUDIODSP) += aarch64/mpegaudiodsp_neon.o NEON-OBJS-$(CONFIG_PIXBLOCKDSP) += aarch64/pixblockdsp_neon.o NEON-OBJS-$(CONFIG_VC1DSP) += aarch64/vc1dsp_neon.o diff --git a/libavcodec/aarch64/me_cmp_init_aarch64.c b/libavcodec/aarch64/me_cmp_init_aarch64.c new file mode 100644 index 0000000000..9fb63e9973 --- /dev/null +++ b/libavcodec/aarch64/me_cmp_init_aarch64.c @@ -0,0 +1,39 @@ +/* + * 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 + */ + +#include <stdint.h> + +#include "config.h" +#include "libavutil/attributes.h" +#include "libavutil/aarch64/cpu.h" +#include "libavcodec/mpegvideo.h" + +int ff_pix_abs16_neon(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2, + ptrdiff_t stride, int h); +int ff_pix_abs16_xy2_neon(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2, + ptrdiff_t stride, int h); + +av_cold void ff_me_cmp_init_aarch64(MECmpContext *c, AVCodecContext *avctx) +{ + int cpu_flags = av_get_cpu_flags(); + + if (have_neon(cpu_flags)) { + c->pix_abs[0][0] = ff_pix_abs16_neon; + c->pix_abs[0][3] = ff_pix_abs16_xy2_neon; + } +} diff --git a/libavcodec/aarch64/me_cmp_neon.S b/libavcodec/aarch64/me_cmp_neon.S new file mode 100644 index 0000000000..a7937bd8be --- /dev/null +++ b/libavcodec/aarch64/me_cmp_neon.S @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2022 Jonathan Swinney <jswinney(a)amazon.com> + * + * 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 + */ + +#include "libavutil/aarch64/asm.S" + +function ff_pix_abs16_neon, export=1 + // x0 unused + // x1 uint8_t *pix1 + // x2 uint8_t *pix2 + // x3 ptrdiff_t stride + // w4 int h + cmp w4, #4 // if h < 4, jump to completion section + movi v18.4S, #0 // clear result accumulator + b.lt 2f +1: + ld1 {v0.16b}, [x1], x3 // load pix1 + ld1 {v4.16b}, [x2], x3 // load pix2 + ld1 {v1.16b}, [x1], x3 // load pix1 + ld1 {v5.16b}, [x2], x3 // load pix2 + uabdl v16.8h, v0.8b, v4.8b // absolute difference accumulate + uabdl2 v17.8h, v0.16b, v4.16b + ld1 {v2.16b}, [x1], x3 // load pix1 + ld1 {v6.16b}, [x2], x3 // load pix2 + uabal v16.8h, v1.8b, v5.8b // absolute difference accumulate + uabal2 v17.8h, v1.16b, v5.16b + ld1 {v3.16b}, [x1], x3 + ld1 {v7.16b}, [x2], x3 + uabal v16.8h, v2.8b, v6.8b + uabal2 v17.8h, v2.16b, v6.16b + sub w4, w4, #4 // h -= 4 + uabal v16.8h, v3.8b, v7.8b + uabal2 v17.8h, v3.16b, v7.16b + cmp w4, #4 // if h >= 4, loop + add v16.8h, v16.8h, v17.8h + uaddlv s16, v16.8h // add up everything in v16 accumulator + add d18, d16, d18 // add to the end result register + + b.ge 1b + cbnz w4, 2f // if iterations remain, jump to completion section + + fmov w0, s18 // copy result to general purpose register + ret + +2: + ld1 {v0.16b}, [x1], x3 // load pix1 + ld1 {v4.16b}, [x2], x3 // load pix2 + uabdl v16.8h, v0.8b, v4.8b // absolute difference accumulate + uabal2 v16.8h, v0.16b, v4.16b + subs w4, w4, #1 // h -= 1 + addv h16, v16.8h // add up v16 + add d18, d16, d18 // add to result + b.ne 2b + + fmov w0, s18 // copy result to general purpose register + ret +endfunc + +function ff_pix_abs16_xy2_neon, export=1 + // x0 unused + // x1 uint8_t *pix1 + // x2 uint8_t *pix2 + // x3 ptrdiff_t stride + // w4 int h + + add x5, x2, x3 // use x5 to hold uint8_t *pix3 + movi v0.2d, #0 // initialize the result register + + // Load initial pix2 values for either the unrolled version or completion version. + ldur q4, [x2, #1] // load pix2+1 + ldr q3, [x2] // load pix2 + uaddl v2.8h, v4.8b, v3.8b // pix2 + pix2+1 0..7 + uaddl2 v3.8h, v4.16b, v3.16b // pix2 + pix2+1 8..15 + cmp w4, #4 // if h < 4 jump to the completion version + b.lt 2f +1: + // This is an unrolled implementation. It completes 4 iterations of the C for each branch. + // In each iteration, pix2[i+1] == pix3[i]. This means we need only three loads per iteration, + // plus two at the beginning to start. + ldur q5, [x5, #1] // load pix3+1 + ld1 {v4.16b}, [x5], x3 // load pix3 + ld1 {v1.16b}, [x1], x3 // load pix1 + + ldur q7, [x5, #1] // load pix3+1 + ld1 {v6.16b}, [x5], x3 // load pix3 + ld1 {v16.16b}, [x1], x3 // load pix1 + + ldur q19, [x5, #1] // load pix3+1 + ld1 {v18.16b}, [x5], x3 // load pix3 + ld1 {v17.16b}, [x1], x3 // load pix1 + + ldur q22, [x5, #1] // load pix3+1 + ld1 {v21.16b}, [x5], x3 // load pix3 + ld1 {v20.16b}, [x1], x3 // load pix1 + + // These blocks compute the average: avg(pix2[n], pix2[n+1], pix3[n], pix3[n+1]) + uaddl v30.8h, v4.8b, v5.8b // pix3 + pix3+1 0..7 + uaddl2 v31.8h, v4.16b, v5.16b // pix3 + pix3+1 8..15 + add v23.8h, v2.8h, v30.8h // add up 0..7, using pix2 + pix2+1 values from previous iteration + add v24.8h, v3.8h, v31.8h // add up 8..15, using pix2 + pix2+1 values from previous iteration + rshrn v23.8b, v23.8h, #2 // shift right 2 0..7 (rounding shift right) + rshrn2 v23.16b, v24.8h, #2 // shift right 2 8..15 + + uaddl v2.8h, v6.8b, v7.8b // pix3 + pix3+1 0..7 + uaddl2 v3.8h, v6.16b, v7.16b // pix3 + pix3+1 8..15 + add v26.8h, v30.8h, v2.8h // add up 0..7, using pix2 + pix2+1 values from pix3 above + add v27.8h, v31.8h, v3.8h // add up 8..15, using pix2 + pix2+1 values from pix3 above + rshrn v26.8b, v26.8h, #2 // shift right 2 0..7 (rounding shift right) + rshrn2 v26.16b, v27.8h, #2 // shift right 2 8..15 + + uaddl v4.8h, v18.8b, v19.8b // pix3 + pix3+1 0..7 + uaddl2 v5.8h, v18.16b, v19.16b // pix3 + pix3+1 8..15 + add v28.8h, v2.8h, v4.8h // add up 0..7, using pix2 + pix2+1 values from pix3 above + add v29.8h, v3.8h, v5.8h // add up 8..15, using pix2 + pix2+1 values from pix3 above + rshrn v28.8b, v28.8h, #2 // shift right 2 0..7 (rounding shift right) + rshrn2 v28.16b, v29.8h, #2 // shift right 2 8..15 + + uaddl v2.8h, v21.8b, v22.8b // pix3 + pix3+1 0..7 + uaddl2 v3.8h, v21.16b, v22.16b // pix3 + pix3+1 8..15 + add v30.8h, v4.8h, v2.8h // add up 0..7, using pix2 + pix2+1 values from pix3 above + add v31.8h, v5.8h, v3.8h // add up 8..15, using pix2 + pix2+1 values from pix3 above + rshrn v30.8b, v30.8h, #2 // shift right 2 0..7 (rounding shift right) + rshrn2 v30.16b, v31.8h, #2 // shift right 2 8..15 + + // Averages are now stored in these registers: + // v23, v16, v28, v30 + // pix1 values in these registers: + // v1, v16, v17, v20 + // available: + // v4, v5, v7, v18, v19, v24, v25, v27, v29, v31 + + sub w4, w4, #4 // h -= 4 + + // Using absolute-difference instructions instead of absolute-difference-accumulate allows + // us to keep the results in 16b vectors instead of widening values with twice the instructions. + // This approach also has fewer data dependencies, allowing better instruction level parallelism. + uabd v4.16b, v1.16b, v23.16b // absolute difference 0..15, i=0 + uabd v5.16b, v16.16b, v26.16b // absolute difference 0..15, i=1 + uabd v6.16b, v17.16b, v28.16b // absolute difference 0..15, i=2 + uabd v7.16b, v20.16b, v30.16b // absolute difference 0..15, i=3 + + cmp w4, #4 // loop if h >= 4 + + // Now add up all the values in each vector, v4-v7 with widening adds + uaddl v19.8h, v4.8b, v5.8b + uaddl2 v18.8h, v4.16b, v5.16b + uaddl v4.8h, v6.8b, v7.8b + uaddl2 v5.8h, v6.16b, v7.16b + add v4.8h, v4.8h, v5.8h + add v4.8h, v4.8h, v18.8h + add v4.8h, v4.8h, v19.8h + uaddlv s4, v4.8h // finish adding up accumulated values + add d0, d0, d4 // add the value to the top level accumulator + + b.ge 1b + cbnz w4, 2f // if iterations remain jump to completion section + + fmov w0, s0 // copy result to general purpose register + ret +2: + // v2 and v3 are set either at the end of this loop or at from the unrolled version + // which branches here to complete iterations when h % 4 != 0. + ldur q5, [x5, #1] // load pix3+1 + ld1 {v4.16b}, [x5], x3 // load pix3 + ld1 {v1.16b}, [x1], x3 // load pix1 + subs w4, w4, #1 // decrement h + + uaddl v18.8h, v4.8b, v5.8b // pix3 + pix3+1 0..7 + uaddl2 v19.8h, v4.16b, v5.16b // pix3 + pix3+1 8..15 + add v16.8h, v2.8h, v18.8h // add up 0..7, using pix2 + pix2+1 values from previous iteration + add v17.8h, v3.8h, v19.8h // add up 8..15, using pix2 + pix2+1 values from previous iteration + // divide by 4 to compute the average of values summed above + urshr v16.8h, v16.8h, #2 // shift right by 2 0..7 (rounding shift right) + urshr v17.8h, v17.8h, #2 // shift right by 2 8..15 + + uxtl2 v8.8h, v1.16b // 8->16 bits pix1 8..15 + uxtl v1.8h, v1.8b // 8->16 bits pix1 0..7 + + uabd v6.8h, v1.8h, v16.8h // absolute difference 0..7 + uaba v6.8h, v8.8h, v17.8h // absolute difference accumulate 8..15 + mov v2.16b, v18.16b // pix3 -> pix2 + mov v3.16b, v19.16b // pix3+1 -> pix2+1 + uaddlv s6, v6.8h // add up accumulator in v6 + add d0, d0, d6 // add to the final result + + b.ne 2b // loop if h > 0 + fmov w0, s0 // copy result to general purpose register + ret +endfunc diff --git a/libavcodec/me_cmp.c b/libavcodec/me_cmp.c index 4407d0a7e9..d0cd14ad33 100644 --- a/libavcodec/me_cmp.c +++ b/libavcodec/me_cmp.c @@ -1061,7 +1061,9 @@ av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx) ff_dsputil_init_dwt(c); #endif -#if ARCH_ALPHA +#if ARCH_AARCH64 + ff_me_cmp_init_aarch64(c, avctx); +#elif ARCH_ALPHA ff_me_cmp_init_alpha(c, avctx); #elif ARCH_ARM ff_me_cmp_init_arm(c, avctx); diff --git a/libavcodec/me_cmp.h b/libavcodec/me_cmp.h index e9b5161c9a..7b057a923b 100644 --- a/libavcodec/me_cmp.h +++ b/libavcodec/me_cmp.h @@ -80,6 +80,7 @@ typedef struct MECmpContext { } MECmpContext; void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx); +void ff_me_cmp_init_aarch64(MECmpContext *c, AVCodecContext *avctx); void ff_me_cmp_init_alpha(MECmpContext *c, AVCodecContext *avctx); void ff_me_cmp_init_arm(MECmpContext *c, AVCodecContext *avctx); void ff_me_cmp_init_ppc(MECmpContext *c, AVCodecContext *avctx); diff --git a/tests/checkasm/Makefile b/tests/checkasm/Makefile index f6b1008855..e869c70b55 100644 --- a/tests/checkasm/Makefile +++ b/tests/checkasm/Makefile @@ -12,6 +12,7 @@ AVCODECOBJS-$(CONFIG_H264QPEL) += h264qpel.o AVCODECOBJS-$(CONFIG_IDCTDSP) += idctdsp.o AVCODECOBJS-$(CONFIG_LLVIDDSP) += llviddsp.o AVCODECOBJS-$(CONFIG_LLVIDENCDSP) += llviddspenc.o +AVCODECOBJS-$(CONFIG_ME_CMP) += motion.o AVCODECOBJS-$(CONFIG_VC1DSP) += vc1dsp.o AVCODECOBJS-$(CONFIG_VP8DSP) += vp8dsp.o AVCODECOBJS-$(CONFIG_VIDEODSP) += videodsp.o diff --git a/tests/checkasm/checkasm.c b/tests/checkasm/checkasm.c index 57134f96ea..5ffcafbda9 100644 --- a/tests/checkasm/checkasm.c +++ b/tests/checkasm/checkasm.c @@ -135,6 +135,9 @@ static const struct { #if CONFIG_LLVIDENCDSP { "llviddspenc", checkasm_check_llviddspenc }, #endif + #if CONFIG_ME_CMP + { "motion", checkasm_check_motion }, + #endif #if CONFIG_OPUS_DECODER { "opusdsp", checkasm_check_opusdsp }, #endif diff --git a/tests/checkasm/checkasm.h b/tests/checkasm/checkasm.h index a86db140e3..b601a98754 100644 --- a/tests/checkasm/checkasm.h +++ b/tests/checkasm/checkasm.h @@ -68,6 +68,7 @@ void checkasm_check_idctdsp(void); void checkasm_check_jpeg2000dsp(void); void checkasm_check_llviddsp(void); void checkasm_check_llviddspenc(void); +void checkasm_check_motion(void); void checkasm_check_nlmeans(void); void checkasm_check_opusdsp(void); void checkasm_check_pixblockdsp(void); diff --git a/tests/checkasm/motion.c b/tests/checkasm/motion.c new file mode 100644 index 0000000000..f337dd6f95 --- /dev/null +++ b/tests/checkasm/motion.c @@ -0,0 +1,151 @@ +/* + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 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 General Public License for more details. + * + * You should have received a copy of the GNU 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. + */ + +#include <string.h> + +#include "libavutil/common.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/mem_internal.h" + +#include "libavcodec/me_cmp.h" + +#include "checkasm.h" + +static void fill_random(uint8_t *tab, int size) +{ + int i; + for (i = 0; i < size; i++) { + tab[i] = rnd() % 256; + } +} + +static void test_motion(const char *name, me_cmp_func test_func) +{ + /* test configurarion */ +#define ITERATIONS 16 +#define WIDTH 64 +#define HEIGHT 64 + + /* motion estimation can look up to 17 bytes ahead */ + static const int look_ahead = 17; + + int i, x, y, d1, d2; + uint8_t *ptr; + + LOCAL_ALIGNED_8(uint8_t, img1, [WIDTH * HEIGHT]); + LOCAL_ALIGNED_8(uint8_t, img2, [WIDTH * HEIGHT]); + + declare_func_emms(AV_CPU_FLAG_MMX, int, struct MpegEncContext *c, + uint8_t *blk1 /* align width (8 or 16) */, + uint8_t *blk2 /* align 1 */, ptrdiff_t stride, + int h); + + if (test_func == NULL) { + return; + } + + /* test correctness */ + fill_random(img1, WIDTH * HEIGHT); + fill_random(img2, WIDTH * HEIGHT); + + if (check_func(test_func, "%s", name)) { + for (i = 0; i < ITERATIONS; i++) { + x = rnd() % (WIDTH - look_ahead); + y = rnd() % (HEIGHT - look_ahead); + + ptr = img2 + y * WIDTH + x; + d2 = call_ref(NULL, img1, ptr, WIDTH, 8); + d1 = call_new(NULL, img1, ptr, WIDTH, 8); + + if (d1 != d2) { + fail(); + printf("func: %s, x=%d y=%d, error: asm=%d c=%d\n", name, x, y, d1, d2); + break; + } + } + // benchmark with the final value of ptr + bench_new(NULL, img1, ptr, WIDTH, 8); + } +} + +#define ME_CMP_1D_ARRAYS(XX) \ + XX(sad) \ + XX(sse) \ + XX(hadamard8_diff) \ + XX(vsad) \ + XX(vsse) \ + XX(nsse) \ + XX(me_pre_cmp) \ + XX(me_cmp) \ + XX(me_sub_cmp) \ + XX(mb_cmp) \ + XX(ildct_cmp) \ + XX(frame_skip_cmp) \ + XX(median_sad) + +// tests for functions not yet implemented +#if 0 + XX(dct_sad) \ + XX(quant_psnr) \ + XX(bit) \ + XX(rd) \ + XX(w53) \ + XX(w97) \ + XX(dct_max) \ + XX(dct264_sad) \ + +#endif + +static void check_motion(void) +{ + char buf[64]; + AVCodecContext *av_ctx; + MECmpContext me_ctx; + + memset(&me_ctx, 0, sizeof(me_ctx)); + + /* allocate AVCodecContext */ + av_ctx = avcodec_alloc_context3(NULL); + av_ctx->flags |= AV_CODEC_FLAG_BITEXACT; + + ff_me_cmp_init(&me_ctx, av_ctx); + + for (int i = 0; i < FF_ARRAY_ELEMS(me_ctx.pix_abs); i++) { + for (int j = 0; j < FF_ARRAY_ELEMS(me_ctx.pix_abs[0]); j++) { + snprintf(buf, sizeof(buf), "pix_abs_%d_%d", i, j); + test_motion(buf, me_ctx.pix_abs[i][j]); + } + } + +#define XX(me_cmp_array) \ + for (int i = 0; i < FF_ARRAY_ELEMS(me_ctx.me_cmp_array); i++) { \ + snprintf(buf, sizeof(buf), #me_cmp_array "_%d", i); \ + test_motion(buf, me_ctx.me_cmp_array[i]); \ + } + ME_CMP_1D_ARRAYS(XX) +#undef XX + + avcodec_free_context(&av_ctx); +} + +void checkasm_check_motion(void) +{ + check_motion(); + report("motion"); +} diff --git a/tests/fate/checkasm.mak b/tests/fate/checkasm.mak index c6273db183..4d2f321e84 100644 --- a/tests/fate/checkasm.mak +++ b/tests/fate/checkasm.mak @@ -23,6 +23,7 @@ FATE_CHECKASM = fate-checkasm-aacpsdsp \ fate-checkasm-jpeg2000dsp \ fate-checkasm-llviddsp \ fate-checkasm-llviddspenc \ + fate-checkasm-motion \ fate-checkasm-opusdsp \ fate-checkasm-pixblockdsp \ fate-checkasm-sbrdsp \

1 0

fftools/ffmpeg: change frame counters to 64 bit
by Marton Balint 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Marton Balint <cus(a)passwd.hu> | Mon Jun 20 20:10:21 2022 +0200| [20e2aa940cd521bb3b1395e7c7a28cc34059abee] | committer: Marton Balint fftools/ffmpeg: change frame counters to 64 bit Frame counters can overflow relatively easily (INT_MAX number of frames is slightly more than 1 year for 60 fps content), so make sure we are always using 64 bit values for them. A live stream can easily run for more than a year and the framedup logic breaks on an overflow. Signed-off-by: Marton Balint <cus(a)passwd.hu> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=20e2aa940cd521bb3… --- fftools/ffmpeg.c | 38 +++++++++++++++++++------------------- fftools/ffmpeg.h | 6 +++--- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/fftools/ffmpeg.c b/fftools/ffmpeg.c index 09caa3e3c4..e7384f052a 100644 --- a/fftools/ffmpeg.c +++ b/fftools/ffmpeg.c @@ -131,9 +131,9 @@ static BenchmarkTimeStamps get_benchmark_time_stamps(void); static int64_t getmaxrss(void); static int ifilter_has_all_input_formats(FilterGraph *fg); -static int nb_frames_dup = 0; -static unsigned dup_warning = 1000; -static int nb_frames_drop = 0; +static int64_t nb_frames_dup = 0; +static uint64_t dup_warning = 1000; +static int64_t nb_frames_drop = 0; static int64_t decode_error_stat[2]; unsigned nb_output_dumped = 0; @@ -839,7 +839,7 @@ static void update_video_stats(OutputStream *ost, const AVPacket *pkt, int write const uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS, NULL); AVCodecContext *enc = ost->enc_ctx; - int frame_number; + int64_t frame_number; double ti1, bitrate, avg_bitrate; ost->quality = sd ? AV_RL32(sd) : -1; @@ -866,10 +866,10 @@ static void update_video_stats(OutputStream *ost, const AVPacket *pkt, int write frame_number = ost->packets_encoded; if (vstats_version <= 1) { - fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, + fprintf(vstats_file, "frame= %5"PRId64" q= %2.1f ", frame_number, ost->quality / (float)FF_QP2LAMBDA); } else { - fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number, + fprintf(vstats_file, "out= %2d st= %2d frame= %5"PRId64" q= %2.1f ", ost->file_index, ost->index, frame_number, ost->quality / (float)FF_QP2LAMBDA); } @@ -1082,7 +1082,7 @@ static void do_video_out(OutputFile *of, int ret; AVCodecContext *enc = ost->enc_ctx; AVRational frame_rate; - int nb_frames, nb0_frames, i; + int64_t nb_frames, nb0_frames, i; double delta, delta0; double duration = 0; double sync_ipts = AV_NOPTS_VALUE; @@ -1152,7 +1152,7 @@ static void do_video_out(OutputFile *of, } else if (delta < -1.1) nb_frames = 0; else if (delta > 1.1) { - nb_frames = lrintf(delta); + nb_frames = llrintf(delta); if (delta0 > 1.1) nb0_frames = llrintf(delta0 - 0.6); } @@ -1188,19 +1188,19 @@ static void do_video_out(OutputFile *of, if (nb0_frames == 0 && ost->last_dropped) { nb_frames_drop++; av_log(NULL, AV_LOG_VERBOSE, - "*** dropping frame %d from stream %d at ts %"PRId64"\n", + "*** dropping frame %"PRId64" from stream %d at ts %"PRId64"\n", ost->frame_number, ost->st->index, ost->last_frame->pts); } if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) { if (nb_frames > dts_error_threshold * 30) { - av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1); + av_log(NULL, AV_LOG_ERROR, "%"PRId64" frame duplication too large, skipping\n", nb_frames - 1); nb_frames_drop++; return; } nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames); - av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1); + av_log(NULL, AV_LOG_VERBOSE, "*** %"PRId64" dup!\n", nb_frames - 1); if (nb_frames_dup > dup_warning) { - av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning); + av_log(NULL, AV_LOG_WARNING, "More than %"PRIu64" frames duplicated\n", dup_warning); dup_warning *= 10; } } @@ -1511,7 +1511,7 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti AVFormatContext *oc; int64_t total_size; AVCodecContext *enc; - int frame_number, vid, i; + int vid, i; double bitrate; double speed; int64_t pts = INT64_MIN + 1; @@ -1562,12 +1562,12 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti } if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { float fps; + int64_t frame_number = ost->frame_number; - frame_number = ost->frame_number; fps = t > 1 ? frame_number / t : 0; - av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ", + av_bprintf(&buf, "frame=%5"PRId64" fps=%3.*f q=%3.1f ", frame_number, fps < 9.95, fps, q); - av_bprintf(&buf_script, "frame=%d\n", frame_number); + av_bprintf(&buf_script, "frame=%"PRId64"\n", frame_number); av_bprintf(&buf_script, "fps=%.2f\n", fps); av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n", ost->file_index, ost->index, q); @@ -1671,9 +1671,9 @@ static void print_report(int is_last_report, int64_t timer_start, int64_t cur_ti } if (nb_frames_dup || nb_frames_drop) - av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop); - av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup); - av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop); + av_bprintf(&buf, " dup=%"PRId64" drop=%"PRId64, nb_frames_dup, nb_frames_drop); + av_bprintf(&buf_script, "dup_frames=%"PRId64"\n", nb_frames_dup); + av_bprintf(&buf_script, "drop_frames=%"PRId64"\n", nb_frames_drop); if (speed < 0) { av_bprintf(&buf, " speed=N/A"); diff --git a/fftools/ffmpeg.h b/fftools/ffmpeg.h index 69a368b8d1..99d31c346e 100644 --- a/fftools/ffmpeg.h +++ b/fftools/ffmpeg.h @@ -458,7 +458,7 @@ typedef struct OutputStream { int source_index; /* InputStream index */ AVStream *st; /* stream in the output file */ int encoding_needed; /* true if encoding needed for this stream */ - int frame_number; + int64_t frame_number; /* input pts and corresponding output pts for A/V sync */ struct InputStream *sync_ist; /* input stream to sync against */ @@ -481,8 +481,8 @@ typedef struct OutputStream { AVFrame *filtered_frame; AVFrame *last_frame; AVPacket *pkt; - int last_dropped; - int last_nb0_frames[3]; + int64_t last_dropped; + int64_t last_nb0_frames[3]; void *hwaccel_ctx;

1 0

avformat/mov: read PCM audio configuration box ('pcmC') if available
by Ivan Baykalov 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Ivan Baykalov <4rusxg(a)gmail.com> | Tue Jun 7 15:26:18 2022 +0700| [cbe216d3a62fe22b16a1ba40b9b3f13e5b4ac9a9] | committer: Marton Balint avformat/mov: read PCM audio configuration box ('pcmC') if available For ipcm and fpcm streams, big-endian format is the default, but it can be changed with additional 'pcmC' sub-atom of audio sample description. Details can be found in ISO/IEC 23003-5:2020 Fixes ticket #9763. Fixes ticket #9790. Patch simplified by Marton Balint. Signed-off-by: Marton Balint <cus(a)passwd.hu> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=cbe216d3a62fe22b1… --- libavformat/mov.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/libavformat/mov.c b/libavformat/mov.c index 0660a51492..c6fbe511c0 100644 --- a/libavformat/mov.c +++ b/libavformat/mov.c @@ -1553,6 +1553,9 @@ static void set_last_stream_little_endian(AVFormatContext *fc) st = fc->streams[fc->nb_streams-1]; switch (st->codecpar->codec_id) { + case AV_CODEC_ID_PCM_S16BE: + st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE; + break; case AV_CODEC_ID_PCM_S24BE: st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE; break; @@ -1579,6 +1582,24 @@ static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom) return 0; } +static int mov_read_pcmc(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + int format_flags; + + if (atom.size < 6) { + av_log(c->fc, AV_LOG_ERROR, "Empty pcmC box\n"); + return AVERROR_INVALIDDATA; + } + + avio_r8(pb); // version + avio_rb24(pb); // flags + format_flags = avio_r8(pb); + if (format_flags == 1) // indicates little-endian format. If not present, big-endian format is used + set_last_stream_little_endian(c->fc); + + return 0; +} + static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom) { AVStream *st; @@ -7674,6 +7695,7 @@ static const MOVParseTableEntry mov_default_parse_table[] = { { MKTAG('S','A','3','D'), mov_read_SA3D }, /* ambisonic audio box */ { MKTAG('S','A','N','D'), mov_read_SAND }, /* non diegetic audio box */ { MKTAG('i','l','o','c'), mov_read_iloc }, +{ MKTAG('p','c','m','C'), mov_read_pcmc }, /* PCM configuration box */ { 0, NULL } };

1 0

avformat/mov: factorize setting little endian PCM streams
by Marton Balint 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Marton Balint <cus(a)passwd.hu> | Sun Jun 19 23:25:51 2022 +0200| [cd83383f4deab43c8207baaa7e19fde4b8ae9cc6] | committer: Marton Balint avformat/mov: factorize setting little endian PCM streams Signed-off-by: Marton Balint <cus(a)passwd.hu> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=cd83383f4deab43c8… --- libavformat/mov.c | 51 +++++++++++++++++++++++++++------------------------ 1 file changed, 27 insertions(+), 24 deletions(-) diff --git a/libavformat/mov.c b/libavformat/mov.c index 3ec0ea2361..0660a51492 100644 --- a/libavformat/mov.c +++ b/libavformat/mov.c @@ -1544,35 +1544,38 @@ static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom) return 0; } -static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom) +static void set_last_stream_little_endian(AVFormatContext *fc) { AVStream *st; - int little_endian; - if (c->fc->nb_streams < 1) - return 0; - st = c->fc->streams[c->fc->nb_streams-1]; + if (fc->nb_streams < 1) + return; + st = fc->streams[fc->nb_streams-1]; - little_endian = avio_rb16(pb) & 0xFF; - av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian); - if (little_endian == 1) { - switch (st->codecpar->codec_id) { - case AV_CODEC_ID_PCM_S24BE: - st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE; - break; - case AV_CODEC_ID_PCM_S32BE: - st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE; - break; - case AV_CODEC_ID_PCM_F32BE: - st->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE; - break; - case AV_CODEC_ID_PCM_F64BE: - st->codecpar->codec_id = AV_CODEC_ID_PCM_F64LE; - break; - default: - break; - } + switch (st->codecpar->codec_id) { + case AV_CODEC_ID_PCM_S24BE: + st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE; + break; + case AV_CODEC_ID_PCM_S32BE: + st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE; + break; + case AV_CODEC_ID_PCM_F32BE: + st->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE; + break; + case AV_CODEC_ID_PCM_F64BE: + st->codecpar->codec_id = AV_CODEC_ID_PCM_F64LE; + break; + default: + break; } +} + +static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom) +{ + int little_endian = avio_rb16(pb) & 0xFF; + av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian); + if (little_endian == 1) + set_last_stream_little_endian(c->fc); return 0; }

1 0

avformat/movenc: Support alpha channel for AVIF
by Vignesh Venkatasubramanian 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Vignesh Venkatasubramanian <vigneshv(a)google.com> | Wed Jun 1 11:05:56 2022 -0700| [2a3640de84975398b1169d29530274cdd38b3939] | committer: James Almer avformat/movenc: Support alpha channel for AVIF AVIF specification allows for alpha channel as an auxiliary item (in case of still images) or as an auxiliary track (in case of animated images). Add support for both of these. The AVIF muxer will take exactly two streams (when alpha is present) as input (first one being the YUV planes and the second one being the alpha plane). The input has to come from two different images (one of it color and the other one being alpha), or it can come from a single file source with the alpha channel extracted using the "alphaextract" filter. Example using alphaextract: ffmpeg -i rgba.png -filter_complex "[0:v]alphaextract[a]" -map 0 -map "[a]" -still-picture 1 avif_with_alpha.avif Example using two sources (first source can be in any pixel format and the second source has to be in monochrome grey pixel format): ffmpeg -i color.avif -i grey.avif -map 0 -map 1 -c copy avif_with_alpha.avif The generated files pass the compliance checks in Compliance Warden: https://github.com/gpac/ComplianceWarden libavif (the reference avif library) is able to decode the files generated using this patch. They also play back properly (with transparent background) in: 1) Chrome 2) Firefox (only still AVIF, no animation support) Reviewed-by: James Zern <jzern(a)google.com> Signed-off-by: Vignesh Venkatasubramanian <vigneshv(a)google.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=2a3640de84975398b… --- libavformat/movenc.c | 188 +++++++++++++++++++++++++++++++++++---------------- libavformat/movenc.h | 4 +- 2 files changed, 130 insertions(+), 62 deletions(-) diff --git a/libavformat/movenc.c b/libavformat/movenc.c index 68a46ba729..106b5a6807 100644 --- a/libavformat/movenc.c +++ b/libavformat/movenc.c @@ -2854,7 +2854,7 @@ static int mov_write_hdlr_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *tra hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0"; if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) { if (track->mode == MODE_AVIF) { - hdlr_type = "pict"; + hdlr_type = (track == &mov->tracks[0]) ? "pict" : "auxv"; descr = "PictureHandler"; } else { hdlr_type = "vide"; @@ -2942,57 +2942,83 @@ static int mov_write_iloc_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatConte avio_wb32(pb, 0); /* Version & flags */ avio_w8(pb, (4 << 4) + 4); /* offset_size(4) and length_size(4) */ avio_w8(pb, 0); /* base_offset_size(4) and reserved(4) */ - avio_wb16(pb, 1); /* item_count */ + avio_wb16(pb, s->nb_streams); /* item_count */ - avio_wb16(pb, 1); /* item_id */ - avio_wb16(pb, 0); /* data_reference_index */ - avio_wb16(pb, 1); /* extent_count */ - mov->avif_extent_pos = avio_tell(pb); - avio_wb32(pb, 0); /* extent_offset (written later) */ - // For animated AVIF, we simply write the first packet's size. - avio_wb32(pb, mov->avif_extent_length); /* extent_length */ + for (int i = 0; i < s->nb_streams; i++) { + avio_wb16(pb, i + 1); /* item_id */ + avio_wb16(pb, 0); /* data_reference_index */ + avio_wb16(pb, 1); /* extent_count */ + mov->avif_extent_pos[i] = avio_tell(pb); + avio_wb32(pb, 0); /* extent_offset (written later) */ + // For animated AVIF, we simply write the first packet's size. + avio_wb32(pb, mov->avif_extent_length[i]); /* extent_length */ + } return update_size(pb, pos); } static int mov_write_iinf_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) { - int64_t infe_pos; int64_t iinf_pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "iinf"); avio_wb32(pb, 0); /* Version & flags */ - avio_wb16(pb, 1); /* entry_count */ + avio_wb16(pb, s->nb_streams); /* entry_count */ - infe_pos = avio_tell(pb); - avio_wb32(pb, 0); /* size */ - ffio_wfourcc(pb, "infe"); - avio_w8(pb, 0x2); /* Version */ - avio_wb24(pb, 0); /* flags */ - avio_wb16(pb, 1); /* item_id */ - avio_wb16(pb, 0); /* item_protection_index */ - avio_write(pb, "av01", 4); /* item_type */ - avio_write(pb, "Color\0", 6); /* item_name */ - update_size(pb, infe_pos); + for (int i = 0; i < s->nb_streams; i++) { + int64_t infe_pos = avio_tell(pb); + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "infe"); + avio_w8(pb, 0x2); /* Version */ + avio_wb24(pb, 0); /* flags */ + avio_wb16(pb, i + 1); /* item_id */ + avio_wb16(pb, 0); /* item_protection_index */ + avio_write(pb, "av01", 4); /* item_type */ + avio_write(pb, !i ? "Color\0" : "Alpha\0", 6); /* item_name */ + update_size(pb, infe_pos); + } return update_size(pb, iinf_pos); } -static int mov_write_ispe_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) + +static int mov_write_iref_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) +{ + int64_t auxl_pos; + int64_t iref_pos = avio_tell(pb); + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "iref"); + avio_wb32(pb, 0); /* Version & flags */ + + auxl_pos = avio_tell(pb); + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "auxl"); + avio_wb16(pb, 2); /* from_item_ID */ + avio_wb16(pb, 1); /* reference_count */ + avio_wb16(pb, 1); /* to_item_ID */ + update_size(pb, auxl_pos); + + return update_size(pb, iref_pos); +} + +static int mov_write_ispe_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s, + int stream_index) { int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "ispe"); avio_wb32(pb, 0); /* Version & flags */ - avio_wb32(pb, s->streams[0]->codecpar->width); /* image_width */ - avio_wb32(pb, s->streams[0]->codecpar->height); /* image_height */ + avio_wb32(pb, s->streams[stream_index]->codecpar->width); /* image_width */ + avio_wb32(pb, s->streams[stream_index]->codecpar->height); /* image_height */ return update_size(pb, pos); } -static int mov_write_pixi_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) +static int mov_write_pixi_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s, + int stream_index) { int64_t pos = avio_tell(pb); - const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->streams[0]->codecpar->format); + const AVPixFmtDescriptor *pixdesc = + av_pix_fmt_desc_get(s->streams[stream_index]->codecpar->format); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "pixi"); avio_wb32(pb, 0); /* Version & flags */ @@ -3003,15 +3029,30 @@ static int mov_write_pixi_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatConte return update_size(pb, pos); } +static int mov_write_auxC_tag(AVIOContext *pb) +{ + int64_t pos = avio_tell(pb); + avio_wb32(pb, 0); /* size */ + ffio_wfourcc(pb, "auxC"); + avio_wb32(pb, 0); /* Version & flags */ + avio_write(pb, "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha\0", 44); + return update_size(pb, pos); +} + static int mov_write_ipco_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) { int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "ipco"); - mov_write_ispe_tag(pb, mov, s); - mov_write_pixi_tag(pb, mov, s); - mov_write_av1c_tag(pb, &mov->tracks[0]); - mov_write_colr_tag(pb, &mov->tracks[0], 0); + for (int i = 0; i < s->nb_streams; i++) { + mov_write_ispe_tag(pb, mov, s, i); + mov_write_pixi_tag(pb, mov, s, i); + mov_write_av1c_tag(pb, &mov->tracks[i]); + if (!i) + mov_write_colr_tag(pb, &mov->tracks[0], 0); + else + mov_write_auxC_tag(pb); + } return update_size(pb, pos); } @@ -3021,18 +3062,21 @@ static int mov_write_ipma_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatConte avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "ipma"); avio_wb32(pb, 0); /* Version & flags */ - avio_wb32(pb, 1); /* entry_count */ - avio_wb16(pb, 1); /* item_ID */ - avio_w8(pb, 4); /* association_count */ - - // ispe association. - avio_w8(pb, 1); /* essential and property_index */ - // pixi association. - avio_w8(pb, 2); /* essential and property_index */ - // av1C association. - avio_w8(pb, 0x80 | 3); /* essential and property_index */ - // colr association. - avio_w8(pb, 4); /* essential and property_index */ + avio_wb32(pb, s->nb_streams); /* entry_count */ + + for (int i = 0, index = 1; i < s->nb_streams; i++) { + avio_wb16(pb, i + 1); /* item_ID */ + avio_w8(pb, 4); /* association_count */ + + // ispe association. + avio_w8(pb, index++); /* essential and property_index */ + // pixi association. + avio_w8(pb, index++); /* essential and property_index */ + // av1C association. + avio_w8(pb, 0x80 | index++); /* essential and property_index */ + // colr/auxC association. + avio_w8(pb, index++); /* essential and property_index */ + } return update_size(pb, pos); } @@ -4114,6 +4158,8 @@ static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov, mov_write_pitm_tag(pb, 1); mov_write_iloc_tag(pb, mov, s); mov_write_iinf_tag(pb, mov, s); + if (s->nb_streams > 1) + mov_write_iref_tag(pb, mov, s); mov_write_iprp_tag(pb, mov, s); } else { /* iTunes metadata tag */ @@ -6042,8 +6088,8 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt) avio_write(pb, reformatted_data, size); } else { size = ff_av1_filter_obus(pb, pkt->data, pkt->size); - if (trk->mode == MODE_AVIF && !mov->avif_extent_length) { - mov->avif_extent_length = size; + if (trk->mode == MODE_AVIF && !mov->avif_extent_length[pkt->stream_index]) { + mov->avif_extent_length[pkt->stream_index] = size; } } @@ -6874,16 +6920,26 @@ static int mov_init(AVFormatContext *s) return AVERROR(EINVAL); } - /* AVIF output must have exactly one video stream */ + /* AVIF output must have at most two video streams (one for YUV and one for + * alpha). */ if (mov->mode == MODE_AVIF) { - if (s->nb_streams > 1) { - av_log(s, AV_LOG_ERROR, "AVIF output requires exactly one stream\n"); + if (s->nb_streams > 2) { + av_log(s, AV_LOG_ERROR, "AVIF output requires exactly one or two streams\n"); return AVERROR(EINVAL); } - if (s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) { - av_log(s, AV_LOG_ERROR, "AVIF output requires one video stream\n"); + if (s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && + (s->nb_streams > 1 && s->streams[1]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)) { + av_log(s, AV_LOG_ERROR, "AVIF output supports only video streams\n"); return AVERROR(EINVAL); } + if (s->nb_streams > 1) { + const AVPixFmtDescriptor *pixdesc = + av_pix_fmt_desc_get(s->streams[1]->codecpar->format); + if (pixdesc->nb_components != 1) { + av_log(s, AV_LOG_ERROR, "Second stream for AVIF (alpha) output must have exactly one plane\n"); + return AVERROR(EINVAL); + } + } s->streams[0]->disposition |= AV_DISPOSITION_DEFAULT; } @@ -7545,18 +7601,25 @@ static int avif_write_trailer(AVFormatContext *s) { AVIOContext *pb = s->pb; MOVMuxContext *mov = s->priv_data; - int64_t pos_backup, mdat_pos; + int64_t pos_backup, extent_offsets[2]; uint8_t *buf; - int buf_size, moov_size; + int buf_size, moov_size, i; if (mov->moov_written) return 0; mov->is_animated_avif = s->streams[0]->nb_frames > 1; + if (mov->is_animated_avif && s->nb_streams > 1) { + // For animated avif with alpha channel, we need to write a tref tag + // with type "auxl". + mov->tracks[1].tref_tag = MKTAG('a', 'u', 'x', 'l'); + mov->tracks[1].tref_id = 1; + } mov_write_identification(pb, s); mov_write_meta_tag(pb, mov, s); moov_size = get_moov_size(s); - mov->tracks[0].data_offset = avio_tell(pb) + moov_size + 8; + for (i = 0; i < s->nb_streams; i++) + mov->tracks[i].data_offset = avio_tell(pb) + moov_size + 8; if (mov->is_animated_avif) { int ret; @@ -7567,19 +7630,24 @@ static int avif_write_trailer(AVFormatContext *s) buf_size = avio_get_dyn_buf(mov->mdat_buf, &buf); avio_wb32(pb, buf_size + 8); ffio_wfourcc(pb, "mdat"); - mdat_pos = avio_tell(pb); - if (mdat_pos != (uint32_t)mdat_pos) { - av_log(s, AV_LOG_ERROR, "mdat offset does not fit in 32 bits\n"); - return AVERROR_INVALIDDATA; - } + // The offset for the YUV planes is the starting position of mdat. + extent_offsets[0] = avio_tell(pb); + // The offset for alpha plane is YUV offset + YUV size. + extent_offsets[1] = extent_offsets[0] + mov->avif_extent_length[0]; avio_write(pb, buf, buf_size); - // write extent offset. + // write extent offsets. pos_backup = avio_tell(pb); - avio_seek(pb, mov->avif_extent_pos, SEEK_SET); - avio_wb32(pb, mdat_pos); /* rewrite offset */ + for (i = 0; i < s->nb_streams; i++) { + if (extent_offsets[i] != (uint32_t)extent_offsets[i]) { + av_log(s, AV_LOG_ERROR, "extent offset does not fit in 32 bits\n"); + return AVERROR_INVALIDDATA; + } + avio_seek(pb, mov->avif_extent_pos[i], SEEK_SET); + avio_wb32(pb, extent_offsets[i]); /* rewrite offset */ + } avio_seek(pb, pos_backup, SEEK_SET); return 0; diff --git a/libavformat/movenc.h b/libavformat/movenc.h index 281576cc66..e4550f7900 100644 --- a/libavformat/movenc.h +++ b/libavformat/movenc.h @@ -246,8 +246,8 @@ typedef struct MOVMuxContext { int empty_hdlr_name; int movie_timescale; - int64_t avif_extent_pos; - int avif_extent_length; + int64_t avif_extent_pos[2]; // index 0 is YUV and 1 is Alpha. + int avif_extent_length[2]; // index 0 is YUV and 1 is Alpha. int is_animated_avif; } MOVMuxContext;

1 0

fftools/ffplay: fix YUV conversion mode
by Niklas Haas 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Niklas Haas <git(a)haasn.dev> | Tue Jun 21 21:39:25 2022 +0200| [a526f0cc3ac938364afe8ce62c4bc47d3b9bb2af] | committer: Niklas Haas fftools/ffplay: fix YUV conversion mode GL and Metal cache the state at time of texture creation. GLES2 and Direct3D 11 use the state at time of the render copy call. So the only way we can get the correct behavior consistently is by making sure the state is set for both the upload *and* the draw call. This probably isn't our bug to fix (upstream should make itself behave consistently and also document its functions), but as it stands, `ffplay` is misrendering BT.709 as BT.601 on my stock Linux system, and that leaves a bad taste in my mouth. Signed-off-by: Niklas Haas <git(a)haasn.dev> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=a526f0cc3ac938364… --- fftools/ffplay.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/fftools/ffplay.c b/fftools/ffplay.c index 040afa0189..9242047f5c 100644 --- a/fftools/ffplay.c +++ b/fftools/ffplay.c @@ -1011,15 +1011,17 @@ static void video_image_display(VideoState *is) } calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar); + set_sdl_yuv_conversion_mode(vp->frame); if (!vp->uploaded) { - if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0) + if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0) { + set_sdl_yuv_conversion_mode(NULL); return; + } vp->uploaded = 1; vp->flip_v = vp->frame->linesize[0] < 0; } - set_sdl_yuv_conversion_mode(vp->frame); SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0); set_sdl_yuv_conversion_mode(NULL); if (sp) {

1 0

avcodec/libx265: make X265 CSP selection pixel format independent
by Jan Ekström 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Jan Ekström <jeebjp(a)gmail.com> | Sun Jun 19 20:21:26 2022 +0300| [49027e7612ac3f349f5fa8b6d8cc0c6a4036d05c] | committer: Jan Ekström avcodec/libx265: make X265 CSP selection pixel format independent Currently the format listing misses the J formats completely, yet they are marked as supported in the encoder. Thus to make the logic support them while not explicitly listing them, make the logic utilize chroma subsampling information in both width and height available through the pixel format descriptor. > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=49027e7612ac3f349… --- libavcodec/libx265.c | 61 ++++++++++++++++++++++++++-------------------------- 1 file changed, 31 insertions(+), 30 deletions(-) diff --git a/libavcodec/libx265.c b/libavcodec/libx265.c index 4dcdcd7a77..f68ecb3092 100644 --- a/libavcodec/libx265.c +++ b/libavcodec/libx265.c @@ -240,39 +240,40 @@ static av_cold int libx265_encode_init(AVCodecContext *avctx) } } - switch (avctx->pix_fmt) { - case AV_PIX_FMT_YUV420P: - case AV_PIX_FMT_YUV420P10: - case AV_PIX_FMT_YUV420P12: - ctx->params->internalCsp = X265_CSP_I420; - break; - case AV_PIX_FMT_YUV422P: - case AV_PIX_FMT_YUV422P10: - case AV_PIX_FMT_YUV422P12: - ctx->params->internalCsp = X265_CSP_I422; - break; - case AV_PIX_FMT_GBRP: - case AV_PIX_FMT_GBRP10: - case AV_PIX_FMT_GBRP12: - ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB; - ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1; - ctx->params->vui.bEnableColorDescriptionPresentFlag = 1; - case AV_PIX_FMT_YUV444P: - case AV_PIX_FMT_YUV444P10: - case AV_PIX_FMT_YUV444P12: + switch (desc->log2_chroma_w) { + // 4:4:4, RGB. gray + case 0: + // gray + if (desc->nb_components == 1) { + if (ctx->api->api_build_number < 85) { + av_log(avctx, AV_LOG_ERROR, + "libx265 version is %d, must be at least 85 for gray encoding.\n", + ctx->api->api_build_number); + return AVERROR_INVALIDDATA; + } + ctx->params->internalCsp = X265_CSP_I400; + break; + } + + // set identity matrix for RGB + if (desc->flags & AV_PIX_FMT_FLAG_RGB) { + ctx->params->vui.matrixCoeffs = AVCOL_SPC_RGB; + ctx->params->vui.bEnableVideoSignalTypePresentFlag = 1; + ctx->params->vui.bEnableColorDescriptionPresentFlag = 1; + } + ctx->params->internalCsp = X265_CSP_I444; break; - case AV_PIX_FMT_GRAY8: - case AV_PIX_FMT_GRAY10: - case AV_PIX_FMT_GRAY12: - if (ctx->api->api_build_number < 85) { - av_log(avctx, AV_LOG_ERROR, - "libx265 version is %d, must be at least 85 for gray encoding.\n", - ctx->api->api_build_number); - return AVERROR_INVALIDDATA; - } - ctx->params->internalCsp = X265_CSP_I400; + // 4:2:0, 4:2:2 + case 1: + ctx->params->internalCsp = desc->log2_chroma_h == 1 ? + X265_CSP_I420 : X265_CSP_I422; break; + default: + av_log(avctx, AV_LOG_ERROR, + "Pixel format '%s' cannot be mapped to a libx265 CSP!\n", + desc->name); + return AVERROR_BUG; } if (ctx->crf >= 0) {

1 0

libavcodec/qsvenc: Enable fixed QP configure in qsv CQP runtime
by Yue Heng 27 Jun '22

27 Jun '22

ffmpeg | branch: master | Yue Heng <yue.heng(a)intel.com> | Thu Jun 23 13:32:42 2022 +0800| [53baf606038f710f0cbd3f19b3d416978b98167f] | committer: Haihao Xiang libavcodec/qsvenc: Enable fixed QP configure in qsv CQP runtime Enable dynamic QP configuration in runtime on qsv encoder. Through AVFrame->metadata, we can set key "qsv_config_qp" to change QP configuration when we encode video in CQP mode. Signed-off-by: Yue Heng <yue.heng(a)intel.com> Signed-off-by: Wenbin Chen <wenbin.chen(a)intel.com> Signed-off-by: Haihao Xiang <haihao.xiang(a)intel.com> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=53baf606038f710f0… --- doc/encoders.texi | 10 ++++++ libavcodec/qsvenc.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 99 insertions(+) diff --git a/doc/encoders.texi b/doc/encoders.texi index 1850c99fe9..02a91ffe96 100644 --- a/doc/encoders.texi +++ b/doc/encoders.texi @@ -3333,6 +3333,16 @@ Forcing I frames as IDR frames. For encoders set this flag to ON to reduce power consumption and GPU usage. @end table +@subsection Runtime Options +Following options can be used durning qsv encoding. + +@table @option +@item @var{qsv_config_qp} +Supported in h264_qsv and hevc_qsv. +This option can be set in per-frame metadata. QP parameter can be dynamically +changed when encoding in CQP mode. +@end table + @subsection H264 options These options are used by h264_qsv diff --git a/libavcodec/qsvenc.c b/libavcodec/qsvenc.c index 902bada55b..2382c2f5f7 100644 --- a/libavcodec/qsvenc.c +++ b/libavcodec/qsvenc.c @@ -146,6 +146,14 @@ static const struct { { MFX_RATECONTROL_QVBR, "QVBR" }, }; +#define UPDATE_PARAM(a, b) \ +do { \ + if ((a) != (b)) { \ + a = b; \ + updated = 1; \ + } \ +} while (0) \ + static const char *print_ratecontrol(mfxU16 rc_mode) { int i; @@ -1613,6 +1621,83 @@ static int set_roi_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, return 0; } +static int update_qp(AVCodecContext *avctx, QSVEncContext *q, + const AVFrame *frame) +{ + int updated = 0, qp = 0, new_qp; + char *tail; + AVDictionaryEntry *entry = NULL; + + if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC) + return 0; + + entry = av_dict_get(frame->metadata, "qsv_config_qp", NULL, 0); + if (entry && q->param.mfx.RateControlMethod == MFX_RATECONTROL_CQP) { + qp = strtol(entry->value, &tail, 10); + if (*tail) { + av_log(avctx, AV_LOG_WARNING, "Invalid qsv_config_qp string. Ignore this metadata\n"); + return 0; + } + if (qp < 0 || qp > 51) { + av_log(avctx, AV_LOG_WARNING, "Invalid qp, clip to 0 ~ 51\n"); + qp = av_clip(qp, 0, 51); + } + av_log(avctx, AV_LOG_DEBUG, "Configure qp: %d\n",qp); + UPDATE_PARAM(q->param.mfx.QPP, qp); + new_qp = av_clip(qp * fabs(avctx->i_quant_factor) + + avctx->i_quant_offset, 0, 51); + UPDATE_PARAM(q->param.mfx.QPI, new_qp); + new_qp = av_clip(qp * fabs(avctx->b_quant_factor) + + avctx->b_quant_offset, 0, 51); + UPDATE_PARAM(q->param.mfx.QPB, new_qp); + av_log(avctx, AV_LOG_DEBUG, + "using fixed qp = %d/%d/%d for idr/p/b frames\n", + q->param.mfx.QPI, q->param.mfx.QPP, q->param.mfx.QPB); + } + return updated; +} + +static int update_parameters(AVCodecContext *avctx, QSVEncContext *q, + const AVFrame *frame) +{ + int needReset = 0, ret = 0; + + if (!frame) + return 0; + + needReset = update_qp(avctx, q, frame); + if (!needReset) + return 0; + + if (avctx->hwaccel_context) { + AVQSVContext *qsv = avctx->hwaccel_context; + int i, j; + q->param.ExtParam = q->extparam; + for (i = 0; i < qsv->nb_ext_buffers; i++) + q->param.ExtParam[i] = qsv->ext_buffers[i]; + q->param.NumExtParam = qsv->nb_ext_buffers; + + for (i = 0; i < q->nb_extparam_internal; i++) { + for (j = 0; j < qsv->nb_ext_buffers; j++) { + if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId) + break; + } + if (j < qsv->nb_ext_buffers) + continue; + q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i]; + } + } else { + q->param.ExtParam = q->extparam_internal; + q->param.NumExtParam = q->nb_extparam_internal; + } + av_log(avctx, AV_LOG_DEBUG, "Parameter change, call msdk reset.\n"); + ret = MFXVideoENCODE_Reset(q->session, &q->param); + if (ret < 0) + return ff_qsv_print_error(avctx, ret, "Error during resetting"); + + return 0; +} + static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame) { @@ -1731,6 +1816,10 @@ int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, { int ret; + ret = update_parameters(avctx, q, frame); + if (ret < 0) + return ret; + ret = encode_frame(avctx, q, frame); if (ret < 0) return ret;

1 0