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  {{29884, 32768, 11534, -2818, -5767, -131},
104  {-2621, -2490, -1049, 24773, 48103, -1180},
105  { -983, -1376, -328, -4719, -7406, 80347}},
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  {{69599,-13435,19595, -1048, -8061, -1114},
136  {-1704, 59507, 4456, 393, 4063, -1114},
137  {-2490,-11338, 1442, 6160, 12124, 59703}},
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  { "tb2l", "above below half height left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_LR}, 0, 0, FLAGS, "in" },
164  { "ab2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "in" },
165  { "tb2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "in" },
166  { "abl", "above below left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_LR}, 0, 0, FLAGS, "in" },
167  { "tbl", "above below left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_LR}, 0, 0, FLAGS, "in" },
168  { "abr", "above below right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_RL}, 0, 0, FLAGS, "in" },
169  { "tbr", "above below right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_RL}, 0, 0, FLAGS, "in" },
170  { "al", "alternating frames left first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_LR}, 0, 0, FLAGS, "in" },
171  { "ar", "alternating frames right first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_RL}, 0, 0, FLAGS, "in" },
172  { "sbs2l", "side by side half width left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_LR}, 0, 0, FLAGS, "in" },
173  { "sbs2r", "side by side half width right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_RL}, 0, 0, FLAGS, "in" },
174  { "sbsl", "side by side left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_LR}, 0, 0, FLAGS, "in" },
175  { "sbsr", "side by side right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_RL}, 0, 0, FLAGS, "in" },
176  { "irl", "interleave rows left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_LR}, 0, 0, FLAGS, "in" },
177  { "irr", "interleave rows right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_RL}, 0, 0, FLAGS, "in" },
178  { "icl", "interleave columns left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_LR}, 0, 0, FLAGS, "in" },
179  { "icr", "interleave columns right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_RL}, 0, 0, FLAGS, "in" },
180  { "out", "set output format", OFFSET(out.format), AV_OPT_TYPE_INT, {.i64=ANAGLYPH_RC_DUBOIS}, 0, STEREO_CODE_COUNT-1, FLAGS, "out"},
181  { "ab2l", "above below half height left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_LR}, 0, 0, FLAGS, "out" },
182  { "tb2l", "above below half height left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_LR}, 0, 0, FLAGS, "out" },
183  { "ab2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "out" },
184  { "tb2r", "above below half height right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_2_RL}, 0, 0, FLAGS, "out" },
185  { "abl", "above below left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_LR}, 0, 0, FLAGS, "out" },
186  { "tbl", "above below left first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_LR}, 0, 0, FLAGS, "out" },
187  { "abr", "above below right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_RL}, 0, 0, FLAGS, "out" },
188  { "tbr", "above below right first", 0, AV_OPT_TYPE_CONST, {.i64=ABOVE_BELOW_RL}, 0, 0, FLAGS, "out" },
189  { "agmc", "anaglyph green magenta color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_COLOR}, 0, 0, FLAGS, "out" },
190  { "agmd", "anaglyph green magenta dubois", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_DUBOIS}, 0, 0, FLAGS, "out" },
191  { "agmg", "anaglyph green magenta gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_GRAY}, 0, 0, FLAGS, "out" },
192  { "agmh", "anaglyph green magenta half color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_GM_HALF}, 0, 0, FLAGS, "out" },
193  { "al", "alternating frames left first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_LR}, 0, 0, FLAGS, "out" },
194  { "ar", "alternating frames right first", 0, AV_OPT_TYPE_CONST, {.i64=ALTERNATING_RL}, 0, 0, FLAGS, "out" },
195  { "arbg", "anaglyph red blue gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RB_GRAY}, 0, 0, FLAGS, "out" },
196  { "arcc", "anaglyph red cyan color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_COLOR}, 0, 0, FLAGS, "out" },
197  { "arcd", "anaglyph red cyan dubois", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_DUBOIS}, 0, 0, FLAGS, "out" },
198  { "arcg", "anaglyph red cyan gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_GRAY}, 0, 0, FLAGS, "out" },
199  { "arch", "anaglyph red cyan half color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RC_HALF}, 0, 0, FLAGS, "out" },
200  { "argg", "anaglyph red green gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_RG_GRAY}, 0, 0, FLAGS, "out" },
201  { "aybc", "anaglyph yellow blue color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_COLOR}, 0, 0, FLAGS, "out" },
202  { "aybd", "anaglyph yellow blue dubois", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_DUBOIS}, 0, 0, FLAGS, "out" },
203  { "aybg", "anaglyph yellow blue gray", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_GRAY}, 0, 0, FLAGS, "out" },
204  { "aybh", "anaglyph yellow blue half color", 0, AV_OPT_TYPE_CONST, {.i64=ANAGLYPH_YB_HALF}, 0, 0, FLAGS, "out" },
205  { "irl", "interleave rows left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_LR}, 0, 0, FLAGS, "out" },
206  { "irr", "interleave rows right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_ROWS_RL}, 0, 0, FLAGS, "out" },
207  { "ml", "mono left", 0, AV_OPT_TYPE_CONST, {.i64=MONO_L}, 0, 0, FLAGS, "out" },
208  { "mr", "mono right", 0, AV_OPT_TYPE_CONST, {.i64=MONO_R}, 0, 0, FLAGS, "out" },
209  { "sbs2l", "side by side half width left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_LR}, 0, 0, FLAGS, "out" },
210  { "sbs2r", "side by side half width right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_2_RL}, 0, 0, FLAGS, "out" },
211  { "sbsl", "side by side left first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_LR}, 0, 0, FLAGS, "out" },
212  { "sbsr", "side by side right first", 0, AV_OPT_TYPE_CONST, {.i64=SIDE_BY_SIDE_RL}, 0, 0, FLAGS, "out" },
213  { "chl", "checkerboard left first", 0, AV_OPT_TYPE_CONST, {.i64=CHECKERBOARD_LR}, 0, 0, FLAGS, "out" },
214  { "chr", "checkerboard right first", 0, AV_OPT_TYPE_CONST, {.i64=CHECKERBOARD_RL}, 0, 0, FLAGS, "out" },
215  { "icl", "interleave columns left first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_LR}, 0, 0, FLAGS, "out" },
216  { "icr", "interleave columns right first", 0, AV_OPT_TYPE_CONST, {.i64=INTERLEAVE_COLS_RL}, 0, 0, FLAGS, "out" },
217  { "hdmi", "HDMI frame pack", 0, AV_OPT_TYPE_CONST, {.i64=HDMI}, 0, 0, FLAGS, "out" },
218  { NULL }
219 };
220 
221 AVFILTER_DEFINE_CLASS(stereo3d);
222 
223 static const enum AVPixelFormat anaglyph_pix_fmts[] = {
224  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
225  AV_PIX_FMT_NONE
226 };
227 
228 static const enum AVPixelFormat other_pix_fmts[] = {
229  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
230  AV_PIX_FMT_RGB48BE, AV_PIX_FMT_BGR48BE,
231  AV_PIX_FMT_RGB48LE, AV_PIX_FMT_BGR48LE,
232  AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_BGRA64BE,
233  AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_BGRA64LE,
234  AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
235  AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
236  AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
237  AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
238  AV_PIX_FMT_GBRP,
239  AV_PIX_FMT_GBRP9BE, AV_PIX_FMT_GBRP9LE,
240  AV_PIX_FMT_GBRP10BE, AV_PIX_FMT_GBRP10LE,
241  AV_PIX_FMT_GBRP12BE, AV_PIX_FMT_GBRP12LE,
242  AV_PIX_FMT_GBRP14BE, AV_PIX_FMT_GBRP14LE,
243  AV_PIX_FMT_GBRP16BE, AV_PIX_FMT_GBRP16LE,
244  AV_PIX_FMT_YUV410P,
245  AV_PIX_FMT_YUV411P,
246  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,
247  AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P,
248  AV_PIX_FMT_YUV440P,
249  AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
250  AV_PIX_FMT_YUVJ411P,
251  AV_PIX_FMT_YUVJ420P,
252  AV_PIX_FMT_YUVJ422P,
253  AV_PIX_FMT_YUVJ440P,
254  AV_PIX_FMT_YUVJ444P,
255  AV_PIX_FMT_YUV420P9LE, AV_PIX_FMT_YUVA420P9LE,
256  AV_PIX_FMT_YUV420P9BE, AV_PIX_FMT_YUVA420P9BE,
257  AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_YUVA422P9LE,
258  AV_PIX_FMT_YUV422P9BE, AV_PIX_FMT_YUVA422P9BE,
259  AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUVA444P9LE,
260  AV_PIX_FMT_YUV444P9BE, AV_PIX_FMT_YUVA444P9BE,
261  AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUVA420P10LE,
262  AV_PIX_FMT_YUV420P10BE, AV_PIX_FMT_YUVA420P10BE,
263  AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUVA422P10LE,
264  AV_PIX_FMT_YUV422P10BE, AV_PIX_FMT_YUVA422P10BE,
265  AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUVA444P10LE,
266  AV_PIX_FMT_YUV444P10BE, AV_PIX_FMT_YUVA444P10BE,
267  AV_PIX_FMT_YUV420P12BE, AV_PIX_FMT_YUV420P12LE,
268  AV_PIX_FMT_YUV422P12BE, AV_PIX_FMT_YUV422P12LE,
269  AV_PIX_FMT_YUV444P12BE, AV_PIX_FMT_YUV444P12LE,
270  AV_PIX_FMT_YUV420P14BE, AV_PIX_FMT_YUV420P14LE,
271  AV_PIX_FMT_YUV422P14BE, AV_PIX_FMT_YUV422P14LE,
272  AV_PIX_FMT_YUV444P14BE, AV_PIX_FMT_YUV444P14LE,
273  AV_PIX_FMT_YUV420P16LE, AV_PIX_FMT_YUVA420P16LE,
274  AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_YUVA420P16BE,
275  AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUVA422P16LE,
276  AV_PIX_FMT_YUV422P16BE, AV_PIX_FMT_YUVA422P16BE,
277  AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUVA444P16LE,
278  AV_PIX_FMT_YUV444P16BE, AV_PIX_FMT_YUVA444P16BE,
279  AV_PIX_FMT_NONE
280 };
281 
282 static int query_formats(AVFilterContext *ctx)
283 {
284  Stereo3DContext *s = ctx->priv;
285  const enum AVPixelFormat *pix_fmts;
286 
287  switch (s->out.format) {
288  case ANAGLYPH_GM_COLOR:
289  case ANAGLYPH_GM_DUBOIS:
290  case ANAGLYPH_GM_GRAY:
291  case ANAGLYPH_GM_HALF:
292  case ANAGLYPH_RB_GRAY:
293  case ANAGLYPH_RC_COLOR:
294  case ANAGLYPH_RC_DUBOIS:
295  case ANAGLYPH_RC_GRAY:
296  case ANAGLYPH_RC_HALF:
297  case ANAGLYPH_RG_GRAY:
298  case ANAGLYPH_YB_COLOR:
299  case ANAGLYPH_YB_DUBOIS:
300  case ANAGLYPH_YB_GRAY:
301  case ANAGLYPH_YB_HALF:
302  pix_fmts = anaglyph_pix_fmts;
303  break;
304  default:
305  pix_fmts = other_pix_fmts;
306  }
307 
308  return ff_set_common_formats_from_list(ctx, pix_fmts);
309 }
310 
311 static inline uint8_t ana_convert(const int *coeff, const uint8_t *left, const uint8_t *right)
312 {
313  int sum;
314 
315  sum = coeff[0] * left[0] + coeff[3] * right[0]; //red in
316  sum += coeff[1] * left[1] + coeff[4] * right[1]; //green in
317  sum += coeff[2] * left[2] + coeff[5] * right[2]; //blue in
318 
319  return av_clip_uint8(sum >> 16);
320 }
321 
322 static void anaglyph_ic(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc,
323  ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize,
324  int width, int height,
325  const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
326 {
327  int x, y, o;
328 
329  for (y = 0; y < height; y++) {
330  for (o = 0, x = 0; x < width; x++, o+= 3) {
331  dst[o ] = ana_convert(ana_matrix_r, lsrc + o * 2, rsrc + o * 2);
332  dst[o + 1] = ana_convert(ana_matrix_g, lsrc + o * 2, rsrc + o * 2);
333  dst[o + 2] = ana_convert(ana_matrix_b, lsrc + o * 2, rsrc + o * 2);
334  }
335 
336  dst += dst_linesize;
337  lsrc += l_linesize;
338  rsrc += r_linesize;
339  }
340 }
341 
342 static void anaglyph(uint8_t *dst, uint8_t *lsrc, uint8_t *rsrc,
343  ptrdiff_t dst_linesize, ptrdiff_t l_linesize, ptrdiff_t r_linesize,
344  int width, int height,
345  const int *ana_matrix_r, const int *ana_matrix_g, const int *ana_matrix_b)
346 {
347  int x, y, o;
348 
349  for (y = 0; y < height; y++) {
350  for (o = 0, x = 0; x < width; x++, o+= 3) {
351  dst[o ] = ana_convert(ana_matrix_r, lsrc + o, rsrc + o);
352  dst[o + 1] = ana_convert(ana_matrix_g, lsrc + o, rsrc + o);
353  dst[o + 2] = ana_convert(ana_matrix_b, lsrc + o, rsrc + o);
354  }
355 
356  dst += dst_linesize;
357  lsrc += l_linesize;
358  rsrc += r_linesize;
359  }
360 }
361 
362 static int config_output(AVFilterLink *outlink)
363 {
364  AVFilterContext *ctx = outlink->src;
365  AVFilterLink *inlink = ctx->inputs[0];
366  Stereo3DContext *s = ctx->priv;
367  AVRational fps = inlink->frame_rate;
368  AVRational tb = inlink->time_base;
369  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
370  int ret;
371  s->aspect = inlink->sample_aspect_ratio;
372 
373  switch (s->in.format) {
374  case INTERLEAVE_COLS_LR:
375  case INTERLEAVE_COLS_RL:
376  case SIDE_BY_SIDE_2_LR:
377  case SIDE_BY_SIDE_LR:
378  case SIDE_BY_SIDE_2_RL:
379  case SIDE_BY_SIDE_RL:
380  if (inlink->w & 1) {
381  av_log(ctx, AV_LOG_ERROR, "width must be even\n");
382  return AVERROR_INVALIDDATA;
383  }
384  break;
385  case INTERLEAVE_ROWS_LR:
386  case INTERLEAVE_ROWS_RL:
387  case ABOVE_BELOW_2_LR:
388  case ABOVE_BELOW_LR:
389  case ABOVE_BELOW_2_RL:
390  case ABOVE_BELOW_RL:
391  if (inlink->h & 1) {
392  av_log(ctx, AV_LOG_ERROR, "height must be even\n");
393  return AVERROR_INVALIDDATA;
394  }
395  break;
396  }
397 
398  s->in.width =
399  s->width = inlink->w;
400  s->in.height =
401  s->height = inlink->h;
402  s->in.off_lstep =
403  s->in.off_rstep =
404  s->in.off_left =
405  s->in.off_right =
406  s->in.row_left =
407  s->in.row_right = 0;
408  s->in.row_step = 1;
409 
410  switch (s->in.format) {
411  case SIDE_BY_SIDE_2_LR:
412  s->aspect.num *= 2;
413  case SIDE_BY_SIDE_LR:
414  s->width = inlink->w / 2;
415  s->in.off_right = s->width;
416  break;
417  case SIDE_BY_SIDE_2_RL:
418  s->aspect.num *= 2;
419  case SIDE_BY_SIDE_RL:
420  s->width = inlink->w / 2;
421  s->in.off_left = s->width;
422  break;
423  case ABOVE_BELOW_2_LR:
424  s->aspect.den *= 2;
425  case ABOVE_BELOW_LR:
426  s->in.row_right =
427  s->height = inlink->h / 2;
428  break;
429  case ABOVE_BELOW_2_RL:
430  s->aspect.den *= 2;
431  case ABOVE_BELOW_RL:
432  s->in.row_left =
433  s->height = inlink->h / 2;
434  break;
435  case ALTERNATING_RL:
436  case ALTERNATING_LR:
437  fps.den *= 2;
438  tb.num *= 2;
439  break;
440  case INTERLEAVE_COLS_RL:
441  case INTERLEAVE_COLS_LR:
442  s->width = inlink->w / 2;
443  break;
444  case INTERLEAVE_ROWS_LR:
445  case INTERLEAVE_ROWS_RL:
446  s->in.row_step = 2;
447  if (s->in.format == INTERLEAVE_ROWS_RL)
448  s->in.off_lstep = 1;
449  else
450  s->in.off_rstep = 1;
451  if (s->out.format != CHECKERBOARD_LR &&
452  s->out.format != CHECKERBOARD_RL)
453  s->height = inlink->h / 2;
454  break;
455  default:
456  av_log(ctx, AV_LOG_ERROR, "input format %d is not supported\n", s->in.format);
457  return AVERROR(EINVAL);
458  }
459 
460  s->out.width = s->width;
461  s->out.height = s->height;
462  s->out.off_lstep =
463  s->out.off_rstep =
464  s->out.off_left =
465  s->out.off_right =
466  s->out.row_left =
467  s->out.row_right = 0;
468  s->out.row_step = 1;
469 
470  switch (s->out.format) {
471  case ANAGLYPH_RB_GRAY:
472  case ANAGLYPH_RG_GRAY:
473  case ANAGLYPH_RC_GRAY:
474  case ANAGLYPH_RC_HALF:
475  case ANAGLYPH_RC_COLOR:
476  case ANAGLYPH_RC_DUBOIS:
477  case ANAGLYPH_GM_GRAY:
478  case ANAGLYPH_GM_HALF:
479  case ANAGLYPH_GM_COLOR:
480  case ANAGLYPH_GM_DUBOIS:
481  case ANAGLYPH_YB_GRAY:
482  case ANAGLYPH_YB_HALF:
483  case ANAGLYPH_YB_COLOR:
484  case ANAGLYPH_YB_DUBOIS: {
485  uint8_t rgba_map[4];
486 
487  ff_fill_rgba_map(rgba_map, outlink->format);
488  s->ana_matrix[rgba_map[0]] = &ana_coeff[s->out.format][0][0];
489  s->ana_matrix[rgba_map[1]] = &ana_coeff[s->out.format][1][0];
490  s->ana_matrix[rgba_map[2]] = &ana_coeff[s->out.format][2][0];
491  break;
492  }
493  case SIDE_BY_SIDE_2_LR:
494  s->aspect.den *= 2;
495  case SIDE_BY_SIDE_LR:
496  s->out.width = s->width * 2;
497  s->out.off_right = s->width;
498  break;
499  case SIDE_BY_SIDE_2_RL:
500  s->aspect.den *= 2;
501  case SIDE_BY_SIDE_RL:
502  s->out.width = s->width * 2;
503  s->out.off_left = s->width;
504  break;
505  case ABOVE_BELOW_2_LR:
506  s->aspect.num *= 2;
507  case ABOVE_BELOW_LR:
508  s->out.height = s->height * 2;
509  s->out.row_right = s->height;
510  break;
511  case HDMI:
512  if (s->height != 720 && s->height != 1080) {
513  av_log(ctx, AV_LOG_ERROR, "Only 720 and 1080 height supported\n");
514  return AVERROR(EINVAL);
515  }
516 
517  s->blanks = s->height / 24;
518  s->out.height = s->height * 2 + s->blanks;
519  s->out.row_right = s->height + s->blanks;
520  break;
521  case ABOVE_BELOW_2_RL:
522  s->aspect.num *= 2;
523  case ABOVE_BELOW_RL:
524  s->out.height = s->height * 2;
525  s->out.row_left = s->height;
526  break;
527  case INTERLEAVE_ROWS_LR:
528  s->in.row_step = 1 + (s->in.format == INTERLEAVE_ROWS_RL);
529  s->out.row_step = 2;
530  s->out.height = s->height * 2;
531  s->out.off_rstep = 1;
532  break;
533  case INTERLEAVE_ROWS_RL:
534  s->in.row_step = 1 + (s->in.format == INTERLEAVE_ROWS_LR);
535  s->out.row_step = 2;
536  s->out.height = s->height * 2;
537  s->out.off_lstep = 1;
538  break;
539  case MONO_R:
540  if (s->in.format != INTERLEAVE_COLS_LR) {
541  s->in.off_left = s->in.off_right;
542  s->in.row_left = s->in.row_right;
543  }
544  if (s->in.format == INTERLEAVE_ROWS_LR)
545  FFSWAP(int, s->in.off_lstep, s->in.off_rstep);
546  break;
547  case MONO_L:
548  if (s->in.format == INTERLEAVE_ROWS_RL)
549  FFSWAP(int, s->in.off_lstep, s->in.off_rstep);
550  break;
551  case ALTERNATING_RL:
552  case ALTERNATING_LR:
553  fps.num *= 2;
554  tb.den *= 2;
555  break;
556  case CHECKERBOARD_LR:
557  case CHECKERBOARD_RL:
558  case INTERLEAVE_COLS_LR:
559  case INTERLEAVE_COLS_RL:
560  s->out.width = s->width * 2;
561  break;
562  default:
563  av_log(ctx, AV_LOG_ERROR, "output format %d is not supported\n", s->out.format);
564  return AVERROR(EINVAL);
565  }
566 
567  if (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) {
568  if ((s->in.format & 1) != (s->out.format & 1)) {
569  FFSWAP(int, s->in.row_left, s->in.row_right);
570  FFSWAP(int, s->in.off_lstep, s->in.off_rstep);
571  FFSWAP(int, s->in.off_left, s->in.off_right);
572  FFSWAP(int, s->out.row_left, s->out.row_right);
573  FFSWAP(int, s->out.off_lstep, s->out.off_rstep);
574  FFSWAP(int, s->out.off_left, s->out.off_right);
575  }
576  }
577 
578  outlink->w = s->out.width;
579  outlink->h = s->out.height;
580  outlink->frame_rate = fps;
581  outlink->time_base = tb;
582  outlink->sample_aspect_ratio = s->aspect;
583 
584  if ((ret = av_image_fill_linesizes(s->linesize, outlink->format, s->width)) < 0)
585  return ret;
586  s->nb_planes = av_pix_fmt_count_planes(outlink->format);
587  av_image_fill_max_pixsteps(s->pixstep, NULL, desc);
588  s->pheight[1] = s->pheight[2] = AV_CEIL_RSHIFT(s->height, desc->log2_chroma_h);
589  s->pheight[0] = s->pheight[3] = s->height;
590  s->hsub = desc->log2_chroma_w;
591  s->vsub = desc->log2_chroma_h;
592 
593  s->dsp.anaglyph = anaglyph;
594 #if ARCH_X86
595  ff_stereo3d_init_x86(&s->dsp);
596 #endif
597 
598  return 0;
599 }
600 
601 typedef struct ThreadData {
602  AVFrame *ileft, *iright;
603  AVFrame *out;
604 } ThreadData;
605 
606 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
607 {
608  Stereo3DContext *s = ctx->priv;
609  ThreadData *td = arg;
610  AVFrame *ileft = td->ileft;
611  AVFrame *iright = td->iright;
612  AVFrame *out = td->out;
613  int height = s->out.height;
614  int start = (height * jobnr ) / nb_jobs;
615  int end = (height * (jobnr+1)) / nb_jobs;
616  const int **ana_matrix = s->ana_matrix;
617 
618  s->dsp.anaglyph(out->data[0] + out->linesize[0] * start,
619  ileft ->data[0] + s->in_off_left [0] + ileft->linesize[0] * start * s->in.row_step,
620  iright->data[0] + s->in_off_right[0] + iright->linesize[0] * start * s->in.row_step,
621  out->linesize[0],
622  ileft->linesize[0] * s->in.row_step,
623  iright->linesize[0] * s->in.row_step,
624  s->out.width, end - start,
625  ana_matrix[0], ana_matrix[1], ana_matrix[2]);
626 
627  return 0;
628 }
629 
630 static void interleave_cols_to_any(Stereo3DContext *s, int *out_off, int p, AVFrame *in, AVFrame *out, int d)
631 {
632  int y, x;
633 
634  for (y = 0; y < s->pheight[p]; y++) {
635  const uint8_t *src = (const uint8_t*)in->data[p] + y * in->linesize[p] + d * s->pixstep[p];
636  uint8_t *dst = out->data[p] + out_off[p] + y * out->linesize[p] * s->out.row_step;
637 
638  switch (s->pixstep[p]) {
639  case 1:
640  for (x = 0; x < s->linesize[p]; x++)
641  dst[x] = src[x * 2];
642  break;
643  case 2:
644  for (x = 0; x < s->linesize[p]; x+=2)
645  AV_WN16(&dst[x], AV_RN16(&src[x * 2]));
646  break;
647  case 3:
648  for (x = 0; x < s->linesize[p]; x+=3)
649  AV_WB24(&dst[x], AV_RB24(&src[x * 2]));
650  break;
651  case 4:
652  for (x = 0; x < s->linesize[p]; x+=4)
653  AV_WN32(&dst[x], AV_RN32(&src[x * 2]));
654  break;
655  case 6:
656  for (x = 0; x < s->linesize[p]; x+=6)
657  AV_WB48(&dst[x], AV_RB48(&src[x * 2]));
658  break;
659  case 8:
660  for (x = 0; x < s->linesize[p]; x+=8)
661  AV_WN64(&dst[x], AV_RN64(&src[x * 2]));
662  break;
663  }
664  }
665 }
666 
667 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
668 {
669  AVFilterContext *ctx = inlink->dst;
670  Stereo3DContext *s = ctx->priv;
671  AVFilterLink *outlink = ctx->outputs[0];
672  AVFrame *out = NULL, *oleft, *oright, *ileft, *iright;
673  int out_off_left[4], out_off_right[4];
674  int i, ret;
675 
676  if (s->in.format == s->out.format)
677  return ff_filter_frame(outlink, inpicref);
678 
679  switch (s->out.format) {
680  case ALTERNATING_LR:
681  case ALTERNATING_RL:
682  if (!s->prev) {
683  s->prev = inpicref;
684  return 0;
685  }
686  break;
687  };
688 
689  switch (s->in.format) {
690  case ALTERNATING_LR:
691  case ALTERNATING_RL:
692  if (!s->prev) {
693  s->prev = inpicref;
694  return 0;
695  }
696  ileft = s->prev;
697  iright = inpicref;
698  if (s->in.format == ALTERNATING_RL)
699  FFSWAP(AVFrame *, ileft, iright);
700  break;
701  default:
702  ileft = iright = inpicref;
703  };
704 
705  if ((s->out.format == ALTERNATING_LR ||
706  s->out.format == ALTERNATING_RL) &&
707  (s->in.format == SIDE_BY_SIDE_LR ||
708  s->in.format == SIDE_BY_SIDE_RL ||
709  s->in.format == SIDE_BY_SIDE_2_LR ||
710  s->in.format == SIDE_BY_SIDE_2_RL ||
711  s->in.format == ABOVE_BELOW_LR ||
712  s->in.format == ABOVE_BELOW_RL ||
713  s->in.format == ABOVE_BELOW_2_LR ||
714  s->in.format == ABOVE_BELOW_2_RL ||
715  s->in.format == INTERLEAVE_ROWS_LR ||
716  s->in.format == INTERLEAVE_ROWS_RL)) {
717  oright = av_frame_clone(s->prev);
718  oleft = av_frame_clone(s->prev);
719  if (!oright || !oleft) {
720  av_frame_free(&oright);
721  av_frame_free(&oleft);
722  av_frame_free(&s->prev);
723  av_frame_free(&inpicref);
724  return AVERROR(ENOMEM);
725  }
726  } else if ((s->out.format == MONO_L ||
727  s->out.format == MONO_R) &&
728  (s->in.format == SIDE_BY_SIDE_LR ||
729  s->in.format == SIDE_BY_SIDE_RL ||
730  s->in.format == SIDE_BY_SIDE_2_LR ||
731  s->in.format == SIDE_BY_SIDE_2_RL ||
732  s->in.format == ABOVE_BELOW_LR ||
733  s->in.format == ABOVE_BELOW_RL ||
734  s->in.format == ABOVE_BELOW_2_LR ||
735  s->in.format == ABOVE_BELOW_2_RL ||
736  s->in.format == INTERLEAVE_ROWS_LR ||
737  s->in.format == INTERLEAVE_ROWS_RL)) {
738  out = oleft = oright = av_frame_clone(inpicref);
739  if (!out) {
740  av_frame_free(&s->prev);
741  av_frame_free(&inpicref);
742  return AVERROR(ENOMEM);
743  }
744  } else if ((s->out.format == MONO_L && s->in.format == ALTERNATING_LR) ||
745  (s->out.format == MONO_R && s->in.format == ALTERNATING_RL)) {
746  s->prev->pts /= 2;
747  ret = ff_filter_frame(outlink, s->prev);
748  av_frame_free(&inpicref);
749  s->prev = NULL;
750  return ret;
751  } else if ((s->out.format == MONO_L && s->in.format == ALTERNATING_RL) ||
752  (s->out.format == MONO_R && s->in.format == ALTERNATING_LR)) {
753  av_frame_free(&s->prev);
754  inpicref->pts /= 2;
755  return ff_filter_frame(outlink, inpicref);
756  } else if ((s->out.format == ALTERNATING_LR && s->in.format == ALTERNATING_RL) ||
757  (s->out.format == ALTERNATING_RL && s->in.format == ALTERNATING_LR)) {
758  FFSWAP(int64_t, s->prev->pts, inpicref->pts);
759  ff_filter_frame(outlink, inpicref);
760  ret = ff_filter_frame(outlink, s->prev);
761  s->prev = NULL;
762  return ret;
763  } else {
764  out = oleft = oright = ff_get_video_buffer(outlink, outlink->w, outlink->h);
765  if (!out) {
766  av_frame_free(&s->prev);
767  av_frame_free(&inpicref);
768  return AVERROR(ENOMEM);
769  }
770  av_frame_copy_props(out, inpicref);
771 
772  if (s->out.format == ALTERNATING_LR ||
773  s->out.format == ALTERNATING_RL) {
774  oright = ff_get_video_buffer(outlink, outlink->w, outlink->h);
775  if (!oright) {
776  av_frame_free(&oleft);
777  av_frame_free(&s->prev);
778  av_frame_free(&inpicref);
779  return AVERROR(ENOMEM);
780  }
781  av_frame_copy_props(oright, s->prev);
782  }
783  }
784 
785  for (i = 0; i < 4; i++) {
786  int hsub = i == 1 || i == 2 ? s->hsub : 0;
787  int vsub = i == 1 || i == 2 ? s->vsub : 0;
788  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);
789  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);
790  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);
791  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);
792  }
793 
794  switch (s->out.format) {
795  case ALTERNATING_LR:
796  case ALTERNATING_RL:
797  switch (s->in.format) {
798  case INTERLEAVE_ROWS_LR:
799  case INTERLEAVE_ROWS_RL:
800  for (i = 0; i < s->nb_planes; i++) {
801  oleft->linesize[i] *= 2;
802  oright->linesize[i] *= 2;
803  }
804  case ABOVE_BELOW_LR:
805  case ABOVE_BELOW_RL:
806  case ABOVE_BELOW_2_LR:
807  case ABOVE_BELOW_2_RL:
808  case SIDE_BY_SIDE_LR:
809  case SIDE_BY_SIDE_RL:
810  case SIDE_BY_SIDE_2_LR:
811  case SIDE_BY_SIDE_2_RL:
812  oleft->width = outlink->w;
813  oright->width = outlink->w;
814  oleft->height = outlink->h;
815  oright->height = outlink->h;
816 
817  for (i = 0; i < s->nb_planes; i++) {
818  oleft->data[i] += s->in_off_left[i];
819  oright->data[i] += s->in_off_right[i];
820  }
821  break;
822  default:
823  goto copy;
824  break;
825  }
826  break;
827  case HDMI:
828  for (i = 0; i < s->nb_planes; i++) {
829  int j, h = s->height >> ((i == 1 || i == 2) ? s->vsub : 0);
830  int b = (s->blanks) >> ((i == 1 || i == 2) ? s->vsub : 0);
831 
832  for (j = h; j < h + b; j++)
833  memset(oleft->data[i] + j * s->linesize[i], 0, s->linesize[i]);
834  }
835  case SIDE_BY_SIDE_LR:
836  case SIDE_BY_SIDE_RL:
837  case SIDE_BY_SIDE_2_LR:
838  case SIDE_BY_SIDE_2_RL:
839  case ABOVE_BELOW_LR:
840  case ABOVE_BELOW_RL:
841  case ABOVE_BELOW_2_LR:
842  case ABOVE_BELOW_2_RL:
843  case INTERLEAVE_ROWS_LR:
844  case INTERLEAVE_ROWS_RL:
845 copy:
846  if (s->in.format == INTERLEAVE_COLS_LR ||
847  s->in.format == INTERLEAVE_COLS_RL) {
848  for (i = 0; i < s->nb_planes; i++) {
849  int d = (s->in.format & 1) != (s->out.format & 1);
850 
851  interleave_cols_to_any(s, out_off_left, i, ileft, oleft, d);
852  interleave_cols_to_any(s, out_off_right, i, iright, oright, !d);
853  }
854  } else {
855  for (i = 0; i < s->nb_planes; i++) {
856  av_image_copy_plane(oleft->data[i] + out_off_left[i],
857  oleft->linesize[i] * s->out.row_step,
858  ileft->data[i] + s->in_off_left[i],
859  ileft->linesize[i] * s->in.row_step,
860  s->linesize[i], s->pheight[i]);
861  av_image_copy_plane(oright->data[i] + out_off_right[i],
862  oright->linesize[i] * s->out.row_step,
863  iright->data[i] + s->in_off_right[i],
864  iright->linesize[i] * s->in.row_step,
865  s->linesize[i], s->pheight[i]);
866  }
867  }
868  break;
869  case MONO_L:
870  iright = ileft;
871  case MONO_R:
872  switch (s->in.format) {
873  case INTERLEAVE_ROWS_LR:
874  case INTERLEAVE_ROWS_RL:
875  for (i = 0; i < s->nb_planes; i++) {
876  out->linesize[i] *= 2;
877  }
878  case ABOVE_BELOW_LR:
879  case ABOVE_BELOW_RL:
880  case ABOVE_BELOW_2_LR:
881  case ABOVE_BELOW_2_RL:
882  case SIDE_BY_SIDE_LR:
883  case SIDE_BY_SIDE_RL:
884  case SIDE_BY_SIDE_2_LR:
885  case SIDE_BY_SIDE_2_RL:
886  out->width = outlink->w;
887  out->height = outlink->h;
888 
889  for (i = 0; i < s->nb_planes; i++) {
890  out->data[i] += s->in_off_left[i];
891  }
892  break;
893  case INTERLEAVE_COLS_LR:
894  case INTERLEAVE_COLS_RL:
895  for (i = 0; i < s->nb_planes; i++) {
896  const int d = (s->in.format & 1) != (s->out.format & 1);
897 
898  interleave_cols_to_any(s, out_off_right, i, iright, out, d);
899  }
900  break;
901  default:
902  for (i = 0; i < s->nb_planes; i++) {
903  av_image_copy_plane(out->data[i], out->linesize[i],
904  iright->data[i] + s->in_off_left[i],
905  iright->linesize[i] * s->in.row_step,
906  s->linesize[i], s->pheight[i]);
907  }
908  break;
909  }
910  break;
911  case ANAGLYPH_RB_GRAY:
912  case ANAGLYPH_RG_GRAY:
913  case ANAGLYPH_RC_GRAY:
914  case ANAGLYPH_RC_HALF:
915  case ANAGLYPH_RC_COLOR:
916  case ANAGLYPH_RC_DUBOIS:
917  case ANAGLYPH_GM_GRAY:
918  case ANAGLYPH_GM_HALF:
919  case ANAGLYPH_GM_COLOR:
920  case ANAGLYPH_GM_DUBOIS:
921  case ANAGLYPH_YB_GRAY:
922  case ANAGLYPH_YB_HALF:
923  case ANAGLYPH_YB_COLOR:
924  case ANAGLYPH_YB_DUBOIS: {
925  if (s->in.format == INTERLEAVE_COLS_LR ||
926  s->in.format == INTERLEAVE_COLS_RL) {
927  const int d = (s->in.format & 1);
928 
929  anaglyph_ic(out->data[0],
930  ileft ->data[0] + s->in_off_left [0] + d * 3,
931  iright->data[0] + s->in_off_right[0] + (!d) * 3,
932  out->linesize[0],
933  ileft->linesize[0] * s->in.row_step,
934  iright->linesize[0] * s->in.row_step,
935  s->out.width, s->out.height,
936  s->ana_matrix[0], s->ana_matrix[1], s->ana_matrix[2]);
937  } else {
938  ThreadData td;
939 
940  td.ileft = ileft; td.iright = iright; td.out = out;
941  ff_filter_execute(ctx, filter_slice, &td, NULL,
942  FFMIN(s->out.height, ff_filter_get_nb_threads(ctx)));
943  }
944  break;
945  }
946  case CHECKERBOARD_RL:
947  case CHECKERBOARD_LR:
948  for (i = 0; i < s->nb_planes; i++) {
949  int x, y;
950 
951  for (y = 0; y < s->pheight[i]; y++) {
952  uint8_t *dst = out->data[i] + out->linesize[i] * y;
953  const int d1 = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) && (s->in.format & 1) != (s->out.format & 1);
954  const int d2 = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL) ? !d1 : 0;
955  const int m = 1 + (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL);
956  uint8_t *left = ileft->data[i] + ileft->linesize[i] * y + s->in_off_left[i] + d1 * s->pixstep[i];
957  uint8_t *right = iright->data[i] + iright->linesize[i] * y + s->in_off_right[i] + d2 * s->pixstep[i];
958  int p, b;
959 
960  if (s->out.format == CHECKERBOARD_RL && s->in.format != INTERLEAVE_COLS_LR && s->in.format != INTERLEAVE_COLS_RL)
961  FFSWAP(uint8_t*, left, right);
962  switch (s->pixstep[i]) {
963  case 1:
964  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b+=2) {
965  dst[x ] = (b&1) == (y&1) ? left[p*m] : right[p*m];
966  dst[x+1] = (b&1) != (y&1) ? left[p*m] : right[p*m];
967  }
968  break;
969  case 2:
970  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b+=2) {
971  AV_WN16(&dst[x ], (b&1) == (y&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
972  AV_WN16(&dst[x+2], (b&1) != (y&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
973  }
974  break;
975  case 3:
976  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b+=2) {
977  AV_WB24(&dst[x ], (b&1) == (y&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
978  AV_WB24(&dst[x+3], (b&1) != (y&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
979  }
980  break;
981  case 4:
982  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b+=2) {
983  AV_WN32(&dst[x ], (b&1) == (y&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
984  AV_WN32(&dst[x+4], (b&1) != (y&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
985  }
986  break;
987  case 6:
988  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b+=2) {
989  AV_WB48(&dst[x ], (b&1) == (y&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
990  AV_WB48(&dst[x+6], (b&1) != (y&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
991  }
992  break;
993  case 8:
994  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b+=2) {
995  AV_WN64(&dst[x ], (b&1) == (y&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
996  AV_WN64(&dst[x+8], (b&1) != (y&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
997  }
998  break;
999  }
1000  }
1001  }
1002  break;
1003  case INTERLEAVE_COLS_LR:
1004  case INTERLEAVE_COLS_RL:
1005  for (i = 0; i < s->nb_planes; i++) {
1006  const int d = (s->in.format == INTERLEAVE_COLS_LR || s->in.format == INTERLEAVE_COLS_RL);
1007  const int m = 1 + d;
1008  int x, y;
1009 
1010  for (y = 0; y < s->pheight[i]; y++) {
1011  uint8_t *dst = out->data[i] + out->linesize[i] * y;
1012  uint8_t *left = ileft->data[i] + ileft->linesize[i] * y * s->in.row_step + s->in_off_left[i] + d * s->pixstep[i];
1013  uint8_t *right = iright->data[i] + iright->linesize[i] * y * s->in.row_step + s->in_off_right[i];
1014  int p, b;
1015 
1016  if (s->out.format == INTERLEAVE_COLS_LR)
1017  FFSWAP(uint8_t*, left, right);
1018 
1019  switch (s->pixstep[i]) {
1020  case 1:
1021  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=2, p++, b+=2) {
1022  dst[x ] = b&1 ? left[p*m] : right[p*m];
1023  dst[x+1] = !(b&1) ? left[p*m] : right[p*m];
1024  }
1025  break;
1026  case 2:
1027  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=4, p+=2, b+=2) {
1028  AV_WN16(&dst[x ], b&1 ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
1029  AV_WN16(&dst[x+2], !(b&1) ? AV_RN16(&left[p*m]) : AV_RN16(&right[p*m]));
1030  }
1031  break;
1032  case 3:
1033  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=6, p+=3, b+=2) {
1034  AV_WB24(&dst[x ], b&1 ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
1035  AV_WB24(&dst[x+3], !(b&1) ? AV_RB24(&left[p*m]) : AV_RB24(&right[p*m]));
1036  }
1037  break;
1038  case 4:
1039  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=8, p+=4, b+=2) {
1040  AV_WN32(&dst[x ], b&1 ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
1041  AV_WN32(&dst[x+4], !(b&1) ? AV_RN32(&left[p*m]) : AV_RN32(&right[p*m]));
1042  }
1043  break;
1044  case 6:
1045  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=12, p+=6, b+=2) {
1046  AV_WB48(&dst[x ], b&1 ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
1047  AV_WB48(&dst[x+6], !(b&1) ? AV_RB48(&left[p*m]) : AV_RB48(&right[p*m]));
1048  }
1049  break;
1050  case 8:
1051  for (x = 0, b = 0, p = 0; x < s->linesize[i] * 2; x+=16, p+=8, b+=2) {
1052  AV_WN64(&dst[x ], b&1 ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
1053  AV_WN64(&dst[x+8], !(b&1) ? AV_RN64(&left[p*m]) : AV_RN64(&right[p*m]));
1054  }
1055  break;
1056  }
1057  }
1058  }
1059  break;
1060  default:
1061  av_assert0(0);
1062  }
1063 
1064  if (oright != oleft) {
1065  if (s->out.format == ALTERNATING_LR)
1066  FFSWAP(AVFrame *, oleft, oright);
1067  oright->pts = s->prev->pts * 2;
1068  ff_filter_frame(outlink, oright);
1069  out = oleft;
1070  oleft->pts = s->prev->pts + inpicref->pts;
1071  av_frame_free(&s->prev);
1072  s->prev = inpicref;
1073  } else if (s->in.format == ALTERNATING_LR ||
1074  s->in.format == ALTERNATING_RL) {
1075  out->pts = s->prev->pts / 2;
1076  av_frame_free(&s->prev);
1077  av_frame_free(&inpicref);
1078  } else {
1079  av_frame_free(&s->prev);
1080  av_frame_free(&inpicref);
1081  }
1082  av_assert0(out);
1083  out->sample_aspect_ratio = s->aspect;
1084  return ff_filter_frame(outlink, out);
1085 }
1086 
1087 static av_cold void uninit(AVFilterContext *ctx)
1088 {
1089  Stereo3DContext *s = ctx->priv;
1090 
1091  av_frame_free(&s->prev);
1092 }
1093 
1094 static const AVFilterPad stereo3d_inputs[] = {
1095  {
1096  .name = "default",
1097  .type = AVMEDIA_TYPE_VIDEO,
1098  .filter_frame = filter_frame,
1099  },
1100 };
1101 
1102 static const AVFilterPad stereo3d_outputs[] = {
1103  {
1104  .name = "default",
1105  .type = AVMEDIA_TYPE_VIDEO,
1106  .config_props = config_output,
1107  },
1108 };
1109 
1110 const AVFilter ff_vf_stereo3d = {
1111  .name = "stereo3d",
1112  .description = NULL_IF_CONFIG_SMALL("Convert video stereoscopic 3D view."),
1113  .priv_size = sizeof(Stereo3DContext),
1114  .uninit = uninit,
1115  FILTER_INPUTS(stereo3d_inputs),
1116  FILTER_OUTPUTS(stereo3d_outputs),
1117  FILTER_QUERY_FUNC(query_formats),
1118  .priv_class = &stereo3d_class,
1119  .flags = AVFILTER_FLAG_SLICE_THREADS,
1120 };
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:101
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
Definition: vf_stereo3d.c:667
ABOVE_BELOW_LR
@ ABOVE_BELOW_LR
Definition: vf_stereo3d.c:58
ana_convert
static uint8_t ana_convert(const int *coeff, const uint8_t *left, const uint8_t *right)
Definition: vf_stereo3d.c:311
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:147
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_PIX_FMT_BGR48LE
@ 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:139
Stereo3DContext::hsub
int hsub
Definition: vf_stereo3d.c:148
MONO_R
@ MONO_R
Definition: vf_stereo3d.c:51
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
AV_PIX_FMT_BGRA64BE
@ 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:197
AV_RB48
#define AV_RB48(x)
Definition: intreadwrite.h:472
out
FILE * out
Definition: movenc.c:54
Stereo3DContext::nb_planes
int nb_planes
Definition: vf_stereo3d.c:145
CHECKERBOARD_RL
@ CHECKERBOARD_RL
Definition: vf_stereo3d.c:65
Stereo3DContext::in_off_left
int in_off_left[4]
Definition: vf_stereo3d.c:152
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:164
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:971
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:162
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_stereo3d.c:362
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:267
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_RN16
#define AV_RN16(p)
Definition: intreadwrite.h:360
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:101
Stereo3DContext::dsp
Stereo3DDSPContext dsp
Definition: vf_stereo3d.c:154
AV_RN64
#define AV_RN64(p)
Definition: intreadwrite.h:368
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
AV_PIX_FMT_YUVA444P10BE
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:178
pixdesc.h
AV_PIX_FMT_RGBA64BE
@ 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:195
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:171
ANAGLYPH_YB_DUBOIS
@ ANAGLYPH_YB_DUBOIS
Definition: vf_stereo3d.c:47
AV_PIX_FMT_YUV420P14BE
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:262
StereoComponent::format
int format
StereoCode.
Definition: vf_stereo3d.c:73
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:121
Stereo3DContext::vsub
int vsub
Definition: vf_stereo3d.c:148
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:274
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
Stereo3DContext::in_off_right
int in_off_right[4]
Definition: vf_stereo3d.c:152
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:172
AV_PIX_FMT_YUV422P9BE
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:156
stereo3d_inputs
static const AVFilterPad stereo3d_inputs[]
Definition: vf_stereo3d.c:1094
ANAGLYPH_RC_HALF
@ ANAGLYPH_RC_HALF
Definition: vf_stereo3d.c:37
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:473
video.h
StereoComponent::off_rstep
int off_rstep
Definition: vf_stereo3d.c:76
Stereo3DContext::pheight
int pheight[4]
Definition: vf_stereo3d.c:147
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
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
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:125
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:74
INTERLEAVE_ROWS_LR
@ INTERLEAVE_ROWS_LR
Definition: vf_stereo3d.c:52
formats.h
ana_coeff
static const int ana_coeff[][3][6]
Definition: vf_stereo3d.c:81
CHECKERBOARD_LR
@ CHECKERBOARD_LR
Definition: vf_stereo3d.c:64
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2928
MONO_L
@ MONO_L
Definition: vf_stereo3d.c:50
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:261
Stereo3DContext
Definition: vf_stereo3d.c:140
ThreadData::ileft
AVFrame * ileft
Definition: vf_stereo3d.c:602
Stereo3DContext::prev
AVFrame * prev
Definition: vf_stereo3d.c:150
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:184
ANAGLYPH_GM_COLOR
@ ANAGLYPH_GM_COLOR
Definition: vf_stereo3d.c:42
AVRational::num
int num
Numerator.
Definition: rational.h:59
Stereo3DContext::out
StereoComponent out
Definition: vf_stereo3d.c:142
AV_PIX_FMT_YUV444P10BE
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:154
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:149
StereoComponent::row_step
int row_step
Definition: vf_stereo3d.c:78
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:269
AV_PIX_FMT_YUVJ411P
@ 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:276
AV_PIX_FMT_YUV422P12BE
@ AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:264
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:271
avassert.h
ANAGLYPH_RG_GRAY
@ ANAGLYPH_RG_GRAY
Definition: vf_stereo3d.c:49
INTERLEAVE_ROWS_RL
@ INTERLEAVE_ROWS_RL
Definition: vf_stereo3d.c:53
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
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:79
width
#define width
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
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:165
ALTERNATING_LR
@ ALTERNATING_LR
Definition: vf_stereo3d.c:62
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
ANAGLYPH_RC_COLOR
@ ANAGLYPH_RC_COLOR
Definition: vf_stereo3d.c:38
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:755
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:273
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:180
ABOVE_BELOW_2_RL
@ ABOVE_BELOW_2_RL
Definition: vf_stereo3d.c:61
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ThreadData::iright
AVFrame * iright
Definition: vf_stereo3d.c:602
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:471
SIDE_BY_SIDE_LR
@ SIDE_BY_SIDE_LR
Definition: vf_stereo3d.c:54
ANAGLYPH_YB_COLOR
@ ANAGLYPH_YB_COLOR
Definition: vf_stereo3d.c:46
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:163
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:66
anaglyph_pix_fmts
static enum AVPixelFormat anaglyph_pix_fmts[]
Definition: vf_stereo3d.c:223
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:194
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:80
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:155
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:177
Stereo3DContext::blanks
int blanks
Definition: vf_stereo3d.c:151
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:152
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:150
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:123
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
other_pix_fmts
static enum AVPixelFormat other_pix_fmts[]
Definition: vf_stereo3d.c:228
stereo3d_options
static const AVOption stereo3d_options[]
Definition: vf_stereo3d.c:160
NULL
#define NULL
Definition: coverity.c:32
StereoComponent
Definition: vf_stereo3d.c:72
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:598
Stereo3DContext::linesize
int linesize[4]
Definition: vf_stereo3d.c:146
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PIX_FMT_RGB48LE
@ 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
stereo3d_outputs
static const AVFilterPad stereo3d_outputs[]
Definition: vf_stereo3d.c:1102
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:78
AV_PIX_FMT_RGBA64LE
@ 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:196
AV_RN32
#define AV_RN32(p)
Definition: intreadwrite.h:364
StereoComponent::off_right
int off_right
Definition: vf_stereo3d.c:75
INTERLEAVE_COLS_RL
@ INTERLEAVE_COLS_RL
Definition: vf_stereo3d.c:67
parseutils.h
ANAGLYPH_RB_GRAY
@ ANAGLYPH_RB_GRAY
Definition: vf_stereo3d.c:48
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:173
Stereo3DContext::height
int height
Definition: vf_stereo3d.c:143
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:181
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:258
HDMI
@ HDMI
Definition: vf_stereo3d.c:68
AV_PIX_FMT_YUVA420P9LE
@ 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:169
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:263
AV_PIX_FMT_YUV444P14BE
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:270
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:146
Stereo3DContext::ana_matrix
const int * ana_matrix[3]
Definition: vf_stereo3d.c:144
ABOVE_BELOW_2_LR
@ ABOVE_BELOW_2_LR
Definition: vf_stereo3d.c:60
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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:115
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:187
ANAGLYPH_YB_HALF
@ ANAGLYPH_YB_HALF
Definition: vf_stereo3d.c:45
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
AV_PIX_FMT_YUV420P12BE
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:260
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:151
AV_PIX_FMT_YUV422P14BE
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:266
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_stereo3d.c:282
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:160
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:148
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(stereo3d)
ANAGLYPH_RC_DUBOIS
@ ANAGLYPH_RC_DUBOIS
Definition: vf_stereo3d.c:39
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:630
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:161
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_stereo3d.c:1087
INTERLEAVE_COLS_LR
@ INTERLEAVE_COLS_LR
Definition: vf_stereo3d.c:66
height
#define height
ALTERNATING_RL
@ ALTERNATING_RL
Definition: vf_stereo3d.c:63
ANAGLYPH_YB_GRAY
@ ANAGLYPH_YB_GRAY
Definition: vf_stereo3d.c:44
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:256
OFFSET
#define OFFSET(x)
Definition: vf_stereo3d.c:157
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:175
internal.h
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AV_PIX_FMT_BGRA64LE
@ 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:198
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:176
Stereo3DContext::aspect
AVRational aspect
Definition: vf_stereo3d.c:153
ANAGLYPH_GM_DUBOIS
@ ANAGLYPH_GM_DUBOIS
Definition: vf_stereo3d.c:43
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:170
AV_PIX_FMT_RGB48BE
@ 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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:779
ThreadData
Used for passing data between threads.
Definition: dsddec.c:69
StereoCode
StereoCode
Definition: vf_stereo3d.c:35
FLAGS
#define FLAGS
Definition: vf_stereo3d.c:158
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:100
tb
#define tb
Definition: regdef.h:68
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_stereo3d.c:606
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
AV_WB48
#define AV_WB48(p, darg)
Definition: intreadwrite.h:481
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:126
Stereo3DContext::width
int width
Definition: vf_stereo3d.c:143
AVFilter
Filter definition.
Definition: avfilter.h:166
ANAGLYPH_GM_GRAY
@ ANAGLYPH_GM_GRAY
Definition: vf_stereo3d.c:40
ANAGLYPH_GM_HALF
@ ANAGLYPH_GM_HALF
Definition: vf_stereo3d.c:41
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:257
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
StereoComponent::height
int height
Definition: vf_stereo3d.c:74
stereo3d.h
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:386
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:272
AV_PIX_FMT_YUV444P12BE
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:268
StereoComponent::row_right
int row_right
Definition: vf_stereo3d.c:77
ff_stereo3d_init_x86
void ff_stereo3d_init_x86(Stereo3DDSPContext *dsp)
Definition: vf_stereo3d_init.c:30
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:153
StereoComponent::row_left
int row_left
Definition: vf_stereo3d.c:77
ANAGLYPH_RC_GRAY
@ ANAGLYPH_RC_GRAY
Definition: vf_stereo3d.c:36
AV_PIX_FMT_YUVA420P10BE
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:174
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
av_clip_uint8
#define av_clip_uint8
Definition: common.h:101
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:71
SIDE_BY_SIDE_2_RL
@ SIDE_BY_SIDE_2_RL
Definition: vf_stereo3d.c:57
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
AV_PIX_FMT_YUV420P16BE
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:122
Stereo3DDSPContext
Definition: stereo3d.h:27
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AV_PIX_FMT_YUV422P16BE
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:124
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:117
desc
const char * desc
Definition: libsvtav1.c:83
Stereo3DContext::pixstep
int pixstep[4]
Definition: vf_stereo3d.c:149
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
Stereo3DContext::in
StereoComponent in
Definition: vf_stereo3d.c:142
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:70
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:179
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_vf_stereo3d
const AVFilter ff_vf_stereo3d
Definition: vf_stereo3d.c:1110
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:195
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:342
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:73
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:182
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:157
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:183
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:275
d
d
Definition: ffmpeg_filter.c:156
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:375
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:255
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:72
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_WN64
#define AV_WN64(p, v)
Definition: intreadwrite.h:380
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
StereoComponent::width
int width
Definition: vf_stereo3d.c:74
SIDE_BY_SIDE_2_LR
@ SIDE_BY_SIDE_2_LR
Definition: vf_stereo3d.c:56
SIDE_BY_SIDE_RL
@ SIDE_BY_SIDE_RL
Definition: vf_stereo3d.c:55
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:322
h
h
Definition: vp9dsp_template.c:2038
ABOVE_BELOW_RL
@ ABOVE_BELOW_RL
Definition: vf_stereo3d.c:59
StereoComponent::off_lstep
int off_lstep
Definition: vf_stereo3d.c:76
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:185
drawutils.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:146
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:97
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:265
AV_PIX_FMT_YUVA420P9BE
@ 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:168
StereoComponent::off_left
int off_left
Definition: vf_stereo3d.c:75
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
AV_PIX_FMT_BGR48BE
@ 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:138
STEREO_CODE_COUNT
@ STEREO_CODE_COUNT
Definition: vf_stereo3d.c:69
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:171
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
Generated on Sun Mar 26 2023 19:21:44 for FFmpeg by   doxygen 1.8.17