FFmpeg
swscale.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "config.h"
20 #include "libavutil/attributes.h"
21 #include "libswscale/swscale.h"
22 #include "libswscale/swscale_internal.h"
23 #include "libavutil/aarch64/cpu.h"
24 
25 void ff_hscale16to15_4_neon_asm(int shift, int16_t *_dst, int dstW,
26  const uint8_t *_src, const int16_t *filter,
27  const int32_t *filterPos, int filterSize);
28 void ff_hscale16to15_X8_neon_asm(int shift, int16_t *_dst, int dstW,
29  const uint8_t *_src, const int16_t *filter,
30  const int32_t *filterPos, int filterSize);
31 void ff_hscale16to15_X4_neon_asm(int shift, int16_t *_dst, int dstW,
32  const uint8_t *_src, const int16_t *filter,
33  const int32_t *filterPos, int filterSize);
34 void ff_hscale16to19_4_neon_asm(int shift, int16_t *_dst, int dstW,
35  const uint8_t *_src, const int16_t *filter,
36  const int32_t *filterPos, int filterSize);
37 void ff_hscale16to19_X8_neon_asm(int shift, int16_t *_dst, int dstW,
38  const uint8_t *_src, const int16_t *filter,
39  const int32_t *filterPos, int filterSize);
40 void ff_hscale16to19_X4_neon_asm(int shift, int16_t *_dst, int dstW,
41  const uint8_t *_src, const int16_t *filter,
42  const int32_t *filterPos, int filterSize);
43 
44 static void ff_hscale16to15_4_neon(SwsInternal *c, int16_t *_dst, int dstW,
45  const uint8_t *_src, const int16_t *filter,
46  const int32_t *filterPos, int filterSize)
47 {
48  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
49  int sh = desc->comp[0].depth - 1;
50 
51  if (sh<15) {
52  sh = isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
53  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
54  sh = 16 - 1;
55  }
56  ff_hscale16to15_4_neon_asm(sh, _dst, dstW, _src, filter, filterPos, filterSize);
57 
58 }
59 
60 static void ff_hscale16to15_X8_neon(SwsInternal *c, int16_t *_dst, int dstW,
61  const uint8_t *_src, const int16_t *filter,
62  const int32_t *filterPos, int filterSize)
63 {
64  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
65  int sh = desc->comp[0].depth - 1;
66 
67  if (sh<15) {
68  sh = isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
69  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
70  sh = 16 - 1;
71  }
72  ff_hscale16to15_X8_neon_asm(sh, _dst, dstW, _src, filter, filterPos, filterSize);
73 
74 }
75 
76 static void ff_hscale16to15_X4_neon(SwsInternal *c, int16_t *_dst, int dstW,
77  const uint8_t *_src, const int16_t *filter,
78  const int32_t *filterPos, int filterSize)
79 {
80  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
81  int sh = desc->comp[0].depth - 1;
82 
83  if (sh<15) {
84  sh = isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
85  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
86  sh = 16 - 1;
87  }
88  ff_hscale16to15_X4_neon_asm(sh, _dst, dstW, _src, filter, filterPos, filterSize);
89 }
90 
91 static void ff_hscale16to19_4_neon(SwsInternal *c, int16_t *_dst, int dstW,
92  const uint8_t *_src, const int16_t *filter,
93  const int32_t *filterPos, int filterSize)
94 {
95  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
96  int bits = desc->comp[0].depth - 1;
97  int sh = bits - 4;
98 
99  if ((isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
100  sh = 9;
101  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
102  sh = 16 - 1 - 4;
103  }
104 
105  ff_hscale16to19_4_neon_asm(sh, _dst, dstW, _src, filter, filterPos, filterSize);
106 
107 }
108 
109 static void ff_hscale16to19_X8_neon(SwsInternal *c, int16_t *_dst, int dstW,
110  const uint8_t *_src, const int16_t *filter,
111  const int32_t *filterPos, int filterSize)
112 {
113  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
114  int bits = desc->comp[0].depth - 1;
115  int sh = bits - 4;
116 
117  if ((isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
118  sh = 9;
119  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
120  sh = 16 - 1 - 4;
121  }
122 
123  ff_hscale16to19_X8_neon_asm(sh, _dst, dstW, _src, filter, filterPos, filterSize);
124 
125 }
126 
127 static void ff_hscale16to19_X4_neon(SwsInternal *c, int16_t *_dst, int dstW,
128  const uint8_t *_src, const int16_t *filter,
129  const int32_t *filterPos, int filterSize)
130 {
131  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
132  int bits = desc->comp[0].depth - 1;
133  int sh = bits - 4;
134 
135  if ((isAnyRGB(c->opts.src_format) || c->opts.src_format==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
136  sh = 9;
137  } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) { /* float input are process like uint 16bpc */
138  sh = 16 - 1 - 4;
139  }
140 
141  ff_hscale16to19_X4_neon_asm(sh, _dst, dstW, _src, filter, filterPos, filterSize);
142 
143 }
144 
145 #define SCALE_FUNC(filter_n, from_bpc, to_bpc, opt) \
146 void ff_hscale ## from_bpc ## to ## to_bpc ## _ ## filter_n ## _ ## opt( \
147  SwsInternal *c, int16_t *data, \
148  int dstW, const uint8_t *src, \
149  const int16_t *filter, \
150  const int32_t *filterPos, int filterSize)
151 #define SCALE_FUNCS(filter_n, opt) \
152  SCALE_FUNC(filter_n, 8, 15, opt); \
153  SCALE_FUNC(filter_n, 8, 19, opt);
154 #define ALL_SCALE_FUNCS(opt) \
155  SCALE_FUNCS(4, opt); \
156  SCALE_FUNCS(X8, opt); \
157  SCALE_FUNCS(X4, opt)
158 
159 ALL_SCALE_FUNCS(neon);
160 
161 void ff_yuv2planeX_8_neon(const int16_t *filter, int filterSize,
162  const int16_t **src, uint8_t *dest, int dstW,
163  const uint8_t *dither, int offset);
164 void ff_yuv2plane1_8_neon(
165  const int16_t *src,
166  uint8_t *dest,
167  int dstW,
168  const uint8_t *dither,
169  int offset);
170 
171 #define ASSIGN_SCALE_FUNC2(hscalefn, filtersize, opt) do { \
172  if (c->srcBpc == 8) { \
173  if(c->dstBpc <= 14) { \
174  hscalefn = \
175  ff_hscale8to15_ ## filtersize ## _ ## opt; \
176  } else \
177  hscalefn = \
178  ff_hscale8to19_ ## filtersize ## _ ## opt; \
179  } else { \
180  if (c->dstBpc <= 14) \
181  hscalefn = \
182  ff_hscale16to15_ ## filtersize ## _ ## opt; \
183  else \
184  hscalefn = \
185  ff_hscale16to19_ ## filtersize ## _ ## opt; \
186  } \
187 } while (0)
188 
189 #define ASSIGN_SCALE_FUNC(hscalefn, filtersize, opt) do { \
190  if (filtersize == 4) \
191  ASSIGN_SCALE_FUNC2(hscalefn, 4, opt); \
192  else if (filtersize % 8 == 0) \
193  ASSIGN_SCALE_FUNC2(hscalefn, X8, opt); \
194  else if (filtersize % 4 == 0 && filtersize % 8 != 0) \
195  ASSIGN_SCALE_FUNC2(hscalefn, X4, opt); \
196 } while (0)
197 
198 #define ASSIGN_VSCALE_FUNC(vscalefn, opt) \
199  switch (c->dstBpc) { \
200  case 8: vscalefn = ff_yuv2plane1_8_ ## opt; break; \
201  default: break; \
202  }
203 
204 #define NEON_INPUT(name) \
205 void ff_##name##ToY_neon(uint8_t *dst, const uint8_t *src, const uint8_t *, \
206  const uint8_t *, int w, uint32_t *coeffs, void *); \
207 void ff_##name##ToUV_neon(uint8_t *, uint8_t *, const uint8_t *, \
208  const uint8_t *, const uint8_t *, int w, \
209  uint32_t *coeffs, void *); \
210 void ff_##name##ToUV_half_neon(uint8_t *, uint8_t *, const uint8_t *, \
211  const uint8_t *, const uint8_t *, int w, \
212  uint32_t *coeffs, void *)
213 
214 NEON_INPUT(abgr32);
215 NEON_INPUT(argb32);
216 NEON_INPUT(bgr24);
217 NEON_INPUT(bgra32);
218 NEON_INPUT(rgb24);
219 NEON_INPUT(rgba32);
220 
221 void ff_lumRangeFromJpeg8_neon(int16_t *dst, int width,
222  uint32_t coeff, int64_t offset);
223 void ff_chrRangeFromJpeg8_neon(int16_t *dstU, int16_t *dstV, int width,
224  uint32_t coeff, int64_t offset);
225 void ff_lumRangeToJpeg8_neon(int16_t *dst, int width,
226  uint32_t coeff, int64_t offset);
227 void ff_chrRangeToJpeg8_neon(int16_t *dstU, int16_t *dstV, int width,
228  uint32_t coeff, int64_t offset);
229 void ff_lumRangeFromJpeg16_neon(int16_t *dst, int width,
230  uint32_t coeff, int64_t offset);
231 void ff_chrRangeFromJpeg16_neon(int16_t *dstU, int16_t *dstV, int width,
232  uint32_t coeff, int64_t offset);
233 void ff_lumRangeToJpeg16_neon(int16_t *dst, int width,
234  uint32_t coeff, int64_t offset);
235 void ff_chrRangeToJpeg16_neon(int16_t *dstU, int16_t *dstV, int width,
236  uint32_t coeff, int64_t offset);
237 
238 av_cold void ff_sws_init_range_convert_aarch64(SwsInternal *c)
239 {
240  int cpu_flags = av_get_cpu_flags();
241 
242  if (have_neon(cpu_flags)) {
243  if (c->dstBpc <= 14) {
244  if (c->opts.src_range) {
245  c->lumConvertRange = ff_lumRangeFromJpeg8_neon;
246  c->chrConvertRange = ff_chrRangeFromJpeg8_neon;
247  } else {
248  c->lumConvertRange = ff_lumRangeToJpeg8_neon;
249  c->chrConvertRange = ff_chrRangeToJpeg8_neon;
250  }
251  } else {
252  if (c->opts.src_range) {
253  c->lumConvertRange = ff_lumRangeFromJpeg16_neon;
254  c->chrConvertRange = ff_chrRangeFromJpeg16_neon;
255  } else {
256  c->lumConvertRange = ff_lumRangeToJpeg16_neon;
257  c->chrConvertRange = ff_chrRangeToJpeg16_neon;
258  }
259  }
260  }
261 }
262 
263 av_cold void ff_sws_init_swscale_aarch64(SwsInternal *c)
264 {
265  int cpu_flags = av_get_cpu_flags();
266 
267  if (have_neon(cpu_flags)) {
268  ASSIGN_SCALE_FUNC(c->hyScale, c->hLumFilterSize, neon);
269  ASSIGN_SCALE_FUNC(c->hcScale, c->hChrFilterSize, neon);
270  ASSIGN_VSCALE_FUNC(c->yuv2plane1, neon);
271  if (c->dstBpc == 8) {
272  c->yuv2planeX = ff_yuv2planeX_8_neon;
273  }
274  switch (c->opts.src_format) {
275  case AV_PIX_FMT_ABGR:
276  c->lumToYV12 = ff_abgr32ToY_neon;
277  if (c->chrSrcHSubSample)
278  c->chrToYV12 = ff_abgr32ToUV_half_neon;
279  else
280  c->chrToYV12 = ff_abgr32ToUV_neon;
281  break;
282 
283  case AV_PIX_FMT_ARGB:
284  c->lumToYV12 = ff_argb32ToY_neon;
285  if (c->chrSrcHSubSample)
286  c->chrToYV12 = ff_argb32ToUV_half_neon;
287  else
288  c->chrToYV12 = ff_argb32ToUV_neon;
289  break;
290  case AV_PIX_FMT_BGR24:
291  c->lumToYV12 = ff_bgr24ToY_neon;
292  if (c->chrSrcHSubSample)
293  c->chrToYV12 = ff_bgr24ToUV_half_neon;
294  else
295  c->chrToYV12 = ff_bgr24ToUV_neon;
296  break;
297  case AV_PIX_FMT_BGRA:
298  c->lumToYV12 = ff_bgra32ToY_neon;
299  if (c->chrSrcHSubSample)
300  c->chrToYV12 = ff_bgra32ToUV_half_neon;
301  else
302  c->chrToYV12 = ff_bgra32ToUV_neon;
303  break;
304  case AV_PIX_FMT_RGB24:
305  c->lumToYV12 = ff_rgb24ToY_neon;
306  if (c->chrSrcHSubSample)
307  c->chrToYV12 = ff_rgb24ToUV_half_neon;
308  else
309  c->chrToYV12 = ff_rgb24ToUV_neon;
310  break;
311  case AV_PIX_FMT_RGBA:
312  c->lumToYV12 = ff_rgba32ToY_neon;
313  if (c->chrSrcHSubSample)
314  c->chrToYV12 = ff_rgba32ToUV_half_neon;
315  else
316  c->chrToYV12 = ff_rgba32ToUV_neon;
317  break;
318  default:
319  break;
320  }
321  }
322 }
_dst
uint8_t * _dst
Definition: dsp.h:52
ff_lumRangeFromJpeg16_neon
void ff_lumRangeFromJpeg16_neon(int16_t *dst, int width, uint32_t coeff, int64_t offset)
ff_hscale16to19_X4_neon_asm
void ff_hscale16to19_X4_neon_asm(int shift, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
ff_sws_init_range_convert_aarch64
av_cold void ff_sws_init_range_convert_aarch64(SwsInternal *c)
Definition: swscale.c:238
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
int64_t
long long int64_t
Definition: coverity.c:34
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
ff_yuv2planeX_8_neon
void ff_yuv2planeX_8_neon(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
ff_yuv2plane1_8_neon
void ff_yuv2plane1_8_neon(const int16_t *src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:109
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:56
ff_lumRangeToJpeg16_neon
void ff_lumRangeToJpeg16_neon(int16_t *dst, int width, uint32_t coeff, int64_t offset)
_src
uint8_t ptrdiff_t const uint8_t * _src
Definition: dsp.h:52
ff_hscale16to15_X4_neon_asm
void ff_hscale16to15_X4_neon_asm(int shift, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
ff_hscale16to15_4_neon
static void ff_hscale16to15_4_neon(SwsInternal *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:44
ff_chrRangeFromJpeg8_neon
void ff_chrRangeFromJpeg8_neon(int16_t *dstU, int16_t *dstV, int width, uint32_t coeff, int64_t offset)
NEON_INPUT
#define NEON_INPUT(name)
Definition: swscale.c:204
ff_hscale16to15_X8_neon_asm
void ff_hscale16to15_X8_neon_asm(int shift, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
ff_hscale16to19_X4_neon
static void ff_hscale16to19_X4_neon(SwsInternal *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:127
av_cold
#define av_cold
Definition: attributes.h:90
ff_lumRangeToJpeg8_neon
void ff_lumRangeToJpeg8_neon(int16_t *dst, int width, uint32_t coeff, int64_t offset)
bits
uint8_t bits
Definition: vp3data.h:128
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
ff_hscale16to15_X4_neon
static void ff_hscale16to15_X4_neon(SwsInternal *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:76
ff_hscale16to19_X8_neon_asm
void ff_hscale16to19_X8_neon_asm(int shift, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
ff_chrRangeToJpeg16_neon
void ff_chrRangeToJpeg16_neon(int16_t *dstU, int16_t *dstV, int width, uint32_t coeff, int64_t offset)
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
ff_lumRangeFromJpeg8_neon
void ff_lumRangeFromJpeg8_neon(int16_t *dst, int width, uint32_t coeff, int64_t offset)
shift
static int shift(int a, int b)
Definition: bonk.c:261
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
isAnyRGB
static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:856
ff_hscale16to19_4_neon
static void ff_hscale16to19_4_neon(SwsInternal *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:91
have_neon
#define have_neon(flags)
Definition: cpu.h:26
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
ff_hscale16to19_4_neon_asm
void ff_hscale16to19_4_neon_asm(int shift, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
swscale_internal.h
ASSIGN_VSCALE_FUNC
#define ASSIGN_VSCALE_FUNC(vscalefn, opt)
Definition: swscale.c:198
ff_hscale16to15_X8_neon
static void ff_hscale16to15_X8_neon(SwsInternal *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:60
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
ASSIGN_SCALE_FUNC
#define ASSIGN_SCALE_FUNC(hscalefn, filtersize, opt)
Definition: swscale.c:189
SwsInternal
Definition: swscale_internal.h:317
ff_chrRangeFromJpeg16_neon
void ff_chrRangeFromJpeg16_neon(int16_t *dstU, int16_t *dstV, int width, uint32_t coeff, int64_t offset)
desc
const char * desc
Definition: libsvtav1.c:79
ff_hscale16to15_4_neon_asm
void ff_hscale16to15_4_neon_asm(int shift, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_hscale16to19_X8_neon
static void ff_hscale16to19_X8_neon(SwsInternal *c, int16_t *_dst, int dstW, const uint8_t *_src, const int16_t *filter, const int32_t *filterPos, int filterSize)
Definition: swscale.c:109
ff_sws_init_swscale_aarch64
av_cold void ff_sws_init_swscale_aarch64(SwsInternal *c)
Definition: swscale.c:263
int32_t
int32_t
Definition: audioconvert.c:56
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:80
width
#define width
Definition: dsp.h:85
cpu.h
ALL_SCALE_FUNCS
#define ALL_SCALE_FUNCS(opt)
Definition: swscale.c:154
src
#define src
Definition: vp8dsp.c:248
swscale.h
ff_chrRangeToJpeg8_neon
void ff_chrRangeToJpeg8_neon(int16_t *dstU, int16_t *dstV, int width, uint32_t coeff, int64_t offset)
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:62
Generated on Wed Dec 25 2024 19:23:02 for FFmpeg by   doxygen 1.8.17