?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
direct3d9: move D3D9_Create/D3D9_Destroy in libd3d9_cmmon
[vlc.git] / modules / video_splitter / panoramix.c
blob9079c028240b9f84ecce8d19e06c083cf75af60b
1 /*****************************************************************************
2 * panoramix.c : Wall panoramic video with edge blending plugin for vlc
3 *****************************************************************************
4 * Copyright (C) 2000, 2001, 2002, 2003 VideoLAN
5 * $Id$
6 *
7 * Authors: Cedric Cocquebert <cedric.cocquebert@supelec.fr>
8 * based on Samuel Hocevar <sam@zoy.org>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32 #include <math.h>
33 #include <assert.h>
34
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_video_splitter.h>
38
39 /* FIXME it is needed for VOUT_ALIGN_* only */
40 #include <vlc_vout.h>
41
42 #define OVERLAP
43
44 #ifdef OVERLAP
45 /* OS CODE DEPENDENT to get display dimensions */
46 # ifdef _WIN32
47 # include <windows.h>
48 # else
49 # include <xcb/xcb.h>
50 # include <xcb/randr.h>
51 # endif
52 #endif
53
54 #define ROW_MAX (15)
55 #define COL_MAX (15)
56
57 /*****************************************************************************
58 * Module descriptor
59 *****************************************************************************/
60 #define COLS_TEXT N_("Number of columns")
61 #define COLS_LONGTEXT N_("Select the number of horizontal video windows in " \
62 "which to split the video")
63
64 #define ROWS_TEXT N_("Number of rows")
65 #define ROWS_LONGTEXT N_("Select the number of vertical video windows in " \
66 "which to split the video")
67
68 #define ACTIVE_TEXT N_("Active windows")
69 #define ACTIVE_LONGTEXT N_("Comma-separated list of active windows, " \
70 "defaults to all")
71
72 #define CFG_PREFIX "panoramix-"
73
74 #define PANORAMIX_HELP N_("Split the video in multiple windows to " \
75 "display on a wall of screens")
76
77 static int Open ( vlc_object_t * );
78 static void Close( vlc_object_t * );
79
80 vlc_module_begin()
81 set_description( N_("Panoramix: wall with overlap video filter") )
82 set_shortname( N_("Panoramix" ))
83 set_help(PANORAMIX_HELP)
84 set_capability( "video splitter", 0 )
85 set_category( CAT_VIDEO )
86 set_subcategory( SUBCAT_VIDEO_SPLITTER )
87
88 add_integer( CFG_PREFIX "cols", -1, COLS_TEXT, COLS_LONGTEXT, true )
89 change_integer_range( -1, COL_MAX )
90 add_integer( CFG_PREFIX "rows", -1, ROWS_TEXT, ROWS_LONGTEXT, true )
91 change_integer_range( -1, ROW_MAX )
92
93 #ifdef OVERLAP
94 #define LENGTH_TEXT N_("length of the overlapping area (in %)")
95 #define LENGTH_LONGTEXT N_("Select in percent the length of the blended zone")
96 add_integer_with_range( CFG_PREFIX "bz-length", 100, 0, 100, LENGTH_TEXT, LENGTH_LONGTEXT, true )
97
98 #define HEIGHT_TEXT N_("height of the overlapping area (in %)")
99 #define HEIGHT_LONGTEXT N_("Select in percent the height of the blended zone (case of 2x2 wall)")
100 add_integer_with_range( CFG_PREFIX "bz-height", 100, 0, 100, HEIGHT_TEXT, HEIGHT_LONGTEXT, true )
101
102 #define ATTENUATION_TEXT N_("Attenuation")
103 #define ATTENUATION_LONGTEXT N_("Check this option if you want attenuate blended zone by this plug-in (if option is unchecked, attenuate is made by opengl)")
104 add_bool( CFG_PREFIX "attenuate", true, ATTENUATION_TEXT, ATTENUATION_LONGTEXT, false )
105
106 #define BEGIN_TEXT N_("Attenuation, begin (in %)")
107 #define BEGIN_LONGTEXT N_("Select in percent the Lagrange coefficient of the beginning blended zone")
108 add_integer_with_range( CFG_PREFIX "bz-begin", 0, 0, 100, BEGIN_TEXT, BEGIN_LONGTEXT, true )
109
110 #define MIDDLE_TEXT N_("Attenuation, middle (in %)")
111 #define MIDDLE_LONGTEXT N_("Select in percent the Lagrange coefficient of the middle of blended zone")
112 add_integer_with_range( CFG_PREFIX "bz-middle", 50, 0, 100, MIDDLE_TEXT, MIDDLE_LONGTEXT, false )
113
114 #define END_TEXT N_("Attenuation, end (in %)")
115 #define END_LONGTEXT N_("Select in percent the Lagrange coefficient of the end of blended zone")
116 add_integer_with_range( CFG_PREFIX "bz-end", 100, 0, 100, END_TEXT, END_LONGTEXT, true )
117
118 #define MIDDLE_POS_TEXT N_("middle position (in %)")
119 #define MIDDLE_POS_LONGTEXT N_("Select in percent (50 is center) the position of the middle point (Lagrange) of blended zone")
120 add_integer_with_range( CFG_PREFIX "bz-middle-pos", 50, 1, 99, MIDDLE_POS_TEXT, MIDDLE_POS_LONGTEXT, false )
121 #define RGAMMA_TEXT N_("Gamma (Red) correction")
122 #define RGAMMA_LONGTEXT N_("Select the gamma for the correction of blended zone (Red or Y component)")
123 add_float_with_range( CFG_PREFIX "bz-gamma-red", 1, 0, 5, RGAMMA_TEXT, RGAMMA_LONGTEXT, true )
124
125 #define GGAMMA_TEXT N_("Gamma (Green) correction")
126 #define GGAMMA_LONGTEXT N_("Select the gamma for the correction of blended zone (Green or U component)")
127 add_float_with_range( CFG_PREFIX "bz-gamma-green", 1, 0, 5, GGAMMA_TEXT, GGAMMA_LONGTEXT, true )
128
129 #define BGAMMA_TEXT N_("Gamma (Blue) correction")
130 #define BGAMMA_LONGTEXT N_("Select the gamma for the correction of blended zone (Blue or V component)")
131 add_float_with_range( CFG_PREFIX "bz-gamma-blue", 1, 0, 5, BGAMMA_TEXT, BGAMMA_LONGTEXT, true )
132
133 #define RGAMMA_BC_TEXT N_("Black Crush for Red")
134 #define RGAMMA_BC_LONGTEXT N_("Select the Black Crush of blended zone (Red or Y component)")
135 #define GGAMMA_BC_TEXT N_("Black Crush for Green")
136 #define GGAMMA_BC_LONGTEXT N_("Select the Black Crush of blended zone (Green or U component)")
137 #define BGAMMA_BC_TEXT N_("Black Crush for Blue")
138 #define BGAMMA_BC_LONGTEXT N_("Select the Black Crush of blended zone (Blue or V component)")
139
140 #define RGAMMA_WC_TEXT N_("White Crush for Red")
141 #define RGAMMA_WC_LONGTEXT N_("Select the White Crush of blended zone (Red or Y component)")
142 #define GGAMMA_WC_TEXT N_("White Crush for Green")
143 #define GGAMMA_WC_LONGTEXT N_("Select the White Crush of blended zone (Green or U component)")
144 #define BGAMMA_WC_TEXT N_("White Crush for Blue")
145 #define BGAMMA_WC_LONGTEXT N_("Select the White Crush of blended zone (Blue or V component)")
146
147 #define RGAMMA_BL_TEXT N_("Black Level for Red")
148 #define RGAMMA_BL_LONGTEXT N_("Select the Black Level of blended zone (Red or Y component)")
149 #define GGAMMA_BL_TEXT N_("Black Level for Green")
150 #define GGAMMA_BL_LONGTEXT N_("Select the Black Level of blended zone (Green or U component)")
151 #define BGAMMA_BL_TEXT N_("Black Level for Blue")
152 #define BGAMMA_BL_LONGTEXT N_("Select the Black Level of blended zone (Blue or V component)")
153
154 #define RGAMMA_WL_TEXT N_("White Level for Red")
155 #define RGAMMA_WL_LONGTEXT N_("Select the White Level of blended zone (Red or Y component)")
156 #define GGAMMA_WL_TEXT N_("White Level for Green")
157 #define GGAMMA_WL_LONGTEXT N_("Select the White Level of blended zone (Green or U component)")
158 #define BGAMMA_WL_TEXT N_("White Level for Blue")
159 #define BGAMMA_WL_LONGTEXT N_("Select the White Level of blended zone (Blue or V component)")
160 add_integer_with_range( CFG_PREFIX "bz-blackcrush-red", 140, 0, 255, RGAMMA_BC_TEXT, RGAMMA_BC_LONGTEXT, true )
161 add_integer_with_range( CFG_PREFIX "bz-blackcrush-green", 140, 0, 255, GGAMMA_BC_TEXT, GGAMMA_BC_LONGTEXT, true )
162 add_integer_with_range( CFG_PREFIX "bz-blackcrush-blue", 140, 0, 255, BGAMMA_BC_TEXT, BGAMMA_BC_LONGTEXT, true )
163 add_integer_with_range( CFG_PREFIX "bz-whitecrush-red", 200, 0, 255, RGAMMA_WC_TEXT, RGAMMA_WC_LONGTEXT, true )
164 add_integer_with_range( CFG_PREFIX "bz-whitecrush-green", 200, 0, 255, GGAMMA_WC_TEXT, GGAMMA_WC_LONGTEXT, true )
165 add_integer_with_range( CFG_PREFIX "bz-whitecrush-blue", 200, 0, 255, BGAMMA_WC_TEXT, BGAMMA_WC_LONGTEXT, true )
166 add_integer_with_range( CFG_PREFIX "bz-blacklevel-red", 150, 0, 255, RGAMMA_BL_TEXT, RGAMMA_BL_LONGTEXT, true )
167 add_integer_with_range( CFG_PREFIX "bz-blacklevel-green", 150, 0, 255, GGAMMA_BL_TEXT, GGAMMA_BL_LONGTEXT, true )
168 add_integer_with_range( CFG_PREFIX "bz-blacklevel-blue", 150, 0, 255, BGAMMA_BL_TEXT, BGAMMA_BL_LONGTEXT, true )
169 add_integer_with_range( CFG_PREFIX "bz-whitelevel-red", 0, 0, 255, RGAMMA_WL_TEXT, RGAMMA_WL_LONGTEXT, true )
170 add_integer_with_range( CFG_PREFIX "bz-whitelevel-green", 0, 0, 255, GGAMMA_WL_TEXT, GGAMMA_WL_LONGTEXT, true )
171 add_integer_with_range( CFG_PREFIX "bz-whitelevel-blue", 0, 0, 255, BGAMMA_WL_TEXT, BGAMMA_WL_LONGTEXT, true )
172 #ifndef _WIN32
173 add_obsolete_bool( CFG_PREFIX "xinerama" );
174 #endif
175 add_obsolete_bool( CFG_PREFIX "offset-x" )
176 #endif
177
178 add_string( CFG_PREFIX "active", NULL, ACTIVE_TEXT, ACTIVE_LONGTEXT, true )
179
180 add_shortcut( "panoramix" )
181 set_callbacks( Open, Close )
182 vlc_module_end()
183
184
185 /*****************************************************************************
186 * Local prototypes
187 *****************************************************************************/
188 static const char *const ppsz_filter_options[] = {
189 "cols", "rows", "bz-length", "bz-height", "attenuate",
190 "bz-begin", "bz-middle", "bz-end", "bz-middle-pos", "bz-gamma-red",
191 "bz-gamma-green", "bz-gamma-blue", "bz-blackcrush-red",
192 "bz-blackcrush-green", "bz-blackcrush-blue", "bz-whitecrush-red",
193 "bz-whitecrush-green", "bz-whitecrush-blue", "bz-blacklevel-red",
194 "bz-blacklevel-green", "bz-blacklevel-blue", "bz-whitelevel-red",
195 "bz-whitelevel-green", "bz-whitelevel-blue", "active",
196 NULL
197 };
198
199 #define ACCURACY 1000
200
201 /* */
202 static inline int clip_accuracy( int a )
203 {
204 return (a > ACCURACY) ? ACCURACY : (a < 0) ? 0 : a;
205 }
206 static inline float clip_unit( float f )
207 {
208 return f < 0.0 ? 0.0 : ( f > 1.0 ? 1.0 : f );
209 }
210
211 /* */
212 typedef struct
213 {
214 float f_black_crush;
215 float f_black_level;
216
217 float f_white_crush;
218 float f_white_level;
219
220 float f_gamma;
221 } panoramix_gamma_t;
222
223 typedef struct
224 {
225 struct
226 {
227 int i_left;
228 int i_right;
229 int i_top;
230 int i_bottom;
231 } black;
232 struct
233 {
234 int i_left;
235 int i_right;
236 int i_top;
237 int i_bottom;
238 } attenuate;
239 } panoramix_filter_t;
240
241 typedef struct
242 {
243 bool b_active;
244 int i_output;
245
246 /* Output position and size */
247 int i_x;
248 int i_y;
249 int i_width;
250 int i_height;
251 int i_align;
252
253 /* Source position and size */
254 int i_src_x;
255 int i_src_y;
256 int i_src_width;
257 int i_src_height;
258
259 /* Filter configuration to use to create the output */
260 panoramix_filter_t filter;
261
262 } panoramix_output_t;
263
264 typedef struct
265 {
266 vlc_fourcc_t i_chroma;
267
268 const int pi_div_w[VOUT_MAX_PLANES];
269 const int pi_div_h[VOUT_MAX_PLANES];
270
271 const int pi_black[VOUT_MAX_PLANES];
272
273 bool b_planar;
274
275 } panoramix_chroma_t;
276
277 struct video_splitter_sys_t
278 {
279 const panoramix_chroma_t *p_chroma;
280
281 /* */
282 bool b_attenuate;
283 unsigned int bz_length, bz_height;
284 unsigned int bz_begin, bz_middle, bz_end;
285 unsigned int bz_middle_pos;
286 unsigned int a_0, a_1, a_2;
287
288 int lambdav[VOUT_MAX_PLANES][2][ACCURACY/2]; /* [plane][position][?] */
289 int lambdah[VOUT_MAX_PLANES][2][ACCURACY/2];
290
291 unsigned int i_overlap_w2; /* Half overlap width */
292 unsigned int i_overlap_h2; /* Half overlap height */
293 uint8_t p_lut[VOUT_MAX_PLANES][ACCURACY + 1][256];
294
295 /* */
296 int i_col;
297 int i_row;
298 panoramix_output_t pp_output[COL_MAX][ROW_MAX]; /* [x][y] */
299 };
300
301 /* */
302 static int Filter( video_splitter_t *, picture_t *pp_dst[], picture_t * );
303
304 static int Mouse( video_splitter_t *, vlc_mouse_t *,
305 int i_index,
306 const vlc_mouse_t *p_old, const vlc_mouse_t *p_new );
307
308
309 /* */
310 static int Configuration( panoramix_output_t pp_output[ROW_MAX][COL_MAX],
311 int i_col, int i_row,
312 int i_src_width, int i_src_height,
313 int i_half_w, int i_half_h,
314 bool b_attenuate,
315 const bool *pb_active );
316 static double GammaFactor( const panoramix_gamma_t *, float f_value );
317
318 static void FilterPlanar( uint8_t *p_out, int i_out_pitch,
319 const uint8_t *p_in, int i_in_pitch,
320 int i_copy_pitch,
321 int i_copy_lines,
322 int i_pixel_black,
323 const panoramix_filter_t *,
324 uint8_t p_lut[ACCURACY + 1][256],
325 int lambdav[2][ACCURACY/2],
326 int lambdah[2][ACCURACY/2] );
327
328 /* */
329 static const panoramix_chroma_t p_chroma_array[] = {
330 /* Planar chroma */
331 { VLC_CODEC_I410, { 1, 4, 4, }, { 1, 1, 1, }, { 0, 128, 128 }, true },
332 { VLC_CODEC_I411, { 1, 4, 4, }, { 1, 4, 4, }, { 0, 128, 128 }, true },
333 { VLC_CODEC_YV12, { 1, 2, 2, }, { 1, 2, 2, }, { 0, 128, 128 }, true },
334 { VLC_CODEC_I420, { 1, 2, 2, }, { 1, 2, 2, }, { 0, 128, 128 }, true },
335 { VLC_CODEC_J420, { 1, 2, 2, }, { 1, 2, 2, }, { 0, 128, 128 }, true },
336 { VLC_CODEC_I422, { 1, 2, 2, }, { 1, 1, 1, }, { 0, 128, 128 }, true },
337 { VLC_CODEC_J422, { 1, 2, 2, }, { 1, 1, 1, }, { 0, 128, 128 }, true },
338 { VLC_CODEC_I440, { 1, 1, 1, }, { 1, 2, 2, }, { 0, 128, 128 }, true },
339 { VLC_CODEC_J440, { 1, 1, 1, }, { 1, 2, 2, }, { 0, 128, 128 }, true },
340 { VLC_CODEC_I444, { 1, 1, 1, }, { 1, 1, 1, }, { 0, 128, 128 }, true },
341 /* TODO packed chroma (yuv/rgb) ? */
342
343 { 0, {0, }, { 0, }, { 0, 0, 0 }, false }
344 };
345
346 #ifndef _WIN32
347 /* Get the number of outputs */
348 static unsigned CountMonitors( vlc_object_t *obj )
349 {
350 char *psz_display = var_InheritString( obj, "x11-display" );
351 int snum;
352 xcb_connection_t *conn = xcb_connect( psz_display, &snum );
353 free( psz_display );
354 if( xcb_connection_has_error( conn ) )
355 return 0;
356
357 const xcb_setup_t *setup = xcb_get_setup( conn );
358 xcb_screen_t *scr = NULL;
359 for( xcb_screen_iterator_t i = xcb_setup_roots_iterator( setup );
360 i.rem > 0; xcb_screen_next( &i ) )
361 {
362 if( snum == 0 )
363 {
364 scr = i.data;
365 break;
366 }
367 snum--;
368 }
369
370 unsigned n = 0;
371 if( scr == NULL )
372 goto error;
373
374 xcb_randr_query_version_reply_t *v =
375 xcb_randr_query_version_reply( conn,
376 xcb_randr_query_version( conn, 1, 2 ), NULL );
377 if( v == NULL )
378 goto error;
379 msg_Dbg( obj, "using X RandR extension v%"PRIu32".%"PRIu32,
380 v->major_version, v->minor_version );
381 free( v );
382
383 xcb_randr_get_screen_resources_reply_t *r =
384 xcb_randr_get_screen_resources_reply( conn,
385 xcb_randr_get_screen_resources( conn, scr->root ), NULL );
386 if( r == NULL )
387 goto error;
388
389 const xcb_randr_output_t *outputs =
390 xcb_randr_get_screen_resources_outputs( r );
391 for( unsigned i = 0; i < r->num_outputs; i++ )
392 {
393 xcb_randr_get_output_info_reply_t *output =
394 xcb_randr_get_output_info_reply( conn,
395 xcb_randr_get_output_info( conn, outputs[i], 0 ), NULL );
396 if( output == NULL )
397 continue;
398 /* FIXME: do not count cloned outputs multiple times */
399 /* XXX: what to do with UNKNOWN state connections? */
400 n += output->connection == XCB_RANDR_CONNECTION_CONNECTED;
401 free( output );
402 }
403 free( r );
404 msg_Dbg( obj, "X randr has %u outputs", n );
405
406 error:
407 xcb_disconnect( conn );
408 return n;
409 }
410 #endif
411
412 /*****************************************************************************
413 * Open: allocates Wall video thread output method
414 *****************************************************************************
415 * This function allocates and initializes a Wall vout method.
416 *****************************************************************************/
417 static int Open( vlc_object_t *p_this )
418 {
419 video_splitter_t *p_splitter = (video_splitter_t*)p_this;
420 video_splitter_sys_t *p_sys;
421
422 const panoramix_chroma_t *p_chroma;
423 for( int i = 0; ; i++ )
424 {
425 vlc_fourcc_t i_chroma = p_chroma_array[i].i_chroma;
426 if( !i_chroma )
427 {
428 msg_Err( p_splitter, "colorspace not supported by plug-in !" );
429 return VLC_EGENERIC;
430 }
431 if( i_chroma == p_splitter->fmt.i_chroma )
432 {
433 p_chroma = &p_chroma_array[i];
434 break;
435 }
436 }
437
438 /* Allocate structure */
439 p_splitter->p_sys = p_sys = malloc( sizeof( *p_sys ) );
440 if( !p_sys )
441 return VLC_ENOMEM;
442
443 /* */
444 p_sys->p_chroma = p_chroma;
445
446 /* */
447 config_ChainParse( p_splitter, CFG_PREFIX, ppsz_filter_options,
448 p_splitter->p_cfg );
449
450 /* */
451 p_sys->i_col = var_InheritInteger( p_splitter, CFG_PREFIX "cols" );
452 p_sys->i_row = var_InheritInteger( p_splitter, CFG_PREFIX "rows" );
453
454 /* Autodetect number of displays */
455 if( p_sys->i_col < 0 || p_sys->i_row < 0 )
456 {
457 #ifdef _WIN32
458 const int i_monitor_count = GetSystemMetrics(SM_CMONITORS);
459 if( i_monitor_count > 1 )
460 {
461 p_sys->i_col = GetSystemMetrics( SM_CXVIRTUALSCREEN ) / GetSystemMetrics( SM_CXSCREEN );
462 p_sys->i_row = GetSystemMetrics( SM_CYVIRTUALSCREEN ) / GetSystemMetrics( SM_CYSCREEN );
463 if( p_sys->i_col * p_sys->i_row != i_monitor_count )
464 {
465 p_sys->i_col = i_monitor_count;
466 p_sys->i_row = 1;
467 }
468 }
469 #else
470 const unsigned i_monitors = CountMonitors( p_this );
471 if( i_monitors > 1 ) /* Find closest to square */
472 for( unsigned w = 1; (i_monitors / w) >= w ; w++ )
473 {
474 if( i_monitors % w )
475 continue;
476 p_sys->i_row = w;
477 p_sys->i_col = i_monitors / w;
478 }
479 #endif
480 /* By default do 2x1 */
481 if( p_sys->i_row < 0 )
482 p_sys->i_row = 1;
483 if( p_sys->i_col < 0 )
484 p_sys->i_col = 2;
485 var_SetInteger( p_splitter, CFG_PREFIX "cols", p_sys->i_col);
486 var_SetInteger( p_splitter, CFG_PREFIX "rows", p_sys->i_row);
487 }
488
489 /* */
490 p_sys->b_attenuate = var_InheritBool( p_splitter, CFG_PREFIX "attenuate");
491 p_sys->bz_length = var_InheritInteger( p_splitter, CFG_PREFIX "bz-length" );
492 p_sys->bz_height = var_InheritInteger( p_splitter, CFG_PREFIX "bz-height" );
493 p_sys->bz_begin = var_InheritInteger( p_splitter, CFG_PREFIX "bz-begin" );
494 p_sys->bz_middle = var_InheritInteger( p_splitter, CFG_PREFIX "bz-middle" );
495 p_sys->bz_end = var_InheritInteger( p_splitter, CFG_PREFIX "bz-end" );
496 p_sys->bz_middle_pos = var_InheritInteger( p_splitter, CFG_PREFIX "bz-middle-pos" );
497 double d_p = 100.0 / p_sys->bz_middle_pos;
498
499 p_sys->a_2 = d_p * p_sys->bz_begin - (double)(d_p * d_p / (d_p - 1)) * p_sys->bz_middle + (double)(d_p / (d_p - 1)) * p_sys->bz_end;
500 p_sys->a_1 = -(d_p + 1) * p_sys->bz_begin + (double)(d_p * d_p / (d_p - 1)) * p_sys->bz_middle - (double)(1 / (d_p - 1)) * p_sys->bz_end;
501 p_sys->a_0 = p_sys->bz_begin;
502
503 /* */
504 p_sys->i_col = VLC_CLIP( p_sys->i_col, 1, COL_MAX );
505 p_sys->i_row = VLC_CLIP( p_sys->i_row, 1, ROW_MAX );
506 msg_Dbg( p_splitter, "opening a %i x %i wall",
507 p_sys->i_col, p_sys->i_row );
508
509 if( p_sys->bz_length > 0 && ( p_sys->i_row > 1 || p_sys->i_col > 1 ) )
510 {
511 const int i_overlap_w2_max = p_splitter->fmt.i_width / p_sys->i_col / 2;
512 const int i_overlap_h2_max = p_splitter->fmt.i_height / p_sys->i_row / 2;
513 const int i_overlap2_max = __MIN( i_overlap_w2_max, i_overlap_h2_max );
514
515 if( p_sys->i_col > 1 )
516 p_sys->i_overlap_w2 = i_overlap2_max * p_sys->bz_length / 100;
517 else
518 p_sys->i_overlap_w2 = 0;
519
520 if( p_sys->i_row > 1 )
521 p_sys->i_overlap_h2 = i_overlap2_max * p_sys->bz_height / 100;
522 else
523 p_sys->i_overlap_h2 = 0;
524
525 /* */
526 int i_div_max_w = 1;
527 int i_div_max_h = 1;
528 for( int i = 0; i < VOUT_MAX_PLANES; i++ )
529 {
530 i_div_max_w = __MAX( i_div_max_w, p_chroma->pi_div_w[i] );
531 i_div_max_h = __MAX( i_div_max_h, p_chroma->pi_div_h[i] );
532 }
533 p_sys->i_overlap_w2 = i_div_max_w * (p_sys->i_overlap_w2 / i_div_max_w);
534 p_sys->i_overlap_h2 = i_div_max_h * (p_sys->i_overlap_h2 / i_div_max_h);
535 }
536 else
537 {
538 p_sys->i_overlap_w2 = 0;
539 p_sys->i_overlap_h2 = 0;
540 }
541
542 /* Compute attenuate parameters */
543 if( p_sys->b_attenuate )
544 {
545 panoramix_gamma_t p_gamma[VOUT_MAX_PLANES];
546
547 p_gamma[0].f_gamma = var_InheritFloat( p_splitter, CFG_PREFIX "bz-gamma-red" );
548 p_gamma[1].f_gamma = var_InheritFloat( p_splitter, CFG_PREFIX "bz-gamma-green" );
549 p_gamma[2].f_gamma = var_InheritFloat( p_splitter, CFG_PREFIX "bz-gamma-blue" );
550
551 p_gamma[0].f_black_crush = var_InheritInteger( p_splitter, CFG_PREFIX "bz-blackcrush-red" ) / 255.0;
552 p_gamma[1].f_black_crush = var_InheritInteger( p_splitter, CFG_PREFIX "bz-blackcrush-green" ) / 255.0;
553 p_gamma[2].f_black_crush = var_InheritInteger( p_splitter, CFG_PREFIX "bz-blackcrush-blue" ) / 255.0;
554 p_gamma[0].f_white_crush = var_InheritInteger( p_splitter, CFG_PREFIX "bz-whitecrush-red" ) / 255.0;
555 p_gamma[1].f_white_crush = var_InheritInteger( p_splitter, CFG_PREFIX "bz-whitecrush-green" ) / 255.0;
556 p_gamma[2].f_white_crush = var_InheritInteger( p_splitter, CFG_PREFIX "bz-whitecrush-blue" ) / 255.0;
557
558 p_gamma[0].f_black_level = var_InheritInteger( p_splitter, CFG_PREFIX "bz-blacklevel-red" ) / 255.0;
559 p_gamma[1].f_black_level = var_InheritInteger( p_splitter, CFG_PREFIX "bz-blacklevel-green" ) / 255.0;
560 p_gamma[2].f_black_level = var_InheritInteger( p_splitter, CFG_PREFIX "bz-blacklevel-blue" ) / 255.0;
561 p_gamma[0].f_white_level = var_InheritInteger( p_splitter, CFG_PREFIX "bz-whitelevel-red" ) / 255.0;
562 p_gamma[1].f_white_level = var_InheritInteger( p_splitter, CFG_PREFIX "bz-whitelevel-green" ) / 255.0;
563 p_gamma[2].f_white_level = var_InheritInteger( p_splitter, CFG_PREFIX "bz-whitelevel-blue" ) / 255.0;
564
565 for( int i = 3; i < VOUT_MAX_PLANES; i++ )
566 {
567 /* Initialize unsupported planes */
568 p_gamma[i].f_gamma = 1.0;
569 p_gamma[i].f_black_crush = 140.0/255.0;
570 p_gamma[i].f_white_crush = 200.0/255.0;
571 p_gamma[i].f_black_level = 150.0/255.0;
572 p_gamma[i].f_white_level = 0.0/255.0;
573 }
574
575 if( p_chroma->i_chroma == VLC_CODEC_YV12 )
576 {
577 /* Exchange U and V */
578 panoramix_gamma_t t = p_gamma[1];
579 p_gamma[1] = p_gamma[2];
580 p_gamma[2] = t;
581 }
582
583 for( int i_index = 0; i_index < 256; i_index++ )
584 {
585 for( int i_index2 = 0; i_index2 <= ACCURACY; i_index2++ )
586 {
587 for( int i_plane = 0; i_plane < VOUT_MAX_PLANES; i_plane++ )
588 {
589 double f_factor = GammaFactor( &p_gamma[i_plane], (float)i_index / 255.0 );
590
591 float f_lut = clip_unit( 1.0 - ((ACCURACY - (float)i_index2) * f_factor / (ACCURACY - 1)) );
592
593 p_sys->p_lut[i_plane][i_index2][i_index] = f_lut * i_index + (int)( (1.0 - f_lut) * (float)p_chroma->pi_black[i_plane] );
594 }
595 }
596 }
597
598 for( int i_plane = 0; i_plane < VOUT_MAX_PLANES; i_plane++ )
599 {
600 if( !p_chroma->pi_div_w[i_plane] || !p_chroma->pi_div_h[i_plane] )
601 continue;
602 const int i_length_w = (2 * p_sys->i_overlap_w2) / p_chroma->pi_div_w[i_plane];
603 const int i_length_h = (2 * p_sys->i_overlap_h2) / p_chroma->pi_div_h[i_plane];
604
605 for( int i_dir = 0; i_dir < 2; i_dir++ )
606 {
607 const int i_length = i_dir == 0 ? i_length_w : i_length_h;
608 const int i_den = i_length * i_length;
609 const int a_2 = p_sys->a_2 * (ACCURACY / 100);
610 const int a_1 = p_sys->a_1 * i_length * (ACCURACY / 100);
611 const int a_0 = p_sys->a_0 * i_den * (ACCURACY / 100);
612
613 for( int i_position = 0; i_position < 2; i_position++ )
614 {
615 for( int i_index = 0; i_index < i_length; i_index++ )
616 {
617 const int v = i_position == 1 ? i_index : (i_length - i_index);
618 const int i_lambda = clip_accuracy( ACCURACY - (a_2 * v*v + a_1 * v + a_0) / i_den );
619
620 if( i_dir == 0 )
621 p_sys->lambdav[i_plane][i_position][i_index] = i_lambda;
622 else
623 p_sys->lambdah[i_plane][i_position][i_index] = i_lambda;
624 }
625 }
626 }
627 }
628 }
629
630 /* */
631 char *psz_state = var_InheritString( p_splitter, CFG_PREFIX "active" );
632
633 /* */
634 bool pb_active[COL_MAX*ROW_MAX];
635
636 for( int i = 0; i < COL_MAX*ROW_MAX; i++ )
637 pb_active[i] = psz_state == NULL;
638
639 /* Parse active list if provided */
640 char *psz_tmp = psz_state;
641 while( psz_tmp && *psz_tmp )
642 {
643 char *psz_next = strchr( psz_tmp, ',' );
644 if( psz_next )
645 *psz_next++ = '\0';
646
647 const int i_index = atoi( psz_tmp );
648 if( i_index >= 0 && i_index < COL_MAX*ROW_MAX )
649 pb_active[i_index] = true;
650
651 psz_tmp = psz_next;
652 }
653 free( psz_state );
654
655 /* */
656 p_splitter->i_output =
657 Configuration( p_sys->pp_output,
658 p_sys->i_col, p_sys->i_row,
659 p_splitter->fmt.i_width, p_splitter->fmt.i_height,
660 p_sys->i_overlap_w2, p_sys->i_overlap_h2,
661 p_sys->b_attenuate,
662 pb_active );
663 p_splitter->p_output = calloc( p_splitter->i_output,
664 sizeof(*p_splitter->p_output) );
665 if( !p_splitter->p_output )
666 {
667 free( p_sys );
668 return VLC_ENOMEM;
669 }
670
671 for( int y = 0; y < p_sys->i_row; y++ )
672 {
673 for( int x = 0; x < p_sys->i_col; x++ )
674 {
675 panoramix_output_t *p_output = &p_sys->pp_output[x][y];
676 if( !p_output->b_active )
677 continue;
678
679 video_splitter_output_t *p_cfg = &p_splitter->p_output[p_output->i_output];
680
681 /* */
682 video_format_Copy( &p_cfg->fmt, &p_splitter->fmt );
683 p_cfg->fmt.i_visible_width =
684 p_cfg->fmt.i_width = p_output->i_width;
685 p_cfg->fmt.i_visible_height =
686 p_cfg->fmt.i_height = p_output->i_height;
687
688 p_cfg->window.i_x = p_output->i_x;
689 p_cfg->window.i_y = p_output->i_y;
690 p_cfg->window.i_align = p_output->i_align;
691
692 p_cfg->psz_module = NULL;
693 }
694 }
695
696
697 /* */
698 p_splitter->pf_filter = Filter;
699 p_splitter->pf_mouse = Mouse;
700
701 return VLC_SUCCESS;
702 }
703
704 /**
705 * Terminate a splitter module
706 */
707 static void Close( vlc_object_t *p_this )
708 {
709 video_splitter_t *p_splitter = (video_splitter_t*)p_this;
710 video_splitter_sys_t *p_sys = p_splitter->p_sys;
711
712 free( p_splitter->p_output );
713 free( p_sys );
714 }
715
716 /**
717 * It creates multiples pictures from the source one
718 */
719 static int Filter( video_splitter_t *p_splitter, picture_t *pp_dst[], picture_t *p_src )
720 {
721 video_splitter_sys_t *p_sys = p_splitter->p_sys;
722
723 if( video_splitter_NewPicture( p_splitter, pp_dst ) )
724 {
725 picture_Release( p_src );
726 return VLC_EGENERIC;
727 }
728
729 for( int y = 0; y < p_sys->i_row; y++ )
730 {
731 for( int x = 0; x < p_sys->i_col; x++ )
732 {
733 const panoramix_output_t *p_output = &p_sys->pp_output[x][y];
734 if( !p_output->b_active )
735 continue;
736
737 /* */
738 picture_t *p_dst = pp_dst[p_output->i_output];
739
740 /* */
741 picture_CopyProperties( p_dst, p_src );
742
743 /* */
744 for( int i_plane = 0; i_plane < p_src->i_planes; i_plane++ )
745 {
746 const int i_div_w = p_sys->p_chroma->pi_div_w[i_plane];
747 const int i_div_h = p_sys->p_chroma->pi_div_h[i_plane];
748
749 if( !i_div_w || !i_div_h )
750 continue;
751
752 const plane_t *p_srcp = &p_src->p[i_plane];
753 const plane_t *p_dstp = &p_dst->p[i_plane];
754
755 /* */
756 panoramix_filter_t filter;
757 filter.black.i_right = p_output->filter.black.i_right / i_div_w;
758 filter.black.i_left = p_output->filter.black.i_left / i_div_w;
759 filter.black.i_top = p_output->filter.black.i_top / i_div_h;
760 filter.black.i_bottom = p_output->filter.black.i_bottom / i_div_h;
761
762 filter.attenuate.i_right = p_output->filter.attenuate.i_right / i_div_w;
763 filter.attenuate.i_left = p_output->filter.attenuate.i_left / i_div_w;
764 filter.attenuate.i_top = p_output->filter.attenuate.i_top / i_div_h;
765 filter.attenuate.i_bottom = p_output->filter.attenuate.i_bottom / i_div_h;
766
767 /* */
768 const int i_x = p_output->i_src_x/i_div_w;
769 const int i_y = p_output->i_src_y/i_div_h;
770
771 assert( p_sys->p_chroma->b_planar );
772 FilterPlanar( p_dstp->p_pixels, p_dstp->i_pitch,
773 &p_srcp->p_pixels[i_y * p_srcp->i_pitch + i_x * p_srcp->i_pixel_pitch], p_srcp->i_pitch,
774 p_output->i_src_width/i_div_w, p_output->i_src_height/i_div_h,
775 p_sys->p_chroma->pi_black[i_plane],
776 &filter,
777 p_sys->p_lut[i_plane],
778 p_sys->lambdav[i_plane],
779 p_sys->lambdah[i_plane] );
780 }
781 }
782 }
783
784 picture_Release( p_src );
785 return VLC_SUCCESS;
786 }
787
788 /**
789 * It converts mouse events
790 */
791 static int Mouse( video_splitter_t *p_splitter, vlc_mouse_t *p_mouse,
792 int i_index,
793 const vlc_mouse_t *p_old, const vlc_mouse_t *p_new )
794 {
795 video_splitter_sys_t *p_sys = p_splitter->p_sys;
796 VLC_UNUSED(p_old);
797
798 for( int y = 0; y < p_sys->i_row; y++ )
799 {
800 for( int x = 0; x < p_sys->i_col; x++ )
801 {
802 const panoramix_output_t *p_output = &p_sys->pp_output[x][y];
803 if( p_output->b_active && p_output->i_output == i_index )
804 {
805 const int i_x = p_new->i_x - p_output->filter.black.i_left;
806 const int i_y = p_new->i_y - p_output->filter.black.i_top;
807 if( i_x >= 0 && i_x < p_output->i_width - p_output->filter.black.i_right &&
808 i_y >= 0 && i_y < p_output->i_height - p_output->filter.black.i_bottom )
809 {
810 *p_mouse = *p_new;
811 p_mouse->i_x = p_output->i_src_x + i_x;
812 p_mouse->i_y = p_output->i_src_y + i_y;
813 return VLC_SUCCESS;
814 }
815 }
816 }
817 }
818 return VLC_EGENERIC;
819 }
820
821 /* It return a coefficient between 0.0 and 1.0 to be applied to the given
822 * value
823 */
824 static double GammaFactor( const panoramix_gamma_t *g, float f_value )
825 {
826 if( f_value <= g->f_black_crush )
827 {
828 float f_input = f_value * g->f_black_level / g->f_black_crush + (1.0 - g->f_black_level);
829
830 return pow( f_input, 1.0 / g->f_gamma );
831 }
832 else if( f_value >= g->f_white_crush )
833 {
834 float f_input = (f_value * (1.0 - (g->f_white_level + 1.0)) + (g->f_white_level + 1.0) * g->f_white_crush - 1.0) / (g->f_white_crush - 1.0);
835 return pow( f_input, 1.0 / g->f_gamma );
836 }
837 return 1.0;
838 }
839
840 /**
841 * It creates the panoramix configuration
842 */
843 static int Configuration( panoramix_output_t pp_output[ROW_MAX][COL_MAX],
844 int i_col, int i_row,
845 int i_src_width, int i_src_height,
846 int i_half_w, int i_half_h,
847 bool b_attenuate,
848 const bool *pb_active )
849 {
850 #ifdef OVERLAP
851 const bool b_overlap = true;
852 #else
853 const bool b_overlap = false;
854 #endif
855
856 /* */
857 int i_output = 0;
858 for( int y = 0, i_src_y = 0, i_dst_y = 0; y < i_row; y++ )
859 {
860 const bool b_row_first = y == 0;
861 const bool b_row_last = y == i_row - 1;
862
863 /* Compute source height */
864 int i_win_height = (i_src_height / i_row ) & ~1;
865 if( b_row_last )
866 i_win_height = i_src_height - y * i_win_height;
867
868 for( int x = 0, i_src_x = 0, i_dst_x = 0; x < i_col; x++ )
869 {
870 const bool b_col_first = x == 0;
871 const bool b_col_last = x == i_col - 1;
872
873 /* Compute source width */
874 int i_win_width = (i_src_width / i_col ) & ~1;
875 if( b_col_last )
876 i_win_width = i_src_width - x * i_win_width;
877
878 /* Compute filter configuration */
879 panoramix_filter_t cfg;
880
881 memset( &cfg, 0, sizeof(cfg) );
882 if( b_overlap && b_attenuate )
883 {
884 if( i_col > 2 )
885 {
886 if( b_col_first )
887 cfg.black.i_left = i_half_w;
888 if( b_col_last )
889 cfg.black.i_right = i_half_w;
890 }
891 if( i_row > 2 )
892 {
893 if( b_row_first )
894 cfg.black.i_top = i_half_h;
895 if( b_row_last )
896 cfg.black.i_bottom = i_half_h;
897 }
898 if( !b_col_first )
899 cfg.attenuate.i_left = 2 * i_half_w;
900 if( !b_col_last )
901 cfg.attenuate.i_right = 2 * i_half_w;
902 if( !b_row_first )
903 cfg.attenuate.i_top = 2 * i_half_h;
904 if( !b_row_last )
905 cfg.attenuate.i_bottom = 2 * i_half_h;
906 }
907
908 /* Compute alignment */
909 int i_align = 0;
910 if( i_col > 1 )
911 {
912 if( b_col_first )
913 i_align |= VOUT_ALIGN_RIGHT;
914 if( b_col_last )
915 i_align |= VOUT_ALIGN_LEFT;
916 }
917 if( i_row > 1 )
918 {
919 if( b_row_first )
920 i_align |= VOUT_ALIGN_BOTTOM;
921 if( b_row_last )
922 i_align |= VOUT_ALIGN_TOP;
923 }
924
925 /* */
926 panoramix_output_t *p_output = &pp_output[x][y];
927
928 /* */
929 p_output->i_src_x = i_src_x - cfg.attenuate.i_left/2;
930 p_output->i_src_y = i_src_y - cfg.attenuate.i_top/2;
931 p_output->i_src_width = i_win_width + cfg.attenuate.i_left/2 + cfg.attenuate.i_right/2;
932 p_output->i_src_height = i_win_height + cfg.attenuate.i_top/2 + cfg.attenuate.i_bottom/2;
933
934 /* */
935 p_output->filter = cfg;
936
937 /* */
938 p_output->i_align = i_align;
939 p_output->i_x = i_dst_x;
940 p_output->i_y = i_dst_y;
941
942 p_output->i_width = cfg.black.i_left + p_output->i_src_width + cfg.black.i_right;
943 p_output->i_height = cfg.black.i_top + p_output->i_src_height + cfg.black.i_bottom;
944
945 /* */
946 p_output->b_active = pb_active[y * i_col + x] &&
947 p_output->i_width > 0 &&
948 p_output->i_height > 0;
949 if( p_output->b_active )
950 p_output->i_output = i_output++;
951
952 /* */
953 i_src_x += i_win_width;
954 i_dst_x += p_output->i_width;
955 }
956 i_src_y += i_win_height;
957 i_dst_y += pp_output[0][y].i_height;
958 }
959 return i_output;
960 }
961
962 /**
963 * It filters a video plane
964 */
965 static void FilterPlanar( uint8_t *p_out, int i_out_pitch,
966 const uint8_t *p_in, int i_in_pitch,
967 int i_copy_pitch,
968 int i_copy_lines,
969 int i_pixel_black,
970 const panoramix_filter_t *p_cfg,
971 uint8_t p_lut[ACCURACY + 1][256],
972 int lambdav[2][ACCURACY/2],
973 int lambdah[2][ACCURACY/2] )
974 {
975 /* */
976 assert( !p_cfg->black.i_left || !p_cfg->attenuate.i_left );
977 assert( !p_cfg->black.i_right || !p_cfg->attenuate.i_right );
978 assert( !p_cfg->black.i_top || !p_cfg->attenuate.i_top );
979 assert( !p_cfg->black.i_bottom || !p_cfg->attenuate.i_bottom );
980
981 const int i_out_width = p_cfg->black.i_left + i_copy_pitch + p_cfg->black.i_right;
982
983 /* Top black border */
984 for( int b = 0; b < p_cfg->black.i_top; b++ )
985 {
986 memset( p_out, i_pixel_black, i_out_width );
987 p_out += i_out_pitch;
988 }
989
990 for( int y = 0; y < i_copy_lines; y++ )
991 {
992 const uint8_t *p_src = p_in;
993 uint8_t *p_dst = p_out;
994
995 /* Black border on the left */
996 if( p_cfg->black.i_left > 0 )
997 {
998 memset( p_dst, i_pixel_black, p_cfg->black.i_left );
999 p_dst += p_cfg->black.i_left;
1000 }
1001 /* Attenuated video on the left */
1002 for( int i = 0; i < p_cfg->attenuate.i_left; i++ )
1003 *p_dst++ = p_lut[lambdav[0][i]][*p_src++];
1004
1005 /* Unmodified video */
1006 const int i_unmodified_width = i_copy_pitch - p_cfg->attenuate.i_left - p_cfg->attenuate.i_right;
1007 memcpy( p_dst, p_src, i_unmodified_width );
1008 p_dst += i_unmodified_width;
1009 p_src += i_unmodified_width;
1010
1011 /* Attenuated video on the right */
1012 for( int i = 0; i < p_cfg->attenuate.i_right; i++ )
1013 *p_dst++ = p_lut[lambdav[1][i]][*p_src++];
1014 /* Black border on the right */
1015 if( p_cfg->black.i_right > 0 )
1016 {
1017 memset( p_dst, i_pixel_black, p_cfg->black.i_right );
1018 p_dst += p_cfg->black.i_right;
1019 }
1020
1021 /* Attenuate complete line at top/bottom */
1022 const bool b_attenuate_top = y < p_cfg->attenuate.i_top;
1023 const bool b_attenuate_bottom = y >= i_copy_lines - p_cfg->attenuate.i_bottom;
1024 if( b_attenuate_top || b_attenuate_bottom )
1025 {
1026 const int i_index = b_attenuate_top ? lambdah[0][y] : lambdah[1][y - (i_copy_lines - p_cfg->attenuate.i_bottom)];
1027 for( int i = 0; i < i_out_width; i++)
1028 p_out[i] = p_lut[i_index][p_out[i]];
1029 }
1030
1031 /* */
1032 p_in += i_in_pitch;
1033 p_out += i_out_pitch;
1034 }
1035 /* Bottom black border */
1036 for( int b = 0; b < p_cfg->black.i_bottom; b++ )
1037 {
1038 memset( p_out, i_pixel_black, i_out_width );
1039 p_out += i_out_pitch;
1040 }
1041 }
1042
1043
1044
1045 #if 0
1046 static void RenderPackedRGB( vout_thread_t *p_vout, picture_t *p_pic )
1047 {
1048 int length;
1049 length = 2 * p_sys->i_overlap_w2 * p_pic->p->i_pixel_pitch;
1050
1051 if (p_sys->b_has_changed)
1052 {
1053 int i_plane_;
1054 int i_col_mod;
1055 Denom = F2(length / p_pic->p->i_pixel_pitch);
1056 a_2 = p_sys->a_2 * (ACCURACY / 100);
1057 a_1 = p_sys->a_1 * 2 * p_sys->i_overlap_w2 * (ACCURACY / 100);
1058 a_0 = p_sys->a_0 * Denom * (ACCURACY / 100);
1059 for(i_col_mod = 0; i_col_mod < 2; i_col_mod++)
1060 for (i_index = 0; i_index < length / p_pic->p->i_pixel_pitch; i_index++)
1061 for (i_plane_ = 0; i_plane_ < p_pic->p->i_pixel_pitch; i_plane_++)
1062 p_sys->lambda[i_col_mod][i_plane_][i_index] = clip_accuracy(!i_col_mod ? ACCURACY - (F4(a_2, a_1, i_index) + a_0) / Denom : ACCURACY - (F4(a_2, a_1,(length / p_pic->p->i_pixel_pitch) - i_index) + a_0) / Denom);
1063 }
1064
1065 length = 2 * p_sys->i_overlap_h2;
1066 if (p_sys->b_has_changed)
1067 {
1068 int i_plane_;
1069 int i_row_mod;
1070 Denom = F2(length);
1071 a_2 = p_sys->a_2 * (ACCURACY / 100);
1072 a_1 = p_sys->a_1 * length * (ACCURACY / 100);
1073 a_0 = p_sys->a_0 * Denom * (ACCURACY / 100);
1074 for(i_row_mod = 0; i_row_mod < 2; i_row_mod++)
1075 for (i_index = 0; i_index < length; i_index++)
1076 for (i_plane_ = 0; i_plane_ < p_pic->p->i_pixel_pitch; i_plane_++)
1077 p_sys->lambda2[i_row_mod][i_plane_][i_index] = clip_accuracy(!i_row_mod ? ACCURACY - (F4(a_2, a_1, i_index) + a_0) / Denom : ACCURACY - (F4(a_2, a_1,(length) - i_index) + a_0) / Denom);
1078 }
1079 }
1080 #endif
1081
1082
VLC Development tree mirror