32441
|
1 /*
|
|
2 * Copyright (C) 2010 Gordon Schmidt <gordon.schmidt <at> s2000.tu-chemnitz.de>
|
|
3 *
|
|
4 * This file is part of MPlayer.
|
|
5 *
|
|
6 * MPlayer is free software; you can redistribute it and/or modify
|
|
7 * it under the terms of the GNU General Public License as published by
|
|
8 * the Free Software Foundation; either version 2 of the License, or
|
|
9 * (at your option) any later version.
|
|
10 *
|
|
11 * MPlayer is distributed in the hope that it will be useful,
|
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
14 * GNU General Public License for more details.
|
|
15 *
|
|
16 * You should have received a copy of the GNU General Public License along
|
|
17 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
19 */
|
|
20
|
|
21 //==includes==//
|
|
22 #include <stdio.h>
|
|
23 #include <stdlib.h>
|
|
24 #include <string.h>
|
|
25
|
|
26 #include "config.h"
|
|
27 #include "mp_msg.h"
|
|
28 #include "help_mp.h"
|
|
29
|
|
30 #include "img_format.h"
|
|
31 #include "mp_image.h"
|
|
32 #include "vf.h"
|
|
33 #include "m_struct.h"
|
|
34
|
|
35 #include "libavutil/common.h"
|
|
36 #include "libvo/fastmemcpy.h"
|
|
37
|
|
38 //==types==//
|
|
39 typedef enum stereo_code {
|
|
40 ANAGLYPH_RC_GRAY, //anaglyph red/cyan gray
|
|
41 ANAGLYPH_RC_HALF, //anaglyph red/cyan half colored
|
|
42 ANAGLYPH_RC_COLOR, //anaglyph red/cyan colored
|
|
43 ANAGLYPH_RC_DUBOIS, //anaglyph red/cyan dubois
|
|
44 ANAGLYPH_GM_GRAY, //anaglyph green/magenta gray
|
|
45 ANAGLYPH_GM_HALF, //anaglyph green/magenta half colored
|
|
46 ANAGLYPH_GM_COLOR, //anaglyph green/magenta colored
|
|
47 ANAGLYPH_YB_GRAY, //anaglyph yellow/blue gray
|
|
48 ANAGLYPH_YB_HALF, //anaglyph yellow/blue half colored
|
|
49 ANAGLYPH_YB_COLOR, //anaglyph yellow/blue colored
|
|
50 MONO_L, //mono output for debugging (left eye only)
|
|
51 MONO_R, //mono output for debugging (right eye only)
|
|
52 SIDE_BY_SIDE_LR, //side by side parallel (left eye left, right eye right)
|
|
53 SIDE_BY_SIDE_RL, //side by side crosseye (right eye left, left eye right)
|
|
54 ABOVE_BELOW_LR, //above-below (left eye above, right eye below)
|
|
55 ABOVE_BELOW_RL, //above-below (right eye above, left eye below)
|
|
56 ABOVE_BELOW_2_LR, //above-below with half height resolution
|
|
57 ABOVE_BELOW_2_RL, //above-below with half height resolution
|
|
58 STEREO_CODE_COUNT //no value set - TODO: needs autodetection
|
|
59 } stereo_code;
|
|
60
|
|
61 typedef struct component {
|
|
62 stereo_code fmt;
|
|
63 unsigned int width;
|
|
64 unsigned int height;
|
|
65 unsigned int off_left;
|
|
66 unsigned int off_right;
|
|
67 unsigned int stride;
|
|
68 unsigned int hres;
|
|
69 } component;
|
|
70
|
|
71 //==global variables==//
|
|
72 static const int ana_coeff[10][3][6] = {
|
|
73 {{19595, 38470, 7471, 0, 0, 0}, //ANAGLYPH_RC_GRAY
|
|
74 { 0, 0, 0, 19595, 38470, 7471},
|
|
75 { 0, 0, 0, 19595, 38470, 7471}},
|
|
76 {{19595, 38470, 7471, 0, 0, 0}, //ANAGLYPH_RC_HALF
|
|
77 { 0, 0, 0, 0, 65536, 0},
|
|
78 { 0, 0, 0, 0, 0, 65536}},
|
|
79 {{65536, 0, 0, 0, 0, 0}, //ANAGLYPH_RC_COLOR
|
|
80 { 0, 0, 0, 0, 65536, 0},
|
|
81 { 0, 0, 0, 0, 0, 65536}},
|
|
82 {{29891, 32800, 11559, -2849, -5763, -102}, //ANAGLYPH_RC_DUBOIS
|
|
83 {-2627, -2479, -1033, 24804, 48080, -1209},
|
|
84 { -997, -1350, -358, -4729, -7403, 80373}},
|
|
85 {{ 0, 0, 0, 19595, 38470, 7471}, //ANAGLYPH_GM_GRAY
|
|
86 {19595, 38470, 7471, 0, 0, 0},
|
|
87 { 0, 0, 0, 19595, 38470, 7471}},
|
|
88 {{ 0, 0, 0, 65536, 0, 0}, //ANAGLYPH_GM_HALF
|
|
89 {19595, 38470, 7471, 0, 0, 0},
|
|
90 { 0, 0, 0, 0, 0, 65536}},
|
|
91 {{ 0, 0, 0, 65536, 0, 0}, //ANAGLYPH_GM_COLOR
|
|
92 { 0, 65536, 0, 0, 0, 0},
|
|
93 { 0, 0, 0, 0, 0, 65536}},
|
|
94 {{ 0, 0, 0, 19595, 38470, 7471}, //ANAGLYPH_YB_GRAY
|
|
95 { 0, 0, 0, 19595, 38470, 7471},
|
|
96 {19595, 38470, 7471, 0, 0, 0}},
|
|
97 {{ 0, 0, 0, 65536, 0, 0}, //ANAGLYPH_YB_HALF
|
|
98 { 0, 0, 0, 0, 65536, 0},
|
|
99 {19595, 38470, 7471, 0, 0, 0}},
|
|
100 {{ 0, 0, 0, 65536, 0, 0}, //ANAGLYPH_YB_COLOR
|
|
101 { 0, 0, 0, 0, 65536, 0},
|
|
102 { 0, 0, 65536, 0, 0, 0}}
|
|
103 };
|
|
104
|
|
105 struct vf_priv_s {
|
|
106 component in;
|
|
107 component out;
|
|
108 int ana_matrix[3][6];
|
|
109 unsigned int width;
|
|
110 unsigned int height;
|
|
111 } const vf_priv_default = {
|
|
112 {SIDE_BY_SIDE_LR},
|
|
113 {ANAGLYPH_RC_DUBOIS}
|
|
114 };
|
|
115
|
|
116 extern int opt_screen_size_x;
|
|
117 extern int opt_screen_size_y;
|
|
118
|
|
119 //==functions==//
|
|
120 static inline uint8_t ana_convert(int coeff[6], uint8_t left[3], uint8_t right[3])
|
|
121 {
|
|
122 int sum;
|
|
123
|
|
124 sum = coeff[0] * left[0] + coeff[3] * right[0]; //red in
|
|
125 sum += coeff[1] * left[1] + coeff[4] * right[1]; //green in
|
|
126 sum += coeff[2] * left[2] + coeff[5] * right[2]; //blue in
|
|
127 return av_clip_uint8(sum >> 16);
|
|
128 }
|
|
129
|
|
130 static int config(struct vf_instance *vf, int width, int height, int d_width,
|
|
131 int d_height, unsigned int flags, unsigned int outfmt)
|
|
132 {
|
|
133 if ((width & 1) || (height & 1)) {
|
|
134 mp_msg(MSGT_VFILTER, MSGL_WARN, "[stereo3d] invalid height or width\n");
|
|
135 return 0;
|
|
136 }
|
|
137 //default input values
|
|
138 vf->priv->width = width;
|
|
139 vf->priv->height = height;
|
|
140 vf->priv->in.width = width;
|
|
141 vf->priv->in.height = height;
|
|
142 vf->priv->in.hres = 1;
|
|
143 vf->priv->in.off_left = 0;
|
|
144 vf->priv->in.off_right = 0;
|
|
145 vf->priv->in.stride = vf->priv->width * 3;
|
|
146
|
|
147 //check input format
|
|
148 switch (vf->priv->in.fmt) {
|
|
149 case SIDE_BY_SIDE_LR:
|
|
150 vf->priv->width = width / 2;
|
|
151 vf->priv->in.off_right = vf->priv->width * 3;
|
|
152 vf->priv->in.stride = vf->priv->width * 6;
|
|
153 break;
|
|
154 case SIDE_BY_SIDE_RL:
|
|
155 vf->priv->width = width / 2;
|
|
156 vf->priv->in.off_left = vf->priv->width * 3;
|
|
157 vf->priv->in.stride = vf->priv->width * 6;
|
|
158 break;
|
|
159 case ABOVE_BELOW_LR:
|
|
160 vf->priv->height = height / 2;
|
|
161 vf->priv->in.off_right = vf->priv->width * vf->priv->height * 3;
|
|
162 break;
|
|
163 case ABOVE_BELOW_RL:
|
|
164 vf->priv->height = height / 2;
|
|
165 vf->priv->in.off_left = vf->priv->width * vf->priv->height * 3;
|
|
166 break;
|
|
167 case ABOVE_BELOW_2_LR:
|
|
168 vf->priv->in.hres = 2;
|
|
169 vf->priv->in.off_right = vf->priv->width * vf->priv->height / 2 * 3;
|
|
170 break;
|
|
171 case ABOVE_BELOW_2_RL:
|
|
172 vf->priv->in.hres = 2;
|
|
173 vf->priv->in.off_left = vf->priv->width * vf->priv->height / 2 * 3;
|
|
174 break;
|
|
175 default:
|
|
176 mp_msg(MSGT_VFILTER, MSGL_WARN,
|
|
177 "[stereo3d] stereo format of input is not supported\n");
|
|
178 return 0;
|
|
179 break;
|
|
180 }
|
|
181 //default output values
|
|
182 vf->priv->out.width = vf->priv->width;
|
|
183 vf->priv->out.height = vf->priv->height;
|
|
184 vf->priv->out.hres = 1;
|
|
185 vf->priv->out.off_left = 0;
|
|
186 vf->priv->out.off_right = 0;
|
|
187 vf->priv->out.stride = vf->priv->width * 3;
|
|
188
|
|
189 //check output format
|
|
190 switch (vf->priv->out.fmt) {
|
|
191 case ANAGLYPH_RC_GRAY:
|
|
192 case ANAGLYPH_RC_HALF:
|
|
193 case ANAGLYPH_RC_COLOR:
|
|
194 case ANAGLYPH_RC_DUBOIS:
|
|
195 case ANAGLYPH_GM_GRAY:
|
|
196 case ANAGLYPH_GM_HALF:
|
|
197 case ANAGLYPH_GM_COLOR:
|
|
198 case ANAGLYPH_YB_GRAY:
|
|
199 case ANAGLYPH_YB_HALF:
|
|
200 case ANAGLYPH_YB_COLOR:
|
|
201 memcpy(vf->priv->ana_matrix, ana_coeff[vf->priv->out.fmt],
|
|
202 sizeof(vf->priv->ana_matrix));
|
|
203 break;
|
|
204 case SIDE_BY_SIDE_LR:
|
|
205 vf->priv->out.width = vf->priv->width * 2;
|
|
206 vf->priv->out.off_right = vf->priv->width * 3;
|
|
207 vf->priv->out.stride = vf->priv->width * 6;
|
|
208 break;
|
|
209 case SIDE_BY_SIDE_RL:
|
|
210 vf->priv->out.width = vf->priv->width * 2;
|
|
211 vf->priv->out.off_left = vf->priv->width * 3;
|
|
212 vf->priv->out.stride = vf->priv->width * 6;
|
|
213 break;
|
|
214 case ABOVE_BELOW_LR:
|
|
215 vf->priv->out.height = vf->priv->height * 2;
|
|
216 vf->priv->out.off_right = vf->priv->width * vf->priv->height * 3;
|
|
217 break;
|
|
218 case ABOVE_BELOW_RL:
|
|
219 vf->priv->out.height = vf->priv->height * 2;
|
|
220 vf->priv->out.off_left = vf->priv->width * vf->priv->height * 3;
|
|
221 break;
|
|
222 case ABOVE_BELOW_2_LR:
|
|
223 vf->priv->out.hres = 2;
|
|
224 vf->priv->out.off_right = vf->priv->width * vf->priv->height / 2 * 3;
|
|
225 break;
|
|
226 case ABOVE_BELOW_2_RL:
|
|
227 vf->priv->out.hres = 2;
|
|
228 vf->priv->out.off_left = vf->priv->width * vf->priv->height / 2 * 3;
|
|
229 break;
|
|
230 case MONO_R:
|
|
231 //same as MONO_L only needs switching of input offsets
|
|
232 vf->priv->in.off_left = vf->priv->in.off_right;
|
|
233 //nobreak;
|
|
234 case MONO_L:
|
|
235 //use default settings
|
|
236 break;
|
|
237 default:
|
|
238 mp_msg(MSGT_VFILTER, MSGL_WARN,
|
|
239 "[stereo3d] stereo format of output is not supported\n");
|
|
240 return 0;
|
|
241 break;
|
|
242 }
|
|
243 if (!opt_screen_size_x && !opt_screen_size_y) {
|
|
244 d_width = d_width * vf->priv->out.width / width;
|
|
245 d_height = d_height * vf->priv->out.height / height;
|
|
246 }
|
|
247 return vf_next_config(vf, vf->priv->out.width, vf->priv->out.height,
|
|
248 d_width, d_height, flags, outfmt);
|
|
249 }
|
|
250
|
|
251 static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
|
|
252 {
|
|
253 mp_image_t *dmpi;
|
|
254 if (vf->priv->in.fmt == vf->priv->out.fmt) { //nothing to do
|
|
255 dmpi = mpi;
|
|
256 } else {
|
|
257 dmpi = vf_get_image(vf->next, IMGFMT_RGB24, MP_IMGTYPE_TEMP, 0,
|
|
258 vf->priv->out.width, vf->priv->out.height);
|
|
259 dmpi->h = vf->priv->out.height;
|
|
260 dmpi->width = vf->priv->out.width;
|
|
261 switch (vf->priv->out.fmt) {
|
|
262 case SIDE_BY_SIDE_LR:
|
|
263 case SIDE_BY_SIDE_RL:
|
|
264 case ABOVE_BELOW_LR:
|
|
265 case ABOVE_BELOW_RL:
|
|
266 case ABOVE_BELOW_2_LR:
|
|
267 case ABOVE_BELOW_2_RL:
|
|
268 for (int i = 0; i < vf->priv->in.hres; i++) {
|
|
269 memcpy_pic(dmpi->planes[0] + vf->priv->out.off_left +
|
|
270 (i * vf->priv->out.stride), mpi->planes[0] +
|
|
271 vf->priv->in.off_left, 3 * vf->priv->width,
|
|
272 vf->priv->height / (vf->priv->in.hres *
|
|
273 vf->priv->out.hres), vf->priv->out.stride *
|
|
274 vf->priv->in.hres, vf->priv->in.stride *
|
|
275 vf->priv->out.hres);
|
|
276 memcpy_pic(dmpi->planes[0] + vf->priv->out.off_right +
|
|
277 (i * vf->priv->out.stride), mpi->planes[0] +
|
|
278 vf->priv->in.off_right, 3 * vf->priv->width,
|
|
279 vf->priv->height / (vf->priv->in.hres *
|
|
280 vf->priv->out.hres), vf->priv->out.stride *
|
|
281 vf->priv->in.hres, vf->priv->in.stride *
|
|
282 vf->priv->out.hres);
|
|
283 }
|
|
284 break;
|
|
285 case MONO_L:
|
|
286 case MONO_R:
|
|
287 for (int i = 0; i < vf->priv->in.hres; i++) {
|
|
288 memcpy_pic(dmpi->planes[0] + (i * vf->priv->out.stride),
|
|
289 mpi->planes[0] + vf->priv->in.off_left, 3 *
|
|
290 vf->priv->width, vf->priv->height /
|
|
291 vf->priv->in.hres, vf->priv->out.stride *
|
|
292 vf->priv->in.hres, vf->priv->in.stride);
|
|
293 }
|
|
294 break;
|
|
295 case ANAGLYPH_RC_GRAY:
|
|
296 case ANAGLYPH_RC_HALF:
|
|
297 case ANAGLYPH_RC_COLOR:
|
|
298 case ANAGLYPH_RC_DUBOIS:
|
|
299 case ANAGLYPH_GM_GRAY:
|
|
300 case ANAGLYPH_GM_HALF:
|
|
301 case ANAGLYPH_GM_COLOR:
|
|
302 case ANAGLYPH_YB_GRAY:
|
|
303 case ANAGLYPH_YB_HALF:
|
|
304 case ANAGLYPH_YB_COLOR: {
|
|
305 int x,y,il,ir,o;
|
|
306 unsigned char *source = mpi->planes[0];
|
|
307 unsigned char *dest = dmpi->planes[0];
|
|
308 unsigned int out_width = vf->priv->out.width;
|
|
309 int *ana_matrix[3];
|
|
310
|
|
311 for(int i = 0; i < 3; i++)
|
|
312 ana_matrix[i] = vf->priv->ana_matrix[i];
|
|
313
|
|
314 for (y = 0; y < vf->priv->out.height; y++) {
|
|
315 o = vf->priv->out.stride * y;
|
|
316 il = vf->priv->in.off_left + (y / vf->priv->in.hres) *
|
|
317 vf->priv->in.stride;
|
|
318 ir = vf->priv->in.off_right + (y / vf->priv->in.hres) *
|
|
319 vf->priv->in.stride;
|
|
320 for (x = 0; x < out_width; x++) {
|
|
321 dest[o ] = ana_convert(
|
|
322 ana_matrix[0], source + il, source + ir); //red out
|
|
323 dest[o + 1] = ana_convert(
|
|
324 ana_matrix[1], source + il, source + ir); //green out
|
|
325 dest[o + 2] = ana_convert(
|
|
326 ana_matrix[2], source + il, source + ir); //blue out
|
|
327 il += 3;
|
|
328 ir += 3;
|
|
329 o += 3;
|
|
330 }
|
|
331 }
|
|
332 break;
|
|
333 }
|
|
334 default:
|
|
335 mp_msg(MSGT_VFILTER, MSGL_WARN,
|
|
336 "[stereo3d] stereo format of output is not supported\n");
|
|
337 return 0;
|
|
338 break;
|
|
339 }
|
|
340 }
|
|
341 return vf_next_put_image(vf, dmpi, pts);
|
|
342 }
|
|
343
|
|
344 static int query_format(struct vf_instance *vf, unsigned int fmt)
|
|
345 {
|
|
346 switch (fmt)
|
|
347 case IMGFMT_RGB24:
|
|
348 return vf_next_query_format(vf, fmt);
|
|
349 return 0;
|
|
350 }
|
|
351
|
|
352 static void uninit(vf_instance_t *vf)
|
|
353 {
|
|
354 free(vf->priv);
|
|
355 }
|
|
356
|
|
357 static int vf_open(vf_instance_t *vf, char *args)
|
|
358 {
|
|
359 vf->config = config;
|
|
360 vf->uninit = uninit;
|
|
361 vf->put_image = put_image;
|
|
362 vf->query_format = query_format;
|
|
363 vf->default_reqs = VFCAP_ACCEPT_STRIDE;
|
|
364
|
|
365 return 1;
|
|
366 }
|
|
367
|
|
368 ///Presets usage
|
|
369 static const struct format_preset {
|
|
370 char* name;
|
|
371 stereo_code scode;
|
|
372 } vf_format_presets_defs[] = {
|
|
373 {"arcg", ANAGLYPH_RC_GRAY},
|
|
374 {"anaglyph_red_cyan_gray", ANAGLYPH_RC_GRAY},
|
|
375 {"arch", ANAGLYPH_RC_HALF},
|
|
376 {"anaglyph_red_cyan_half_color", ANAGLYPH_RC_HALF},
|
|
377 {"arcc", ANAGLYPH_RC_COLOR},
|
|
378 {"anaglyph_red_cyan_color", ANAGLYPH_RC_COLOR},
|
|
379 {"arcd", ANAGLYPH_RC_DUBOIS},
|
|
380 {"anaglyph_red_cyan_dubios", ANAGLYPH_RC_DUBOIS},
|
|
381 {"agmg", ANAGLYPH_GM_GRAY},
|
|
382 {"anaglyph_green_magenta_gray", ANAGLYPH_GM_GRAY},
|
|
383 {"agmh", ANAGLYPH_GM_HALF},
|
|
384 {"anaglyph_green_magenta_half_color",ANAGLYPH_GM_HALF},
|
|
385 {"agmc", ANAGLYPH_GM_COLOR},
|
|
386 {"anaglyph_green_magenta_color", ANAGLYPH_GM_COLOR},
|
|
387 {"aybg", ANAGLYPH_YB_GRAY},
|
|
388 {"anaglyph_yellow_blue_gray", ANAGLYPH_YB_GRAY},
|
|
389 {"aybh", ANAGLYPH_YB_HALF},
|
|
390 {"anaglyph_yellow_blue_half_color", ANAGLYPH_YB_HALF},
|
|
391 {"aybc", ANAGLYPH_YB_COLOR},
|
|
392 {"anaglyph_yellow_blue_color", ANAGLYPH_YB_COLOR},
|
|
393 {"ml", MONO_L},
|
|
394 {"mono_left", MONO_L},
|
|
395 {"mr", MONO_R},
|
|
396 {"mono_right", MONO_R},
|
|
397 {"sbsl", SIDE_BY_SIDE_LR},
|
|
398 {"side_by_side_left_first", SIDE_BY_SIDE_LR},
|
|
399 {"sbsr", SIDE_BY_SIDE_RL},
|
|
400 {"side_by_side_right_first", SIDE_BY_SIDE_RL},
|
|
401 {"abl", ABOVE_BELOW_LR},
|
|
402 {"above_below_left_first", ABOVE_BELOW_LR},
|
|
403 {"abr", ABOVE_BELOW_RL},
|
|
404 {"above_below_right_first", ABOVE_BELOW_RL},
|
|
405 {"ab2l", ABOVE_BELOW_2_LR},
|
|
406 {"above_below_half_height_left_first", ABOVE_BELOW_2_LR},
|
|
407 {"ab2r", ABOVE_BELOW_2_RL},
|
|
408 {"above_below_half_height_right_first",ABOVE_BELOW_2_RL},
|
|
409 { NULL, 0}
|
|
410 };
|
|
411
|
|
412 #define ST_OFF(f) M_ST_OFF(struct format_preset,f)
|
|
413 static const m_option_t vf_format_preset_fields_in[] = {
|
|
414 {"in", ST_OFF(scode), CONF_TYPE_INT, 0,0,0, NULL},
|
|
415 { NULL, NULL, 0, 0, 0, 0, NULL }
|
|
416 };
|
|
417 static const m_option_t vf_format_preset_fields_out[] = {
|
|
418 {"out", ST_OFF(scode), CONF_TYPE_INT, 0,0,0, NULL},
|
|
419 { NULL, NULL, 0, 0, 0, 0, NULL }
|
|
420 };
|
|
421
|
|
422 static const m_struct_t vf_format_preset_in = {
|
|
423 "stereo_format_preset_in",
|
|
424 sizeof(struct format_preset),
|
|
425 NULL,
|
|
426 vf_format_preset_fields_in
|
|
427 };
|
|
428 static const m_struct_t vf_format_preset_out = {
|
|
429 "stereo_format_preset_out",
|
|
430 sizeof(struct format_preset),
|
|
431 NULL,
|
|
432 vf_format_preset_fields_out
|
|
433 };
|
|
434
|
|
435 static const m_struct_t vf_opts;
|
|
436 static const m_obj_presets_t format_preset_in = {
|
|
437 (struct m_struct_st*)&vf_format_preset_in,
|
|
438 (struct m_struct_st*)&vf_opts,
|
|
439 (struct format_preset*)vf_format_presets_defs,
|
|
440 ST_OFF(name)
|
|
441 };
|
|
442 static const m_obj_presets_t format_preset_out = {
|
|
443 (struct m_struct_st*)&vf_format_preset_out,
|
|
444 (struct m_struct_st*)&vf_opts,
|
|
445 (struct format_preset*)vf_format_presets_defs,
|
|
446 ST_OFF(name)
|
|
447 };
|
|
448
|
|
449 /// Now the options
|
|
450 #undef ST_OFF
|
|
451 #define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f)
|
|
452 static const m_option_t vf_opts_fields[] = {
|
|
453 {"stereo_in", 0, CONF_TYPE_OBJ_PRESETS, 0, 0, 0,
|
|
454 (m_obj_presets_t*)&format_preset_in},
|
|
455 {"stereo_out", 0, CONF_TYPE_OBJ_PRESETS, 0, 0, 0,
|
|
456 (m_obj_presets_t*)&format_preset_out},
|
|
457 {"in", ST_OFF(in.fmt), CONF_TYPE_INT, 0,0,0, NULL},
|
|
458 {"out", ST_OFF(out.fmt), CONF_TYPE_INT, 0,0,0, NULL},
|
|
459 { NULL, NULL, 0, 0, 0, 0, NULL }
|
|
460 };
|
|
461
|
|
462 static const m_struct_t vf_opts = {
|
|
463 "stereo3d",
|
|
464 sizeof(struct vf_priv_s),
|
|
465 &vf_priv_default,
|
|
466 vf_opts_fields
|
|
467 };
|
|
468
|
|
469
|
|
470 //==info struct==//
|
|
471 const vf_info_t vf_info_stereo3d = {
|
|
472 "stereoscopic 3d view",
|
|
473 "stereo3d",
|
|
474 "Gordon Schmidt",
|
|
475 "view stereoscopic videos",
|
|
476 vf_open,
|
|
477 &vf_opts
|
|
478 };
|