FFmpeg: libavfilter/vf_pp7.c Source File

FFmpeg
vf_pp7.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (c) 2014 Arwa Arif <arwaarif1994@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21 
22 /**
23  * @file
24  * Postprocessing filter - 7
25  *
26  * Originally written by Michael Niedermayer for the MPlayer
27  * project, and ported by Arwa Arif for FFmpeg.
28  */
29 
30 #include "libavutil/emms.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 
37 #include "filters.h"
38 #include "qp_table.h"
39 #include "vf_pp7.h"
40 #include "video.h"
41 
42  enum mode {
43   MODE_HARD,
44   MODE_SOFT,
45   MODE_MEDIUM
46 };
47 
48  #define OFFSET(x) offsetof(PP7Context, x)
49  #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
50  static const AVOption pp7_options[] = {
51  { "qp", "force a constant quantizer parameter", OFFSET(qp), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 64, FLAGS },
52  { "mode", "set thresholding mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_MEDIUM}, 0, 2, FLAGS, .unit = "mode" },
53  { "hard", "hard thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_HARD}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
54  { "soft", "soft thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_SOFT}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
55  { "medium", "medium thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_MEDIUM}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },
56  { NULL }
57 };
58 
59 AVFILTER_DEFINE_CLASS(pp7);
60 
61  DECLARE_ALIGNED(8, static const uint8_t, dither)[8][8] = {
62  { 0, 48, 12, 60, 3, 51, 15, 63, },
63  { 32, 16, 44, 28, 35, 19, 47, 31, },
64  { 8, 56, 4, 52, 11, 59, 7, 55, },
65  { 40, 24, 36, 20, 43, 27, 39, 23, },
66  { 2, 50, 14, 62, 1, 49, 13, 61, },
67  { 34, 18, 46, 30, 33, 17, 45, 29, },
68  { 10, 58, 6, 54, 9, 57, 5, 53, },
69  { 42, 26, 38, 22, 41, 25, 37, 21, },
70 };
71 
72  #define N0 4
73  #define N1 5
74  #define N2 10
75  #define SN0 2
76  #define SN1 2.2360679775
77  #define SN2 3.16227766017
78  #define N (1 << 16)
79 
80  static const int factor[16] = {
81  N / (N0 * N0), N / (N0 * N1), N / (N0 * N0), N / (N0 * N2),
82  N / (N1 * N0), N / (N1 * N1), N / (N1 * N0), N / (N1 * N2),
83  N / (N0 * N0), N / (N0 * N1), N / (N0 * N0), N / (N0 * N2),
84  N / (N2 * N0), N / (N2 * N1), N / (N2 * N0), N / (N2 * N2),
85 };
86 
87  static void init_thres2(PP7Context *p)
88 {
89  int qp, i;
90  int bias = 0; //FIXME
91 
92  for (qp = 0; qp < 99; qp++) {
93  for (i = 0; i < 16; i++) {
94  p->thres2[qp][i] = ((i&1) ? SN2 : SN0) * ((i&4) ? SN2 : SN0) * FFMAX(1, qp) * (1<<2) - 1 - bias;
95  }
96  }
97 }
98 
99  static inline void dctA_c(int16_t *dst, uint8_t *src, int stride)
100 {
101  int i;
102 
103  for (i = 0; i < 4; i++) {
104  int s0 = src[0 * stride] + src[6 * stride];
105  int s1 = src[1 * stride] + src[5 * stride];
106  int s2 = src[2 * stride] + src[4 * stride];
107  int s3 = src[3 * stride];
108  int s = s3 + s3;
109  s3 = s - s0;
110  s0 = s + s0;
111  s = s2 + s1;
112  s2 = s2 - s1;
113  dst[0] = s0 + s;
114  dst[2] = s0 - s;
115  dst[1] = 2 * s3 + s2;
116  dst[3] = s3 - 2 * s2;
117  src++;
118  dst += 4;
119  }
120 }
121 
122  static void dctB_c(int16_t *dst, int16_t *src)
123 {
124  int i;
125 
126  for (i = 0; i < 4; i++) {
127  int s0 = src[0 * 4] + src[6 * 4];
128  int s1 = src[1 * 4] + src[5 * 4];
129  int s2 = src[2 * 4] + src[4 * 4];
130  int s3 = src[3 * 4];
131  int s = s3 + s3;
132  s3 = s - s0;
133  s0 = s + s0;
134  s = s2 + s1;
135  s2 = s2 - s1;
136  dst[0 * 4] = s0 + s;
137  dst[2 * 4] = s0 - s;
138  dst[1 * 4] = 2 * s3 + s2;
139  dst[3 * 4] = s3 - 2 * s2;
140  src++;
141  dst++;
142  }
143 }
144 
145  static int hardthresh_c(PP7Context *p, int16_t *src, int qp)
146 {
147  int i;
148  int a;
149 
150  a = src[0] * factor[0];
151  for (i = 1; i < 16; i++) {
152  unsigned int threshold1 = p->thres2[qp][i];
153  unsigned int threshold2 = threshold1 << 1;
154  int level = src[i];
155  if (((unsigned)(level + threshold1)) > threshold2)
156  a += level * factor[i];
157  }
158  return (a + (1 << 11)) >> 12;
159 }
160 
161  static int mediumthresh_c(PP7Context *p, int16_t *src, int qp)
162 {
163  int i;
164  int a;
165 
166  a = src[0] * factor[0];
167  for (i = 1; i < 16; i++) {
168  unsigned int threshold1 = p->thres2[qp][i];
169  unsigned int threshold2 = threshold1 << 1;
170  int level = src[i];
171  if (((unsigned)(level + threshold1)) > threshold2) {
172  if (((unsigned)(level + 2 * threshold1)) > 2 * threshold2)
173  a += level * factor[i];
174  else {
175  if (level > 0)
176  a += 2 * (level - (int)threshold1) * factor[i];
177  else
178  a += 2 * (level + (int)threshold1) * factor[i];
179  }
180  }
181  }
182  return (a + (1 << 11)) >> 12;
183 }
184 
185  static int softthresh_c(PP7Context *p, int16_t *src, int qp)
186 {
187  int i;
188  int a;
189 
190  a = src[0] * factor[0];
191  for (i = 1; i < 16; i++) {
192  unsigned int threshold1 = p->thres2[qp][i];
193  unsigned int threshold2 = threshold1 << 1;
194  int level = src[i];
195  if (((unsigned)(level + threshold1)) > threshold2) {
196  if (level > 0)
197  a += (level - (int)threshold1) * factor[i];
198  else
199  a += (level + (int)threshold1) * factor[i];
200  }
201  }
202  return (a + (1 << 11)) >> 12;
203 }
204 
205  static void filter(PP7Context *p, uint8_t *dst, uint8_t *src,
206  int dst_stride, int src_stride,
207  int width, int height,
208  uint8_t *qp_store, int qp_stride, int is_luma)
209 {
210  int x, y;
211  const int stride = is_luma ? p->temp_stride : ((width + 16 + 15) & (~15));
212  uint8_t *p_src = p->src + 8 * stride;
213  int16_t *block = (int16_t *)p->src;
214  int16_t *temp = (int16_t *)(p->src + 32);
215 
216  if (!src || !dst) return;
217  for (y = 0; y < height; y++) {
218  int index = 8 + 8 * stride + y * stride;
219  memcpy(p_src + index, src + y * src_stride, width);
220  for (x = 0; x < 8; x++) {
221  p_src[index - x - 1]= p_src[index + x ];
222  p_src[index + width + x ]= p_src[index + width - x - 1];
223  }
224  }
225  for (y = 0; y < 8; y++) {
226  memcpy(p_src + ( 7 - y ) * stride, p_src + ( y + 8 ) * stride, stride);
227  memcpy(p_src + (height + 8 + y) * stride, p_src + (height - y + 7) * stride, stride);
228  }
229  //FIXME (try edge emu)
230 
231  for (y = 0; y < height; y++) {
232  for (x = -8; x < 0; x += 4) {
233  const int index = x + y * stride + (8 - 3) * (1 + stride) + 8; //FIXME silly offset
234  uint8_t *src = p_src + index;
235  int16_t *tp = temp + 4 * x;
236 
237  dctA_c(tp + 4 * 8, src, stride);
238  }
239  for (x = 0; x < width; ) {
240  const int qps = 3 + is_luma;
241  int qp;
242  int end = FFMIN(x + 8, width);
243 
244  if (p->qp)
245  qp = p->qp;
246  else {
247  qp = qp_store[ (FFMIN(x, width - 1) >> qps) + (FFMIN(y, height - 1) >> qps) * qp_stride];
248  qp = ff_norm_qscale(qp, p->qscale_type);
249  }
250  for (; x < end; x++) {
251  const int index = x + y * stride + (8 - 3) * (1 + stride) + 8; //FIXME silly offset
252  uint8_t *src = p_src + index;
253  int16_t *tp = temp + 4 * x;
254  int v;
255 
256  if ((x & 3) == 0)
257  dctA_c(tp + 4 * 8, src, stride);
258 
259  p->dctB(block, tp);
260 
261  v = p->requantize(p, block, qp);
262  v = (v + dither[y & 7][x & 7]) >> 6;
263  if ((unsigned)v > 255)
264  v = (-v) >> 31;
265  dst[x + y * dst_stride] = v;
266  }
267  }
268  }
269 }
270 
271  static const enum AVPixelFormat pix_fmts[] = {
272  AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P,
273  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
274  AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,
275  AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
276  AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ440P,
277  AV_PIX_FMT_GBRP,
278  AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
279 };
280 
281  static int config_input(AVFilterLink *inlink)
282 {
283  AVFilterContext *ctx = inlink->dst;
284  PP7Context *pp7 = ctx->priv;
285  const int h = FFALIGN(inlink->h + 16, 16);
286  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
287 
288  pp7->hsub = desc->log2_chroma_w;
289  pp7->vsub = desc->log2_chroma_h;
290 
291  pp7->temp_stride = FFALIGN(inlink->w + 16, 16);
292  pp7->src = av_malloc_array(pp7->temp_stride, (h + 8) * sizeof(uint8_t));
293 
294  if (!pp7->src)
295  return AVERROR(ENOMEM);
296 
297  init_thres2(pp7);
298 
299  switch (pp7->mode) {
300  case 0: pp7->requantize = hardthresh_c; break;
301  case 1: pp7->requantize = softthresh_c; break;
302  default:
303  case 2: pp7->requantize = mediumthresh_c; break;
304  }
305 
306  pp7->dctB = dctB_c;
307 
308 #if ARCH_X86
309  ff_pp7_init_x86(pp7);
310 #endif
311 
312  return 0;
313 }
314 
315  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
316 {
317  AVFilterContext *ctx = inlink->dst;
318  PP7Context *pp7 = ctx->priv;
319  AVFilterLink *outlink = ctx->outputs[0];
320  AVFrame *out = in;
321 
322  int qp_stride = 0;
323  int8_t *qp_table = NULL;
324 
325  if (!pp7->qp) {
326  int ret = ff_qp_table_extract(in, &qp_table, &qp_stride, NULL, &pp7->qscale_type);
327  if (ret < 0) {
328  av_frame_free(&in);
329  return ret;
330  }
331  }
332 
333  if (!ctx->is_disabled) {
334  const int cw = AV_CEIL_RSHIFT(inlink->w, pp7->hsub);
335  const int ch = AV_CEIL_RSHIFT(inlink->h, pp7->vsub);
336 
337  /* get a new frame if in-place is not possible or if the dimensions
338  * are not multiple of 8 */
339  if (!av_frame_is_writable(in) || (inlink->w & 7) || (inlink->h & 7)) {
340  const int aligned_w = FFALIGN(inlink->w, 8);
341  const int aligned_h = FFALIGN(inlink->h, 8);
342 
343  out = ff_get_video_buffer(outlink, aligned_w, aligned_h);
344  if (!out) {
345  av_frame_free(&in);
346  av_freep(&qp_table);
347  return AVERROR(ENOMEM);
348  }
349  av_frame_copy_props(out, in);
350  out->width = in->width;
351  out->height = in->height;
352  }
353 
354  if (qp_table || pp7->qp) {
355 
356  filter(pp7, out->data[0], in->data[0], out->linesize[0], in->linesize[0],
357  inlink->w, inlink->h, qp_table, qp_stride, 1);
358  filter(pp7, out->data[1], in->data[1], out->linesize[1], in->linesize[1],
359  cw, ch, qp_table, qp_stride, 0);
360  filter(pp7, out->data[2], in->data[2], out->linesize[2], in->linesize[2],
361  cw, ch, qp_table, qp_stride, 0);
362  emms_c();
363  }
364  }
365 
366  if (in != out) {
367  if (in->data[3])
368  av_image_copy_plane(out->data[3], out->linesize[3],
369  in ->data[3], in ->linesize[3],
370  inlink->w, inlink->h);
371  av_frame_free(&in);
372  }
373  av_freep(&qp_table);
374  return ff_filter_frame(outlink, out);
375 }
376 
377  static av_cold void uninit(AVFilterContext *ctx)
378 {
379  PP7Context *pp7 = ctx->priv;
380  av_freep(&pp7->src);
381 }
382 
383  static const AVFilterPad pp7_inputs[] = {
384  {
385  .name = "default",
386  .type = AVMEDIA_TYPE_VIDEO,
387  .config_props = config_input,
388  .filter_frame = filter_frame,
389  },
390 };
391 
392  const FFFilter ff_vf_pp7 = {
393  .p.name = "pp7",
394  .p.description = NULL_IF_CONFIG_SMALL("Apply Postprocessing 7 filter."),
395  .p.priv_class = &pp7_class,
396  .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
397  .priv_size = sizeof(PP7Context),
398  .uninit = uninit,
399  FILTER_INPUTS(pp7_inputs),
400  FILTER_OUTPUTS(ff_video_default_filterpad),
401  FILTER_PIXFMTS_ARRAY(pix_fmts),
402 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:117
OFFSET
#define OFFSET(x)
Definition: vf_pp7.c:48
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:208
qp_table.h
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
mem_internal.h
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: filters.h:243
out
FILE * out
Definition: movenc.c:55
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1067
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3447
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:263
mode
Definition: swscale.c:56
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
pixdesc.h
AVFrame::width
int width
Definition: frame.h:499
pp7_options
static const AVOption pp7_options[]
Definition: vf_pp7.c:50
AVOption
AVOption.
Definition: opt.h:429
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
N2
#define N2
Definition: vf_pp7.c:74
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:220
ff_norm_qscale
static int ff_norm_qscale(int qscale, enum AVVideoEncParamsType type)
Normalize the qscale factor FIXME Add support for other values of enum AVVideoEncParamsType besides A...
Definition: qp_table.h:39
MODE_HARD
@ MODE_HARD
Definition: vf_pp7.c:43
video.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
init_thres2
static void init_thres2(PP7Context *p)
Definition: vf_pp7.c:87
PP7Context::requantize
int(* requantize)(struct PP7Context *p, int16_t *src, int qp)
Definition: vf_pp7.h:40
softthresh_c
static int softthresh_c(PP7Context *p, int16_t *src, int qp)
Definition: vf_pp7.c:185
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(pp7)
dctB_c
static void dctB_c(int16_t *dst, int16_t *src)
Definition: vf_pp7.c:122
FLAGS
#define FLAGS
Definition: vf_pp7.c:49
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
SN0
#define SN0
Definition: vf_pp7.c:75
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_pp7.c:377
av_cold
#define av_cold
Definition: attributes.h:106
ff_video_default_filterpad
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
Definition: video.c:37
FFFilter
Definition: filters.h:266
hardthresh_c
static int hardthresh_c(PP7Context *p, int16_t *src, int qp)
Definition: vf_pp7.c:145
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
emms_c
#define emms_c()
Definition: emms.h:63
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:49
filter
static void filter(PP7Context *p, uint8_t *dst, uint8_t *src, int dst_stride, int src_stride, int width, int height, uint8_t *qp_store, int qp_stride, int is_luma)
Definition: vf_pp7.c:205
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:264
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:599
bias
static int bias(int x, int c)
Definition: vqcdec.c:115
N
#define N
Definition: vf_pp7.c:78
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
mediumthresh_c
static int mediumthresh_c(PP7Context *p, int16_t *src, int qp)
Definition: vf_pp7.c:161
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
index
int index
Definition: gxfenc.c:90
PP7Context::temp_stride
int temp_stride
Definition: vf_pp7.h:37
SN2
#define SN2
Definition: vf_pp7.c:77
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
height
#define height
Definition: dsp.h:89
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
N0
#define N0
Definition: vf_pp7.c:72
dither
static const uint8_t dither[8][8]
Definition: vf_pp7.c:61
vf_pp7.h
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:535
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_pp7.c:315
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
dctA_c
static void dctA_c(int16_t *dst, uint8_t *src, int stride)
Definition: vf_pp7.c:99
PP7Context::hsub
int hsub
Definition: vf_pp7.h:35
emms.h
PP7Context::qscale_type
enum AVVideoEncParamsType qscale_type
Definition: vf_pp7.h:34
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
PP7Context::src
uint8_t * src
Definition: vf_pp7.h:38
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
MODE_SOFT
@ MODE_SOFT
Definition: vf_pp7.c:44
ff_vf_pp7
const FFFilter ff_vf_pp7
Definition: vf_pp7.c:392
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
pp7_inputs
static const AVFilterPad pp7_inputs[]
Definition: vf_pp7.c:383
PP7Context::vsub
int vsub
Definition: vf_pp7.h:36
PP7Context::qp
int qp
Definition: vf_pp7.h:32
stride
#define stride
Definition: h264pred_template.c:536
ret
ret
Definition: filter_design.txt:187
ff_qp_table_extract
int ff_qp_table_extract(AVFrame *frame, int8_t **table, int *table_w, int *table_h, enum AVVideoEncParamsType *qscale_type)
Extract a libpostproc-compatible QP table - an 8-bit QP value per 16x16 macroblock,...
Definition: qp_table.c:27
ff_pp7_init_x86
void ff_pp7_init_x86(PP7Context *pp7)
Definition: vf_pp7_init.c:28
N1
#define N1
Definition: vf_pp7.c:73
AVFrame::height
int height
Definition: frame.h:499
PP7Context::mode
int mode
Definition: vf_pp7.h:33
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
temp
else temp
Definition: vf_mcdeint.c:271
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:274
factor
static const int factor[16]
Definition: vf_pp7.c:80
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MODE_MEDIUM
@ MODE_MEDIUM
Definition: vf_pp7.c:45
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
PP7Context
Definition: vf_pp7.h:28
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:205
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:472
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
h
h
Definition: vp9dsp_template.c:2070
width
#define width
Definition: dsp.h:89
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_pp7.c:271
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_pp7.c:281
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
src
#define src
Definition: vp8dsp.c:248
PP7Context::dctB
void(* dctB)(int16_t *dst, int16_t *src)
Definition: vf_pp7.h:41
Generated on Sat Oct 18 2025 19:23:10 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /