effects.c

Revision 00cc9dcaaef99e5238ee4f5d8b4bdc2c5689d87c, 34.0 kB (checked in by Rémi Duraffort <ivoire@videolan.org>, 4 months ago)
Remove stupid test and error message.
Property mode set to `100644`

Line
1	/*****************************************************************************
2	* effects.c : Effects for the visualization system
3	*****************************************************************************
4	* Copyright (C) 2002 the VideoLAN team
5	* $Id$
6	*
7	* Authors: Clément Stenac <zorglub@via.ecp.fr>
8	* Adrien Maglo <magsoft@videolan.org>
9	*
10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 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 General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23	*****************************************************************************/
24
25	/*****************************************************************************
26	* Preamble
27	*****************************************************************************/
28	#ifdef HAVE_CONFIG_H
29	# include "config.h"
30	#endif
31
32	#include <vlc_common.h>
33	#include <vlc_vout.h>
34	#include <vlc_aout.h>
35
36	#include "visual.h"
37	#include <math.h>
38
39	#include "fft.h"
40
41	#define PEAK_SPEED 1
42
43	#define GRAD_ANGLE_MIN 0.2
44	#define GRAD_ANGLE_MAX 0.5
45	#define GRAD_INCR 0.01
46
47	/*****************************************************************************
48	* dummy_Run
49	*****************************************************************************/
50	int dummy_Run( visual_effect_t * p_effect, aout_instance_t *p_aout,
51	aout_buffer_t * p_buffer , picture_t * p_picture)
52	{
53	VLC_UNUSED(p_effect); VLC_UNUSED(p_aout); VLC_UNUSED(p_buffer);
54	VLC_UNUSED(p_picture);
55	return 0;
56	}
57
58	/*****************************************************************************
59	* spectrum_Run: spectrum analyser
60	*****************************************************************************/
61	int spectrum_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
62	aout_buffer_t * p_buffer , picture_t * p_picture)
63	{
64	float p_output[FFT_BUFFER_SIZE]; / Raw FFT Result /
65	int height; /* Bar heights /
66	int peaks; /* Peaks /
67	int i_nb_bands; / number of bands /
68	int i_band_width; / width of bands /
69	int i_separ; / Should we let blanks ? /
70	int i_amp; / Vertical amplification /
71	int i_peak; / Should we draw peaks ? /
72
73	/ Horizontal scale for 20-band equalizer /
74	const int xscale1[]={0,1,2,3,4,5,6,7,8,11,15,20,27,
75	36,47,62,82,107,141,184,255};
76
77	/ Horizontal scale for 80-band equalizer /
78	const int xscale2[] =
79	{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
80	19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,
81	35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
82	52,53,54,55,56,57,58,59,61,63,67,72,77,82,87,93,99,105,
83	110,115,121,130,141,152,163,174,185,200,255};
84	const int *xscale;
85	const double y_scale = 3.60673760222; / (log 256) /
86
87	fft_state p_state; /* internal FFT data /
88
89	int i , j , y , k;
90	int i_line;
91	int16_t p_dest[FFT_BUFFER_SIZE]; / Adapted FFT result /
92	int16_t p_buffer1[FFT_BUFFER_SIZE]; / Buffer on which we perform*
93	the FFT (first channel) /*
94
95	float p_buffl = /* Original buffer /
96	(float*)p_buffer->p_buffer;
97
98	int16_t p_buffs; /* int16_t converted buffer /
99	int16_t p_s16_buff = NULL; /* int16_t converted buffer /
100
101	p_s16_buff = (int16_t*)malloc(
102	p_buffer->i_nb_samples * p_effect->i_nb_chans * sizeof(int16_t));
103
104	if( !p_s16_buff )
105	{
106	msg_Err(p_aout,"out of memory");
107	return -1;
108	}
109
110	p_buffs = p_s16_buff;
111	i_nb_bands = config_GetInt ( p_aout, "visual-nbbands" );
112	i_separ = config_GetInt( p_aout, "visual-separ" );
113	i_amp = config_GetInt ( p_aout, "visual-amp" );
114	i_peak = config_GetInt ( p_aout, "visual-peaks" );
115
116	if( i_nb_bands == 20)
117	{
118	xscale = xscale1;
119	}
120	else
121	{
122	i_nb_bands = 80;
123	xscale = xscale2;
124	}
125
126	if( !p_effect->p_data )
127	{
128	p_effect->p_data=(void )malloc(i_nb_bands sizeof(int) );
129	if( !p_effect->p_data)
130	{
131	msg_Err(p_aout,"out of memory");
132	return -1;
133	}
134	peaks = (int *)p_effect->p_data;
135	for( i = 0 ; i < i_nb_bands ; i++)
136	{
137	peaks[i] = 0;
138	}
139
140	}
141	else
142	{
143	peaks =(int *)p_effect->p_data;
144	}
145
146
147	height = (int )malloc( i_nb_bands sizeof(int) );
148	if( !height)
149	{
150	msg_Err(p_aout,"out of memory");
151	return -1;
152	}
153	/ Convert the buffer to int16_t /
154	/ Pasted from float32tos16.c /
155	for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
156	{
157	union { float f; int32_t i; } u;
158	u.f = *p_buffl + 384.0;
159	if(u.i > 0x43c07fff ) * p_buffs = 32767;
160	else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
161	else *p_buffs = u.i - 0x43c00000;
162
163	p_buffl++ ; p_buffs++ ;
164	}
165	p_state = visual_fft_init();
166	if( !p_state)
167	{
168	msg_Err(p_aout,"unable to initialize FFT transform");
169	return -1;
170	}
171	p_buffs = p_s16_buff;
172	for ( i = 0 ; i < FFT_BUFFER_SIZE ; i++)
173	{
174	p_output[i] = 0;
175	p_buffer1[i] = *p_buffs;
176	p_buffs = p_buffs + p_effect->i_nb_chans;
177	}
178	fft_perform( p_buffer1, p_output, p_state);
179	for(i= 0; i< FFT_BUFFER_SIZE ; i++ )
180	p_dest[i] = ( (int) sqrt( p_output [ i ] ) ) >> 8;
181
182	for ( i = 0 ; i< i_nb_bands ;i++)
183	{
184	/ We search the maximum on one scale /
185	for( j = xscale[i] , y=0 ; j< xscale[ i + 1 ] ; j++ )
186	{
187	if ( p_dest[j] > y )
188	y = p_dest[j];
189	}
190	/ Calculate the height of the bar /
191	y >>=7;/ remove some noise /
192	if( y != 0)
193	{
194	height[i] = (int)log(y)* y_scale;
195	if(height[i] > 150)
196	height[i] = 150;
197	}
198	else
199	{
200	height[i] = 0 ;
201	}
202
203	/ Draw the bar now /
204	i_band_width = floor( p_effect->i_width / i_nb_bands) ;
205
206	if( i_amp * height[i] > peaks[i])
207	{
208	peaks[i] = i_amp * height[i];
209	}
210	else if (peaks[i] > 0 )
211	{
212	peaks[i] -= PEAK_SPEED;
213	if( peaks[i] < i_amp * height[i] )
214	{
215	peaks[i] = i_amp * height[i];
216	}
217	if( peaks[i] < 0 )
218	{
219	peaks[i] = 0;
220	}
221	}
222
223	if( peaks[i] > 0 && i_peak )
224	{
225	if( peaks[i] >= p_effect->i_height )
226	peaks[i] = p_effect->i_height - 2;
227	i_line = peaks[i];
228
229	for( j = 0 ; j< i_band_width - i_separ; j++)
230	{
231	for( k = 0 ; k< 3 ; k ++)
232	{
233	/ Draw the peak /
234	*(p_picture->p[0].p_pixels +
235	(p_picture->p[0].i_lines - i_line -1 -k ) *
236	p_picture->p[0].i_pitch + (i_band_width*i +j) )
237	= 0xff;
238
239	*(p_picture->p[1].p_pixels +
240	(p_picture->p[1].i_lines - i_line /2 -1 -k/2 ) *
241	p_picture->p[1].i_pitch +
242	( ( i_band_width * i + j ) /2 ) )
243	= 0x00;
244
245	if( 0x04 * (i_line + k ) - 0x0f > 0 )
246	{
247	if ( 0x04 * (i_line + k ) -0x0f < 0xff)
248	*(p_picture->p[2].p_pixels +
249	(p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
250	p_picture->p[2].i_pitch +
251	( ( i_band_width * i + j ) /2 ) )
252	= ( 0x04 * ( i_line + k ) ) -0x0f ;
253	else
254	*(p_picture->p[2].p_pixels +
255	(p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
256	p_picture->p[2].i_pitch +
257	( ( i_band_width * i + j ) /2 ) )
258	= 0xff;
259	}
260	else
261	{
262	*(p_picture->p[2].p_pixels +
263	(p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
264	p_picture->p[2].i_pitch +
265	( ( i_band_width * i + j ) /2 ) )
266	= 0x10 ;
267	}
268	}
269	}
270	}
271
272	if(height[i] * i_amp > p_effect->i_height)
273	height[i] = floor(p_effect->i_height / i_amp );
274
275	for(i_line = 0 ; i_line < i_amp * height[i]; i_line ++ )
276	{
277	for( j = 0 ; j< i_band_width - i_separ ; j++)
278	{
279	*(p_picture->p[0].p_pixels +
280	(p_picture->p[0].i_lines - i_line -1) *
281	p_picture->p[0].i_pitch + (i_band_width*i +j) ) = 0xff;
282
283	*(p_picture->p[1].p_pixels +
284	(p_picture->p[1].i_lines - i_line /2 -1) *
285	p_picture->p[1].i_pitch +
286	( ( i_band_width * i + j ) /2 ) ) = 0x00;
287
288	if( 0x04 * i_line - 0x0f > 0 )
289	{
290	if( 0x04 * i_line - 0x0f < 0xff )
291	*(p_picture->p[2].p_pixels +
292	(p_picture->p[2].i_lines - i_line /2 - 1) *
293	p_picture->p[2].i_pitch +
294	( ( i_band_width * i + j ) /2 ) ) =
295	( 0x04 * i_line) -0x0f ;
296	else
297	*(p_picture->p[2].p_pixels +
298	(p_picture->p[2].i_lines - i_line /2 - 1) *
299	p_picture->p[2].i_pitch +
300	( ( i_band_width * i + j ) /2 ) ) =
301	0xff;
302	}
303	else
304	{
305	*(p_picture->p[2].p_pixels +
306	(p_picture->p[2].i_lines - i_line /2 - 1) *
307	p_picture->p[2].i_pitch +
308	( ( i_band_width * i + j ) /2 ) ) =
309	0x10 ;
310	}
311	}
312	}
313	}
314
315	fft_close( p_state );
316
317	free( p_s16_buff );
318	free( height );
319
320	return 0;
321	}
322
323
324	/*****************************************************************************
325	* spectrometer_Run: derivative spectrum analysis
326	*****************************************************************************/
327	int spectrometer_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
328	aout_buffer_t * p_buffer , picture_t * p_picture)
329	{
330	#define Y(R,G,B) ((uint8_t)( (R * .299) + (G * .587) + (B * .114) ))
331	#define U(R,G,B) ((uint8_t)( (R * -.169) + (G * -.332) + (B * .500) + 128 ))
332	#define V(R,G,B) ((uint8_t)( (R * .500) + (G * -.419) + (B * -.0813) + 128 ))
333	float p_output[FFT_BUFFER_SIZE]; / Raw FFT Result /
334	int height; /* Bar heights /
335	int peaks; /* Peaks /
336	int i_nb_bands; / number of bands /
337	int i_band_width; / width of bands /
338	int i_separ; / Should we let blanks ? /
339	int i_amp; / Vertical amplification /
340	int i_peak; / Should we draw peaks ? /
341
342	int i_original; / original spectrum graphic routine /
343	int i_rad; / radius of circle of base of bands /
344	int i_sections; / sections of spectranalysis /
345	int i_extra_width; / extra width on peak /
346	int i_peak_height; / height of peak /
347	int c; / sentinel container of total spectral sections /
348	double band_sep_angle; / angled separation between beginning of each band /
349	double section_sep_angle;/ " " ' " ' " " spectrum section /
350	int max_band_length; / try not to go out of screen /
351	int i_show_base; / Should we draw base of circle ? /
352	int i_show_bands; / Should we draw bands ? /
353	//int i_invert_bands; / do the bands point inward ? /
354	double a; / for various misc angle situations in radians /
355	int x,y,xx,yy; / various misc x/y /
356	char color1; / V slide on a YUV color cube /
357	//char color2; / U slide.. ? color2 fade color ? /
358
359	/ Horizontal scale for 20-band equalizer /
360	const int xscale1[]={0,1,2,3,4,5,6,7,8,11,15,20,27,
361	36,47,62,82,107,141,184,255};
362
363	/ Horizontal scale for 80-band equalizer /
364	const int xscale2[] =
365	{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
366	19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,
367	35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
368	52,53,54,55,56,57,58,59,61,63,67,72,77,82,87,93,99,105,
369	110,115,121,130,141,152,163,174,185,200,255};
370	const int *xscale;
371	const double y_scale = 3.60673760222; / (log 256) /
372
373	fft_state p_state; /* internal FFT data /
374
375	int i , j , k;
376	int i_line;
377	int16_t p_dest[FFT_BUFFER_SIZE]; / Adapted FFT result /
378	int16_t p_buffer1[FFT_BUFFER_SIZE]; / Buffer on which we perform*
379	the FFT (first channel) /*
380	float p_buffl = /* Original buffer /
381	(float*)p_buffer->p_buffer;
382
383	int16_t p_buffs; /* int16_t converted buffer /
384	int16_t p_s16_buff = NULL; /* int16_t converted buffer /
385
386	i_line = 0;
387
388	p_s16_buff = (int16_t*)malloc(
389	p_buffer->i_nb_samples * p_effect->i_nb_chans * sizeof(int16_t));
390
391	if( !p_s16_buff )
392	return -1;
393
394	p_buffs = p_s16_buff;
395	i_original = config_GetInt ( p_aout, "spect-show-original" );
396	i_nb_bands = config_GetInt ( p_aout, "spect-nbbands" );
397	i_separ = config_GetInt ( p_aout, "spect-separ" );
398	i_amp = config_GetInt ( p_aout, "spect-amp" );
399	i_peak = config_GetInt ( p_aout, "spect-show-peaks" );
400	i_show_base = config_GetInt ( p_aout, "spect-show-base" );
401	i_show_bands = config_GetInt ( p_aout, "spect-show-bands" );
402	i_rad = config_GetInt ( p_aout, "spect-radius" );
403	i_sections = config_GetInt ( p_aout, "spect-sections" );
404	i_extra_width = config_GetInt ( p_aout, "spect-peak-width" );
405	i_peak_height = config_GetInt ( p_aout, "spect-peak-height" );
406	color1 = config_GetInt ( p_aout, "spect-color" );
407
408	if( i_nb_bands == 20)
409	{
410	xscale = xscale1;
411	}
412	else
413	{
414	if( i_nb_bands > 80 )
415	i_nb_bands = 80;
416	xscale = xscale2;
417	}
418
419	if( !p_effect->p_data )
420	{
421	p_effect->p_data=(void )malloc( i_nb_bands sizeof(int) );
422	if( !p_effect->p_data )
423	{
424	free( p_s16_buff );
425	return -1;
426	}
427	peaks = (int *)p_effect->p_data;
428	for( i = 0 ; i < i_nb_bands ; i++ )
429	{
430	peaks[i] = 0;
431	}
432	}
433	else
434	{
435	peaks =(int *)p_effect->p_data;
436	}
437
438	height = (int )malloc( i_nb_bands sizeof(int) );
439	if( !height)
440	{
441	free( p_effect->p_data );
442	free( p_s16_buff );
443	return -1;
444	}
445
446	/ Convert the buffer to int16_t /
447	/ Pasted from float32tos16.c /
448	for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
449	{
450	union { float f; int32_t i; } u;
451	u.f = *p_buffl + 384.0;
452	if(u.i > 0x43c07fff ) * p_buffs = 32767;
453	else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
454	else *p_buffs = u.i - 0x43c00000;
455
456	p_buffl++ ; p_buffs++ ;
457	}
458	p_state = visual_fft_init();
459	if( !p_state)
460	{
461	msg_Err(p_aout,"unable to initialize FFT transform");
462	free( height );
463	free( p_effect->p_data );
464	free( p_s16_buff );
465	return -1;
466	}
467	p_buffs = p_s16_buff;
468	for ( i = 0 ; i < FFT_BUFFER_SIZE ; i++)
469	{
470	p_output[i] = 0;
471	p_buffer1[i] = *p_buffs;
472	p_buffs = p_buffs + p_effect->i_nb_chans;
473	}
474	fft_perform( p_buffer1, p_output, p_state);
475	for(i= 0; i< FFT_BUFFER_SIZE ; i++ )
476	p_dest[i] = ( (int) sqrt( p_output [ i ] ) ) >> 8;
477
478	i_nb_bands *= i_sections;
479
480	for ( i = 0 ; i< i_nb_bands/i_sections ;i++)
481	{
482	/ We search the maximum on one scale /
483	for( j = xscale[i] , y=0 ; j< xscale[ i + 1 ] ; j++ )
484	{
485	if ( p_dest[j] > y )
486	y = p_dest[j];
487	}
488	/ Calculate the height of the bar /
489	y >>=7;/ remove some noise /
490	if( y != 0)
491	{
492	height[i] = (int)log(y)* y_scale;
493	if(height[i] > 150)
494	height[i] = 150;
495	}
496	else
497	{
498	height[i] = 0 ;
499	}
500
501	/ Draw the bar now /
502	i_band_width = floor( p_effect->i_width / (i_nb_bands/i_sections)) ;
503
504	if( i_amp * height[i] > peaks[i])
505	{
506	peaks[i] = i_amp * height[i];
507	}
508	else if (peaks[i] > 0 )
509	{
510	peaks[i] -= PEAK_SPEED;
511	if( peaks[i] < i_amp * height[i] )
512	{
513	peaks[i] = i_amp * height[i];
514	}
515	if( peaks[i] < 0 )
516	{
517	peaks[i] = 0;
518	}
519	}
520
521	if( i_original != 0 )
522	{
523	if( peaks[i] > 0 && i_peak )
524	{
525	if( peaks[i] >= p_effect->i_height )
526	peaks[i] = p_effect->i_height - 2;
527	i_line = peaks[i];
528
529	for( j = 0 ; j< i_band_width - i_separ; j++)
530	{
531	for( k = 0 ; k< 3 ; k ++)
532	{
533	// Draw the peak*
534	*(p_picture->p[0].p_pixels +
535	(p_picture->p[0].i_lines - i_line -1 -k ) *
536	p_picture->p[0].i_pitch + (i_band_width*i +j) )
537	= 0xff;
538
539	*(p_picture->p[1].p_pixels +
540	(p_picture->p[1].i_lines - i_line /2 -1 -k/2 ) *
541	p_picture->p[1].i_pitch +
542	( ( i_band_width * i + j ) /2 ) )
543	= 0x00;
544
545	if( 0x04 * (i_line + k ) - 0x0f > 0 )
546	{
547	if ( 0x04 * (i_line + k ) -0x0f < 0xff)
548	*(p_picture->p[2].p_pixels +
549	(p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
550	p_picture->p[2].i_pitch +
551	( ( i_band_width * i + j ) /2 ) )
552	= ( 0x04 * ( i_line + k ) ) -0x0f ;
553	else
554	*(p_picture->p[2].p_pixels +
555	(p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
556	p_picture->p[2].i_pitch +
557	( ( i_band_width * i + j ) /2 ) )
558	= 0xff;
559	}
560	else
561	{
562	*(p_picture->p[2].p_pixels +
563	(p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
564	p_picture->p[2].i_pitch +
565	( ( i_band_width * i + j ) /2 ) )
566	= 0x10 ;
567	}
568	}
569	}
570	}
571	if(height[i] * i_amp > p_effect->i_height)
572	height[i] = floor(p_effect->i_height / i_amp );
573
574	for(i_line = 0 ; i_line < i_amp * height[i]; i_line ++ )
575	{
576	for( j = 0 ; j< i_band_width - i_separ ; j++)
577	{
578	*(p_picture->p[0].p_pixels +
579	(p_picture->p[0].i_lines - i_line -1) *
580	p_picture->p[0].i_pitch + (i_band_width*i +j) ) = 0xff;
581
582	*(p_picture->p[1].p_pixels +
583	(p_picture->p[1].i_lines - i_line /2 -1) *
584	p_picture->p[1].i_pitch +
585	( ( i_band_width * i + j ) /2 ) ) = 0x00;
586
587	if( 0x04 * i_line - 0x0f > 0 )
588	{
589	if( 0x04 * i_line - 0x0f < 0xff )
590	*(p_picture->p[2].p_pixels +
591	(p_picture->p[2].i_lines - i_line /2 - 1) *
592	p_picture->p[2].i_pitch +
593	( ( i_band_width * i + j ) /2 ) ) =
594	( 0x04 * i_line) -0x0f ;
595	else
596	*(p_picture->p[2].p_pixels +
597	(p_picture->p[2].i_lines - i_line /2 - 1) *
598	p_picture->p[2].i_pitch +
599	( ( i_band_width * i + j ) /2 ) ) =
600	0xff;
601	}
602	else
603	{
604	*(p_picture->p[2].p_pixels +
605	(p_picture->p[2].i_lines - i_line /2 - 1) *
606	p_picture->p[2].i_pitch +
607	( ( i_band_width * i + j ) /2 ) ) =
608	0x10 ;
609	}
610	}
611	}
612	}
613	}
614
615	band_sep_angle = 360.0 / i_nb_bands;
616	section_sep_angle = 360.0 / i_sections;
617	if( i_peak_height < 1 )
618	i_peak_height = 1;
619	max_band_length = p_picture->p[0].i_lines / 2 - ( i_rad + i_peak_height + 1 );
620
621	i_band_width = floor( 360 / i_nb_bands - i_separ );
622	if( i_band_width < 1 )
623	i_band_width = 1;
624
625	for( c = 0 ; c < i_sections ; c++ )
626	for( i = 0 ; i < (i_nb_bands / i_sections) ; i++ )
627	{
628	/ DO A PEAK /
629	if( peaks[i] > 0 && i_peak )
630	{
631	if( peaks[i] >= p_effect->i_height )
632	peaks[i] = p_effect->i_height - 2;
633	i_line = peaks[i];
634
635	/ circular line pattern(so color blend is more visible) /
636	for( j = 0 ; j < i_peak_height ; j++ )
637	{
638	x = p_picture->p[0].i_pitch / 2;
639	y = p_picture->p[0].i_lines / 2;
640	xx = x;
641	yy = y;
642	for( k = 0 ; k < (i_band_width + i_extra_width) ; k++ )
643	{
644	x = xx;
645	y = yy;
646	a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) + k )
647	* 3.141592 / 180.0;
648	x += (double)( cos(a) * (double)( i_line + j + i_rad ) );
649	y += (double)( -sin(a) * (double)( i_line + j + i_rad ) );
650
651	(p_picture->p[0].p_pixels + x + y p_picture->p[0].i_pitch
652	) = 255;/ Y(R,G,B); /
653
654	x /= 2;
655	y /= 2;
656
657	(p_picture->p[1].p_pixels + x + y p_picture->p[1].i_pitch
658	) = 0;/ U(R,G,B); /
659
660	if( 0x04 * (i_line + k ) - 0x0f > 0 )
661	{
662	if ( 0x04 * (i_line + k ) -0x0f < 0xff)
663	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
664	) = ( 0x04 * ( i_line + k ) ) -(color1-1);/ -V(R,G,B); /
665	else
666	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
667	) = 255;/ V(R,G,B); /
668	}
669	else
670	{
671	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
672	) = color1;/ V(R,G,B); /
673	}
674	}
675	}
676	}
677
678	if( (height[i] * i_amp) > p_effect->i_height )
679	height[i] = floor( p_effect->i_height / i_amp );
680
681	/ DO BASE OF BAND (mostly makes a circle) /
682	if( i_show_base != 0 )
683	{
684	x = p_picture->p[0].i_pitch / 2;
685	y = p_picture->p[0].i_lines / 2;
686
687	a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) )
688	* 3.141592 / 180.0;
689	x += (double)( cos(a) * (double)i_rad );/ newb-forceful casting /
690	y += (double)( -sin(a) * (double)i_rad );
691
692	(p_picture->p[0].p_pixels + x + y p_picture->p[0].i_pitch
693	) = 255;/ Y(R,G,B); /
694
695	x /= 2;
696	y /= 2;
697
698	(p_picture->p[1].p_pixels + x + y p_picture->p[1].i_pitch
699	) = 0;/ U(R,G,B); /
700
701	if( 0x04 * i_line - 0x0f > 0 )
702	{
703	if( 0x04 * i_line -0x0f < 0xff)
704	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
705	) = ( 0x04 * i_line) -(color1-1);/ -V(R,G,B); /
706	else
707	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
708	) = 255;/ V(R,G,B); /
709	}
710	else
711	{
712	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
713	) = color1;/ V(R,G,B); /
714	}
715	}
716
717	/ DO A BAND /
718	if( i_show_bands != 0 )
719	for( j = 0 ; j < i_band_width ; j++ )
720	{
721	x = p_picture->p[0].i_pitch / 2;
722	y = p_picture->p[0].i_lines / 2;
723	xx = x;
724	yy = y;
725	a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) + j )
726	* 3.141592/180.0;
727
728	for( k = (i_rad+1) ; k < max_band_length ; k++ )
729	{
730	if( (k-i_rad) > height[i] )
731	break;/ uhh.. /
732
733	x = xx;
734	y = yy;
735	x += (double)( cos(a) * (double)k );/ newbed! /
736	y += (double)( -sin(a) * (double)k );
737
738	(p_picture->p[0].p_pixels + x + y p_picture->p[0].i_pitch
739	) = 255;
740
741	x /= 2;
742	y /= 2;
743
744	(p_picture->p[1].p_pixels + x + y p_picture->p[1].i_pitch
745	) = 0;
746
747	if( 0x04 * i_line - 0x0f > 0 )
748	{
749	if ( 0x04 * i_line -0x0f < 0xff)
750	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
751	) = ( 0x04 * i_line) -(color1-1);
752	else
753	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
754	) = 255;
755	}
756	else
757	{
758	(p_picture->p[2].p_pixels + x + y p_picture->p[2].i_pitch
759	) = color1;
760	}
761	}
762	}
763	}
764
765	fft_close( p_state );
766
767	free( p_s16_buff );
768	free( height );
769
770	return 0;
771	}
772
773
774	/*****************************************************************************
775	* scope_Run: scope effect
776	*****************************************************************************/
777	int scope_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
778	aout_buffer_t * p_buffer , picture_t * p_picture)
779	{
780	VLC_UNUSED(p_aout);
781	int i_index;
782	float *p_sample ;
783	uint8_t *ppp_area[2][3];
784
785
786	for( i_index = 0 ; i_index < 2 ; i_index++ )
787	{
788	int j;
789	for( j = 0 ; j < 3 ; j++ )
790	{
791	ppp_area[i_index][j] =
792	p_picture->p[j].p_pixels + i_index * p_picture->p[j].i_lines
793	/ 2 * p_picture->p[j].i_pitch;
794	}
795	}
796
797	for( i_index = 0, p_sample = (float *)p_buffer->p_buffer;
798	i_index < p_effect->i_width;
799	i_index++ )
800	{
801	uint8_t i_value;
802
803	/ Left channel /
804	i_value = (p_sample++ +1) 127;
805	*(ppp_area[0][0]
806	+ p_picture->p[0].i_pitch * i_index / p_effect->i_width
807	+ p_picture->p[0].i_lines * i_value / 512
808	* p_picture->p[0].i_pitch) = 0xbf;
809	*(ppp_area[0][1]
810	+ p_picture->p[1].i_pitch * i_index / p_effect->i_width
811	+ p_picture->p[1].i_lines * i_value / 512
812	* p_picture->p[1].i_pitch) = 0xff;
813
814
815	/ Right channel /
816	i_value = ( p_sample++ +1 ) 127;
817	*(ppp_area[1][0]
818	+ p_picture->p[0].i_pitch * i_index / p_effect->i_width
819	+ p_picture->p[0].i_lines * i_value / 512
820	* p_picture->p[0].i_pitch) = 0x9f;
821	*(ppp_area[1][2]
822	+ p_picture->p[2].i_pitch * i_index / p_effect->i_width
823	+ p_picture->p[2].i_lines * i_value / 512
824	* p_picture->p[2].i_pitch) = 0xdd;
825	}
826	return 0;
827	}
828
829
830	/*****************************************************************************
831	* vuMeter_Run: vu meter effect
832	*****************************************************************************/
833	int vuMeter_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
834	aout_buffer_t * p_buffer , picture_t * p_picture)
835	{
836	VLC_UNUSED(p_aout);
837	int i, j;
838	float p_sample = (float* *)p_buffer->p_buffer;
839	float i_value_l = 0;
840	float i_value_r = 0;
841	float ch;
842
843	/ Compute the peack values /
844	for ( i = 0 ; i < 1024; i++ )
845	{
846	ch = (p_sample++) 256;
847	if (ch > i_value_l)
848	i_value_l = ch;
849
850	ch = (p_sample++) 256;
851	if (ch > i_value_r)
852	i_value_r = ch;
853	}
854
855	i_value_l = abs(i_value_l);
856	i_value_r = abs(i_value_r);
857
858	/ Stay under maximum value admited /
859	if ( i_value_l > 200 * M_PI_2 )
860	i_value_l = 200 * M_PI_2;
861	if ( i_value_r > 200 * M_PI_2 )
862