July 2025 - ffmpeg-devel - lists.ffmpeg.org

[PATCH] doc/infra: More details about hosting and security
by Michael Niedermayer 30 Sep '25

30 Sep '25

From: Nikolay Aleksandrov <razor(a)blackwall.org> Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> I have redacted the exact location of the FFmpeg server as writing that in public seems just a bad idea --- doc/infra.txt | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/doc/infra.txt b/doc/infra.txt index 0c339d7f9fd..08dcf04c307 100644 --- a/doc/infra.txt +++ b/doc/infra.txt @@ -24,6 +24,26 @@ Our Main server is hosted at telepoint.bg for more details see: https://www.ffmpeg.org/#thanks_sponsor_0001 Nothing runs on our main server directly, instead several VMs run on it. +Main server security: +--------------------- +Telepoint is one of the largest Bulgarian DC providers with multiple sibling companies offering +Internet, SDH, DWDM, peering exchange and hosting. They have multiple DC buildings in Sofia and +FFmpeg is hosted in XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX. The building is locked down and accessible +only with personal key cards that are registered. People who are granted access to a rack have +to go through the access center with their ID to get logged and receive a one-time access card +that can open the service elevator and only the hall where the destination rack is. All racks are +locked, once access is granted to someone they will get a key for the rack for the duration of +their visit. There are security cameras everywhere and personnel in the access center 24/7. As for +software security, our BIOS and IPMI are protected by password and encrypted connection, and +the machines can be accessed only by root administrators with their SSH keys. They're using +a Ubuntu LTS release and get regular security updates as they are released. We also get +notified by email for various security related events (e.g. failed sudo). + +Side note - Telepoint provides the rack and physical infrastructure, their sibling company called + Telehouse which is an ISP provides the connectivity, they are directly connected with + over 15 tier-1 service providers and have over 100 PoPs (points of presence) + in various cities. You can see more on www.telehouse.bg + ffmpeg.org VM: -------------- -- 2.47.0

1 2

[POLL] [VOTE] code.ffmpeg.org
by Michael Niedermayer 17 Sep '25

17 Sep '25

Hi all Do people want Forgejo or Gitlab on code.ffmpeg.org for testing? F. code.ffmpeg.org should run Forgejo G. code.ffmpeg.org should run Gitlab all GA members can vote, by publically replying here with a "F." / "Forgejo" vs "G." / "Gitlab" End time is in 7 days unless teh community wants to extend that. (or do people want a formal vote to be setup? on vote.ffmpeg.org) After we decide what to run on code.ffmpeg.org, I intend to * apply the CI patches which timo currently keeps rebasing on the Forgejo git (maybe timo can post these to ffmpeg-devel) * extend my github cronjob to autosync Forgejo or Gitlab too (or someone else can set one up) * announce code.ffmpeg.org publically so people can start submitting and reviewing on it as an alternative to the ML * and a month or 2 after that we can re-asses how many people use code.ffmpeg.org and how many use the ML. Then we could decide to keep using both in parallel or switch back to ML or just use code.ffmpeg.org. Or in fact we could switch between Gitlab or Forgejo here still as well. thx -- Michael GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB Frequently ignored answer#1 FFmpeg bugs should be sent to our bugtracker. User questions about the command line tools should be sent to the ffmpeg-user ML. And questions about how to use libav* should be sent to the libav-user ML.

22 41

[PATCH v8] libavcodec/riscv: add RVV optimized idct_32x32_8 for HEVC
by daichengrong＠iscas.ac.cn 05 Sep '25

05 Sep '25

From: daichengrong <daichengrong(a)iscas.ac.cn> On Banana PI F3(256-bit vectors): hevc_idct_32x32_8_c: 119103.4 ( 1.00x) hevc_idct_32x32_8_rvv_i64: 5233.3 (22.76x) Changes in v8: Remove VLEN related code and scale execution by VL Changes in v7: Globally optimize VLEN > 128 Cancel explicit transposition Optimize half-vector operations Changes in v6: Optimize data loading and avoid sliding half-sized vectors Adopt an instruction sorting strategy that is more favorable to in-order cores Encode more immediate values into instructions Support register save and restore of different xlen Optimize for VLEN > 128 Changes in v5: Improve the continuity of vector operations Optimize loading matrices from memory to using immediate instructions Changes in v4: Optimize unnecessary slide operations Extract more scalars from vector registers into purpose registers Changes in v3: remove the slides in transposition and spill values from vector registers to stack Changes in v2: deleted tabs remove the unnecessary t0 in vsetivli extract scalars directly into general registers --- libavcodec/riscv/Makefile | 1 + libavcodec/riscv/hevcdsp_idct_rvv.S | 690 ++++++++++++++++++++++++++++ libavcodec/riscv/hevcdsp_init.c | 39 +- 3 files changed, 716 insertions(+), 14 deletions(-) create mode 100644 libavcodec/riscv/hevcdsp_idct_rvv.S diff --git a/libavcodec/riscv/Makefile b/libavcodec/riscv/Makefile index 736f873fe8..7b1a3f079b 100644 --- a/libavcodec/riscv/Makefile +++ b/libavcodec/riscv/Makefile @@ -36,6 +36,7 @@ RVV-OBJS-$(CONFIG_H264DSP) += riscv/h264addpx_rvv.o riscv/h264dsp_rvv.o \ OBJS-$(CONFIG_H264QPEL) += riscv/h264qpel_init.o RVV-OBJS-$(CONFIG_H264QPEL) += riscv/h264qpel_rvv.o OBJS-$(CONFIG_HEVC_DECODER) += riscv/hevcdsp_init.o +OBJS-$(CONFIG_HEVC_DECODER) += riscv/hevcdsp_idct_rvv.o RVV-OBJS-$(CONFIG_HEVC_DECODER) += riscv/h26x/h2656_inter_rvv.o OBJS-$(CONFIG_HUFFYUV_DECODER) += riscv/huffyuvdsp_init.o RVV-OBJS-$(CONFIG_HUFFYUV_DECODER) += riscv/huffyuvdsp_rvv.o diff --git a/libavcodec/riscv/hevcdsp_idct_rvv.S b/libavcodec/riscv/hevcdsp_idct_rvv.S new file mode 100644 index 0000000000..9389b7a9b4 --- /dev/null +++ b/libavcodec/riscv/hevcdsp_idct_rvv.S @@ -0,0 +1,690 @@ +/* + * Copyright (c) 2025 Institute of Software, Chinese Academy of Sciences (ISCAS). + * + * 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/riscv/asm.S" + +.macro lx rd, addr +#if (__riscv_xlen == 32) + lw \rd, \addr +#elif (__riscv_xlen == 64) + ld \rd, \addr +#else + lq \rd, \addr +#endif +.endm + +.macro sx rd, addr +#if (__riscv_xlen == 32) + sw \rd, \addr +#elif (__riscv_xlen == 64) + sd \rd, \addr +#else + sq \rd, \addr +#endif +.endm + +.macro load_trans_4x4 + li s2, 64 + li s3, 83 + + li s5, 36 + li s6, -64 + li s7, -83 +.endm + +.macro load_trans_8x4 + li s6, 89 + li s7, 75 + li s8, 50 + li s9, 18 + + li s2, -89 + li s4, -50 + li s5, -18 +.endm + +.macro load_trans_16x4 + li x12, 90 + li x13, 87 + li x14, 80 + li x15, 70 + + li x16, 57 + li x17, 43 + li x18, 25 + li x19, 9 + + li x20, -90 + li x21, -87 + li x22, -80 + li x23, -70 + + li x24, -57 + li x25, -43 + li x26, -25 + li x27, -9 +.endm + +.macro load_trans_32x4 + li x12, 90 + li x13, 90 + li x14, 88 + li x15, 85 + + li x16, 82 + li x17, 78 + li x18, 73 + li x19, 67 + + li x20, 61 + li x21, 54 + li x22, 46 + li x23, 38 + + li x24, 31 + li x25, 22 + li x26, 13 + li x27, 4 +.endm + +.macro add_member32 in, t0, t1, t2, t3, op0, op1, op2, op3 + .ifc \op0, - + neg t0, \t0 + .endif + .ifc \op1, - + neg t1, \t1 + .endif + .ifc \op2, - + neg t4, \t2 + .endif + .ifc \op3, - + neg t3, \t3 + .endif + + .ifc \op0, - + vwmacc.vx v24, t0, \in + .else + vwmacc.vx v24, \t0, \in + .endif + .ifc \op1, - + vwmacc.vx v25, t1, \in + .else + vwmacc.vx v25, \t1, \in + .endif + .ifc \op2, - + vwmacc.vx v26, t4, \in + .else + vwmacc.vx v26, \t2, \in + .endif + .ifc \op3, - + vwmacc.vx v27, t3, \in + .else + vwmacc.vx v27, \t3, \in + .endif +.endm + +.macro tr_block1 + vwmul.vx v24, v4, x12 + vwmul.vx v25, v4, x13 + vwmul.vx v26, v4, x14 + vwmul.vx v27, v4, x15 + + add_member32 v12, x13, x16, x19, x22, +, +, +, + + add_member32 v5, x14, x19, x24, x26, +, +, +, - + add_member32 v13, x15, x22, x26, x19, +, +, -, - + add_member32 v6, x16, x25, x21, x12, +, +, -, - + add_member32 v14, x17, x27, x16, x18, +, -, -, - + add_member32 v7, x18, x24, x12, x25, +, -, -, - + add_member32 v15, x19, x21, x17, x23, +, -, -, + + + add_member32 v16, x20, x18, x22, x16, +, -, -, + + add_member32 v20, x21, x15, x27, x14, +, -, -, + + add_member32 v17, x22, x13, x23, x21, +, -, +, + + add_member32 v21, x23, x14, x18, x27, +, -, +, - + add_member32 v18, x24, x17, x13, x20, +, -, +, - + add_member32 v22, x25, x20, x15, x13, +, -, +, - + add_member32 v19, x26, x23, x20, x17, +, -, +, - + add_member32 v23, x27, x26, x25, x24, +, -, +, - +.endm + +.macro tr_block2 + vwmul.vx v24, v4, x16 + vwmul.vx v25, v4, x17 + vwmul.vx v26, v4, x18 + vwmul.vx v27, v4, x19 + + add_member32 v12, x25, x27, x24, x21, +, -, -, - + add_member32 v5, x21, x16, x12, x17, -, -, -, - + add_member32 v13, x12, x18, x25, x23, -, -, -, + + add_member32 v6, x20, x26, x17, x15, -, +, +, + + add_member32 v14, x26, x15, x19, x25, +, +, +, - + add_member32 v7, x17, x19, x23, x12, +, +, -, - + add_member32 v15, x15, x25, x13, x27, +, -, -, + + + add_member32 v16, x24, x14, x26, x13, +, -, -, + + add_member32 v20, x22, x20, x16, x26, -, -, +, + + add_member32 v17, x13, x24, x20, x14, -, +, +, - + add_member32 v21, x19, x13, x22, x24, -, +, -, - + add_member32 v18, x27, x21, x14, x16, +, +, -, + + add_member32 v22, x18, x23, x27, x22, +, -, -, + + add_member32 v19, x14, x13, x15, x18, +, -, +, - + add_member32 v23, x23, x22, x21, x20, +, -, +, - +.endm + +.macro tr_block3 + vwmul.vx v24, v4, x20 + vwmul.vx v25, v4, x21 + vwmul.vx v26, v4, x22 + vwmul.vx v27, v4, x23 + + add_member32 v12, x18, x15, x12, x14, -, -, -, - + add_member32 v5, x22, x27, x23, x18, -, -, +, + + add_member32 v13, x16, x14, x21, x27, +, +, +, - + add_member32 v6, x24, x22, x13, x19, +, -, -, - + add_member32 v14, x14, x20, x24, x12, -, -, +, + + add_member32 v7, x26, x16, x20, x22, -, +, +, - + add_member32 v15, x12, x26, x14, x24, +, +, -, - + add_member32 v16, x27, x13, x25, x15, -, -, +, + + add_member32 v20, x13, x23, x19, x17, -, +, +, - + add_member32 v17, x25, x19, x15, x26, +, +, -, + + add_member32 v21, x15, x17, x26, x20, +, -, +, + + add_member32 v18, x23, x25, x18, x13, -, -, +, - + add_member32 v22, x17, x12, x16, x21, -, +, -, + + add_member32 v19, x21, x24, x27, x25, +, -, +, + + add_member32 v23, x19, x18, x17, x16, +, -, +, - +.endm + +.macro tr_block4 + vwmul.vx v24, v4, x24 + vwmul.vx v25, v4, x25 + vwmul.vx v26, v4, x26 + vwmul.vx v27, v4, x27 + + add_member32 v12, x17, x20, x23, x26, -, -, -, - + add_member32 v5, x12, x15, x20, x25, +, +, +, + + add_member32 v13, x20, x12, x17, x24, -, -, -, - + add_member32 v6, x27, x18, x14, x23, +, +, +, + + add_member32 v14, x21, x23, x12, x22, +, -, -, - + add_member32 v7, x14, x27, x15, x21, -, -, +, + + add_member32 v15, x16, x22, x18, x20, +, +, -, - + add_member32 v16, x23, x17, x21, x19, -, -, +, + + add_member32 v20, x25, x13, x24, x18, -, +, -, - + add_member32 v17, x18, x16, x27, x17, +, -, +, + + add_member32 v21, x13, x21, x25, x16, -, +, +, - + add_member32 v18, x19, x26, x22, x15, +, -, -, + + add_member32 v22, x26, x24, x19, x14, -, -, +, - + add_member32 v19, x22, x19, x16, x13, -, +, -, + + add_member32 v23, x15, x14, x13, x12, +, -, +, - +.endm + +.macro butterfly e, o, tmp_p, tmp_m + vadd.vv \tmp_p, \e, \o + vsub.vv \tmp_m, \e, \o +.endm + +.macro butterfly16 in0, in1, in2, in3, in4, in5, in6, in7 + vadd.vv v20, \in0, \in1 + vsub.vv \in0, \in0, \in1 + vadd.vv \in1, \in2, \in3 + vsub.vv \in2, \in2, \in3 + vadd.vv \in3, \in4, \in5 + vsub.vv \in4, \in4, \in5 + vadd.vv \in5, \in6, \in7 + vsub.vv \in6, \in6, \in7 +.endm + +.macro butterfly32 in0, in1, in2, in3, out + vadd.vv \out, \in0, \in1 + vsub.vv \in0, \in0, \in1 + vadd.vv \in1, \in2, \in3 + vsub.vv \in2, \in2, \in3 +.endm + +.macro add_member in, tt0, tt1, tt2, tt3, tt4, tt5, tt6, tt7 + vwmacc.vx v21, \tt0, \in + vwmacc.vx v22, \tt1, \in + vwmacc.vx v23, \tt2, \in + vwmacc.vx v24, \tt3, \in + vwmacc.vx v25, \tt4, \in + vwmacc.vx v26, \tt5, \in + vwmacc.vx v27, \tt6, \in + vwmacc.vx v28, \tt7, \in +.endm + +.macro load16xN_rvv + addi t0, a0, 64 + addi a2, t0, 256 * 1 + addi a3, t0, 256 * 2 + addi a4, t0, 256 * 3 + addi a5, t0, 256 * 4 + addi a6, t0, 256 * 5 + addi a7, t0, 256 * 6 + addi s9, t0, 256 * 7 + + addi t1, t0, 128 + addi s2, t1, 256 * 1 + addi s3, t1, 256 * 2 + addi s4, t1, 256 * 3 + addi s5, t1, 256 * 4 + addi s6, t1, 256 * 5 + addi s7, t1, 256 * 6 + addi s8, t1, 256 * 7 + + vle16.v v4, (t0) + vle16.v v5, (a2) + vle16.v v6, (a3) + vle16.v v7, (a4) + + vle16.v v16, (a5) + vle16.v v17, (a6) + vle16.v v18, (a7) + vle16.v v19, (s9) + + vle16.v v12, (t1) + vle16.v v13, (s2) + vle16.v v14, (s3) + vle16.v v15, (s4) + + vle16.v v20, (s5) + vle16.v v21, (s6) + vle16.v v22, (s7) + vle16.v v23, (s8) +.endm + +.macro load16_rvv in0, in1, in2, in3, off1, off2, step, in4, in5, in6, in7 + addi t0, a0, \off1 + addi a2, t0, \step * 1 + addi a3, t0, \step * 2 + addi a4, t0, \step * 3 + + addi t1, a0, \off2 + addi s2, t1, \step * 1 + addi s3, t1, \step * 2 + addi s4, t1, \step * 3 + + vle16.v \in0, (t0) + vle16.v \in1, (a2) + vle16.v \in2, (a3) + vle16.v \in3, (a4) + + vle16.v \in4, (t1) + vle16.v \in5, (s2) + vle16.v \in6, (s3) + vle16.v \in7, (s4) +.endm + +.macro reload16 reload_offset + li t0, 2048 + add t0, sp, t0 + + add t0, t0, \reload_offset + + add t1, t0, t5 + add t2, t1, t5 + add t3, t2, t5 + + vle32.v v28, (t0) + vle32.v v29, (t1) + vle32.v v30, (t2) + vle32.v v31, (t3) +.endm + +.macro storeNx4_rvv in0, in1, in2, in3, off1, step, tmp0, tmp1, tmp2, tmp3 + li t0, \step + + addi t1, a1, \off1 + addi t2, t1, 1 * 2 + addi t3, t1, 2 * 2 + addi t4, t1, 3 * 2 + + vsse16.v \in0, (t1), t0 + vsse16.v \in1, (t2), t0 + vsse16.v \in2, (t3), t0 + vsse16.v \in3, (t4), t0 + + addi t1, a1, \step\() - \off1\() - 2 + addi t2, t1, -1 * 2 + addi t3, t1, -2 * 2 + addi t4, t1, -3 * 2 + + vsse16.v \tmp0, (t1), t0 + vsse16.v \tmp1, (t2), t0 + vsse16.v \tmp2, (t3), t0 + vsse16.v \tmp3, (t4), t0 +.endm + +.macro scale_store_rvv shift, step, off, reload_offset + vsetvli zero, zero, e32, m1, ta, ma + reload16 \reload_offset + + butterfly32 v28, v24, v29, v25, v2 + butterfly32 v30, v26, v31, v27, v3 + + vsetvli zero, zero, e16, mf2, ta, ma + scale v1, v10, v11, v9, v2, v28, v24, v29, v3, v30, v26, v31, \shift + storeNx4_rvv v1, v10, v11, v9, \off, \step, v2, v28, v24, v29 +.endm + +.macro store_to_stack_rvv off1, off2, in0, in2, in4, in6, in7, in5, in3, in1 + add a2, sp, \off1 + add a3, sp, \off2 + + add a4, a2, t5 + sub a5, a3, t5 + + add a6, a4, t5 + sub a7, a5, t5 + + add s2, a6, t5 + sub s3, a7, t5 + + vse32.v \in0, (a2) + vse32.v \in1, (a3) + vse32.v \in2, (a4) + vse32.v \in3, (a5) + vse32.v \in4, (a6) + vse32.v \in5, (a7) + vse32.v \in6, (s2) + vse32.v \in7, (s3) +.endm + +.macro scale out0, out1, out2, out3, in0, in1, in2, in3, in4, in5, in6, in7, shift + vnclip.wi \out0\(), \in0\(), \shift + vnclip.wi \out1\(), \in2\(), \shift + vnclip.wi \out2\(), \in4\(), \shift + vnclip.wi \out3\(), \in6\(), \shift + + vnclip.wi \in0\(), \in1\(), \shift + vnclip.wi \in1\(), \in3\(), \shift + vnclip.wi \in2\(), \in5\(), \shift + vnclip.wi \in3\(), \in7\(), \shift +.endm + +.macro tr_4xN_8 in0, in1, in2, in3, out0, out1, out2, out3 + vwcvt.x.x.v v8, \in0 + + vsetvli zero, zero, e32, m1, ta, ma + vsll.vi v28, v8, 6 + vmv.v.v v29, v28 + + load_trans_4x4 + + vsetvli zero, zero, e16, mf2, ta, ma + vwmul.vx v30, \in1, s3 + vwmul.vx v31, \in1, s5 + vwmacc.vx v28, s2, \in2 + + vwmacc.vx v29, s6, \in2 + vwmacc.vx v30, s5, \in3 + vwmacc.vx v31, s7, \in3 + + vsetvli zero, zero, e32, m1, ta, ma + vadd.vv \out0, v28, v30 + vadd.vv \out1, v29, v31 + vsub.vv \out2, v29, v31 + vsub.vv \out3, v28, v30 +.endm + +.macro tr16_8xN in0, in1, in2, in3, offset, in4, in5, in6, in7 + tr_4xN_8 \in0, \in1, \in2, \in3, v24, v25, v26, v27 + load_trans_8x4 + + vsetvli zero, zero, e16, mf2, ta, ma + vwmul.vx v28, \in4, s6 + vwmul.vx v29, \in4, s7 + vwmul.vx v30, \in4, s8 + vwmul.vx v31, \in4, s9 + + vwmacc.vx v28, s7, \in5 + vwmacc.vx v29, s5, \in5 + vwmacc.vx v30, s2, \in5 + vwmacc.vx v31, s4, \in5 + + vwmacc.vx v28, s8, \in6 + vwmacc.vx v29, s2, \in6 + vwmacc.vx v30, s9, \in6 + vwmacc.vx v31, s7, \in6 + + vwmacc.vx v28, s9, \in7 + vwmacc.vx v29, s4, \in7 + vwmacc.vx v30, s7, \in7 + vwmacc.vx v31, s2, \in7 + + vsetvli zero, zero, e32, m1, ta, ma + butterfly v24, v28, v16, v23 + butterfly v25, v29, v17, v22 + butterfly v26, v30, v18, v21 + butterfly v27, v31, v19, v20 +.if \offset < 2048 + addi t0, sp, \offset +.else + li t0, \offset + add t0, sp, t0 +.endif + + add s2, t0, t5 + add s3, s2, t5 + add s4, s3, t5 + + add s5, s4, t5 + add s6, s5, t5 + add s7, s6, t5 + add s8, s7, t5 + + vsetvli zero, zero, e32, m1, ta, ma + vse32.v v16, (t0) + vse32.v v17, (s2) + vse32.v v18, (s3) + vse32.v v19, (s4) + + vse32.v v20, (s5) + vse32.v v21, (s6) + vse32.v v22, (s7) + vse32.v v23, (s8) +.endm + +.macro tr_16xN_rvv name, shift, offset, step +func func_tr_16xN_\name\()_rvv, zve64x + vsetvli zero, zero, e16, mf2, ta, ma + load16_rvv v16, v17, v18, v19, 0, \step * 64, \step * (2 * 64), v0, v1, v2, v3, + tr16_8xN v16, v17, v18, v19, \offset, v0, v1, v2, v3 + + vsetvli zero, zero, e16, mf2, ta, ma + load16_rvv v20, v17, v18, v19, \step * 32, \step * 3 * 32, \step * (2 * 64), v3, v0, v1, v2, + + load_trans_16x4 + + vwmul.vx v21, v20, x12 + vwmul.vx v22, v20, x13 + vwmul.vx v23, v20, x14 + vwmul.vx v24, v20, x15 + + vwmul.vx v25, v20, x16 + vwmul.vx v26, v20, x17 + vwmul.vx v27, v20, x18 + vwmul.vx v28, v20, x19 + + add_member v3, x13, x16, x19, x25, x22, x20, x23, x26 + add_member v17, x14, x19, x23, x21, x26, x16, x12, x17 + add_member v0, x15, x25, x21, x19, x12, x18, x22, x24 + add_member v18, x16, x22, x26, x12, x27, x21, x17, x15 + add_member v1, x17, x20, x16, x18, x21, x15, x19, x22 + add_member v19, x18, x23, x12, x22, x17, x19, x24, x13 + add_member v2, x19, x26, x17, x24, x15, x22, x13, x20 + +.if \offset < 2048 + addi t0, sp, \offset +.else + li t0, \offset + add t0, sp, t0 +.endif + + add s2, t0, t5 + add s3, s2, t5 + add s4, s3, t5 + + vsetvli zero, zero, e32, m1, ta, ma + + vle32.v v16, (t0) + vle32.v v17, (s2) + vle32.v v18, (s3) + vle32.v v19, (s4) + + butterfly16 v16, v21, v17, v22, v18, v23, v19, v24 + + li a2, \offset + li a3, \offset + + slli s2, s1, 1 + + add a3, a3, s2 + sub a3, a3, t5 + + store_to_stack_rvv a2, a3, v20, v21, v22, v23, v19, v18, v17, v16 + + slli t0, t5, 2 + + li s4, \offset + add t0, t0, s4 + add t0, t0, sp + + add s2, t0, t5 + add s3, s2, t5 + add s4, s3, t5 + + vle32.v v16, (t0) + vle32.v v17, (s2) + vle32.v v18, (s3) + vle32.v v19, (s4) + + butterfly16 v16, v25, v17, v26, v18, v27, v19, v28 + + li a2, \offset + slli s2, t5, 2 + add a2, a2, s2 + + li a3, \offset + slli s4, s1, 1 + add a3, a3, s4 + sub a3, a3, t5 + sub a3, a3, s2 + + store_to_stack_rvv a2, a3, v20, v25, v26, v27, v19, v18, v17, v16 + ret +endfunc +.endm + +tr_16xN_rvv noscale, 0, 2048, 4 + +.macro tr_32xN_rvv name, shift +func func_tr_32xN_\name\()_rvv, zve64x + vsetvli zero, zero, e16, mf2, ta, ma + load16xN_rvv + + load_trans_32x4 + + tr_block1 + li t3, 0 + scale_store_rvv \shift, 64, 0, t3 + + tr_block2 + slli t3, t5, 2 + scale_store_rvv \shift, 64, 8, t3 + + tr_block3 + scale_store_rvv \shift, 64, 16, s1 + + tr_block4 + li t0, 12 + mul t3, t5, t0 + scale_store_rvv \shift, 64, 24, t3 + + ret +endfunc +.endm + +tr_32xN_rvv firstpass, 7 +tr_32xN_rvv secondpass_8, 20 - 8 + +.macro idct_32x32 bitdepth +func ff_hevc_idct_32x32_\bitdepth\()_rvv, zve64x + + addi sp, sp, -(__riscv_xlen / 8)*13 + sx ra, (__riscv_xlen / 8)*(12)(sp) +.irp i, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 + sx s\i, (__riscv_xlen / 8)*(11-\i)(sp) +.endr + mv t6, a0 + + csrwi vxrm, 1 + + li t0, 4224 + sub sp, sp, t0 + + li t0, 32 + vsetvli t0, t0, e32, m1, ta, ma + + csrr t0, vl + slli s0, t0, 1 + slli t5, t0, 2 + slli s1, t0, 5 + + mv a1, sp +1: + jal func_tr_16xN_noscale_rvv + jal func_tr_32xN_firstpass_rvv + + add a0, a0, s0 + + slli t0, s1, 1 + add a1, a1, t0 + sub a3, a1, sp + + li a4, (32 * 32 * 2) + bgt a4, a3, 1b + + mv a0, sp + mv a1, t6 +1: + jal func_tr_16xN_noscale_rvv + jal func_tr_32xN_secondpass_\bitdepth\()_rvv + + add a0, a0, s0 + + slli t0, s1, 1 + add a1, a1, t0 + sub a3, a1, t6 + + li a4, (32 * 32 * 2) + bgt a4, a3, 1b + + li t0, 4224 + add sp, sp, t0 + + lx ra, (__riscv_xlen / 8)*(12)(sp) +.irp i, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 + lx s\i, (__riscv_xlen / 8)*(11-\i)(sp) +.endr + addi sp, sp, (__riscv_xlen / 8)*13 + ret +endfunc +.endm + +idct_32x32 8 diff --git a/libavcodec/riscv/hevcdsp_init.c b/libavcodec/riscv/hevcdsp_init.c index 1d8326a573..919d8202ad 100644 --- a/libavcodec/riscv/hevcdsp_init.c +++ b/libavcodec/riscv/hevcdsp_init.c @@ -27,6 +27,8 @@ #include "libavcodec/hevc/dsp.h" #include "libavcodec/riscv/h26x/h2656dsp.h" +void ff_hevc_idct_32x32_8_rvv(int16_t *coeffs, int col_limit); + #define RVV_FNASSIGN(member, v, h, fn, ext) \ member[1][v][h] = ff_h2656_put_pixels_##8_##ext; \ member[3][v][h] = ff_h2656_put_pixels_##8_##ext; \ @@ -40,27 +42,36 @@ void ff_hevc_dsp_init_riscv(HEVCDSPContext *c, const int bit_depth) const int flags = av_get_cpu_flags(); int vlenb; - if (!(flags & AV_CPU_FLAG_RVV_I32) || !(flags & AV_CPU_FLAG_RVB)) - return; - vlenb = ff_get_rv_vlenb(); - if (vlenb >= 32) { + + if (flags & AV_CPU_FLAG_RVV_I64) switch (bit_depth) { case 8: - RVV_FNASSIGN(c->put_hevc_qpel, 0, 0, pel_pixels, rvv_256); - RVV_FNASSIGN(c->put_hevc_epel, 0, 0, pel_pixels, rvv_256); + c->idct[3] = ff_hevc_idct_32x32_8_rvv; break; default: break; } - } else if (vlenb >= 16) { - switch (bit_depth) { - case 8: - RVV_FNASSIGN(c->put_hevc_qpel, 0, 0, pel_pixels, rvv_128); - RVV_FNASSIGN(c->put_hevc_epel, 0, 0, pel_pixels, rvv_128); - break; - default: - break; + + if ((flags & AV_CPU_FLAG_RVV_I32) && (flags & AV_CPU_FLAG_RVB)){ + if (vlenb >= 32) { + switch (bit_depth) { + case 8: + RVV_FNASSIGN(c->put_hevc_qpel, 0, 0, pel_pixels, rvv_256); + RVV_FNASSIGN(c->put_hevc_epel, 0, 0, pel_pixels, rvv_256); + break; + default: + break; + } + } else if (vlenb >= 16) { + switch (bit_depth) { + case 8: + RVV_FNASSIGN(c->put_hevc_qpel, 0, 0, pel_pixels, rvv_128); + RVV_FNASSIGN(c->put_hevc_epel, 0, 0, pel_pixels, rvv_128); + break; + default: + break; + } } } #endif -- 2.25.1

3 3

[PATCH] avcodec/aarch64/vvc: optimised alf_classify function 8/10/12bit of vvc codec for aarch64
by Georgii Zagoruiko 31 Aug '25

31 Aug '25

- vvc_alf.alf_classify [OK] vvc_alf_classify_8x8_8_c: 1314.4 ( 1.00x) vvc_alf_classify_8x8_8_neon: 794.3 ( 1.65x) vvc_alf_classify_8x8_10_c: 1154.7 ( 1.00x) vvc_alf_classify_8x8_10_neon: 770.0 ( 1.50x) vvc_alf_classify_8x8_12_c: 1091.7 ( 1.00x) vvc_alf_classify_8x8_12_neon: 770.7 ( 1.42x) vvc_alf_classify_16x16_8_c: 3710.0 ( 1.00x) vvc_alf_classify_16x16_8_neon: 2205.6 ( 1.68x) vvc_alf_classify_16x16_10_c: 3306.2 ( 1.00x) vvc_alf_classify_16x16_10_neon: 2087.9 ( 1.58x) vvc_alf_classify_16x16_12_c: 3307.9 ( 1.00x) vvc_alf_classify_16x16_12_neon: 2089.6 ( 1.58x) vvc_alf_classify_32x32_8_c: 12770.2 ( 1.00x) vvc_alf_classify_32x32_8_neon: 7124.6 ( 1.79x) vvc_alf_classify_32x32_10_c: 11780.3 ( 1.00x) vvc_alf_classify_32x32_10_neon: 6856.7 ( 1.72x) vvc_alf_classify_32x32_12_c: 11779.2 ( 1.00x) vvc_alf_classify_32x32_12_neon: 7002.8 ( 1.68x) vvc_alf_classify_64x64_8_c: 49332.3 ( 1.00x) vvc_alf_classify_64x64_8_neon: 26040.4 ( 1.89x) vvc_alf_classify_64x64_10_c: 45353.7 ( 1.00x) vvc_alf_classify_64x64_10_neon: 26251.5 ( 1.73x) vvc_alf_classify_64x64_12_c: 44876.9 ( 1.00x) vvc_alf_classify_64x64_12_neon: 26491.3 ( 1.69x) vvc_alf_classify_128x128_8_c: 191953.5 ( 1.00x) vvc_alf_classify_128x128_8_neon: 96166.3 ( 2.00x) vvc_alf_classify_128x128_10_c: 177198.5 ( 1.00x) vvc_alf_classify_128x128_10_neon: 96077.9 ( 1.84x) vvc_alf_classify_128x128_12_c: 177461.1 ( 1.00x) vvc_alf_classify_128x128_12_neon: 96184.4 ( 1.85x) --- libavcodec/aarch64/vvc/alf.S | 278 ++++++++++++++++++++++++++ libavcodec/aarch64/vvc/alf_template.c | 87 ++++++++ libavcodec/aarch64/vvc/dsp_init.c | 6 + 3 files changed, 371 insertions(+) diff --git a/libavcodec/aarch64/vvc/alf.S b/libavcodec/aarch64/vvc/alf.S index 8801b3afb6..9c9765ead1 100644 --- a/libavcodec/aarch64/vvc/alf.S +++ b/libavcodec/aarch64/vvc/alf.S @@ -291,3 +291,281 @@ function ff_alf_filter_chroma_kernel_10_neon, export=1 1: alf_filter_chroma_kernel 2 endfunc + + + +.macro alf_classify_argvar2v30 + mov w16, #0 + mov v30.b[0], w16 + mov w16, #1 + mov v30.b[1], w16 + mov w16, #2 + mov v30.b[2], w16 + mov v30.b[3], w16 + mov v30.b[4], w16 + mov v30.b[5], w16 + mov v30.b[6], w16 + mov w16, #3 + mov v30.b[7], w16 + mov v30.b[8], w16 + mov v30.b[9], w16 + mov v30.b[10], w16 + mov v30.b[11], w16 + mov v30.b[12], w16 + mov v30.b[13], w16 + mov v30.b[14], w16 + mov w16, #4 + mov v30.b[15], w16 +.endm + +.macro alf_classify_load_pixel pix_size, dst, src + .if \pix_size == 1 + ldrb \dst, [\src], #1 + .else + ldrh \dst, [\src], #2 + .endif +.endm + +.macro alf_classify_load_pixel_with_offset pix_size, dst, src, offset + .if \pix_size == 1 + ldrb \dst, [\src, #(\offset)] + .else + ldrh \dst, [\src, #(2*\offset)] + .endif +.endm + +#define ALF_BLOCK_SIZE 4 +#define ALF_GRADIENT_STEP 2 +#define ALF_GRADIENT_BORDER 2 +#define ALF_NUM_DIR 4 +#define ALF_GRAD_BORDER_X2 (ALF_GRADIENT_BORDER * 2) +#define ALF_STRIDE_MUL (ALF_GRADIENT_BORDER + 1) +#define ALF_GRAD_X_VSTEP (ALF_GRADIENT_STEP * 8) +#define ALF_GSTRIDE_MUL (ALF_NUM_DIR / ALF_GRADIENT_STEP) + +// Shift right: equal to division by 2 (see ALF_GRADIENT_STEP) +#define ALF_GSTRIDE_XG_BYTES (2 * ALF_NUM_DIR / ALF_GRADIENT_STEP) + +#define ALF_GSTRIDE_SUB_BYTES (2 * ((ALF_BLOCK_SIZE + ALF_GRADIENT_BORDER * 2) / ALF_GRADIENT_STEP) * ALF_NUM_DIR) + +#define ALF_CLASS_INC (ALF_GRADIENT_BORDER / ALF_GRADIENT_STEP) +#define ALF_CLASS_END ((ALF_BLOCK_SIZE + ALF_GRADIENT_BORDER * 2) / ALF_GRADIENT_STEP) + +.macro ff_alf_classify_grad pix_size + // class_idx .req x0 + // transpose_idx .req x1 + // _src .req x2 + // _src_stride .req x3 + // width .req w4 + // height .req w5 + // vb_pos .req w6 + // gradient_tmp .req x7 + + mov w16, #ALF_STRIDE_MUL + add w5, w5, #ALF_GRAD_BORDER_X2 // h = height + 4 + mul x16, x3, x16 // 3 * stride + add w4, w4, #ALF_GRAD_BORDER_X2 // w = width + 4 + sub x15, x2, x16 // src -= (3 * stride) + mov x17, x7 + .if \pix_size == 1 + sub x15, x15, #ALF_GRADIENT_BORDER + .else + sub x15, x15, #4 + .endif + mov w8, #0 // y loop: y = 0 +1: + cmp w8, w5 + bge 10f + + add x16, x8, #1 + mul x14, x8, x3 // y * stride + mul x16, x16, x3 + add x10, x15, x14 // s0 = src + y * stride + add x14, x16, x3 + add x11, x15, x16 // s1 + add x16, x14, x3 + add x12, x15, x14 // s2 + add x13, x15, x16 // s3 + + // if (y == vb_pos): s3 = s2 + cmp w8, w6 + add w16, w6, #ALF_GRADIENT_BORDER + csel x13, x12, x13, eq + // if (y == vb_pos + 2): s0 = s1 + cmp w8, w16 + csel x10, x11, x10, eq + + alf_classify_load_pixel_with_offset \pix_size, w16, x10, -1 + alf_classify_load_pixel \pix_size, w14, x13 + mov v16.h[7], w16 + mov v28.h[7], w14 + + // load 4 pixels from *(s1-2) & *(s2-2) + .if \pix_size == 1 + sub x11, x11, #2 + sub x12, x12, #2 + ld1 {v0.8b}, [x11] + ld1 {v1.8b}, [x12] + uxtl v17.8h, v0.8b + uxtl v18.8h, v1.8b + .else + sub x11, x11, #4 + sub x12, x12, #4 + ld1 {v17.8h}, [x11] + ld1 {v18.8h}, [x12] + .endif + ext v22.16b, v22.16b, v17.16b, #8 + ext v24.16b, v24.16b, v18.16b, #8 + .if \pix_size == 1 + add x11, x11, #4 + add x12, x12, #4 + .else + add x11, x11, #8 + add x12, x12, #8 + .endif + + // x loop + mov w9, #0 + b 11f +2: + cmp w9, w4 + bge 20f + + // Store operation starts from the second cycle + st2 {v4.8h, v5.8h}, [x17], #32 +11: + .if \pix_size == 1 + // Load 8 pixels: s0 & s1+2 + ld1 {v0.8b}, [x10], #8 + ld1 {v1.8b}, [x11], #8 + uxtl v20.8h, v0.8b + uxtl v26.8h, v1.8b + // Load 8 pixels: s2+2 & s3+1 + ld1 {v0.8b}, [x12], #8 + ld1 {v1.8b}, [x13], #8 + uxtl v27.8h, v0.8b + uxtl v19.8h, v1.8b + .else + // Load 8 pixels: s0 + ld1 {v20.8h}, [x10], #16 + // Load 8 pixels: s1+2 + ld1 {v26.8h}, [x11], #16 + // Load 8 pixels: s2+2 + ld1 {v27.8h}, [x12], #16 + // Load 8 pixels: s3+1 + ld1 {v19.8h}, [x13], #16 + .endif + + ext v16.16b, v16.16b, v20.16b, #14 + ext v28.16b, v28.16b, v19.16b, #14 + + ext v17.16b, v22.16b, v26.16b, #8 + ext v22.16b, v22.16b, v26.16b, #12 + + ext v18.16b, v24.16b, v27.16b, #8 + ext v24.16b, v24.16b, v27.16b, #12 + + // Grad: Vertical & D0 (interleaved) + trn1 v21.8h, v20.8h, v16.8h // first abs: operand 1 + rev32 v23.8h, v22.8h // second abs: operand 1 + trn2 v29.8h, v28.8h, v19.8h // second abs: operand 2 + trn1 v30.8h, v22.8h, v22.8h + trn2 v31.8h, v24.8h, v24.8h + add v30.8h, v30.8h, v30.8h + add v31.8h, v31.8h, v31.8h + sub v0.8h, v30.8h, v21.8h + sub v1.8h, v31.8h, v23.8h + sabd v4.8h, v0.8h, v24.8h + + // Grad: Horizontal & D1 (interleaved) + trn2 v21.8h, v17.8h, v20.8h // first abs: operand 1 + saba v4.8h, v1.8h, v29.8h + trn2 v23.8h, v22.8h, v18.8h // first abs: operand 2 + trn1 v25.8h, v24.8h, v26.8h // second abs: operand 1 + trn1 v29.8h, v27.8h, v28.8h // second abs: operand 2 + sub v0.8h, v30.8h, v21.8h + sub v1.8h, v31.8h, v25.8h + sabd v5.8h, v0.8h, v23.8h + + // Prepare for the next interation: + mov v16.16b, v20.16b + saba v5.8h, v1.8h, v29.8h + mov v28.16b, v19.16b + mov v22.16b, v26.16b + mov v24.16b, v27.16b + + add w9, w9, #8 // x += 8 + b 2b +20: + // 8 pixels -> 4 cycles of generic + // 4 pixels -> paddings => half needs to be saved + st2 {v4.4h, v5.4h}, [x17], #16 + + add w8, w8, #ALF_GRADIENT_STEP // y += 2 + b 1b +10: + ret +.endm + +.macro ff_alf_classify_sum + // sum0 .req x0 + // sum1 .req x1 + // grad .req x2 + // gshift .req w3 + // steps .req w4 + mov w5, #2 + mov w6, #0 + mul w3, w3, w5 + movi v16.4s, #0 + movi v21.4s, #0 +6: + prfm pldl1keep, [x2] + cmp w6, w4 + bge 60f + + ld1 {v17.4h}, [x2], #8 + ld1 {v18.4h}, [x2], #8 + uxtl v17.4s, v17.4h + ld1 {v19.4h}, [x2], #8 + uxtl v18.4s, v18.4h + ld1 {v20.4h}, [x2], #8 + uxtl v19.4s, v19.4h + ld1 {v22.4h}, [x2], #8 + uxtl v20.4s, v20.4h + ld1 {v23.4h}, [x2] + uxtl v22.4s, v22.4h + uxtl v23.4s, v23.4h + add v17.4s, v17.4s, v18.4s + add v16.4s, v16.4s, v17.4s + add v19.4s, v19.4s, v20.4s + add v22.4s, v22.4s, v23.4s + add v21.4s, v21.4s, v19.4s + add v16.4s, v16.4s, v19.4s + add v21.4s, v21.4s, v22.4s + + sub x2, x2, #8 + add w6, w6, #1 // i += 1 + add x2, x2, x3 // grad += gstride - size * ALF_NUM_DIR + b 6b +60: + st1 {v16.4s}, [x0] + st1 {v21.4s}, [x1] + ret +.endm + + +function ff_alf_classify_sum_neon, export=1 + ff_alf_classify_sum +endfunc + +function ff_alf_classify_grad_8_neon, export=1 + ff_alf_classify_grad 1 +endfunc + +function ff_alf_classify_grad_10_neon, export=1 + ff_alf_classify_grad 2 +endfunc + +function ff_alf_classify_grad_12_neon, export=1 + ff_alf_classify_grad 2 +endfunc diff --git a/libavcodec/aarch64/vvc/alf_template.c b/libavcodec/aarch64/vvc/alf_template.c index 41f7bf8995..470222a634 100644 --- a/libavcodec/aarch64/vvc/alf_template.c +++ b/libavcodec/aarch64/vvc/alf_template.c @@ -155,3 +155,90 @@ static void FUNC2(alf_filter_chroma, BIT_DEPTH, _neon)(uint8_t *_dst, } } } + +#define ALF_DIR_VERT 0 +#define ALF_DIR_HORZ 1 +#define ALF_DIR_DIGA0 2 +#define ALF_DIR_DIGA1 3 + +static void FUNC(ff_alf_get_idx)(int *class_idx, int *transpose_idx, const int *sum, const int ac) +{ + static const int arg_var[] = {0, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4 }; + + int hv0, hv1, dir_hv, d0, d1, dir_d, hvd1, hvd0, sum_hv, dir1; + + dir_hv = sum[ALF_DIR_VERT] <= sum[ALF_DIR_HORZ]; + hv1 = FFMAX(sum[ALF_DIR_VERT], sum[ALF_DIR_HORZ]); + hv0 = FFMIN(sum[ALF_DIR_VERT], sum[ALF_DIR_HORZ]); + + dir_d = sum[ALF_DIR_DIGA0] <= sum[ALF_DIR_DIGA1]; + d1 = FFMAX(sum[ALF_DIR_DIGA0], sum[ALF_DIR_DIGA1]); + d0 = FFMIN(sum[ALF_DIR_DIGA0], sum[ALF_DIR_DIGA1]); + + //promote to avoid overflow + dir1 = (uint64_t)d1 * hv0 <= (uint64_t)hv1 * d0; + hvd1 = dir1 ? hv1 : d1; + hvd0 = dir1 ? hv0 : d0; + + sum_hv = sum[ALF_DIR_HORZ] + sum[ALF_DIR_VERT]; + *class_idx = arg_var[av_clip_uintp2(sum_hv * ac >> (BIT_DEPTH - 1), 4)]; + if (hvd1 * 2 > 9 * hvd0) + *class_idx += ((dir1 << 1) + 2) * 5; + else if (hvd1 > 2 * hvd0) + *class_idx += ((dir1 << 1) + 1) * 5; + + *transpose_idx = dir_d * 2 + dir_hv; +} + +static void FUNC(ff_alf_classify)(int *class_idx, int *transpose_idx, + const uint8_t *_src, const ptrdiff_t _src_stride, const int width, const int height, + const int vb_pos, int16_t *gradient_tmp) +{ + int16_t *grad; + + const int w = width + ALF_GRADIENT_BORDER * 2; + const int size = (ALF_BLOCK_SIZE + ALF_GRADIENT_BORDER * 2) / ALF_GRADIENT_STEP; + const int gstride = (w / ALF_GRADIENT_STEP) * ALF_NUM_DIR; + const int gshift = gstride - size * ALF_NUM_DIR; + + for (int y = 0; y < height ; y += ALF_BLOCK_SIZE ) { + int start = 0; + int end = (ALF_BLOCK_SIZE + ALF_GRADIENT_BORDER * 2) / ALF_GRADIENT_STEP; + int ac = 2; + if (y + ALF_BLOCK_SIZE == vb_pos) { + end -= ALF_GRADIENT_BORDER / ALF_GRADIENT_STEP; + ac = 3; + } else if (y == vb_pos) { + start += ALF_GRADIENT_BORDER / ALF_GRADIENT_STEP; + ac = 3; + } + for (int x = 0; x < width; x += (2*ALF_BLOCK_SIZE)) { + const int xg = x / ALF_GRADIENT_STEP; + const int yg = y / ALF_GRADIENT_STEP; + int sum0[ALF_NUM_DIR]; + int sum1[ALF_NUM_DIR]; + grad = gradient_tmp + (yg + start) * gstride + xg * ALF_NUM_DIR; + ff_alf_classify_sum_neon(sum0, sum1, grad, gshift, end-start); + FUNC(ff_alf_get_idx)(class_idx, transpose_idx, sum0, ac); + class_idx++; + transpose_idx++; + FUNC(ff_alf_get_idx)(class_idx, transpose_idx, sum1, ac); + class_idx++; + transpose_idx++; + } + } + +} + +void FUNC2(ff_alf_classify_grad, BIT_DEPTH, _neon)(int *class_idx, int *transpose_idx, + const uint8_t *_src, const ptrdiff_t _src_stride, const int width, const int height, + const int vb_pos, int16_t *gradient_tmp); + + +static void FUNC2(alf_classify, BIT_DEPTH, _neon)(int *class_idx, int *transpose_idx, + const uint8_t *_src, const ptrdiff_t _src_stride, const int width, const int height, + const int vb_pos, int *gradient_tmp) { + FUNC2(ff_alf_classify_grad, BIT_DEPTH, _neon)(class_idx, transpose_idx, _src, _src_stride, width, height, vb_pos, (int16_t*)gradient_tmp); + FUNC(ff_alf_classify)(class_idx, transpose_idx, _src, _src_stride, width, height, vb_pos, (int16_t*)gradient_tmp); +} + diff --git a/libavcodec/aarch64/vvc/dsp_init.c b/libavcodec/aarch64/vvc/dsp_init.c index 9a171234f6..75360d33f3 100644 --- a/libavcodec/aarch64/vvc/dsp_init.c +++ b/libavcodec/aarch64/vvc/dsp_init.c @@ -42,6 +42,9 @@ void ff_vvc_derive_bdof_vx_vy_neon(const int16_t *_src0, const int16_t *_src1, const int16_t **gradient_h, const int16_t **gradient_v, int16_t *vx, int16_t *vy); + +void ff_alf_classify_sum_neon(int *sum0, int *sum1, int16_t *grad, uint32_t gshift, uint32_t steps); + #define BIT_DEPTH 8 #include "alf_template.c" #include "of_template.c" @@ -205,6 +208,7 @@ void ff_vvc_dsp_init_aarch64(VVCDSPContext *const c, const int bd) c->sao.edge_filter[i] = ff_vvc_sao_edge_filter_16x16_8_neon; c->alf.filter[LUMA] = alf_filter_luma_8_neon; c->alf.filter[CHROMA] = alf_filter_chroma_8_neon; + c->alf.classify = alf_classify_8_neon; if (have_i8mm(cpu_flags)) { c->inter.put[0][1][0][1] = ff_vvc_put_qpel_h4_8_neon_i8mm; @@ -243,6 +247,7 @@ void ff_vvc_dsp_init_aarch64(VVCDSPContext *const c, const int bd) c->alf.filter[LUMA] = alf_filter_luma_10_neon; c->alf.filter[CHROMA] = alf_filter_chroma_10_neon; + c->alf.classify = alf_classify_10_neon; } else if (bd == 12) { c->inter.avg = ff_vvc_avg_12_neon; c->inter.w_avg = vvc_w_avg_12; @@ -252,6 +257,7 @@ void ff_vvc_dsp_init_aarch64(VVCDSPContext *const c, const int bd) c->alf.filter[LUMA] = alf_filter_luma_12_neon; c->alf.filter[CHROMA] = alf_filter_chroma_12_neon; + c->alf.classify = alf_classify_12_neon; } c->inter.sad = ff_vvc_sad_neon; -- 2.34.1

3 5

STF 2025 grant request (2025-09-01 target)
by Pierre-Anthony Lemieux 27 Aug '25

27 Aug '25

Hi all, As with last year, Michael asked me to help coordinate the creation of grant request to the STF: https://trac.ffmpeg.org/wiki/SponsoringPrograms/STF/2025 The objective remains to unlock funds for individuals that are interested in contributing to the FFMPEG codebase. The proposed deadline for individuals to submit their proposal is 2025-09-01. The proposals will be published at the link above upon submission. I am happy to collate the proposals and forward the grant request to SPI, who would handle the submission to STF and payments to contributors as the case may be. I am also happy to do nothing. This activity is completely voluntary, there is no guarantee that all (or any) proposals will be accepted by SPI and/or STF, and the chances of success are unknown (to me). The activity was reasonably successful last year. Best, -- Pierre

7 18

[PATCH 1/1] add option in file.c: pkt_size to set max_packet_size
by 1441923451＠qq.com 25 Aug '25

25 Aug '25

From: yangsen5 <1441923451(a)qq.com> Signed-off-by: yangsen5 <1441923451(a)qq.com> --- libavformat/file.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/libavformat/file.c b/libavformat/file.c index 6a66040b65..8099a7e931 100644 --- a/libavformat/file.c +++ b/libavformat/file.c @@ -94,6 +94,7 @@ typedef struct FileContext { int fd; int trunc; int blocksize; + int pkt_size; int follow; int seekable; #if HAVE_DIRENT_H @@ -106,6 +107,7 @@ static const AVOption file_options[] = { { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM }, { "follow", "Follow a file as it is being written", offsetof(FileContext, follow), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM }, { "seekable", "Sets if the file is seekable", offsetof(FileContext, seekable), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM }, + { "pkt_size", "Maximum file packet size", offsetof(FileContext, pkt_size), AV_OPT_TYPE_INT, { .i64 = 262144 }, -1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM }, { NULL } }; @@ -313,7 +315,7 @@ static int file_open(URLContext *h, const char *filename, int flags) /* Buffer writes more than the default 32k to improve throughput especially * with networked file systems */ if (!h->is_streamed && flags & AVIO_FLAG_WRITE) - h->min_packet_size = h->max_packet_size = 262144; + h->min_packet_size = h->max_packet_size = c->pkt_size; if (c->seekable >= 0) h->is_streamed = !c->seekable; -- 2.34.1

4 6

FFmpeg 8.0 Release
by Michael Niedermayer 21 Aug '25

21 Aug '25

Hi everyone I intend to create the release/8.0 branch in the next 1-2 weeks after that i intend to make teh 8.0 release in the following 1-2 weeks If theres something you want in it make sure its pushed before the branch is made. And if theres a bugfix that you want included make sure it either hits master before the branch point or cherry pick it into release/8.0 before the release Also name ideas as always are welcome, will choose teh one with most votes. If theres a tie, i plan to vote last so i can break ties thx -- Michael GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB The real ebay dictionary, page 1 "Used only once" - "Some unspecified defect prevented a second use" "In good condition" - "Can be repaird by experienced expert" "As is" - "You wouldnt want it even if you were payed for it, if you knew ..."

14 30

[RFC] Advanced Error Codes
by Michael Niedermayer 16 Aug '25

16 Aug '25

Hi People are asking for better error codes Heres a quick pseodocode design / implementation / brainstorming: I hope iam not re-doing some past one but i didnt quickly find a past discussion Observations. Errors are for developers debuging or users resolving problems We rarely care about more then 2-3 independant errors but we care about their history like from where they came and how and what arguments caused them We also care about the error free case being fast, really fast We are lazy we dont want maintaince burden We also dont want to deal with maintaining matching cleanup for each generated error Idea 1 + very simple + fully compatible can be freely mixed with existing error codes - needs a global table + we never alloc, so we have no cleanup to do + zero overhead for passing around as its just integers Idea 2 (Alternatrive) This is exactly like Idea 1 but using thread local instead of a global tabl + No mutex + no global table + no denial of service if a thread blasts errors out while another has an occasional error - Thread local table - More complex and slow to move errors accross thread boundaries For both ideas: * New error codes are 64bit * if they are trunctaed to 32bit they are a valid 32bit error code like AVERROR(EIO) * That means the new error codes are 32bit (existing error code for compatibility) and 32bit (a identifier into a fixed size table.) Pseudocode: #define MAX_CONCURRENT_ERRORS 256 // error 256 will use slot 0, 257 slot 1 and so on #define MASK (MAX_CONCURRENT_ERRORS - 1) #define FREE_FORM_LEN 64 //probably we will need more, can just be bumped typedef struct AdvancedError { const char *error_name; ///< like "Timeout" or "Invalid Bitstream" const char *operation_name; ///< like "Network Read" or "H.264 block parsing" const char *source_filename; ///< like ffmpeg.c int source_line_number; ///< like line 123 in ffmpeg.c char free_form_description[FREE_FORM_LEN]; ///< anything extra that doesnt fit in pointers to static const strings int64_t this_error; int64_t previous_error; ///< A previous related error, if any int64_t timestamp; ///< Timestamp at which the error occured int thread_id; } AdvancedError; struct AdvancedError advanced_error[MAX_CONCURRENT_ERRORS]; // the whole is 32kb ATM int64_t av_adv_err_new(int error_code, const char *error_name, const char *operation_name, const char *source_filename, int source_line_number, int64_t previous_error, const char free_form_description[FREE_FORM_LEN], ) { pthread_mutex_lock() int64_t err = error_code + (counter++ << 32); AdvancedError *ae = &advanced_error[(err>>32) & MASK]; ae->error_name = error_name; ae->operation_name = operation_name; ae->source_filename = source_filename; ae->source_line_number = source_line_number; ae->this_error = err; ae->previous_error = previous_error; ae->timestamp = av_gettime(); memcpy(ae->free_form_description, free_form_description, FREE_FORM_LEN); pthread_mutex_unlock() return err; } /** * Retrieve AdvancedError struct for a given error code or fail * @param adv_err [OUT] where to store the AdvancedError in * * @return 0 on success negative on failure */ int av_adv_err_retrieve(int64_t err, AdvancedError *adv_err) { int ret = -1; pthread_mutex_lock() int index = err >> 32; if (advanced_error[index & MASK].this_error == err) { memcpy(adv_err, &advanced_error[index & MASK], sizeof(adv_err)); ret = 0; } pthread_mutex_unlock() return ret; } -- Michael GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB If you drop bombs on a foreign country and kill a hundred thousand innocent people, expect your government to call the consequence "unprovoked inhuman terrorist attacks" and use it to justify dropping more bombs and killing more people. The technology changed, the idea is old.

2 12

[PATCH] Revert "avformat/mpegts: update stream info when PMT ES stream_type changes"
by Michael Niedermayer 16 Aug '25

16 Aug '25

This fixes mixing up contexts, use of uninitialized data and crashes. More specifically: ==1001752== Conditional jump or move depends on uninitialised value(s) ==1001752== at 0xA9ED82: avpriv_h264_has_num_reorder_frames (h264dec.c:64) ==1001752== by 0x668C7E: has_decode_delay_been_guessed (demux.c:757) ==1001752== by 0x66AB13: compute_pkt_fields (demux.c:1137) ==1001752== by 0x66B2E9: parse_packet (demux.c:1265) ==1001752== by 0x66BD84: read_frame_internal (demux.c:1449) ==1001752== by 0x67085B: avformat_find_stream_info (demux.c:2692) ==1001752== by 0x25157C: ifile_open (ffmpeg_demux.c:1814) ==1001752== by 0x272B15: open_files (ffmpeg_opt.c:1366) ==1001752== by 0x272D85: ffmpeg_parse_options (ffmpeg_opt.c:1415) ==1001752== by 0x2925C9: main (ffmpeg.c:991) ==1001752== Uninitialised value was created by a heap allocation ==1001752== at 0x483E0F0: memalign (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so) ==1001752== by 0x483E212: posix_memalign (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so) ==1001752== by 0x14882CE: av_malloc (mem.c:107) ==1001752== by 0x1463785: av_buffer_alloc (buffer.c:82) ==1001752== by 0x146423F: pool_alloc_buffer (buffer.c:369) ==1001752== by 0x14643C4: av_buffer_pool_get (buffer.c:407) ==1001752== by 0x752C4B: buffer_pool_get (mpegts.c:1142) ==1001752== by 0x7538F2: mpegts_push_data (mpegts.c:1407) ==1001752== by 0x758893: handle_packet (mpegts.c:2909) ==1001752== by 0x758E90: handle_packets (mpegts.c:3048) ==1001752== by 0x759B1D: mpegts_read_packet (mpegts.c:3290) ==1001752== by 0x6687A3: ff_read_packet (demux.c:649) ==1001752== by 0x66B594: read_frame_internal (demux.c:1346) ==1001752== by 0x67085B: avformat_find_stream_info (demux.c:2692) ==1001752== by 0x25157C: ifile_open (ffmpeg_demux.c:1814) ==1001752== by 0x272B15: open_files (ffmpeg_opt.c:1366) ==1001752== by 0x272D85: ffmpeg_parse_options (ffmpeg_opt.c:1415) ==1001752== by 0x2925C9: main (ffmpeg.c:991) Found-by: Alexander A. Shvedov <shvedov(a)gmx.com> CC: Pavel Koshevoy <pkoshevoy(a)gmail.com> This reverts commit 0021484d05f9b0f032fa319399de6e24eea0c04f. --- libavformat/mpegts.c | 4 +--- tests/ref/fate/ts-demux | 4 ++-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c index deb69a0548b..54594b3a11b 100644 --- a/libavformat/mpegts.c +++ b/libavformat/mpegts.c @@ -940,8 +940,6 @@ static int mpegts_set_stream_info(AVStream *st, PESContext *pes, mpegts_find_stream_type(st, pes->stream_type, ISO_types); if (pes->stream_type == STREAM_TYPE_AUDIO_MPEG2 || pes->stream_type == STREAM_TYPE_AUDIO_AAC) sti->request_probe = 50; - if (pes->stream_type == STREAM_TYPE_PRIVATE_DATA) - sti->request_probe = AVPROBE_SCORE_STREAM_RETRY; if ((prog_reg_desc == AV_RL32("HDMV") || prog_reg_desc == AV_RL32("HDPR")) && st->codecpar->codec_id == AV_CODEC_ID_NONE) { @@ -2510,7 +2508,7 @@ static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len if (!st) goto out; - if (pes && pes->stream_type != stream_type) + if (pes && !pes->stream_type) mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc); add_pid_to_program(prg, pid); diff --git a/tests/ref/fate/ts-demux b/tests/ref/fate/ts-demux index d56cc279379..6a830d0d99f 100644 --- a/tests/ref/fate/ts-demux +++ b/tests/ref/fate/ts-demux @@ -24,6 +24,6 @@ packet|codec_type=video|stream_index=0|pts=3912686363|pts_time=43474.292922|dts= packet|codec_type=audio|stream_index=1|pts=3912644825|pts_time=43473.831389|dts=3912644825|dts_time=43473.831389|duration=2880|duration_time=0.032000|size=906|pos=474888|flags=K__|data_hash=CRC32:0893d398 packet|codec_type=audio|stream_index=2|pts=3912645580|pts_time=43473.839778|dts=3912645580|dts_time=43473.839778|duration=2880|duration_time=0.032000|size=354|pos=491808|flags=K__|data_hash=CRC32:f5963fa6 stream|index=0|codec_name=mpeg2video|profile=4|codec_type=video|codec_tag_string=[2][0][0][0]|codec_tag=0x0002|width=1280|height=720|coded_width=0|coded_height=0|has_b_frames=1|sample_aspect_ratio=1:1|display_aspect_ratio=16:9|pix_fmt=yuv420p|level=4|color_range=tv|color_space=unknown|color_transfer=unknown|color_primaries=unknown|chroma_location=left|field_order=progressive|refs=1|ts_id=32776|ts_packetsize=188|id=0x31|r_frame_rate=60000/1001|avg_frame_rate=60000/1001|time_base=1/90000|start_pts=3912669846|start_time=43474.109400|duration_ts=19519|duration=0.216878|bit_rate=15000000|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=N/A|nb_read_packets=15|extradata_size=150|extradata_hash=CRC32:53134fa8|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|disposition:non_diegetic=0|disposition:captions=0|disposition:descriptions=0|disposition:metadata=0|disposition:dependent=0|disposition:still_image=0|disposition:multilayer=0|side_datum/cpb_properties:side_data_type=CPB properties|side_datum/cpb_properties:max_bitrate=15000000|side_datum/cpb_properties:min_bitrate=0|side_datum/cpb_properties:avg_bitrate=0|side_datum/cpb_properties:buffer_size=9781248|side_datum/cpb_properties:vbv_delay=-1 -stream|index=1|codec_name=ac3|profile=unknown|codec_type=audio|codec_tag_string=[6][0][0][0]|codec_tag=0x0006|sample_fmt=fltp|sample_rate=48000|channels=6|channel_layout=5.1(side)|bits_per_sample=0|initial_padding=0|dmix_mode=0|ltrt_cmixlev=0.000000|ltrt_surmixlev=0.000000|loro_cmixlev=0.000000|loro_surmixlev=0.000000|ts_id=32776|ts_packetsize=188|id=0x34|r_frame_rate=0/0|avg_frame_rate=0/0|time_base=1/90000|start_pts=3912633305|start_time=43473.703389|duration_ts=14400|duration=0.160000|bit_rate=384000|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=N/A|nb_read_packets=5|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|disposition:non_diegetic=0|disposition:captions=0|disposition:descriptions=0|disposition:metadata=0|disposition:dependent=0|disposition:still_image=0|disposition:multilayer=0|tag:language=eng -stream|index=2|codec_name=ac3|profile=unknown|codec_type=audio|codec_tag_string=[6][0][0][0]|codec_tag=0x0006|sample_fmt=fltp|sample_rate=48000|channels=2|channel_layout=stereo|bits_per_sample=0|initial_padding=0|dmix_mode=0|ltrt_cmixlev=0.000000|ltrt_surmixlev=0.000000|loro_cmixlev=0.000000|loro_surmixlev=0.000000|ts_id=32776|ts_packetsize=188|id=0x35|r_frame_rate=0/0|avg_frame_rate=0/0|time_base=1/90000|start_pts=3912634060|start_time=43473.711778|duration_ts=14400|duration=0.160000|bit_rate=192000|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=N/A|nb_read_packets=5|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|disposition:non_diegetic=0|disposition:captions=0|disposition:descriptions=0|disposition:metadata=0|disposition:dependent=0|disposition:still_image=0|disposition:multilayer=0|tag:language=es +stream|index=1|codec_name=ac3|profile=unknown|codec_type=audio|codec_tag_string=[4][0][0][0]|codec_tag=0x0004|sample_fmt=fltp|sample_rate=48000|channels=6|channel_layout=5.1(side)|bits_per_sample=0|initial_padding=0|dmix_mode=0|ltrt_cmixlev=0.000000|ltrt_surmixlev=0.000000|loro_cmixlev=0.000000|loro_surmixlev=0.000000|ts_id=32776|ts_packetsize=188|id=0x34|r_frame_rate=0/0|avg_frame_rate=0/0|time_base=1/90000|start_pts=3912633305|start_time=43473.703389|duration_ts=14400|duration=0.160000|bit_rate=384000|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=N/A|nb_read_packets=5|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|disposition:non_diegetic=0|disposition:captions=0|disposition:descriptions=0|disposition:metadata=0|disposition:dependent=0|disposition:still_image=0|disposition:multilayer=0|tag:language=eng +stream|index=2|codec_name=ac3|profile=unknown|codec_type=audio|codec_tag_string=[4][0][0][0]|codec_tag=0x0004|sample_fmt=fltp|sample_rate=48000|channels=2|channel_layout=stereo|bits_per_sample=0|initial_padding=0|dmix_mode=0|ltrt_cmixlev=0.000000|ltrt_surmixlev=0.000000|loro_cmixlev=0.000000|loro_surmixlev=0.000000|ts_id=32776|ts_packetsize=188|id=0x35|r_frame_rate=0/0|avg_frame_rate=0/0|time_base=1/90000|start_pts=3912634060|start_time=43473.711778|duration_ts=14400|duration=0.160000|bit_rate=192000|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=N/A|nb_read_packets=5|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|disposition:non_diegetic=0|disposition:captions=0|disposition:descriptions=0|disposition:metadata=0|disposition:dependent=0|disposition:still_image=0|disposition:multilayer=0|tag:language=es format|filename=mp3ac325-4864-small.ts|nb_streams=3|nb_programs=1|nb_stream_groups=0|format_name=mpegts|start_time=43473.703389|duration=0.622889|size=512000|bit_rate=6575810|probe_score=50 -- 2.49.0

3 8

Re: [FFmpeg-devel] [PATCH v2] ffprobe: add -codec:<media_spec> option
by Stefano Sabatini 10 Aug '25

10 Aug '25

On date Friday 2025-06-27 10:23:56 +0200, ffmpeg-devel Mailing List wrote: > From: Maryla Ustarroz-Calonge <maryla(a)google.com> > Subject: [PATCH v2] ffprobe: add -codec:<media_spec> option > Date: Fri, 27 Jun 2025 10:23:56 +0200 > To: ffmpeg-devel(a)ffmpeg.org > X-Mailer: git-send-email 2.50.0.727.gbf7dc18ff4-goog > > And -c:<media_spec> variant. > Update ffprobe.texi. > opt_codec() is mostly copied over from ffplay.c > > Signed-off-by: Maryla Ustarroz-Calonge <maryla(a)google.com> > --- > Changelog | 2 +- > doc/ffprobe.texi | 8 ++++ > fftools/ffprobe.c | 117 +++++++++++++++++++++++++++++++++++++++++----- > 3 files changed, 114 insertions(+), 13 deletions(-) > > diff --git a/Changelog b/Changelog > index 4217449438..ae73611222 100644 > --- a/Changelog > +++ b/Changelog > @@ -18,7 +18,7 @@ version <next>: > - APV encoding support through a libopenapv wrapper > - VVC decoder supports all content of SCC (Screen Content Coding): > IBC (Inter Block Copy), Palette Mode and ACT (Adaptive Color Transform > - > +- ffprobe -codec option > > version 7.1: > - Raw Captions with Time (RCWT) closed caption demuxer > diff --git a/doc/ffprobe.texi b/doc/ffprobe.texi > index 8834df8d35..4ce0c8b583 100644 > --- a/doc/ffprobe.texi > +++ b/doc/ffprobe.texi > @@ -368,6 +368,14 @@ Read @var{input_url}. > Write output to @var{output_url}. If not specified, the output is sent > to stdout. > > +@item -c:@var{media_specifier} @var{codec_name} > +Force a specific decoder implementation for the stream identified by > +@var{media_specifier}, which can assume the values @code{a} (audio), > +@code{v} (video), @code{s} (subtitle), and @code{d} (data). > + > +@item -codec:@var{media_specifier} @var{codec_name} > +Alias for -c:@var{media_specifier}. Nit: I'd put the long version before the short one, but keep as is if this is consistent with the other docs. > + > @end table > @c man end > > diff --git a/fftools/ffprobe.c b/fftools/ffprobe.c > index 1346ed33c5..14ba4d3fb0 100644 > --- a/fftools/ffprobe.c > +++ b/fftools/ffprobe.c > @@ -36,6 +36,7 @@ > #include "libavutil/ambient_viewing_environment.h" > #include "libavutil/avassert.h" > #include "libavutil/avstring.h" > +#include "libavutil/avutil.h" > #include "libavutil/bprint.h" > #include "libavutil/channel_layout.h" > #include "libavutil/display.h" > @@ -130,6 +131,11 @@ static int use_byte_value_binary_prefix = 0; > static int use_value_sexagesimal_format = 0; > static int show_private_data = 1; > > +static const char *audio_codec_name = NULL; > +static const char *data_codec_name = NULL; > +static const char *subtitle_codec_name = NULL; > +static const char *video_codec_name = NULL; > + > #define SHOW_OPTIONAL_FIELDS_AUTO -1 > #define SHOW_OPTIONAL_FIELDS_NEVER 0 > #define SHOW_OPTIONAL_FIELDS_ALWAYS 1 > @@ -2284,6 +2290,64 @@ static void show_error(AVTextFormatContext *tfc, int err) > avtext_print_section_footer(tfc); > } > > +static int get_decoder_by_name(const char *codec_name, const AVCodec **codec) > +{ > + if (codec_name == NULL) > + return 0; > + > + *codec = avcodec_find_decoder_by_name(codec_name); > + if (*codec == NULL) { > + av_log(NULL, AV_LOG_ERROR, > + "No codec could be found with name '%s'\n", codec_name); > + return AVERROR(EINVAL); > + } > + return 0; > +} > + > +static int set_decoders(AVFormatContext *fmt_ctx) > +{ > + int ret; > + ret = get_decoder_by_name(audio_codec_name, &fmt_ctx->audio_codec); > + if (ret < 0) return ret; nit++: could be turned to a macro to capture the pattern: #define GET_DECODER(type_) \ ret = get_decoder_by_name(type_##_codec_name, &fmt_ctx->type_##_codec);\ if (ret < 0) return ret; GET_DECODER(audio); GET_DECODER(data); ... > + ret = get_decoder_by_name(data_codec_name, &fmt_ctx->data_codec); > + if (ret < 0) return ret; > + ret = get_decoder_by_name(subtitle_codec_name, &fmt_ctx->subtitle_codec); > + if (ret < 0) return ret; > + ret = get_decoder_by_name(video_codec_name, &fmt_ctx->video_codec); > + if (ret < 0) return ret; > + return 0; > +} > + Looks good apart from the minor nits, you can update the patch with the extended commit description otherwise I'd push this in a few days if there are no more comments. Thanks.

2 2