?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove legacy parameter from add_string()
[vlc/asuraparaju-public.git] / modules / video_filter / audiobargraph_v.c
blob70754e0e3201e84ec82987e9d8fafb26208714c3
1 /*****************************************************************************
2 * audiobargraph_v.c : audiobargraph video plugin for vlc
3 *****************************************************************************
4 * Copyright (C) 2003-2006 the VideoLAN team
5 *
6 * Authors: Clement CHESNIN <clement.chesnin@gmail.com>
7 * Philippe COENT <philippe.coent@tdf.fr>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 /*****************************************************************************
25 * Preamble
26 *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31 #include <string.h>
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_filter.h>
36
37 #include <vlc_image.h>
38
39 #ifdef LoadImage
40 # undef LoadImage
41 #endif
42
43 /*****************************************************************************
44 * Module descriptor
45 *****************************************************************************/
46
47 #define I_VALUES_TEXT N_("Value of the audio channels levels")
48 #define I_VALUES_LONGTEXT N_("Value of the audio level of each channels between 0 and 1" \
49 "Each level should be separated with ':'.")
50 #define POSX_TEXT N_("X coordinate")
51 #define POSX_LONGTEXT N_("X coordinate of the bargraph." )
52 #define POSY_TEXT N_("Y coordinate")
53 #define POSY_LONGTEXT N_("Y coordinate of the bargraph." )
54 #define TRANS_TEXT N_("Transparency of the bargraph")
55 #define TRANS_LONGTEXT N_("Bargraph transparency value " \
56 "(from 0 for full transparency to 255 for full opacity)." )
57 #define POS_TEXT N_("Bargraph position")
58 #define POS_LONGTEXT N_( \
59 "Enforce the bargraph position on the video " \
60 "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
61 "also use combinations of these values, eg 6 = top-right).")
62 #define ALARM_TEXT N_("Alarm")
63 #define ALARM_LONGTEXT N_("Signals a silence and displays and alert " \
64 "(0=no alarm, 1=alarm).")
65 #define BARWIDTH_TEXT N_("Bar width in pixel (default : 10)")
66 #define BARWIDTH_LONGTEXT N_("Width in pixel of each bar in the BarGraph to be displayed " \
67 "(default : 10).")
68
69 #define CFG_PREFIX "audiobargraph_v-"
70
71 static const int pi_pos_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
72 static const char *const ppsz_pos_descriptions[] =
73 { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
74 N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
75
76 static int OpenSub ( vlc_object_t * );
77 static int OpenVideo( vlc_object_t * );
78 static void Close ( vlc_object_t * );
79
80 vlc_module_begin ()
81
82 set_category( CAT_VIDEO )
83 set_subcategory( SUBCAT_VIDEO_SUBPIC )
84
85 set_capability( "sub filter", 0 )
86 set_callbacks( OpenSub, Close )
87 set_description( N_("Audio Bar Graph Video sub filter") )
88 set_shortname( N_("Audio Bar Graph Video") )
89 add_shortcut( "audiobargraph_v" )
90
91 add_string( CFG_PREFIX "i_values", NULL, I_VALUES_TEXT, I_VALUES_LONGTEXT, false )
92 add_integer( CFG_PREFIX "x", 0, NULL, POSX_TEXT, POSX_LONGTEXT, true )
93 add_integer( CFG_PREFIX "y", 0, NULL, POSY_TEXT, POSY_LONGTEXT, true )
94 add_integer_with_range( CFG_PREFIX "transparency", 255, 0, 255, NULL,
95 TRANS_TEXT, TRANS_LONGTEXT, false )
96 add_integer( CFG_PREFIX "position", -1, NULL, POS_TEXT, POS_LONGTEXT, false )
97 change_integer_list( pi_pos_values, ppsz_pos_descriptions )
98 add_integer( CFG_PREFIX "alarm", 0, NULL, ALARM_TEXT, ALARM_LONGTEXT, true )
99 add_integer( CFG_PREFIX "barWidth", 10, NULL, BARWIDTH_TEXT, BARWIDTH_LONGTEXT, true )
100
101 /* video output filter submodule */
102 add_submodule ()
103 set_capability( "video filter2", 0 )
104 set_callbacks( OpenVideo, Close )
105 set_description( N_("Audio Bar Graph Video sub filter") )
106 add_shortcut( "audiobargraph_v" )
107 vlc_module_end ()
108
109
110 /*****************************************************************************
111 * Local prototypes
112 *****************************************************************************/
113
114 /*****************************************************************************
115 * Structure to hold the Bar Graph properties
116 ****************************************************************************/
117 typedef struct
118 {
119 int i_alpha; /* -1 means use default alpha */
120 int nbChannels;
121 int *i_values;
122 picture_t *p_pic;
123 mtime_t date;
124 int scale;
125 int alarm;
126 int barWidth;
127
128 } BarGraph_t;
129
130 /**
131 * Private data holder
132 */
133 struct filter_sys_t
134 {
135 filter_t *p_blend;
136
137 vlc_mutex_t lock;
138
139 BarGraph_t p_BarGraph;
140
141 int i_pos;
142 int i_pos_x;
143 int i_pos_y;
144 bool b_absolute;
145
146 /* On the fly control variable */
147 bool b_spu_update;
148 };
149
150 static const char *const ppsz_filter_options[] = {
151 "i_values", "x", "y", "transparency", "position", "alarm", "barWidth", NULL
152 };
153
154 static const char *const ppsz_filter_callbacks[] = {
155 "audiobargraph_v-i_values",
156 "audiobargraph_v-x",
157 "audiobargraph_v-y",
158 "audiobargraph_v-transparency",
159 "audiobargraph_v-position",
160 "audiobargraph_v-alarm",
161 "audiobargraph_v-barWidth",
162 NULL
163 };
164
165 static int OpenCommon( vlc_object_t *, bool b_sub );
166
167 static subpicture_t *FilterSub( filter_t *, mtime_t );
168 static picture_t *FilterVideo( filter_t *, picture_t * );
169
170 static int BarGraphCallback( vlc_object_t *, char const *,
171 vlc_value_t, vlc_value_t, void * );
172
173 static void LoadBarGraph( vlc_object_t *, BarGraph_t *);
174 void parse_i_values( BarGraph_t *p_BarGraph, char *i_values);
175
176 /**
177 * Open the sub filter
178 */
179 static int OpenSub( vlc_object_t *p_this )
180 {
181 return OpenCommon( p_this, true );
182 }
183
184 /**
185 * Open the video filter
186 */
187 static int OpenVideo( vlc_object_t *p_this )
188 {
189 return OpenCommon( p_this, false );
190 }
191
192 /**
193 * Common open function
194 */
195 static int OpenCommon( vlc_object_t *p_this, bool b_sub )
196 {
197 filter_t *p_filter = (filter_t *)p_this;
198 filter_sys_t *p_sys;
199 BarGraph_t *p_BarGraph;
200 char* i_values = NULL;
201
202 /* */
203 if( !b_sub && !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) )
204 {
205 msg_Err( p_filter, "Input and output format does not match" );
206 return VLC_EGENERIC;
207 }
208
209
210 /* */
211 p_filter->p_sys = p_sys = malloc( sizeof( *p_sys ) );
212 if( !p_sys )
213 return VLC_ENOMEM;
214 p_BarGraph = &(p_sys->p_BarGraph);
215
216 /* */
217 p_sys->p_blend = NULL;
218 if( !b_sub )
219 {
220
221 p_sys->p_blend = filter_NewBlend( VLC_OBJECT(p_filter),
222 &p_filter->fmt_in.video );
223 if( !p_sys->p_blend )
224 {
225 //free( p_BarGraph );
226 free( p_sys );
227 return VLC_EGENERIC;
228 }
229 }
230
231 /* */
232 config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
233 p_filter->p_cfg );
234
235 /* create and initialize variables */
236 p_sys->i_pos = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-position" );
237 p_sys->i_pos_x = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-x" );
238 p_sys->i_pos_y = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-y" );
239 p_BarGraph->i_alpha = var_CreateGetIntegerCommand( p_filter,
240 "audiobargraph_v-transparency" );
241 p_BarGraph->i_alpha = __MAX( __MIN( p_BarGraph->i_alpha, 255 ), 0 );
242 i_values = var_CreateGetStringCommand( p_filter, "audiobargraph_v-i_values" );
243 //p_BarGraph->nbChannels = 0;
244 //p_BarGraph->i_values = NULL;
245 parse_i_values(p_BarGraph, i_values);
246 p_BarGraph->alarm = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-alarm" );
247 p_BarGraph->barWidth = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-barWidth" );
248 p_BarGraph->scale = 400;
249
250 /* Ignore aligment if a position is given for video filter */
251 if( !b_sub && p_sys->i_pos_x >= 0 && p_sys->i_pos_y >= 0 )
252 p_sys->i_pos = 0;
253
254 vlc_mutex_init( &p_sys->lock );
255 LoadBarGraph( p_this, p_BarGraph );
256 p_sys->b_spu_update = true;
257
258 for( int i = 0; ppsz_filter_callbacks[i]; i++ )
259 var_AddCallback( p_filter, ppsz_filter_callbacks[i],
260 BarGraphCallback, p_sys );
261
262 /* Misc init */
263 if( b_sub )
264 {
265 p_filter->pf_sub_filter = FilterSub;
266 }
267 else
268 {
269 p_filter->pf_video_filter = FilterVideo;
270 }
271
272 free( i_values );
273 return VLC_SUCCESS;
274 }
275
276 /**
277 * Common close function
278 */
279 static void Close( vlc_object_t *p_this )
280 {
281 filter_t *p_filter = (filter_t *)p_this;
282 filter_sys_t *p_sys = p_filter->p_sys;
283 BarGraph_t *p_BarGraph = &(p_sys->p_BarGraph);
284
285 for( int i = 0; ppsz_filter_callbacks[i]; i++ )
286 var_DelCallback( p_filter, ppsz_filter_callbacks[i],
287 BarGraphCallback, p_sys );
288
289 if( p_sys->p_blend )
290 filter_DeleteBlend( p_sys->p_blend );
291
292 vlc_mutex_destroy( &p_sys->lock );
293
294 if( p_BarGraph->p_pic )
295 {
296 picture_Release( p_BarGraph->p_pic );
297 p_BarGraph->p_pic = NULL;
298 }
299 free( p_BarGraph->i_values );
300
301 free( p_sys );
302 }
303
304 /**
305 * Sub filter
306 */
307 static subpicture_t *FilterSub( filter_t *p_filter, mtime_t date )
308 {
309 filter_sys_t *p_sys = p_filter->p_sys;
310 BarGraph_t *p_BarGraph = &(p_sys->p_BarGraph);
311
312 subpicture_t *p_spu;
313 subpicture_region_t *p_region;
314 video_format_t fmt;
315 picture_t *p_pic;
316
317 vlc_mutex_lock( &p_sys->lock );
318 /* Basic test: b_spu_update occurs on a dynamic change */
319 if( !p_sys->b_spu_update )
320 {
321 vlc_mutex_unlock( &p_sys->lock );
322 return 0;
323 }
324
325 p_pic = p_BarGraph->p_pic;
326
327 /* Allocate the subpicture internal data. */
328 p_spu = filter_NewSubpicture( p_filter );
329 if( !p_spu )
330 goto exit;
331
332 p_spu->b_absolute = p_sys->b_absolute;
333 p_spu->i_start = date;
334 p_spu->i_stop = 0;
335 p_spu->b_ephemer = true;
336
337 /* Send an empty subpicture to clear the display when needed */
338 if( !p_pic || !p_BarGraph->i_alpha )
339 goto exit;
340
341 /* Create new SPU region */
342 memset( &fmt, 0, sizeof(video_format_t) );
343 fmt.i_chroma = VLC_CODEC_YUVA;
344 fmt.i_sar_num = fmt.i_sar_den = 1;
345 fmt.i_width = fmt.i_visible_width = p_pic->p[Y_PLANE].i_visible_pitch;
346 fmt.i_height = fmt.i_visible_height = p_pic->p[Y_PLANE].i_visible_lines;
347 fmt.i_x_offset = fmt.i_y_offset = 0;
348 p_region = subpicture_region_New( &fmt );
349 if( !p_region )
350 {
351 msg_Err( p_filter, "cannot allocate SPU region" );
352 p_filter->pf_sub_buffer_del( p_filter, p_spu );
353 p_spu = NULL;
354 goto exit;
355 }
356
357 /* */
358 picture_Copy( p_region->p_picture, p_pic );
359
360 /* where to locate the bar graph: */
361 if( p_sys->i_pos < 0 )
362 { /* set to an absolute xy */
363 p_region->i_align = SUBPICTURE_ALIGN_RIGHT | SUBPICTURE_ALIGN_TOP;
364 p_spu->b_absolute = true;
365 }
366 else
367 { /* set to one of the 9 relative locations */
368 p_region->i_align = p_sys->i_pos;
369 p_spu->b_absolute = false;
370 }
371
372 p_region->i_x = p_sys->i_pos_x;
373 p_region->i_y = p_sys->i_pos_y;
374
375 p_spu->p_region = p_region;
376
377 p_spu->i_alpha = p_BarGraph->i_alpha ;
378
379 exit:
380 vlc_mutex_unlock( &p_sys->lock );
381
382 return p_spu;
383 }
384
385 /**
386 * Video filter
387 */
388 static picture_t *FilterVideo( filter_t *p_filter, picture_t *p_src )
389 {
390 filter_sys_t *p_sys = p_filter->p_sys;
391 BarGraph_t *p_BarGraph = &(p_sys->p_BarGraph);
392
393 picture_t *p_dst = filter_NewPicture( p_filter );
394 if( !p_dst )
395 goto exit;
396
397 picture_Copy( p_dst, p_src );
398
399 /* */
400 vlc_mutex_lock( &p_sys->lock );
401
402 /* */
403 const picture_t *p_pic = p_BarGraph->p_pic;
404 if( p_pic )
405 {
406 const video_format_t *p_fmt = &p_pic->format;
407 const int i_dst_w = p_filter->fmt_out.video.i_visible_width;
408 const int i_dst_h = p_filter->fmt_out.video.i_visible_height;
409
410 if( p_sys->i_pos )
411 {
412 if( p_sys->i_pos & SUBPICTURE_ALIGN_BOTTOM )
413 {
414 p_sys->i_pos_y = i_dst_h - p_fmt->i_visible_height;
415 }
416 else if ( !(p_sys->i_pos & SUBPICTURE_ALIGN_TOP) )
417 {
418 p_sys->i_pos_y = ( i_dst_h - p_fmt->i_visible_height ) / 2;
419 }
420 else
421 {
422 p_sys->i_pos_y = 0;
423 }
424
425 if( p_sys->i_pos & SUBPICTURE_ALIGN_RIGHT )
426 {
427 p_sys->i_pos_x = i_dst_w - p_fmt->i_visible_width;
428 }
429 else if ( !(p_sys->i_pos & SUBPICTURE_ALIGN_LEFT) )
430 {
431 p_sys->i_pos_x = ( i_dst_w - p_fmt->i_visible_width ) / 2;
432 }
433 else
434 {
435 p_sys->i_pos_x = 0;
436 }
437 }
438
439 /* */
440 const int i_alpha = p_BarGraph->i_alpha;
441 if( filter_ConfigureBlend( p_sys->p_blend, i_dst_w, i_dst_h, p_fmt ) ||
442 filter_Blend( p_sys->p_blend, p_dst, p_sys->i_pos_x, p_sys->i_pos_y,
443 p_pic, i_alpha ) )
444 {
445 msg_Err( p_filter, "failed to blend a picture" );
446 }
447 }
448 vlc_mutex_unlock( &p_sys->lock );
449
450 exit:
451 picture_Release( p_src );
452 return p_dst;
453 }
454
455 /*****************************************************************************
456 * Callback to update params on the fly
457 *****************************************************************************/
458 static int BarGraphCallback( vlc_object_t *p_this, char const *psz_var,
459 vlc_value_t oldval, vlc_value_t newval, void *p_data )
460 {
461 VLC_UNUSED(oldval);
462 filter_sys_t *p_sys = (filter_sys_t *)p_data;
463 BarGraph_t *p_BarGraph = &(p_sys->p_BarGraph);
464 char* i_values;
465 char* res = NULL;
466
467 vlc_mutex_lock( &p_sys->lock );
468 if ( !strcmp( psz_var, "audiobargraph_v-x" ) )
469 {
470 p_sys->i_pos_x = newval.i_int;
471 }
472 else if ( !strcmp( psz_var, "audiobargraph_v-y" ) )
473 {
474 p_sys->i_pos_y = newval.i_int;
475 }
476 else if ( !strcmp( psz_var, "audiobargraph_v-position" ) )
477 {
478 p_sys->i_pos = newval.i_int;
479 }
480 else if ( !strcmp( psz_var, "audiobargraph_v-transparency" ) )
481 {
482 p_BarGraph->i_alpha = __MAX( __MIN( newval.i_int, 255 ), 0 );
483 }
484 else if ( !strcmp( psz_var, "audiobargraph_v-i_values" ) )
485 {
486 if( p_BarGraph->p_pic )
487 {
488 picture_Release( p_BarGraph->p_pic );
489 p_BarGraph->p_pic = NULL;
490 }
491 i_values = strdup( newval.psz_string );
492 free(p_BarGraph->i_values);
493 //p_BarGraph->i_values = NULL;
494 //p_BarGraph->nbChannels = 0;
495 // in case many answer are received at the same time, only keep one
496 res = strchr(i_values, '@');
497 if (res)
498 *res = 0;
499 parse_i_values( p_BarGraph, i_values);
500 LoadBarGraph(p_this,p_BarGraph);
501 }
502 else if ( !strcmp( psz_var, "audiobargraph_v-alarm" ) )
503 {
504 if( p_BarGraph->p_pic )
505 {
506 picture_Release( p_BarGraph->p_pic );
507 p_BarGraph->p_pic = NULL;
508 }
509 p_BarGraph->alarm = newval.i_int;
510 LoadBarGraph(p_this,p_BarGraph);
511 }
512 else if ( !strcmp( psz_var, "audiobargraph_v-barWidth" ) )
513 {
514 if( p_BarGraph->p_pic )
515 {
516 picture_Release( p_BarGraph->p_pic );
517 p_BarGraph->p_pic = NULL;
518 }
519 p_BarGraph->barWidth = newval.i_int;
520 LoadBarGraph(p_this,p_BarGraph);
521 }
522 p_sys->b_spu_update = true;
523 vlc_mutex_unlock( &p_sys->lock );
524
525 return VLC_SUCCESS;
526 }
527
528 /*****************************************************************************
529 * LoadImage: creates and returns the bar graph image
530 *****************************************************************************/
531 static picture_t *LoadImage( vlc_object_t *p_this, int nbChannels, int* i_values, int scale, int alarm, int barWidth)
532 {
533 VLC_UNUSED(p_this);
534 picture_t *p_pic;
535 int i,j;
536 int i_width = 0;
537 int i_line;
538 int moinsTrois, moinsCinq, moinsSept, moinsDix, moinsVingt;
539
540 if (nbChannels == 0) {
541 i_width = 20;
542 } else {
543 i_width = 2 * nbChannels * barWidth + 10;
544 }
545
546 moinsTrois = 0.71*scale + 20;
547 moinsCinq = 0.56*scale + 20;
548 moinsSept = 0.45*scale + 20;
549 moinsDix = 0.32*scale + 20;
550 moinsVingt = 0.1*scale + 20;
551
552 p_pic = picture_New(VLC_FOURCC('Y','U','V','A'), i_width+20, scale+30, 1, 1);
553
554 // blacken the whole picture
555 for( i = 0 ; i < p_pic->i_planes ; i++ )
556 {
557 memset( p_pic->p[i].p_pixels, 0x00,
558 p_pic->p[i].i_visible_lines * p_pic->p[i].i_pitch );
559 }
560
561 // side bar
562 for ( i_line = 20; i_line < scale+20; i_line++ ) {
563
564 #define DrawPointsBlack(a,b) {\
565 for (i=a; i<b; i++) {\
566 *(p_pic->p[0].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[0].i_pitch + i ) = 0x00; \
567 *(p_pic->p[1].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[1].i_pitch + i ) = 128; \
568 *(p_pic->p[2].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[2].i_pitch + i ) = 128; \
569 *(p_pic->p[3].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[3].i_pitch + i ) = 0xFF; \
570 }\
571 }
572 #define DrawPointsWhite(a,b) {\
573 for (i=a; i<b; i++) {\
574 *(p_pic->p[0].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[0].i_pitch + i ) = 0xFF;\
575 *(p_pic->p[1].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[1].i_pitch + i ) = 128;\
576 *(p_pic->p[2].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[2].i_pitch + i ) = 128;\
577 *(p_pic->p[3].p_pixels + (scale + 30 - i_line - 1) * p_pic->p[3].i_pitch + i ) = 0xFF; \
578 }\
579 }
580
581 // vertical line
582 DrawPointsBlack(20,22);
583 DrawPointsWhite(22,24);
584
585 // -3dB
586 if (i_line == moinsTrois - 2) {
587 // 3
588 DrawPointsBlack(16,19);
589 }
590 if (i_line == moinsTrois - 1) {
591 // 3
592 DrawPointsBlack(18,19);
593 // limit
594 DrawPointsWhite(24,27);
595 }
596 if (i_line == moinsTrois) {
597 // 3
598 DrawPointsBlack(16,19);
599 // limit
600 DrawPointsBlack(24,27);
601 }
602 if (i_line == moinsTrois + 1) {
603 // 3
604 DrawPointsBlack(18,19);
605 // limit
606 DrawPointsBlack(24,27);
607 }
608 if (i_line == moinsTrois + 2) {
609 // 3
610 DrawPointsBlack(16,19);
611 }
612
613 // -5dB
614 if (i_line == moinsCinq - 2) {
615 // 5
616 DrawPointsBlack(16,19);
617 }
618 if (i_line == moinsCinq - 1) {
619 // 5
620 DrawPointsBlack(18,19);
621 // limit
622 DrawPointsWhite(24,27);
623 }
624 if (i_line == moinsCinq) {
625 // 5
626 DrawPointsBlack(16,19);
627 // limit
628 DrawPointsBlack(24,27);
629 }
630 if (i_line == moinsCinq + 1) {
631 // 5
632 DrawPointsBlack(16,17);
633 // limit
634 DrawPointsBlack(24,27);
635 }
636 if (i_line == moinsCinq + 2) {
637 // 5
638 DrawPointsBlack(16,19);
639 }
640
641 // -7dB
642 if (i_line == moinsSept - 2) {
643 // 7
644 DrawPointsBlack(18,19);
645 }
646 if (i_line == moinsSept - 1) {
647 // 7
648 DrawPointsBlack(18,19);
649 // limit
650 DrawPointsWhite(24,27);
651 }
652 if (i_line == moinsSept) {
653 // 7
654 DrawPointsBlack(18,19);
655 // limit
656 DrawPointsBlack(24,27);
657 }
658 if (i_line == moinsSept + 1) {
659 // 7
660 DrawPointsBlack(18,19);
661 // limit
662 DrawPointsBlack(24,27);
663 }
664 if (i_line == moinsSept + 2) {
665 // 7
666 DrawPointsBlack(16,19);
667 }
668
669
670 // -10dB
671 if (i_line == moinsDix - 2) {
672 // 1
673 DrawPointsBlack(14,15);
674 // 0
675 DrawPointsBlack(16,19);
676 }
677 if (i_line == moinsDix - 1) {
678 // 1
679 DrawPointsBlack(14,15);
680 // 0
681 DrawPointsBlack(16,17);
682 DrawPointsBlack(18,19);
683 // limit
684 DrawPointsWhite(24,27);
685 }
686 if (i_line == moinsDix) {
687 // 1
688 DrawPointsBlack(14,15);
689 // 0
690 DrawPointsBlack(16,17);
691 DrawPointsBlack(18,19);
692 // limit
693 DrawPointsBlack(24,27);
694 }
695 if (i_line == moinsDix + 1) {
696 // 1
697 DrawPointsBlack(14,15);
698 // 0
699 DrawPointsBlack(16,17);
700 DrawPointsBlack(18,19);
701 // limit
702 DrawPointsBlack(24,27);
703 }
704 if (i_line == moinsDix + 2) {
705 // 1
706 DrawPointsBlack(14,15);
707 // 0
708 DrawPointsBlack(16,19);
709 }
710
711 // -20dB
712 if (i_line == moinsVingt - 2) {
713 // 2
714 DrawPointsBlack(12,15);
715 // 0
716 DrawPointsBlack(16,19);
717 }
718 if (i_line == moinsVingt - 1) {
719 // 2
720 DrawPointsBlack(12,13);
721 // 0
722 DrawPointsBlack(16,17);
723 DrawPointsBlack(18,19);
724 // limit
725 DrawPointsWhite(24,27);
726 }
727 if (i_line == moinsVingt) {
728 // 2
729 DrawPointsBlack(12,15);
730 // 0
731 DrawPointsBlack(16,17);
732 DrawPointsBlack(18,19);
733 // limit
734 DrawPointsBlack(24,27);
735 }
736 if (i_line == moinsVingt + 1) {
737 // 2
738 DrawPointsBlack(14,15);
739 // 0
740 DrawPointsBlack(16,17);
741 DrawPointsBlack(18,19);
742 // limit
743 DrawPointsBlack(24,27);
744 }
745 if (i_line == moinsVingt + 2) {
746 // 2
747 DrawPointsBlack(12,15);
748 // 0
749 DrawPointsBlack(16,19);
750 }
751
752
753 }
754
755 // draw the bars and channel indicators
756 for (i=0; i<nbChannels; i++) {
757 for( j = barWidth+20 ; j < 2*barWidth+20; j++)
758 {
759 // channel indicators
760 for ( i_line = 12; i_line < 18; i_line++ ) {
761 // white
762 *(p_pic->p[0].p_pixels +
763 (scale + 30 - i_line - 1) *
764 p_pic->p[0].i_pitch +
765 ( (2*i*barWidth)+j ) ) = 255;
766 *(p_pic->p[1].p_pixels +
767 (scale + 30 - i_line - 1) *
768 p_pic->p[1].i_pitch +
769 ( (2*i*barWidth)+j ) ) = 128;
770 *(p_pic->p[2].p_pixels +
771 (scale + 30 - i_line - 1) *
772 p_pic->p[2].i_pitch +
773 ( (2*i*barWidth)+j ) ) = 128;
774 *(p_pic->p[3].p_pixels +
775 (scale + 30 - i_line - 1) *
776 p_pic->p[3].i_pitch +
777 ( (2*i*barWidth)+j )) = 0xFF;
778 }
779 // bars
780 for( i_line = 20; i_line < i_values[i]+20; i_line++ )
781 {
782 if (i_line < moinsDix) { // green if < -10 dB
783 *(p_pic->p[0].p_pixels +
784 (scale + 30 - i_line - 1) *
785 p_pic->p[0].i_pitch +
786 ( (2*i*barWidth)+j ) ) = 150;
787 *(p_pic->p[1].p_pixels +
788 (scale + 30 - i_line - 1) *
789 p_pic->p[1].i_pitch +
790 ( (2*i*barWidth)+j ) ) = 44;
791 *(p_pic->p[2].p_pixels +
792 (scale + 30 - i_line - 1) *
793 p_pic->p[2].i_pitch +
794 ( (2*i*barWidth)+j ) ) = 21;
795 *(p_pic->p[3].p_pixels +
796 (scale + 30 - i_line - 1) *
797 p_pic->p[3].i_pitch +
798 ( (2*i*barWidth)+j )) = 0xFF;
799 } else if (i_line < moinsTrois) { // yellow if > -10dB and < -3dB
800 *(p_pic->p[0].p_pixels +
801 (scale + 30 - i_line - 1) *
802 p_pic->p[0].i_pitch +
803 ( (2*i*barWidth)+j ) ) = 226;
804 *(p_pic->p[1].p_pixels +
805 (scale + 30 - i_line - 1) *
806 p_pic->p[1].i_pitch +
807 ( (2*i*barWidth)+j ) ) = 1;
808 *(p_pic->p[2].p_pixels +
809 (scale + 30 - i_line - 1) *
810 p_pic->p[2].i_pitch +
811 ( (2*i*barWidth)+j ) ) = 148;
812 *(p_pic->p[3].p_pixels +
813 (scale + 30 - i_line - 1) *
814 p_pic->p[3].i_pitch +
815 ( (2*i*barWidth)+j )) = 0xFF;
816 } else { // red if > -3 dB
817 *(p_pic->p[0].p_pixels +
818 (scale + 30 - i_line - 1) *
819 p_pic->p[0].i_pitch +
820 ( (2*i*barWidth)+j ) ) = 76;
821 *(p_pic->p[1].p_pixels +
822 (scale + 30 - i_line - 1) *
823 p_pic->p[1].i_pitch +
824 ( (2*i*barWidth)+j ) ) = 85;
825 *(p_pic->p[2].p_pixels +
826 (scale + 30 - i_line - 1) *
827 p_pic->p[2].i_pitch +
828 ( (2*i*barWidth)+j ) ) = 0xFF;
829 *(p_pic->p[3].p_pixels +
830 (scale + 30 - i_line - 1) *
831 p_pic->p[3].i_pitch +
832 ( (2*i*barWidth)+j )) = 0xFF;
833 }
834 }
835 }
836 }
837
838
839
840 if (alarm) {// draw the alarm square
841 // bottom
842 for ( i_line = 0; i_line < 10; i_line++ ) {
843 for (i=0; i<i_width+20; i++) {
844 *(p_pic->p[0].p_pixels +
845 (scale + 30 - i_line - 1) *
846 p_pic->p[0].i_pitch + i ) = 76;
847 *(p_pic->p[1].p_pixels +
848 (scale + 30 - i_line - 1) *
849 p_pic->p[1].i_pitch + i ) = 85;
850 *(p_pic->p[2].p_pixels +
851 (scale + 30 - i_line - 1) *
852 p_pic->p[2].i_pitch + i ) = 0xFF;
853 *(p_pic->p[3].p_pixels +
854 (scale + 30 - i_line - 1) *
855 p_pic->p[3].i_pitch + i ) = 0xFF;
856 }
857 }
858 // top
859 for ( i_line = scale+21; i_line < scale+30; i_line++ ) {
860 for (i=0; i<i_width+20; i++) {
861 *(p_pic->p[0].p_pixels +
862 (scale + 30 - i_line - 1) *
863 p_pic->p[0].i_pitch + i ) = 76;
864 *(p_pic->p[1].p_pixels +
865 (scale + 30 - i_line - 1) *
866 p_pic->p[1].i_pitch + i ) = 85;
867 *(p_pic->p[2].p_pixels +
868 (scale + 30 - i_line - 1) *
869 p_pic->p[2].i_pitch + i ) = 0xFF;
870 *(p_pic->p[3].p_pixels +
871 (scale + 30 - i_line - 1) *
872 p_pic->p[3].i_pitch + i ) = 0xFF;
873 }
874 }
875 // sides
876 for ( i_line = 9; i_line < scale+21; i_line++ ) {
877 for (i=0; i<10; i++) {
878 *(p_pic->p[0].p_pixels +
879 (scale + 30 - i_line - 1) *
880 p_pic->p[0].i_pitch + i ) = 76;
881 *(p_pic->p[1].p_pixels +
882 (scale + 30 - i_line - 1) *
883 p_pic->p[1].i_pitch + i ) = 85;
884 *(p_pic->p[2].p_pixels +
885 (scale + 30 - i_line - 1) *
886 p_pic->p[2].i_pitch + i ) = 0xFF;
887 *(p_pic->p[3].p_pixels +
888 (scale + 30 - i_line - 1) *
889 p_pic->p[3].i_pitch + i ) = 0xFF;
890 }
891 for (i=i_width+11; i<i_width+20; i++) {
892 *(p_pic->p[0].p_pixels +
893 (scale + 30 - i_line - 1) *
894 p_pic->p[0].i_pitch + i ) = 76;
895 *(p_pic->p[1].p_pixels +
896 (scale + 30 - i_line - 1) *
897 p_pic->p[1].i_pitch + i ) = 85;
898 *(p_pic->p[2].p_pixels +
899 (scale + 30 - i_line - 1) *
900 p_pic->p[2].i_pitch + i ) = 0xFF;
901 *(p_pic->p[3].p_pixels +
902 (scale + 30 - i_line - 1) *
903 p_pic->p[3].i_pitch + i ) = 0xFF;
904 }
905 }
906 }
907
908
909 return p_pic;
910 }
911
912 /*****************************************************************************
913 * LoadBarGraph: loads the BarGraph images into memory
914 *****************************************************************************/
915 static void LoadBarGraph( vlc_object_t *p_this, BarGraph_t *p_BarGraph )
916 {
917
918 p_BarGraph->p_pic = LoadImage( p_this, p_BarGraph->nbChannels, p_BarGraph->i_values, p_BarGraph->scale, p_BarGraph->alarm, p_BarGraph->barWidth);
919 if( !p_BarGraph->p_pic )
920 {
921 msg_Warn( p_this, "error while creating picture" );
922 }
923
924 }
925
926 /*****************************************************************************
927 * parse_i_values : parse i_values parameter and store the corresponding values
928 *****************************************************************************/
929 void parse_i_values( BarGraph_t *p_BarGraph, char *i_values)
930 {
931 char* res = NULL;
932 char delim[] = ":";
933 char* tok;
934
935 p_BarGraph->nbChannels = 0;
936 p_BarGraph->i_values = NULL;
937 res = strtok_r(i_values, delim, &tok);
938 while (res != NULL) {
939 p_BarGraph->nbChannels++;
940 p_BarGraph->i_values = xrealloc(p_BarGraph->i_values,
941 p_BarGraph->nbChannels*sizeof(int));
942 p_BarGraph->i_values[p_BarGraph->nbChannels-1] = __MAX( __MIN( atof(res)*p_BarGraph->scale, p_BarGraph->scale ), 0 );
943 res = strtok_r(NULL, delim, &tok);
944 }
945
946 }