FFmpeg
vf_stereo3d.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010 Gordon Schmidt <gordon.schmidt <at> s2000.tu-chemnitz.de>
3  * Copyright (c) 2013-2015 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (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
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
23 #include "libavutil/imgutils.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/parseutils.h"
27 #include "libavutil/pixdesc.h"
28 #include "avfilter.h"
29 #include "drawutils.h"
30 #include "formats.h"
31 #include "internal.h"
32 #include "video.h"
33 #include "stereo3d.h"
34 
35 enum StereoCode {
36  ANAGLYPH_RC_GRAY, // anaglyph red/cyan gray
37  ANAGLYPH_RC_HALF, // anaglyph red/cyan half colored
38  ANAGLYPH_RC_COLOR, // anaglyph red/cyan colored
39  ANAGLYPH_RC_DUBOIS, // anaglyph red/cyan dubois
40  ANAGLYPH_GM_GRAY, // anaglyph green/magenta gray
41  ANAGLYPH_GM_HALF, // anaglyph green/magenta half colored
42  ANAGLYPH_GM_COLOR, // anaglyph green/magenta colored
43  ANAGLYPH_GM_DUBOIS, // anaglyph green/magenta dubois
44  ANAGLYPH_YB_GRAY, // anaglyph yellow/blue gray
45  ANAGLYPH_YB_HALF, // anaglyph yellow/blue half colored
46  ANAGLYPH_YB_COLOR, // anaglyph yellow/blue colored
47  ANAGLYPH_YB_DUBOIS, // anaglyph yellow/blue dubois
48  ANAGLYPH_RB_GRAY, // anaglyph red/blue gray
49  ANAGLYPH_RG_GRAY, // anaglyph red/green gray
50  MONO_L, // mono output for debugging (left eye only)
51  MONO_R, // mono output for debugging (right eye only)
52  INTERLEAVE_ROWS_LR, // row-interleave (left eye has top row)
53  INTERLEAVE_ROWS_RL, // row-interleave (right eye has top row)
54  SIDE_BY_SIDE_LR, // side by side parallel (left eye left, right eye right)
55  SIDE_BY_SIDE_RL, // side by side crosseye (right eye left, left eye right)
56  SIDE_BY_SIDE_2_LR, // side by side parallel with half width resolution
57  SIDE_BY_SIDE_2_RL, // side by side crosseye with half width resolution
58  ABOVE_BELOW_LR, // above-below (left eye above, right eye below)
59  ABOVE_BELOW_RL, // above-below (right eye above, left eye below)
60  ABOVE_BELOW_2_LR, // above-below with half height resolution
61  ABOVE_BELOW_2_RL, // above-below with half height resolution
62  ALTERNATING_LR, // alternating frames (left eye first, right eye second)
63  ALTERNATING_RL, // alternating frames (right eye first, left eye second)
64  CHECKERBOARD_LR, // checkerboard pattern (left eye first, right eye second)
65  CHECKERBOARD_RL, // checkerboard pattern (right eye first, left eye second)
66  INTERLEAVE_COLS_LR, // column-interleave (left eye first, right eye second)
67  INTERLEAVE_COLS_RL, // column-interleave (right eye first, left eye second)
68  HDMI, // HDMI frame pack (left eye first, right eye second)
69  STEREO_CODE_COUNT // TODO: needs autodetection
70 };
71 
72 typedef struct StereoComponent {
73  int format; ///< StereoCode
74  int width, height;
75  int off_left, off_right;
76  int off_lstep, off_rstep;
77  int row_left, row_right;
78  int row_step;
79 } StereoComponent;
80 
81 static const int ana_coeff[][3][6] = {
82  [ANAGLYPH_RB_GRAY] =
83  {{19595, 38470, 7471, 0, 0, 0},
84  { 0, 0, 0, 0, 0, 0},
85  { 0, 0, 0, 19595, 38470, 7471}},
86  [ANAGLYPH_RG_GRAY] =
87  {{19595, 38470, 7471, 0, 0, 0},
88  { 0, 0, 0, 19595, 38470, 7471},
89  { 0, 0, 0, 0, 0, 0}},
90  [ANAGLYPH_RC_GRAY] =
91  {{19595, 38470, 7471, 0, 0, 0},
92  { 0, 0, 0, 19595, 38470, 7471},
93  { 0, 0, 0, 19595, 38470, 7471}},
94  [ANAGLYPH_RC_HALF] =
95  {{19595, 38470, 7471, 0, 0, 0},
96  { 0, 0, 0, 0, 65536, 0},
97  { 0, 0, 0, 0, 0, 65536}},
98  [ANAGLYPH_RC_COLOR] =
99  {{65536, 0, 0, 0, 0, 0},
100  { 0, 0, 0, 0, 65536, 0},
101  { 0, 0, 0, 0, 0, 65536}},
102  [ANAGLYPH_RC_DUBOIS] =
103  {{29891, 32800, 11559, -2849, -5763, -102},
104  {-2627, -2479, -1033, 24804, 48080, -1209},
105  { -997, -1350, -358, -4729, -7403, 80373}},
106  [ANAGLYPH_GM_GRAY] =
107  {{ 0, 0, 0, 19595, 38470, 7471},
108  {19595, 38470, 7471, 0, 0, 0},
109  { 0, 0, 0, 19595, 38470, 7471}},
110  [ANAGLYPH_GM_HALF] =
111  {{ 0, 0, 0, 65536, 0, 0},
112  {19595, 38470, 7471, 0, 0, 0},
113  { 0, 0, 0, 0, 0, 65536}},
114  [ANAGLYPH_GM_COLOR] =
115  {{ 0, 0, 0, 65536, 0, 0},
116  { 0, 65536, 0, 0, 0, 0},
117  { 0, 0, 0, 0, 0, 65536}},
118  [ANAGLYPH_GM_DUBOIS] =
119  {{-4063,-10354, -2556, 34669, 46203, 1573},
120  {18612, 43778, 9372, -1049, -983, -4260},
121  { -983, -1769, 1376, 590, 4915, 61407}},
122  [ANAGLYPH_YB_GRAY] =
123  {{ 0, 0, 0, 19595, 38470, 7471},
124  { 0, 0, 0, 19595, 38470, 7471},
125  {19595, 38470, 7471, 0, 0, 0}},
126  [ANAGLYPH_YB_HALF] =
127  {{ 0, 0, 0, 65536, 0, 0},
128  { 0, 0, 0, 0, 65536, 0},
129  {19595, 38470, 7471, 0, 0, 0}},
130  [ANAGLYPH_YB_COLOR] =
131  {{ 0, 0, 0, 65536, 0, 0},
132  { 0, 0, 0, 0, 65536, 0},
133  { 0, 0, 65536, 0, 0, 0}},
134  [ANAGLYPH_YB_DUBOIS] =
135  {{65535,-12650,18451, -987, -7590, -1049},
136  {-1604, 56032, 4196, 370, 3826, -1049},
137  {-2345,-10676, 1358, 5801, 11416, 56217}},
138 };
139 
140 typedef struct Stereo3DContext {
141  const AVClass *class;
142  StereoComponent in, out;
143  int width, height;
144  const int *ana_matrix[3];
145  int nb_planes;
146  int linesize[4];
147  int pheight[4];
148  int hsub, vsub;
149  int pixstep[4];
150  AVFrame *prev;
151  int blanks;
152  int in_off_left[4], in_off_right[4];
153  AVRational aspect;
154  Stereo3DDSPContext dsp;
155 } Stereo3DContext;
156 
157 #define OFFSET(x) offsetof(Stereo3DContext, x)
158 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
159 
160 static const AVOption stereo3d_options[] = {
161  { "in", "set input format", OFFSET(in.format), AV_OPT_TYPE_INT, {.i64=SIDE_BY_SIDE_LR}, INTERLEAVE_ROWS_LR, STEREO_CODE_COUNT-1, FLAGS, "in"},
162  { "ab2l", "above below half height left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_LR}, 0, 0, FLAGS, "in" },
163  { "ab2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "in" },
164  { "abl", "above below left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_LR}, 0, 0, FLAGS, "in" },
165  { "abr", "above below right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_RL}, 0, 0, FLAGS, "in" },
166  { "al", "alternating frames left first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_LR}, 0, 0, FLAGS, "in" },
167  { "ar", "alternating frames right first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_RL}, 0, 0, FLAGS, "in" },
168  { "sbs2l", "side by side half width left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_LR}, 0, 0, FLAGS, "in" },
169  { "sbs2r", "side by side half width right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_RL}, 0, 0, FLAGS, "in" },
170  { "sbsl", "side by side left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_LR}, 0, 0, FLAGS, "in" },
171  { "sbsr", "side by side right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_RL}, 0, 0, FLAGS, "in" },
172  { "irl", "interleave rows left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_LR}, 0, 0, FLAGS, "in" },
173  { "irr", "interleave rows right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_RL}, 0, 0, FLAGS, "in" },
174  { "icl", "interleave columns left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_LR}, 0, 0, FLAGS, "in" },
175  { "icr", "interleave columns right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_RL}, 0, 0, FLAGS, "in" },
176  { "out", "set output format", OFFSET(out.format), AV_OPT_TYPE_INT, {.i64=ANAGLYPH_RC_DUBOIS}, 0, STEREO_CODE_COUNT-1, FLAGS, "out"},
177  { "ab2l", "above below half height left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_LR}, 0, 0, FLAGS, "out" },
178  { "ab2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "out" },
179  { "abl", "above below left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_LR}, 0, 0, FLAGS, "out" },
180  { "abr", "above below right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_RL}, 0, 0, FLAGS, "out" },
181  { "agmc", "anaglyph green magenta color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_COLOR}, 0, 0, FLAGS, "out" },
182  { "agmd", "anaglyph green magenta dubois", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_DUBOIS}, 0, 0, FLAGS, "out" },
183  { "agmg", "anaglyph green magenta gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_GRAY}, 0, 0, FLAGS, "out" },
184  { "agmh", "anaglyph green magenta half color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_HALF}, 0, 0, FLAGS, "out" },
185  { "al", "alternating frames left first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_LR}, 0, 0, FLAGS, "out" },
186  { "ar", "alternating frames right first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_RL}, 0, 0, FLAGS, "out" },
187  { "arbg", "anaglyph red blue gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RB_GRAY}, 0, 0, FLAGS, "out" },
188  { "arcc", "anaglyph red cyan color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_COLOR}, 0, 0, FLAGS, "out" },
189  { "arcd", "anaglyph red cyan dubois", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_DUBOIS}, 0, 0, FLAGS, "out" },
190  { "arcg", "anaglyph red cyan gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_GRAY}, 0, 0, FLAGS, "out" },
191  { "arch", "anaglyph red cyan half color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_HALF}, 0, 0, FLAGS, "out" },
192  { "argg", "anaglyph red green gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RG_GRAY}, 0, 0, FLAGS, "out" },
193  { "aybc", "anaglyph yellow blue color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_COLOR}, 0, 0, FLAGS, "out" },
194  { "aybd", "anaglyph yellow blue dubois", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_DUBOIS}, 0, 0, FLAGS, "out" },
195  { "aybg", "anaglyph yellow blue gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_GRAY}, 0, 0, FLAGS, "out" },
196  { "aybh", "anaglyph yellow blue half color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_HALF}, 0, 0, FLAGS, "out" },
197  { "irl", "interleave rows left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_LR}, 0, 0, FLAGS, "out" },
198  { "irr", "interleave rows right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_RL}, 0, 0, FLAGS, "out" },
199  { "ml", "mono left", 0, AV_OPT_TYPE_CONST, {.i64=MONO_L}, 0, 0, FLAGS, "out" },
200  { "mr", "mono right", 0, AV_OPT_TYPE_CONST, {.i64=MONO_R}, 0, 0, FLAGS, "out" },
201  { "sbs2l", "side by side half width left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_LR}, 0, 0, FLAGS, "out" },
202  { "sbs2r", "side by side half width right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_RL}, 0, 0, FLAGS, "out" },
203  { "sbsl", "side by side left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_LR}, 0, 0, FLAGS, "out" },
204  { "sbsr", "side by side right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_RL}, 0, 0, FLAGS, "out" },
205  { "chl", "checkerboard left first", 0, AV_OPT_TYPE_CONST, {.i64=CHECKERBOARD_LR}, 0, 0, FLAGS, "out" },
206  { "chr", "checkerboard right first", 0, AV_OPT_TYPE_CONST, {.i64=CHECKERBOARD_RL}, 0, 0, FLAGS, "out" },
207  { "icl", "interleave columns left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_LR}, 0, 0, FLAGS, "out" },
208  { "icr", "interleave columns right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_RL}, 0, 0, FLAGS, "out" },
209  { "hdmi", "HDMI frame pack", 0, AV_OPT_TYPE_CONST, {.i64=HDMI}, 0, 0, FLAGS, "out" },
210  { NULL }
211 };
212 
213 AVFILTER_DEFINE_CLASS(stereo3d);
214 
215 static const enum AVPixelFormat anaglyph_pix_fmts[] = {
216  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
217  AV_PIX_FMT_NONE
218 };
219 
220 static const enum AVPixelFormat other_pix_fmts[] = {
221  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
222  AV_PIX_FMT_RGB48BE, AV_PIX_FMT_BGR48BE,
223  AV_PIX_FMT_RGB48LE, AV_PIX_FMT_BGR48LE,
224  AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_BGRA64BE,
225  AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_BGRA64LE,
226  AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
227  AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
228  AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
229  AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
230  AV_PIX_FMT_GBRP,
231  AV_PIX_FMT_GBRP9BE, AV_PIX_FMT_GBRP9LE,
232  AV_PIX_FMT_GBRP10BE, AV_PIX_FMT_GBRP10LE,
233  AV_PIX_FMT_GBRP12BE, AV_PIX_FMT_GBRP12LE,
234  AV_PIX_FMT_GBRP14BE, AV_PIX_FMT_GBRP14LE,
235  AV_PIX_FMT_GBRP16BE, AV_PIX_FMT_GBRP16LE,
236  AV_PIX_FMT_YUV410P,
237  AV_PIX_FMT_YUV411P,
238  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,
239  AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P,
240  AV_PIX_FMT_YUV440P,
241  AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
242  AV_PIX_FMT_YUVJ411P,
243  AV_PIX_FMT_YUVJ420P,
244  AV_PIX_FMT_YUVJ422P,
245  AV_PIX_FMT_YUVJ440P,
246  AV_PIX_FMT_YUVJ444P,
247  AV_PIX_FMT_YUV420P9LE, AV_PIX_FMT_YUVA420P9LE,
248  AV_PIX_FMT_YUV420P9BE, AV_PIX_FMT_YUVA420P9BE,
249  AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_YUVA422P9LE,
250  AV_PIX_FMT_YUV422P9BE, AV_PIX_FMT_YUVA422P9BE,
251  AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUVA444P9LE,
252  AV_PIX_FMT_YUV444P9BE, AV_PIX_FMT_YUVA444P9BE,
253  AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUVA420P10LE,
254  AV_PIX_FMT_YUV420P10BE, AV_PIX_FMT_YUVA420P10BE,
255  AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUVA422P10LE,
256  AV_PIX_FMT_YUV422P10BE, AV_PIX_FMT_YUVA422P10BE,
257  AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUVA444P10LE,
258  AV_PIX_FMT_YUV444P10BE, AV_PIX_FMT_YUVA444P10BE,
259  AV_PIX_FMT_YUV420P12BE, AV_PIX_FMT_YUV420P12LE,
260  AV_PIX_FMT_YUV422P12BE, AV_PIX_FMT_YUV422P12LE,
261  AV_PIX_FMT_YUV444P12BE, AV_PIX_FMT_YUV444P12LE,
262  AV_PIX_FMT_YUV420P14BE, AV_PIX_FMT_YUV420P14LE,
263  AV_PIX_FMT_YUV422P14BE, AV_PIX_FMT_YUV422P14LE,
264  AV_PIX_FMT_YUV444P14BE, AV_PIX_FMT_YUV444P14LE,
265  AV_PIX_FMT_YUV420P16LE, AV_PIX_FMT_YUVA420P16LE,
266  AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_YUVA420P16BE,
267  AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUVA422P16LE,
268  AV_PIX_FMT_YUV422P16BE, AV_PIX_FMT_YUVA422P16BE,
269  AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUVA444P16LE,
270  AV_PIX_FMT_YUV444P16BE, AV_PIX_FMT_YUVA444P16BE,
271  AV_PIX_FMT_NONE
272 };
273 
274 static int query_formats(AVFilterContext *ctx)
275 {
276  Stereo3DContext *s = ctx->priv;
277  const enum AVPixelFormat *pix_fmts;
278  AVFilterFormats *fmts_list;
279 
280  switch (s->out.format) {
281  case ANAGLYPH_GM_COLOR:
282  case ANAGLYPH_GM_DUBOIS:
283  case ANAGLYPH_GM_GRAY:
284  case ANAGLYPH_GM_HALF:
285  case ANAGLYPH_RB_GRAY:
286  case ANAGLYPH_RC_COLOR:
287  case ANAGLYPH_RC_DUBOIS:
288  case ANAGLYPH_RC_GRAY:
289  case ANAGLYPH_RC_HALF:
290  case ANAGLYPH_RG_GRAY:
291  case ANAGLYPH_YB_COLOR:
292  case ANAGLYPH_YB_DUBOIS:
293  case ANAGLYPH_YB_GRAY:
294  case ANAGLYPH_YB_HALF:
295  pix_fmts = anaglyph_pix_fmts;
296  break;
297  default:
298  pix_fmts = other_pix_fmts;
299  }
300 
301  fmts_list = ff_make_format_list(pix_fmts);
302  if (!fmts_list)
303  return AVERROR(ENOMEM);
304  return ff_set_common_formats(ctx, fmts_list);
305 }
306 
307 static inline uint8_t ana_convert(const int *coeff, const uint8_t *left, const uint8_t *right)
308 {
309  int sum;
310 
311  sum = coeff[0] * left[0] + coeff[3] * right[0]; //red in
312  sum += coeff[1] * left[1] + coeff[4] * right[1]; //green in
313  sum += coeff[2] * left[2] + coeff[5] * right[2]; //blue in
314 
315  return av_clip_uint8(sum >> 16);
316 }
317 
318 static void anaglyph_ic(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc,
319  ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize,
320  int width, int height,
321  const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
322 {
323  int x, y, o;
324 
325  for (y = 0; y < height; y++) {
326  for (o = 0, x = 0; x < width; x++, o+= 3) {
327  dst[o ] = ana_convert(ana_matrix_r, lsrc + o * 2, rsrc + o * 2);
328  dst[o + 1] = ana_convert(ana_matrix_g, lsrc + o * 2, rsrc + o * 2);
329  dst[o + 2] = ana_convert(ana_matrix_b, lsrc + o * 2, rsrc + o * 2);
330  }
331 
332  dst += dst_linesize;
333  lsrc += l_linesize;
334  rsrc += r_linesize;
335  }
336 }
337 
338 static void anaglyph(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc,
339  ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize,
340  int width, int height,
341  const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
342 {
343  int x, y, o;
344 
345  for (y = 0; y < height; y++) {
346  for (o = 0, x = 0; x < width; x++, o+= 3) {
347  dst[o ] = ana_convert(ana_matrix_r, lsrc + o, rsrc + o);
348  dst[o + 1] = ana_convert(ana_matrix_g, lsrc + o, rsrc + o);
349  dst[o + 2] = ana_convert(ana_matrix_b, lsrc + o, rsrc + o);
350  }
351 
352  dst += dst_linesize;
353  lsrc += l_linesize;
354  rsrc += r_linesize;
355  }
356 }
357 
358 static int config_output(AVFilterLink *outlink)
359 {
360  AVFilterContext *ctx = outlink->src;
361  AVFilterLink *inlink = ctx->inputs[0];
362  Stereo3DContext *s = ctx->priv;
363  AVRational fps = inlink->frame_rate;
364  AVRational tb = inlink->time_base;
365  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
366  int ret;
367  s->aspect = inlink->sample_aspect_ratio;
368 
369  switch (s->in.format) {
370  case INTERLEAVE_COLS_LR:
371  case INTERLEAVE_COLS_RL:
372  case SIDE_BY_SIDE_2_LR:
373  case SIDE_BY_SIDE_LR:
374  case SIDE_BY_SIDE_2_RL:
375  case SIDE_BY_SIDE_RL:
376  if (inlink->w & 1) {
377  av_log(ctx, AV_LOG_ERROR, "width must be even\n");
378  return AVERROR_INVALIDDATA;
379  }
380  break;
381  case INTERLEAVE_ROWS_LR:
382  case INTERLEAVE_ROWS_RL:
383  case ABOVE_BELOW_2_LR:
384  case ABOVE_BELOW_LR:
385  case ABOVE_BELOW_2_RL:
386  case ABOVE_BELOW_RL:
387  if (inlink->h & 1) {
388  av_log(ctx, AV_LOG_ERROR, "height must be even\n");
389  return AVERROR_INVALIDDATA;
390  }
391  break;
392  }
393 
394  s->in.width =
395  s->width = inlink->w;
396  s->in.height =
397  s->height = inlink->h;
398  s->in.off_lstep =
399  s->in.off_rstep =
400  s->in.off_left =
401  s->in.off_right =
402  s->in.row_left =
403  s->in.row_right = 0;
404  s->in.row_step = 1;
405 
406  switch (s->in.format) {
407  case SIDE_BY_SIDE_2_LR:
408  s->aspect.num *= 2;
409  case SIDE_BY_SIDE_LR:
410  s->width = inlink->w / 2;
411  s->in.off_right = s->width;
412  break;
413  case SIDE_BY_SIDE_2_RL:
414  s->aspect.num *= 2;
415  case SIDE_BY_SIDE_RL:
416  s->width = inlink->w / 2;
417  s->in.off_left = s->width;
418  break;
419  case ABOVE_BELOW_2_LR:
420  s->aspect.den *= 2;
421  case ABOVE_BELOW_LR:
422  s->in.row_right =
423  s->height = inlink->h / 2;
424  break;
425  case ABOVE_BELOW_2_RL:
426  s->aspect.den *= 2;
427  case ABOVE_BELOW_RL:
428  s->in.row_left =
429  s->height = inlink->h / 2;
430  break;
431  case ALTERNATING_RL:
432  case ALTERNATING_LR:
433  fps.den *= 2;
434  tb.num *= 2;
435  break;
436  case INTERLEAVE_COLS_RL:
437  case INTERLEAVE_COLS_LR:
438  s->width = inlink->w / 2;
439  break;
440  case INTERLEAVE_ROWS_LR:
441  case INTERLEAVE_ROWS_RL:
442  s->in.row_step = 2;
443  if (s->in.format == INTERLEAVE_ROWS_RL)
444  s->in.off_lstep = 1;
445  else
446  s->in.off_rstep = 1;
447  if (s->out.format != CHECKERBOARD_LR &&
448  s->out.format != CHECKERBOARD_RL)
449  s->height = inlink->h / 2;
450  break;
451  default:
452  av_log(ctx, AV_LOG_ERROR, "input format %d is not supported\n", s->in.format);
453  return AVERROR(EINVAL);
454  }
455 
456  s->out.width = s->width;
457  s->out.height = s->height;
458  s->out.off_lstep =
459  s->out.off_rstep =
460  s->out.off_left =
461  s->out.off_right =
462  s->out.row_left =
463  s->out.row_right = 0;
464  s->out.row_step = 1;
465 
466  switch (s->out.format) {
467  case ANAGLYPH_RB_GRAY:
468  case ANAGLYPH_RG_GRAY:
469  case ANAGLYPH_RC_GRAY:
470  case ANAGLYPH_RC_HALF:
471  case ANAGLYPH_RC_COLOR:
472  case ANAGLYPH_RC_DUBOIS:
473  case ANAGLYPH_GM_GRAY:
474  case ANAGLYPH_GM_HALF:
475  case ANAGLYPH_GM_COLOR:
476  case ANAGLYPH_GM_DUBOIS:
477  case ANAGLYPH_YB_GRAY:
478  case ANAGLYPH_YB_HALF:
479  case ANAGLYPH_YB_COLOR:
480  case ANAGLYPH_YB_DUBOIS: {
481  uint8_t rgba_map[4];
482 
483  ff_fill_rgba_map(rgba_map, outlink->format);
484  s->ana_matrix[rgba_map[0]] = &ana_coeff[s->out.format][0][0];
485  s->ana_matrix[rgba_map[1]] = &ana_coeff[s->out.format][1][0];
486  s->ana_matrix[rgba_map[2]] = &ana_coeff[s->out.format][2][0];
487  break;
488  }
489  case SIDE_BY_SIDE_2_LR:
490  s->aspect.den *= 2;
491  case SIDE_BY_SIDE_LR:
492  s->out.width = s->width * 2;
493  s->out.off_right = s->width;
494  break;
495  case SIDE_BY_SIDE_2_RL:
496  s->aspect.den *= 2;
497  case SIDE_BY_SIDE_RL:
498  s->out.width = s->width * 2;
499  s->out.off_left = s->width;
500  break;
501  case ABOVE_BELOW_2_LR:
502  s->aspect.num *= 2;
503  case ABOVE_BELOW_LR:
504  s->out.height = s->height * 2;
505  s->out.row_right = s->height;
506  break;
507  case HDMI:
508  if (s->height != 720 && s->height != 1080) {
509  av_log(ctx, AV_LOG_ERROR, "Only 720 and 1080 height supported\n");
510  return AVERROR(EINVAL);
511  }
512 
513  s->blanks = s->height / 24;
514  s->out.height = s->height * 2 + s->blanks;
515  s->out.row_right = s->height + s->blanks;
516  break;
517  case ABOVE_BELOW_2_RL:
518  s->aspect.num *= 2;
519  case ABOVE_BELOW_RL:
520  s->out.height = s->height * 2;
521  s->out.row_left = s->height;
522  break;
523  case INTERLEAVE_ROWS_LR:
524  s->in.row_step = 1 + (s->in.format == INTERLEAVE_ROWS_RL);
525  s->out.row_step = 2;
526  s->out.height = s->height * 2;
527  s->out.off_rstep = 1;
528  break;
529  case INTERLEAVE_ROWS_RL:
530  s->in.row_step = 1 + (s->in.format == INTERLEAVE_ROWS_LR);
531  s->out.row_step = 2;
532  s->out.height = s->height * 2;
533  s->out.off_lstep = 1;
534  break;
535  case MONO_R:
536  if (s->in.format != INTERLEAVE_COLS_LR) {
537  s->in.off_left = s->in.off_right;
538  s->in.row_left = s->in.row_right;
539  }
540  if (s->in.format == INTERLEAVE_ROWS_LR)
541  FFSWAP(int, s->in.off_lstep, s->in.off_rstep);
542  break;
543  case MONO_L:
544  if (s->in.format == INTERLEAVE_ROWS_RL)
545  FFSWAP(int, s->in.off_lstep, s->in.off_rstep);
546  break;
547  case ALTERNATING_RL:
548  case ALTERNATING_LR:
549  fps.num *= 2;
550  tb.den *= 2;
551  break;
552  case CHECKERBOARD_LR:
553  case CHECKERBOARD_RL:
554  s->out.width = s->width * 2;
555  break;
556  case INTERLEAVE_COLS_LR:
557  case INTERLEAVE_COLS_RL:
558  s->out.width = s->width * 2;
559  break;
560  default:
561  av_log(ctx, AV_LOG_ERROR, "output format %d is not supported\n", s->out.format);
562  return AVERROR(EINVAL);
563  }
564 
565  if (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) {
566  if ((s->in.format & 1) != (s->out.format & 1)) {
567  FFSWAP(int, s->in.row_left, s->in.row_right);
568  FFSWAP(int, s->in.off_lstep, s->in.off_rstep);
569  FFSWAP(int, s->in.off_left, s->in.off_right);
570  FFSWAP(int, s->out.row_left, s->out.row_right);
571  FFSWAP(int, s->out.off_lstep, s->out.off_rstep);
572  FFSWAP(int, s->out.off_left, s->out.off_right);
573  }
574  }
575 
576  outlink->w = s->out.width;
577  outlink->h = s->out.height;
578  outlink->frame_rate = fps;
579  outlink->time_base = tb;
580  outlink->sample_aspect_ratio = s->aspect;
581 
582  if ((ret = av_image_fill_linesizes(s->linesize, outlink->format, s->width)) < 0)
583  return ret;
584  s->nb_planes = av_pix_fmt_count_planes(outlink->format);
585  av_image_fill_max_pixsteps(s->pixstep, NULL, desc);
586  s->pheight[1] = s->pheight[2] = AV_CEIL_RSHIFT(s->height, desc->log2_chroma_h);
587  s->pheight[0] = s->pheight[3] = s->height;
588  s->hsub = desc->log2_chroma_w;
589  s->vsub = desc->log2_chroma_h;
590 
591  s->dsp.anaglyph = anaglyph;
592  if (ARCH_X86)
593  ff_stereo3d_init_x86(&s->dsp);
594 
595  return 0;
596 }
597 
598 typedef struct ThreadData {
599  AVFrame *ileft, *iright;
600  AVFrame *out;
601 } ThreadData;
602 
603 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
604 {
605  Stereo3DContext *s = ctx->priv;
606  ThreadData *td = arg;
607  AVFrame *ileft = td->ileft;
608  AVFrame *iright = td->iright;
609  AVFrame *out = td->out;
610  int height = s->out.height;
611  int start = (height * jobnr ) / nb_jobs;
612  int end = (height * (jobnr+1)) / nb_jobs;
613  const int **ana_matrix = s->ana_matrix;
614 
615  s->dsp.anaglyph(out->data[0] + out->linesize[0] * start,
616  ileft ->data[0] + s->in_off_left [0] + ileft->linesize[0] * start * s->in.row_step,
617  iright->data[0] + s->in_off_right[0] + iright->linesize[0] * start * s->in.row_step,
618  out->linesize[0],
619  ileft->linesize[0] * s->in.row_step,
620  iright->linesize[0] * s->in.row_step,
621  s->out.width, end - start,
622  ana_matrix[0], ana_matrix[1], ana_matrix[2]);
623 
624  return 0;
625 }
626 
627 static void interleave_cols_to_any(Stereo3DContext *s, int *out_off, int p, AVFrame *in, AVFrame *out, int d)
628 {
629  int y, x;
630 
631  for (y = 0; y < s->pheight[p]; y++) {
632  const uint8_t *src = (const uint8_t*)in->data[p] + y * in->linesize[p] + d * s->pixstep[p];
633  uint8_t *dst = out->data[p] + out_off[p] + y * out->linesize[p] * s->out.row_step;
634 
635  switch (s->pixstep[p]) {
636  case 1:
637  for (x = 0; x < s->linesize[p]; x++)
638  dst[x] = src[x * 2];
639  break;
640  case 2:
641  for (x = 0; x < s->linesize[p]; x+=2)
642  AV_WN16(&dst[x], AV_RN16(&src[x * 2]));
643  break;
644  case 3:
645  for (x = 0; x < s->linesize[p]; x+=3)
646  AV_WB24(&dst[x], AV_RB24(&src[x * 2]));
647  break;
648  case 4:
649  for (x = 0; x < s->linesize[p]; x+=4)
650  AV_WN32(&dst[x], AV_RN32(&src[x * 2]));
651  break;
652  case 6:
653  for (x = 0; x < s->linesize[p]; x+=6)
654  AV_WB48(&dst[x], AV_RB48(&src[x * 2]));
655  break;
656  case 8:
657  for (x = 0; x < s->linesize[p]; x+=8)
658  AV_WN64(&dst[x], AV_RN64(&src[x * 2]));
659  break;
660  }
661  }
662 }
663 
664 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
665 {
666  AVFilterContext *ctx = inlink->dst;
667  Stereo3DContext *s = ctx->priv;
668  AVFilterLink *outlink = ctx->outputs[0];
669  AVFrame *out, *oleft, *oright, *ileft, *iright;
670  int out_off_left[4], out_off_right[4];
671  int i, ret;
672 
673  if (s->in.format == s->out.format)
674  return ff_filter_frame(outlink, inpicref);
675 
676  switch (s->out.format) {
677  case ALTERNATING_LR:
678  case ALTERNATING_RL:
679  if (!s->prev) {
680  s->prev = inpicref;
681  return 0;
682  }
683  break;
684  };
685 
686  switch (s->in.format) {
687  case ALTERNATING_LR:
688  case ALTERNATING_RL:
689  if (!s->prev) {
690  s->prev = inpicref;
691  return 0;
692  }
693  ileft = s->prev;
694  iright = inpicref;
695  if (s->in.format == ALTERNATING_RL)
696  FFSWAP(AVFrame *, ileft, iright);
697  break;
698  default:
699  ileft = iright = inpicref;
700  };
701 
702  if ((s->out.format == ALTERNATING_LR ||
703  s->out.format == ALTERNATING_RL) &&
704  (s->in.format == SIDE_BY_SIDE_LR ||
705  s->in.format == SIDE_BY_SIDE_RL ||
706  s->in.format == SIDE_BY_SIDE_2_LR ||
707  s->in.format == SIDE_BY_SIDE_2_RL ||
708  s->in.format == ABOVE_BELOW_LR ||
709  s->in.format == ABOVE_BELOW_RL ||
710  s->in.format == ABOVE_BELOW_2_LR ||
711  s->in.format == ABOVE_BELOW_2_RL ||
712  s->in.format == INTERLEAVE_ROWS_LR ||
713  s->in.format == INTERLEAVE_ROWS_RL)) {
714  oright = av_frame_clone(s->prev);
715  oleft = av_frame_clone(s->prev);
716  if (!oright || !oleft) {
717  av_frame_free(&oright);
718  av_frame_free(&oleft);
719  av_frame_free(&s->prev);
720  av_frame_free(&inpicref);
721  return AVERROR(ENOMEM);
722  }
723  } else if ((s->out.format == MONO_L ||
724  s->out.format == MONO_R) &&
725  (s->in.format == SIDE_BY_SIDE_LR ||
726  s->in.format == SIDE_BY_SIDE_RL ||
727  s->in.format == SIDE_BY_SIDE_2_LR ||
728  s->in.format == SIDE_BY_SIDE_2_RL ||
729  s->in.format == ABOVE_BELOW_LR ||
730  s->in.format == ABOVE_BELOW_RL ||
731  s->in.format == ABOVE_BELOW_2_LR ||
732  s->in.format == ABOVE_BELOW_2_RL ||
733  s->in.format == INTERLEAVE_ROWS_LR ||
734  s->in.format == INTERLEAVE_ROWS_RL)) {
735  out = oleft = oright = av_frame_clone(inpicref);
736  if (!out) {
737  av_frame_free(&s->prev);
738  av_frame_free(&inpicref);
739  return AVERROR(ENOMEM);
740  }
741  } else if ((s->out.format == MONO_L && s->in.format == ALTERNATING_LR) ||
742  (s->out.format == MONO_R && s->in.format == ALTERNATING_RL)) {
743  s->prev->pts /= 2;
744  ret = ff_filter_frame(outlink, s->prev);
745  av_frame_free(&inpicref);
746  s->prev = NULL;
747  return ret;
748  } else if ((s->out.format == MONO_L && s->in.format == ALTERNATING_RL) ||
749  (s->out.format == MONO_R && s->in.format == ALTERNATING_LR)) {
750  av_frame_free(&s->prev);
751  inpicref->pts /= 2;
752  return ff_filter_frame(outlink, inpicref);
753  } else if ((s->out.format == ALTERNATING_LR && s->in.format == ALTERNATING_RL) ||
754  (s->out.format == ALTERNATING_RL && s->in.format == ALTERNATING_LR)) {
755  FFSWAP(int64_t, s->prev->pts, inpicref->pts);
756  ff_filter_frame(outlink, inpicref);
757  ret = ff_filter_frame(outlink, s->prev);
758  s->prev = NULL;
759  return ret;
760  } else {
761  out = oleft = oright = ff_get_video_buffer(outlink, outlink->w, outlink->h);
762  if (!out) {
763  av_frame_free(&s->prev);
764  av_frame_free(&inpicref);
765  return AVERROR(ENOMEM);
766  }
767  av_frame_copy_props(out, inpicref);
768 
769  if (s->out.format == ALTERNATING_LR ||
770  s->out.format == ALTERNATING_RL) {
771  oright = ff_get_video_buffer(outlink, outlink->w, outlink->h);
772  if (!oright) {
773  av_frame_free(&oleft);
774  av_frame_free(&s->prev);
775  av_frame_free(&inpicref);
776  return AVERROR(ENOMEM);
777  }
778  av_frame_copy_props(oright, s->prev);
779  }
780  }
781 
782  for (i = 0; i < 4; i++) {
783  int hsub = i == 1 || i == 2 ? s->hsub : 0;
784  int vsub = i == 1 || i == 2 ? s->vsub : 0;
785  s->in_off_left[i] = (AV_CEIL_RSHIFT(s->in.row_left, vsub) + s->in.off_lstep) * ileft->linesize[i] + AV_CEIL_RSHIFT(s->in.off_left * s->pixstep[i], hsub);
786  s->in_off_right[i] = (AV_CEIL_RSHIFT(s->in.row_right, vsub) + s->in.off_rstep) * iright->linesize[i] + AV_CEIL_RSHIFT(s->in.off_right * s->pixstep[i], hsub);
787  out_off_left[i] = (AV_CEIL_RSHIFT(s->out.row_left, vsub) + s->out.off_lstep) * oleft->linesize[i] + AV_CEIL_RSHIFT(s->out.off_left * s->pixstep[i], hsub);
788  out_off_right[i] = (AV_CEIL_RSHIFT(s->out.row_right, vsub) + s->out.off_rstep) * oright->linesize[i] + AV_CEIL_RSHIFT(s->out.off_right * s->pixstep[i], hsub);
789  }
790 
791  switch (s->out.format) {
792  case ALTERNATING_LR:
793  case ALTERNATING_RL:
794  switch (s->in.format) {
795  case INTERLEAVE_ROWS_LR:
796  case INTERLEAVE_ROWS_RL:
797  for (i = 0; i < s->nb_planes; i++) {
798  oleft->linesize[i] *= 2;
799  oright->linesize[i] *= 2;
800  }
801  case ABOVE_BELOW_LR:
802  case ABOVE_BELOW_RL:
803  case ABOVE_BELOW_2_LR:
804  case ABOVE_BELOW_2_RL:
805  case SIDE_BY_SIDE_LR:
806  case SIDE_BY_SIDE_RL:
807  case SIDE_BY_SIDE_2_LR:
808  case SIDE_BY_SIDE_2_RL:
809  oleft->width = outlink->w;
810  oright->width = outlink->w;
811  oleft->height = outlink->h;
812  oright->height = outlink->h;
813 
814  for (i = 0; i < s->nb_planes; i++) {
815  oleft->data[i] += s->in_off_left[i];
816  oright->data[i] += s->in_off_right[i];
817  }
818  break;
819  default:
820  goto copy;
821  break;
822  }
823  break;
824  case HDMI:
825  for (i = 0; i < s->nb_planes; i++) {
826  int j, h = s->height >> ((i == 1 || i == 2) ? s->vsub : 0);
827  int b = (s->blanks) >> ((i == 1 || i == 2) ? s->vsub : 0);
828 
829  for (j = h; j < h + b; j++)
830  memset(oleft->data[i] + j * s->linesize[i], 0, s->linesize[i]);
831  }
832  case SIDE_BY_SIDE_LR:
833  case SIDE_BY_SIDE_RL:
834  case SIDE_BY_SIDE_2_LR:
835  case SIDE_BY_SIDE_2_RL:
836  case ABOVE_BELOW_LR:
837  case ABOVE_BELOW_RL:
838  case ABOVE_BELOW_2_LR:
839  case ABOVE_BELOW_2_RL:
840  case INTERLEAVE_ROWS_LR:
841  case INTERLEAVE_ROWS_RL:
842 copy:
843  if (s->in.format == INTERLEAVE_COLS_LR ||
844  s->in.format == INTERLEAVE_COLS_RL) {
845  for (i = 0; i < s->nb_planes; i++) {
846  int d = (s->in.format & 1) != (s->out.format & 1);
847 
848  interleave_cols_to_any(s, out_off_left, i, ileft, oleft, d);
849  interleave_cols_to_any(s, out_off_right, i, iright, oright, !d);
850  }
851  } else {
852  for (i = 0; i < s->nb_planes; i++) {
853  av_image_copy_plane(oleft->data[i] + out_off_left[i],
854  oleft->linesize[i] * s->out.row_step,
855  ileft->data[i] + s->in_off_left[i],
856  ileft->linesize[i] * s->in.row_step,
857  s->linesize[i], s->pheight[i]);
858  av_image_copy_plane(oright->data[i] + out_off_right[i],
859  oright->linesize[i] * s->out.row_step,
860  iright->data[i] + s->in_off_right[i],
861  iright->linesize[i] * s->in.row_step,
862  s->linesize[i], s->pheight[i]);
863  }
864  }
865  break;
866  case MONO_L:
867  iright = ileft;
868  case MONO_R:
869  switch (s->in.format) {
870  case INTERLEAVE_ROWS_LR:
871  case INTERLEAVE_ROWS_RL:
872  for (i = 0; i < s->nb_planes; i++) {
873  out->linesize[i] *= 2;
874  }
875  case ABOVE_BELOW_LR:
876  case ABOVE_BELOW_RL:
877  case ABOVE_BELOW_2_LR:
878  case ABOVE_BELOW_2_RL:
879  case SIDE_BY_SIDE_LR:
880  case SIDE_BY_SIDE_RL:
881  case SIDE_BY_SIDE_2_LR:
882  case SIDE_BY_SIDE_2_RL:
883  out->width = outlink->w;
884  out->height = outlink->h;
885 
886  for (i = 0; i < s->nb_planes; i++) {
887  out->data[i] += s->in_off_left[i];
888  }
889  break;
890  case INTERLEAVE_COLS_LR:
891  case INTERLEAVE_COLS_RL:
892  for (i = 0; i < s->nb_planes; i++) {
893  const int d = (s->in.format & 1) != (s->out.format & 1);
894 
895  interleave_cols_to_any(s, out_off_right, i, iright, out, d);
896  }
897  break;
898  default:
899  for (i = 0; i < s->nb_planes; i++) {
900  av_image_copy_plane(out->data[i], out->linesize[i],
901  iright->data[i] + s->in_off_left[i],
902  iright->linesize[i] * s->in.row_step,
903  s->linesize[i], s->pheight[i]);
904  }
905  break;
906  }
907  break;
908  case ANAGLYPH_RB_GRAY:
909  case ANAGLYPH_RG_GRAY:
910  case ANAGLYPH_RC_GRAY:
911  case ANAGLYPH_RC_HALF:
912  case ANAGLYPH_RC_COLOR:
913  case ANAGLYPH_RC_DUBOIS:
914  case ANAGLYPH_GM_GRAY:
915  case ANAGLYPH_GM_HALF:
916  case ANAGLYPH_GM_COLOR:
917  case ANAGLYPH_GM_DUBOIS:
918  case ANAGLYPH_YB_GRAY:
919  case ANAGLYPH_YB_HALF:
920  case ANAGLYPH_YB_COLOR:
921  case ANAGLYPH_YB_DUBOIS: {
922  if (s->in.format == INTERLEAVE_COLS_LR ||
923  s->in.format == INTERLEAVE_COLS_RL) {
924  const int d = (s->in.format & 1);
925 
926  anaglyph_ic(out->data[0],
927  ileft ->data[0] + s->in_off_left [0] + d * 3,
928  iright->data[0] + s->in_off_right[0] + (!d) * 3,
929  out->linesize[0],
930  ileft->linesize[0] * s->in.row_step,
931  iright->linesize[0] * s->in.row_step,
932  s->out.width, s->out.height,
933  s->ana_matrix[0], s->ana_matrix[1], s->ana_matrix[2]);
934  } else {
935  ThreadData td;
936 
937  td.ileft = ileft; td.iright = iright; td.out = out;
938  ctx->internal->execute(ctx, filter_slice, &td, NULL,
939  FFMIN(s->out.height, ff_filter_get_nb_threads(ctx)));
940  }
941  break;
942  }
943  case CHECKERBOARD_RL:
944  case CHECKERBOARD_LR:
945  for (i = 0; i < s->nb_planes; i++) {
946  int x, y;
947 
948  for (y = 0; y < s->pheight[i]; y++) {
949  uint8_t *dst = out->data[i] + out->linesize[i] * y;
950  const int d1 = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) && (s->in.format & 1) != (s->out.format & 1);
951  const int d2 = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) ? !d1 : 0;
952  const int m = 1 + (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL);
953  uint8_t *left = ileft->data[i] + ileft->linesize[i] * y + s->in_off_left[i] + d1 * s->pixstep[i];
954  uint8_t *right = iright->data[i] + iright->linesize[i] * y + s->in_off_right[i] + d2 * s->pixstep[i];
955  int p, b;
956 
957  if (s->out.format == CHECKERBOARD_RL && s->in.format != INTERLEAVE_COLS_LR && s->in.format != INTERLEAVE_COLS_RL)
958  FFSWAP(uint8_t*, left, right);
959  switch (s->pixstep[i]) {
960  case 1:
961  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b+=2) {
962  dst[x ] = (b&1) == (y&1) ? left[p*m] : right[p*m];
963  dst[x+1] = (b&1) != (y&1) ? left[p*m] : right[p*m];
964  }
965  break;
966  case 2:
967  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b+=2) {
968  AV_WN16(&dst[x ], (b&1) == (y&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
969  AV_WN16(&dst[x+2], (b&1) != (y&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
970  }
971  break;
972  case 3:
973  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b+=2) {
974  AV_WB24(&dst[x ], (b&1) == (y&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
975  AV_WB24(&dst[x+3], (b&1) != (y&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
976  }
977  break;
978  case 4:
979  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b+=2) {
980  AV_WN32(&dst[x ], (b&1) == (y&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
981  AV_WN32(&dst[x+4], (b&1) != (y&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
982  }
983  break;
984  case 6:
985  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b+=2) {
986  AV_WB48(&dst[x ], (b&1) == (y&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
987  AV_WB48(&dst[x+6], (b&1) != (y&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
988  }
989  break;
990  case 8:
991  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b+=2) {
992  AV_WN64(&dst[x ], (b&1) == (y&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
993  AV_WN64(&dst[x+8], (b&1) != (y&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
994  }
995  break;
996  }
997  }
998  }
999  break;
1000  case INTERLEAVE_COLS_LR:
1001  case INTERLEAVE_COLS_RL:
1002  for (i = 0; i < s->nb_planes; i++) {
1003  const int d = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL);
1004  const int m = 1 + d;
1005  int x, y;
1006 
1007  for (y = 0; y < s->pheight[i]; y++) {
1008  uint8_t *dst = out->data[i] + out->linesize[i] * y;
1009  uint8_t *left = ileft->data[i] + ileft->linesize[i] * y * s->in.row_step + s->in_off_left[i] + d * s->pixstep[i];
1010  uint8_t *right = iright->data[i] + iright->linesize[i] * y * s->in.row_step + s->in_off_right[i];
1011  int p, b;
1012 
1013  if (s->out.format == INTERLEAVE_COLS_LR)
1014  FFSWAP(uint8_t*, left, right);
1015 
1016  switch (s->pixstep[i]) {
1017  case 1:
1018  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b+=2) {
1019  dst[x ] = b&1 ? left[p*m] : right[p*m];
1020  dst[x+1] = !(b&1) ? left[p*m] : right[p*m];
1021  }
1022  break;
1023  case 2:
1024  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b+=2) {
1025  AV_WN16(&dst[x ], b&1 ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
1026  AV_WN16(&dst[x+2], !(b&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
1027  }
1028  break;
1029  case 3:
1030  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b+=2) {
1031  AV_WB24(&dst[x ], b&1 ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
1032  AV_WB24(&dst[x+3], !(b&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
1033  }
1034  break;
1035  case 4:
1036  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b+=2) {
1037  AV_WN32(&dst[x ], b&1 ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
1038  AV_WN32(&dst[x+4], !(b&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
1039  }
1040  break;
1041  case 6:
1042  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b+=2) {
1043  AV_WB48(&dst[x ], b&1 ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
1044  AV_WB48(&dst[x+6], !(b&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
1045  }
1046  break;
1047  case 8:
1048  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b+=2) {
1049  AV_WN64(&dst[x ], b&1 ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
1050  AV_WN64(&dst[x+8], !(b&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
1051  }
1052  break;
1053  }
1054  }
1055  }
1056  break;
1057  default:
1058  av_assert0(0);
1059  }
1060 
1061  if (oright != oleft) {
1062  if (s->out.format == ALTERNATING_LR)
1063  FFSWAP(AVFrame *, oleft, oright);
1064  oright->pts = s->prev->pts * 2;
1065  ff_filter_frame(outlink, oright);
1066  out = oleft;
1067  oleft->pts = s->prev->pts + inpicref->pts;
1068  av_frame_free(&s->prev);
1069  s->prev = inpicref;
1070  } else if (s->in.format == ALTERNATING_LR ||
1071  s->in.format == ALTERNATING_RL) {
1072  out->pts = s->prev->pts / 2;
1073  av_frame_free(&s->prev);
1074  av_frame_free(&inpicref);
1075  } else {
1076  av_frame_free(&s->prev);
1077  av_frame_free(&inpicref);
1078  }
1079  out->sample_aspect_ratio = s->aspect;
1080  return ff_filter_frame(outlink, out);
1081 }
1082 
1083 static av_cold void uninit(AVFilterContext *ctx)
1084 {
1085  Stereo3DContext *s = ctx->priv;
1086 
1087  av_frame_free(&s->prev);
1088 }
1089 
1090 static const AVFilterPad stereo3d_inputs[] = {
1091  {
1092  .name = "default",
1093  .type = AVMEDIA_TYPE_VIDEO,
1094  .filter_frame = filter_frame,
1095  },
1096  { NULL }
1097 };
1098 
1099 static const AVFilterPad stereo3d_outputs[] = {
1100  {
1101  .name = "default",
1102  .type = AVMEDIA_TYPE_VIDEO,
1103  .config_props = config_output,
1104  },
1105  { NULL }
1106 };
1107 
1108 AVFilter ff_vf_stereo3d = {
1109  .name = "stereo3d",
1110  .description = NULL_IF_CONFIG_SMALL("Convert video stereoscopic 3D view."),
1111  .priv_size = sizeof(Stereo3DContext),
1112  .uninit = uninit,
1113  .query_formats = query_formats,
1114  .inputs = stereo3d_inputs,
1115  .outputs = stereo3d_outputs,
1116  .priv_class = &stereo3d_class,
1117  .flags = AVFILTER_FLAG_SLICE_THREADS,
1118 };
NULL
#define NULL
Definition: coverity.c:32
AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:166
AV_RB48
#define AV_RB48(x)
Definition: intreadwrite.h:472
AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:252
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:488
AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:245
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:185
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
h
h
Definition: vp9dsp_template.c:2038
Stereo3DContext::in
StereoComponent in
Definition: vf_stereo3d.c:142
AVOption
AVOption.
Definition: opt.h:246
AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:249
AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:159
ABOVE_BELOW_2_RL
Definition: vf_stereo3d.c:61
AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:208
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
anaglyph
static void anaglyph(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc, ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize, int width, int height, const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
Definition: vf_stereo3d.c:338
imgutils.h
misc image utilities
interleave_cols_to_any
static void interleave_cols_to_any(Stereo3DContext *s, int *out_off, int p, AVFrame *in, AVFrame *out, int d)
Definition: vf_stereo3d.c:627
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2562
SIDE_BY_SIDE_LR
Definition: vf_stereo3d.c:54
Stereo3DDSPContext::anaglyph
void(* anaglyph)(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc, ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize, int width, int height, const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
Definition: stereo3d.h:28
avfilter.h
Main libavfilter public API header.
AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
StereoComponent::format
int format
StereoCode.
Definition: vf_stereo3d.c:73
desc
const char * desc
Definition: nvenc.c:68
AV_OPT_TYPE_INT
Definition: opt.h:223
AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:162
AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:250
Stereo3DContext::in_off_right
int in_off_right[4]
Definition: vf_stereo3d.c:152
AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
ANAGLYPH_YB_GRAY
Definition: vf_stereo3d.c:44
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:207
AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:189
AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:255
AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:156
ANAGLYPH_RC_COLOR
Definition: vf_stereo3d.c:38
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(stereo3d)
AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:239
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:99
ANAGLYPH_GM_COLOR
Definition: vf_stereo3d.c:42
src
#define src
Definition: vp8dsp.c:254
AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:131
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
ana_convert
static uint8_t ana_convert(const int *coeff, const uint8_t *left, const uint8_t *right)
Definition: vf_stereo3d.c:307
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
ANAGLYPH_RC_DUBOIS
Definition: vf_stereo3d.c:39
ff_vf_stereo3d
AVFilter ff_vf_stereo3d
Definition: vf_stereo3d.c:1108
av_image_fill_max_pixsteps
void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], const AVPixFmtDescriptor *pixdesc)
Compute the max pixel step for each plane of an image with a format described by pixdesc.
Definition: imgutils.c:35
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian ...
Definition: pixfmt.h:179
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
ThreadData::iright
AVFrame * iright
Definition: vf_stereo3d.c:599
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:190
AV_OPT_TYPE_CONST
Definition: opt.h:232
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
Stereo3DContext::out
StereoComponent out
Definition: vf_stereo3d.c:142
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:238
opt.h
AVOptions.
AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:205
AV_WB48
#define AV_WB48(p, darg)
Definition: intreadwrite.h:481
AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:361
CHECKERBOARD_RL
Definition: vf_stereo3d.c:65
AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:191
anaglyph_ic
static void anaglyph_ic(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc, ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize, int width, int height, const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
Definition: vf_stereo3d.c:318
ThreadData::ileft
AVFrame * ileft
Definition: vf_stereo3d.c:599
stereo3d_outputs
static const AVFilterPad stereo3d_outputs[]
Definition: vf_stereo3d.c:1099
AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:174
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:100
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:79
AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:194
INTERLEAVE_COLS_RL
Definition: vf_stereo3d.c:67
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:170
AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:165
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_stereo3d.c:1083
AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
AVFrame::width
int width
Definition: frame.h:326
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
td
#define td
Definition: regdef.h:70
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:136
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
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:186
AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:353
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
ALTERNATING_RL
Definition: vf_stereo3d.c:63
AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:182
arg
const char * arg
Definition: jacosubdec.c:66
AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:161
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:248
AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:134
ANAGLYPH_GM_GRAY
Definition: vf_stereo3d.c:40
Stereo3DContext::prev
AVFrame * prev
Definition: vf_stereo3d.c:150
AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:183
FLAGS
#define FLAGS
Definition: vf_stereo3d.c:158
AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:149
AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:184
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ALTERNATING_LR
Definition: vf_stereo3d.c:62
OFFSET
#define OFFSET(x)
Definition: vf_stereo3d.c:157
STEREO_CODE_COUNT
Definition: vf_stereo3d.c:69
b
#define b
Definition: input.c:41
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
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:78
HDMI
Definition: vf_stereo3d.c:68
ABOVE_BELOW_RL
Definition: vf_stereo3d.c:59
SIDE_BY_SIDE_2_LR
Definition: vf_stereo3d.c:56
stereo3d_inputs
static const AVFilterPad stereo3d_inputs[]
Definition: vf_stereo3d.c:1090
SIDE_BY_SIDE_RL
Definition: vf_stereo3d.c:55
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:188
ANAGLYPH_YB_DUBOIS
Definition: vf_stereo3d.c:47
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:180
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_stereo3d.c:603
AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:243
AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:158
ANAGLYPH_RC_HALF
Definition: vf_stereo3d.c:37
ABOVE_BELOW_LR
Definition: vf_stereo3d.c:58
AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:167
AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:148
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
other_pix_fmts
static enum AVPixelFormat other_pix_fmts[]
Definition: vf_stereo3d.c:220
ff_stereo3d_init_x86
void ff_stereo3d_init_x86(Stereo3DDSPContext *dsp)
Definition: vf_stereo3d_init.c:30
Stereo3DContext::aspect
AVRational aspect
Definition: vf_stereo3d.c:153
stereo3d_options
static const AVOption stereo3d_options[]
Definition: vf_stereo3d.c:160
AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:132
MONO_L
Definition: vf_stereo3d.c:50
INTERLEAVE_ROWS_LR
Definition: vf_stereo3d.c:52
drawutils.h
misc drawing utilities
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
ThreadData
Used for passing data between threads.
Definition: af_adeclick.c:487
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AV_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:360
AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:192
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:356
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
anaglyph_pix_fmts
static enum AVPixelFormat anaglyph_pix_fmts[]
Definition: vf_stereo3d.c:215
AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:257
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:194
ANAGLYPH_GM_HALF
Definition: vf_stereo3d.c:41
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:193
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AVFilter
Filter definition.
Definition: avfilter.h:144
av_image_fill_linesizes
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:195
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:244
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_stereo3d.c:358
Stereo3DContext::ana_matrix
const int * ana_matrix[3]
Definition: vf_stereo3d.c:144
ANAGLYPH_YB_COLOR
Definition: vf_stereo3d.c:46
AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148
AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:256
AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:178
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
parseutils.h
misc parsing utilities
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_stereo3d.c:274
AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:187
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFilterContext::internal
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:163
AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:135
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:207
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:247
CHECKERBOARD_LR
Definition: vf_stereo3d.c:64
ANAGLYPH_RC_GRAY
Definition: vf_stereo3d.c:36
ANAGLYPH_GM_DUBOIS
Definition: vf_stereo3d.c:43
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:171
AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:133
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:80
AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVFilterInternal::execute
avfilter_execute_func * execute
Definition: internal.h:155
AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:185
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
Definition: vf_stereo3d.c:664
ana_coeff
static const int ana_coeff[][3][6]
Definition: vf_stereo3d.c:81
ABOVE_BELOW_2_LR
Definition: vf_stereo3d.c:60
AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:253
SIDE_BY_SIDE_2_RL
Definition: vf_stereo3d.c:57
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
AV_RN64
#define AV_RN64(p)
Definition: intreadwrite.h:368
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
ANAGLYPH_RB_GRAY
Definition: vf_stereo3d.c:48
INTERLEAVE_ROWS_RL
Definition: vf_stereo3d.c:53
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:186
ANAGLYPH_RG_GRAY
Definition: vf_stereo3d.c:49
Stereo3DContext::in_off_left
int in_off_left[4]
Definition: vf_stereo3d.c:152
AVFrame::height
int height
Definition: frame.h:326
out
FILE * out
Definition: movenc.c:54
AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
start
void INT64 start
Definition: avisynth_c.h:766
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:175
INTERLEAVE_COLS_LR
Definition: vf_stereo3d.c:66
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
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:338
AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:181
internal.h
internal API functions
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
ANAGLYPH_YB_HALF
Definition: vf_stereo3d.c:45
Stereo3DContext::dsp
Stereo3DDSPContext dsp
Definition: vf_stereo3d.c:154
AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:237
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
MONO_R
Definition: vf_stereo3d.c:51
StereoCode
StereoCode
Definition: vf_stereo3d.c:35
AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:242
AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:164
AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:246
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:654
AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:173
AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:206
tb
#define tb
Definition: regdef.h:68
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AV_WN64
#define AV_WN64(p, v)
Definition: intreadwrite.h:380
AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:160
Generated on Mon Jun 24 2019 19:22:12 for FFmpeg by   doxygen 1.8.11