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