git.sesse.net Git - vlc/blob - modules/visualization/visual/effects.c

   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                 i_value_r = 200 * M_PI_2;
 863
 864         float *i_value;
 865
 866         if( !p_effect->p_data )
 867         {
 868                 /* Allocate memory to save hand positions */
 869                 p_effect->p_data = (void *)malloc( 2 * sizeof(float) );
 870                 i_value = p_effect->p_data;
 871                 i_value[0] = i_value_l;
 872                 i_value[1] = i_value_r;
 873         }
 874         else
 875         {
 876                 /* Make the hands go down slowly if the current values are slower
 877                 than the previous */
 878                 i_value = p_effect->p_data;
 879
 880                 if ( i_value_l > i_value[0] - 6 )
 881                         i_value[0] = i_value_l;
 882                 else
 883                         i_value[0] = i_value[0] - 6;
 884
 885                 if ( i_value_r > i_value[1] - 6 )
 886                         i_value[1] = i_value_r;
 887                 else
 888                         i_value[1] = i_value[1] - 6;
 889         }
 890
 891         int x, y, k;
 892         float teta;
 893         float teta_grad;
 894
 895         for ( j = 0; j < 2; j++ )
 896         {
 897                 /* Draw the two scales */
 898                 k = 0;
 899                 teta_grad = GRAD_ANGLE_MIN;
 900                 for ( teta = -M_PI_4; teta <= M_PI_4; teta = teta + 0.003 )
 901                 {
 902                         for ( i = 140; i <= 150; i++ )
 903                         {
 904                                 y = i * cos(teta) + 20;
 905                                 x = i * sin(teta) + 150 + 240 * j;
 906                                 /* Compute the last color for the gradation */
 907                                 if (teta >= teta_grad + GRAD_INCR && teta_grad <= GRAD_ANGLE_MAX)
 908                                 {
 909                                         teta_grad = teta_grad + GRAD_INCR;
 910                                         k = k + 5;
 911                                 }
 912                                 *(p_picture->p[0].p_pixels +
 913                                  (p_picture->p[0].i_lines - y - 1 ) * p_picture->p[0].i_pitch
 914                                  + x ) = 0x45;
 915                                 *(p_picture->p[1].p_pixels +
 916                                  (p_picture->p[1].i_lines - y / 2 - 1 ) * p_picture->p[1].i_pitch
 917                                  + x / 2 ) = 0x0;
 918                                 *(p_picture->p[2].p_pixels +
 919                                  (p_picture->p[2].i_lines - y / 2 - 1 ) * p_picture->p[2].i_pitch
 920                                  + x / 2 ) = 0x4D + k;
 921                         }
 922                 }
 923
 924                 /* Draw the two hands */
 925                 teta = (float)i_value[j] / 200 - M_PI_4;
 926                 for ( i = 0; i <= 150; i++ )
 927                 {
 928                         y = i * cos(teta) + 20;
 929                         x = i * sin(teta) + 150 + 240 * j;
 930                         *(p_picture->p[0].p_pixels +
 931                          (p_picture->p[0].i_lines - y - 1 ) * p_picture->p[0].i_pitch
 932                          + x ) = 0xAD;
 933                         *(p_picture->p[1].p_pixels +
 934                          (p_picture->p[1].i_lines - y / 2 - 1 ) * p_picture->p[1].i_pitch
 935                          + x / 2 ) = 0xFC;
 936                         *(p_picture->p[2].p_pixels +
 937                          (p_picture->p[2].i_lines - y / 2 - 1 ) * p_picture->p[2].i_pitch
 938                          + x / 2 ) = 0xAC;
 939                 }
 940
 941                 /* Draw the hand bases */
 942                 for ( teta = -M_PI_2; teta <= M_PI_2 + 0.01; teta = teta + 0.003 )
 943                 {
 944                         for ( i = 0; i < 10; i++ )
 945                         {
 946                                 y = i * cos(teta) + 20;
 947                                 x = i * sin(teta) + 150 + 240 * j;
 948                                 *(p_picture->p[0].p_pixels +
 949                                  (p_picture->p[0].i_lines - y - 1 ) * p_picture->p[0].i_pitch
 950                                  + x ) = 0xFF;
 951                                 *(p_picture->p[1].p_pixels +
 952                                  (p_picture->p[1].i_lines - y / 2 - 1 ) * p_picture->p[1].i_pitch
 953                                  + x / 2 ) = 0x80;
 954                                 *(p_picture->p[2].p_pixels +
 955                                  (p_picture->p[2].i_lines - y / 2 - 1 ) * p_picture->p[2].i_pitch
 956                                  + x / 2 ) = 0x80;
 957                         }
 958                 }
 959
 960         }
 961
 962         return 0;
 963 }