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  *
   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 #include <stdlib.h>                                      /* malloc(), free() */
  28 #include <vlc/vlc.h>
  29 #include <vlc/vout.h>
  30 #include "audio_output.h"
  31 #include "aout_internal.h"
  32
  33 #include "visual.h"
  34 #include <math.h>
  35
  36 #include "fft.h"
  37
  38 #define PEAK_SPEED 1
  39
  40 /*****************************************************************************
  41  * dummy_Run
  42  *****************************************************************************/
  43 int dummy_Run( visual_effect_t * p_effect, aout_instance_t *p_aout,
  44                aout_buffer_t * p_buffer , picture_t * p_picture)
  45 {
  46     return 0;
  47 }
  48
  49 /*****************************************************************************
  50  * spectrum_Run: spectrum analyser
  51  *****************************************************************************/
  52 int spectrum_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
  53                  aout_buffer_t * p_buffer , picture_t * p_picture)
  54 {
  55     float p_output[FFT_BUFFER_SIZE];  /* Raw FFT Result  */
  56     int *height;                      /* Bar heights */
  57     int *peaks;                       /* Peaks */
  58     int i_nb_bands;                   /* number of bands */
  59     int i_band_width;                 /* width of bands */
  60     int i_separ;                      /* Should we let blanks ? */
  61     int i_amp;                        /* Vertical amplification */
  62     int i_peak;                       /* Should we draw peaks ? */
  63     char *psz_parse = NULL;           /* Args line */
  64
  65     /* Horizontal scale for 20-band equalizer */
  66     const int xscale1[]={0,1,2,3,4,5,6,7,8,11,15,20,27,
  67                         36,47,62,82,107,141,184,255};
  68
  69     /* Horizontal scale for 80-band equalizer */
  70     const int xscale2[] =
  71     {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
  72      19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,
  73      35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
  74      52,53,54,55,56,57,58,59,61,63,67,72,77,82,87,93,99,105,
  75      110,115,121,130,141,152,163,174,185,200,255};
  76     const int *xscale;
  77     const double y_scale =  3.60673760222;  /* (log 256) */
  78
  79     fft_state *p_state;                 /* internal FFT data */
  80
  81     int i , j , y , k;
  82     int i_line;
  83     int16_t p_dest[FFT_BUFFER_SIZE];      /* Adapted FFT result */
  84     int16_t p_buffer1[FFT_BUFFER_SIZE];   /* Buffer on which we perform
  85                                              the FFT (first channel) */
  86
  87     float *p_buffl =                     /* Original buffer */
  88             (float*)p_buffer->p_buffer;
  89
  90     int16_t  *p_buffs;                    /* int16_t converted buffer */
  91     int16_t  *p_s16_buff = NULL;                /* int16_t converted buffer */
  92
  93     p_s16_buff = (int16_t*)malloc(
  94               p_buffer->i_nb_samples * p_effect->i_nb_chans * sizeof(int16_t));
  95
  96     if( !p_s16_buff )
  97     {
  98         msg_Err(p_aout,"Out of memory");
  99         return -1;
 100     }
 101
 102     p_buffs = p_s16_buff;
 103     i_nb_bands = config_GetInt ( p_aout, "visual-nbbands" );
 104     i_separ    = config_GetInt( p_aout, "visual-separ" );
 105     i_amp     = config_GetInt ( p_aout, "visual-amp" );
 106     i_peak     = config_GetInt ( p_aout, "visual-peaks" );
 107
 108     if( i_nb_bands == 20)
 109     {
 110         xscale = xscale1;
 111     }
 112     else
 113     {
 114         i_nb_bands = 80;
 115         xscale = xscale2;
 116     }
 117
 118     if( !p_effect->p_data )
 119     {
 120         p_effect->p_data=(void *)malloc(i_nb_bands * sizeof(int) );
 121         if( !p_effect->p_data)
 122         {
 123             msg_Err(p_aout,"Out of memory");
 124             return -1;
 125         }
 126         peaks = (int *)p_effect->p_data;
 127         for( i = 0 ; i < i_nb_bands ; i++)
 128         {
 129            peaks[i] = 0;
 130         }
 131
 132     }
 133     else
 134     {
 135         peaks =(int *)p_effect->p_data;
 136     }
 137
 138
 139     height = (int *)malloc( i_nb_bands * sizeof(int) );
 140     if( !height)
 141     {
 142         msg_Err(p_aout,"Out of memory");
 143         return -1;
 144     }
 145     /* Convert the buffer to int16_t  */
 146     /* Pasted from float32tos16.c */
 147     for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
 148     {
 149         union { float f; int32_t i; } u;
 150         u.f = *p_buffl + 384.0;
 151         if(u.i >  0x43c07fff ) * p_buffs = 32767;
 152         else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
 153         else *p_buffs = u.i - 0x43c00000;
 154
 155         p_buffl++ ; p_buffs++ ;
 156     }
 157     p_state  = visual_fft_init();
 158     if( !p_state)
 159     {
 160         msg_Err(p_aout,"Unable to initialize FFT transform");
 161         return -1;
 162     }
 163     p_buffs = p_s16_buff;
 164     for ( i = 0 ; i < FFT_BUFFER_SIZE ; i++)
 165     {
 166         p_output[i]    = 0;
 167         p_buffer1[i] = *p_buffs;
 168         p_buffs      = p_buffs + p_effect->i_nb_chans;
 169     }
 170     fft_perform( p_buffer1, p_output, p_state);
 171     for(i= 0; i< FFT_BUFFER_SIZE ; i++ )
 172         p_dest[i] = ( (int) sqrt( p_output [ i + 1 ] ) ) >> 8;
 173
 174     for ( i = 0 ; i< i_nb_bands ;i++)
 175     {
 176         /* We search the maximum on one scale */
 177         for( j = xscale[i] , y=0 ; j< xscale[ i + 1 ] ; j++ )
 178         {
 179             if ( p_dest[j] > y )
 180                  y = p_dest[j];
 181         }
 182         /* Calculate the height of the bar */
 183         y >>=7;/* remove some noise */
 184         if( y != 0)
 185         {
 186             height[i] = (int)log(y)* y_scale;
 187                if(height[i] > 150)
 188                   height[i] = 150;
 189         }
 190         else
 191         {
 192             height[i] = 0 ;
 193         }
 194
 195         /* Draw the bar now */
 196         i_band_width = floor( p_effect->i_width / i_nb_bands) ;
 197
 198         if( i_amp * height[i] > peaks[i])
 199         {
 200             peaks[i] = i_amp * height[i];
 201         }
 202         else if (peaks[i] > 0 )
 203         {
 204             peaks[i] -= PEAK_SPEED;
 205             if( peaks[i] < i_amp * height[i] )
 206             {
 207                 peaks[i] = i_amp * height[i];
 208             }
 209             if( peaks[i] < 0 )
 210             {
 211                 peaks[i] = 0;
 212             }
 213         }
 214
 215         if( peaks[i] > 0 && i_peak )
 216         {
 217             if( peaks[i] >= p_effect->i_height )
 218                 peaks[i] = p_effect->i_height - 2;
 219             i_line = peaks[i];
 220
 221             for( j = 0 ; j< i_band_width - i_separ; j++)
 222             {
 223                for( k = 0 ; k< 3 ; k ++)
 224                {
 225                    /* Draw the peak */
 226                      *(p_picture->p[0].p_pixels +
 227                     (p_picture->p[0].i_lines - i_line -1 -k ) *
 228                      p_picture->p[0].i_pitch + (i_band_width*i +j) )
 229                                     = 0xff;
 230
 231                     *(p_picture->p[1].p_pixels +
 232                      (p_picture->p[1].i_lines - i_line /2 -1 -k/2 ) *
 233                      p_picture->p[1].i_pitch +
 234                     ( ( i_band_width * i + j ) /2  ) )
 235                                     = 0x00;
 236
 237                    if( 0x04 * (i_line + k ) - 0x0f > 0 )
 238                    {
 239                        if ( 0x04 * (i_line + k ) -0x0f < 0xff)
 240                            *(p_picture->p[2].p_pixels  +
 241                             (p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
 242                              p_picture->p[2].i_pitch +
 243                              ( ( i_band_width * i + j ) /2  ) )
 244                                     = ( 0x04 * ( i_line + k ) ) -0x0f ;
 245                        else
 246                            *(p_picture->p[2].p_pixels  +
 247                             (p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
 248                              p_picture->p[2].i_pitch +
 249                              ( ( i_band_width * i + j ) /2  ) )
 250                                     = 0xff;
 251                    }
 252                    else
 253                    {
 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                                = 0x10 ;
 259                    }
 260                }
 261             }
 262         }
 263
 264         if(height[i] * i_amp > p_effect->i_height)
 265             height[i] = floor(p_effect->i_height / i_amp );
 266
 267         for(i_line = 0 ; i_line < i_amp * height[i]; i_line ++ )
 268         {
 269             for( j = 0 ; j< i_band_width - i_separ ; j++)
 270             {
 271                *(p_picture->p[0].p_pixels +
 272                  (p_picture->p[0].i_lines - i_line -1) *
 273                   p_picture->p[0].i_pitch + (i_band_width*i +j) ) = 0xff;
 274
 275                 *(p_picture->p[1].p_pixels +
 276                  (p_picture->p[1].i_lines - i_line /2 -1) *
 277                  p_picture->p[1].i_pitch +
 278                  ( ( i_band_width * i + j ) /2  ) ) = 0x00;
 279
 280                if( 0x04 * i_line - 0x0f > 0 )
 281                {
 282                     if( 0x04 * i_line - 0x0f < 0xff )
 283                          *(p_picture->p[2].p_pixels  +
 284                           (p_picture->p[2].i_lines - i_line /2 - 1) *
 285                            p_picture->p[2].i_pitch +
 286                            ( ( i_band_width * i + j ) /2  ) ) =
 287                                ( 0x04 * i_line) -0x0f ;
 288                     else
 289                          *(p_picture->p[2].p_pixels  +
 290                           (p_picture->p[2].i_lines - i_line /2 - 1) *
 291                            p_picture->p[2].i_pitch +
 292                            ( ( i_band_width * i + j ) /2  ) ) =
 293                                        0xff;
 294                }
 295                else
 296                {
 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                             0x10 ;
 302                }
 303             }
 304         }
 305     }
 306
 307     fft_close( p_state );
 308
 309     if( p_s16_buff != NULL )
 310     {
 311         free( p_s16_buff );
 312         p_s16_buff = NULL;
 313     }
 314
 315     if(height) free(height);
 316
 317     if(psz_parse) free(psz_parse);
 318
 319     return 0;
 320 }
 321
 322
 323 /*****************************************************************************
 324  * spectrometer_Run: derivative spectrum analysis
 325  *****************************************************************************/
 326 int spectrometer_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
 327                  aout_buffer_t * p_buffer , picture_t * p_picture)
 328 {
 329 #define Y(R,G,B) ((uint8_t)( (R * .299) + (G * .587) + (B * .114) ))
 330 #define U(R,G,B) ((uint8_t)( (R * -.169) + (G * -.332) + (B * .500) + 128 ))
 331 #define V(R,G,B) ((uint8_t)( (R * .500) + (G * -.419) + (B * -.0813) + 128 ))
 332     float p_output[FFT_BUFFER_SIZE];  /* Raw FFT Result  */
 333     int *height;                      /* Bar heights */
 334     int *peaks;                       /* Peaks */
 335     int i_nb_bands;                   /* number of bands */
 336     int i_band_width;                 /* width of bands */
 337     int i_separ;                      /* Should we let blanks ? */
 338     int i_amp;                        /* Vertical amplification */
 339     int i_peak;                       /* Should we draw peaks ? */
 340
 341     int i_original;          /* original spectrum graphic routine */
 342     int i_rad;               /* radius of circle of base of bands */
 343     int i_sections;          /* sections of spectranalysis */
 344     int i_extra_width;       /* extra width on peak */
 345     int i_peak_height;       /* height of peak */
 346     int c;                   /* sentinel container of total spectral sections */
 347     double band_sep_angle;   /* angled separation between beginning of each band */
 348     double section_sep_angle;/* "   "    '     "    '    "     "    spectrum section */
 349     int max_band_length;     /* try not to go out of screen */
 350     int i_show_base;         /* Should we draw base of circle ? */
 351     int i_show_bands;        /* Should we draw bands ? */
 352     //int i_invert_bands;      /* do the bands point inward ? */
 353     double a;                /* for various misc angle situations in radians */
 354     int x,y,xx,yy;           /* various misc x/y */
 355     char color1;             /* V slide on a YUV color cube */
 356     //char color2;             /* U slide.. ?  color2 fade color ? */
 357
 358     char *psz_parse = NULL;           /* Args line */
 359
 360     /* Horizontal scale for 20-band equalizer */
 361     const int xscale1[]={0,1,2,3,4,5,6,7,8,11,15,20,27,
 362                         36,47,62,82,107,141,184,255};
 363
 364     /* Horizontal scale for 80-band equalizer */
 365     const int xscale2[] =
 366     {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
 367      19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,
 368      35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
 369      52,53,54,55,56,57,58,59,61,63,67,72,77,82,87,93,99,105,
 370      110,115,121,130,141,152,163,174,185,200,255};
 371     const int *xscale;
 372     const double y_scale =  3.60673760222;  /* (log 256) */
 373
 374     fft_state *p_state;                 /* internal FFT data */
 375
 376     int i , j , k;
 377     int i_line;
 378     int16_t p_dest[FFT_BUFFER_SIZE];      /* Adapted FFT result */
 379     int16_t p_buffer1[FFT_BUFFER_SIZE];   /* Buffer on which we perform
 380                                              the FFT (first channel) */
 381     float *p_buffl =                     /* Original buffer */
 382             (float*)p_buffer->p_buffer;
 383
 384     int16_t  *p_buffs;                    /* int16_t converted buffer */
 385     int16_t  *p_s16_buff = NULL;                /* int16_t converted buffer */
 386
 387     i_line = 0;
 388
 389     p_s16_buff = (int16_t*)malloc(
 390               p_buffer->i_nb_samples * p_effect->i_nb_chans * sizeof(int16_t));
 391
 392     if( !p_s16_buff )
 393     {
 394         msg_Err(p_aout,"Out of memory");
 395         return -1;
 396     }
 397
 398     p_buffs = p_s16_buff;
 399     i_original     = config_GetInt ( p_aout, "spect-show-original" );
 400     i_nb_bands     = config_GetInt ( p_aout, "spect-nbbands" );
 401     i_separ        = config_GetInt ( p_aout, "spect-separ" );
 402     i_amp          = config_GetInt ( p_aout, "spect-amp" );
 403     i_peak         = config_GetInt ( p_aout, "spect-show-peaks" );
 404     i_show_base    = config_GetInt ( p_aout, "spect-show-base" );
 405     i_show_bands   = config_GetInt ( p_aout, "spect-show-bands" );
 406     i_rad          = config_GetInt ( p_aout, "spect-radius" );
 407     i_sections     = config_GetInt ( p_aout, "spect-sections" );
 408     i_extra_width  = config_GetInt ( p_aout, "spect-peak-width" );
 409     i_peak_height  = config_GetInt ( p_aout, "spect-peak-height" );
 410     color1         = config_GetInt ( p_aout, "spect-color" );
 411
 412     if( i_nb_bands == 20)
 413     {
 414         xscale = xscale1;
 415     }
 416     else
 417     {
 418         if( i_nb_bands > 80 )
 419             i_nb_bands = 80;
 420         xscale = xscale2;
 421     }
 422
 423     if( !p_effect->p_data )
 424     {
 425         p_effect->p_data=(void *)malloc(i_nb_bands * sizeof(int) );
 426         if( !p_effect->p_data)
 427         {
 428             msg_Err(p_aout,"Out of memory");
 429             return -1;
 430         }
 431         peaks = (int *)p_effect->p_data;
 432         for( i = 0 ; i < i_nb_bands ; i++)
 433         {
 434            peaks[i] = 0;
 435         }
 436     }
 437     else
 438     {
 439         peaks =(int *)p_effect->p_data;
 440     }
 441
 442     height = (int *)malloc( i_nb_bands * sizeof(int) );
 443     if( !height)
 444     {
 445         msg_Err(p_aout,"Out of memory");
 446         return -1;
 447     }
 448
 449     /* Convert the buffer to int16_t  */
 450     /* Pasted from float32tos16.c */
 451     for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
 452     {
 453         union { float f; int32_t i; } u;
 454         u.f = *p_buffl + 384.0;
 455         if(u.i >  0x43c07fff ) * p_buffs = 32767;
 456         else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
 457         else *p_buffs = u.i - 0x43c00000;
 458
 459         p_buffl++ ; p_buffs++ ;
 460     }
 461     p_state  = visual_fft_init();
 462     if( !p_state)
 463     {
 464         msg_Err(p_aout,"Unable to initialize FFT transform");
 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 + 1 ] ) ) >> 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     if( p_s16_buff != NULL )
 768     {
 769         free( p_s16_buff );
 770         p_s16_buff = NULL;
 771     }
 772
 773     if(height) free(height);
 774
 775     if(psz_parse) free(psz_parse);
 776
 777     return 0;
 778 }
 779
 780
 781 /*****************************************************************************
 782  * scope_Run: scope effect
 783  *****************************************************************************/
 784 int scope_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
 785               aout_buffer_t * p_buffer , picture_t * p_picture)
 786 {
 787     int i_index;
 788     float *p_sample ;
 789     uint8_t *ppp_area[2][3];
 790
 791
 792         for( i_index = 0 ; i_index < 2 ; i_index++ )
 793         {
 794             int j;
 795             for( j = 0 ; j < 3 ; j++ )
 796             {
 797                 ppp_area[i_index][j] =
 798                     p_picture->p[j].p_pixels + i_index * p_picture->p[j].i_lines
 799                                 / 2 * p_picture->p[j].i_pitch;
 800             }
 801         }
 802
 803         for( i_index = 0, p_sample = (float *)p_buffer->p_buffer;
 804              i_index < p_effect->i_width;
 805              i_index++ )
 806         {
 807             uint8_t i_value;
 808
 809             /* Left channel */
 810             i_value =  (*p_sample++ +1) * 127;
 811             *(ppp_area[0][0]
 812                + p_picture->p[0].i_pitch * i_index / p_effect->i_width
 813                + p_picture->p[0].i_lines * i_value / 512
 814                    * p_picture->p[0].i_pitch) = 0xbf;
 815             *(ppp_area[0][1]
 816                 + p_picture->p[1].i_pitch * i_index / p_effect->i_width
 817                 + p_picture->p[1].i_lines * i_value / 512
 818                    * p_picture->p[1].i_pitch) = 0xff;
 819
 820
 821            /* Right channel */
 822            i_value = ( *p_sample++ +1 ) * 127;
 823            *(ppp_area[1][0]
 824               + p_picture->p[0].i_pitch * i_index / p_effect->i_width
 825               + p_picture->p[0].i_lines * i_value / 512
 826                  * p_picture->p[0].i_pitch) = 0x9f;
 827            *(ppp_area[1][2]
 828               + p_picture->p[2].i_pitch * i_index / p_effect->i_width
 829               + p_picture->p[2].i_lines * i_value / 512
 830                 * p_picture->p[2].i_pitch) = 0xdd;
 831         }
 832         return 0;
 833 }
 834
 835 /*****************************************************************************
 836  * blur_Run:  blur effect
 837  *****************************************************************************/
 838 #if 0
 839   /* This code is totally crappy */
 840 int blur_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
 841               aout_buffer_t * p_buffer , picture_t * p_picture)
 842 {
 843     uint8_t * p_pictures;
 844     int i,j;
 845     int i_size;   /* Total size of one image */
 846
 847     i_size = (p_picture->p[0].i_pitch * p_picture->p[0].i_lines +
 848               p_picture->p[1].i_pitch * p_picture->p[1].i_lines +
 849               p_picture->p[2].i_pitch * p_picture->p[2].i_lines );
 850
 851     if( !p_effect->p_data )
 852     {
 853         p_effect->p_data=(void *)malloc( 5 * i_size *sizeof(uint8_t));
 854
 855         if( !p_effect->p_data)
 856         {
 857             msg_Err(p_aout,"Out of memory");
 858             return -1;
 859         }
 860         p_pictures = (uint8_t *)p_effect->p_data;
 861     }
 862     else
 863     {
 864         p_pictures =(uint8_t *)p_effect->p_data;
 865     }
 866
 867     for( i = 0 ; i < 5 ; i++)
 868     {
 869         for ( j = 0 ; j< p_picture->p[0].i_pitch * p_picture->p[0].i_lines; i++)
 870             p_picture->p[0].p_pixels[j] =
 871                     p_pictures[i * i_size + j] * (100 - 20 * i) /100 ;
 872         for ( j = 0 ; j< p_picture->p[1].i_pitch * p_picture->p[1].i_lines; i++)
 873             p_picture->p[1].p_pixels[j] =
 874                     p_pictures[i * i_size +
 875                     p_picture->p[0].i_pitch * p_picture->p[0].i_lines + j ];
 876         for ( j = 0 ; j< p_picture->p[2].i_pitch * p_picture->p[2].i_lines; i++)
 877             p_picture->p[2].p_pixels[j] =
 878                     p_pictures[i * i_size +
 879                     p_picture->p[0].i_pitch * p_picture->p[0].i_lines +
 880                     p_picture->p[1].i_pitch * p_picture->p[1].i_lines
 881                     + j ];
 882     }
 883
 884     memcpy ( &p_pictures[ i_size ] , &p_pictures[0] , 4 * i_size * sizeof(uint8_t) );
 885 }
 886 #endif