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., 59 Temple Place - Suite 330, Boston, MA  02111, 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_nb_bands = config_GetInt ( p_aout, "visual-nbbands" );
 400     //i_separ    = config_GetInt( p_aout, "visual-separ" );
 401     //i_amp     = config_GetInt ( p_aout, "visual-amp" );
 402     //i_peak     = config_GetInt ( p_aout, "visual-peaks" );
 403     /* previous 4 vars changed.. using them as `spect' variables */
 404     i_original     = config_GetInt ( p_aout, "spect-show-original" );
 405     i_nb_bands     = config_GetInt ( p_aout, "spect-nbbands" );
 406     i_separ        = config_GetInt ( p_aout, "spect-separ" );
 407     i_amp          = config_GetInt ( p_aout, "spect-amp" );
 408     i_peak         = config_GetInt ( p_aout, "spect-show-peaks" );
 409     i_show_base    = config_GetInt ( p_aout, "spect-show-base" );
 410     i_show_bands   = config_GetInt ( p_aout, "spect-show-bands" );
 411     i_rad          = config_GetInt ( p_aout, "spect-radius" );
 412     i_sections     = config_GetInt ( p_aout, "spect-sections" );
 413     i_extra_width  = config_GetInt ( p_aout, "spect-peak-width" );
 414     i_peak_height  = config_GetInt ( p_aout, "spect-peak-height" );
 415     color1         = config_GetInt ( p_aout, "spect-color" );
 416
 417     if( i_nb_bands == 20)
 418     {
 419         xscale = xscale1;
 420     }
 421     else
 422     {
 423         i_nb_bands = 80;
 424         xscale = xscale2;
 425     }
 426     i_nb_bands *= i_sections;
 427     /* whoops, dont malloc the following memory for all the duplicated bands..
 428         -only the original 20 or 80 will be fine */
 429
 430     if( !p_effect->p_data )
 431     {
 432         p_effect->p_data=(void *)malloc(i_nb_bands * sizeof(int) );
 433         if( !p_effect->p_data)
 434         {
 435             msg_Err(p_aout,"Out of memory");
 436             return -1;
 437         }
 438         peaks = (int *)p_effect->p_data;
 439         for( i = 0 ; i < i_nb_bands ; i++)
 440         {
 441            peaks[i] = 0;
 442         }
 443     }
 444     else
 445     {
 446         peaks =(int *)p_effect->p_data;
 447     }
 448
 449
 450     height = (int *)malloc( i_nb_bands * sizeof(int) );
 451     if( !height)
 452     {
 453         msg_Err(p_aout,"Out of memory");
 454         return -1;
 455     }
 456     /* Convert the buffer to int16_t  */
 457     /* Pasted from float32tos16.c */
 458     for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
 459     {
 460         union { float f; int32_t i; } u;
 461         u.f = *p_buffl + 384.0;
 462         if(u.i >  0x43c07fff ) * p_buffs = 32767;
 463         else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
 464         else *p_buffs = u.i - 0x43c00000;
 465
 466         p_buffl++ ; p_buffs++ ;
 467     }
 468     p_state  = visual_fft_init();
 469     if( !p_state)
 470     {
 471         msg_Err(p_aout,"Unable to initialize FFT transform");
 472         return -1;
 473     }
 474     p_buffs = p_s16_buff;
 475     for ( i = 0 ; i < FFT_BUFFER_SIZE ; i++)
 476     {
 477         p_output[i]    = 0;
 478         p_buffer1[i] = *p_buffs;
 479         p_buffs      = p_buffs + p_effect->i_nb_chans;
 480     }
 481     fft_perform( p_buffer1, p_output, p_state);
 482     for(i= 0; i< FFT_BUFFER_SIZE ; i++ )
 483         p_dest[i] = ( (int) sqrt( p_output [ i + 1 ] ) ) >> 8;
 484
 485     for ( i = 0 ; i< i_nb_bands/i_sections ;i++)
 486     {
 487         /* We search the maximum on one scale */
 488         for( j = xscale[i] , y=0 ; j< xscale[ i + 1 ] ; j++ )
 489         {
 490             if ( p_dest[j] > y )
 491                  y = p_dest[j];
 492         }
 493         /* Calculate the height of the bar */
 494         y >>=7;/* remove some noise */
 495         if( y != 0)
 496         {
 497             height[i] = (int)log(y)* y_scale;
 498                if(height[i] > 150)
 499                   height[i] = 150;
 500         }
 501         else
 502         {
 503             height[i] = 0 ;
 504         }
 505
 506         /* Draw the bar now */
 507         i_band_width = floor( p_effect->i_width / (i_nb_bands/i_sections)) ;
 508
 509         if( i_amp * height[i] > peaks[i])
 510         {
 511             peaks[i] = i_amp * height[i];
 512         }
 513         else if (peaks[i] > 0 )
 514         {
 515             peaks[i] -= PEAK_SPEED;
 516             if( peaks[i] < i_amp * height[i] )
 517             {
 518                 peaks[i] = i_amp * height[i];
 519             }
 520             if( peaks[i] < 0 )
 521             {
 522                 peaks[i] = 0;
 523             }
 524         }
 525
 526         if( i_original != 0 )
 527         {
 528         if( peaks[i] > 0 && i_peak )
 529         {
 530             if( peaks[i] >= p_effect->i_height )
 531                 peaks[i] = p_effect->i_height - 2;
 532             i_line = peaks[i];
 533
 534             for( j = 0 ; j< i_band_width - i_separ; j++)
 535             {
 536                for( k = 0 ; k< 3 ; k ++)
 537                {
 538                    //* Draw the peak
 539                      *(p_picture->p[0].p_pixels +
 540                     (p_picture->p[0].i_lines - i_line -1 -k ) *
 541                      p_picture->p[0].i_pitch + (i_band_width*i +j) )
 542                                     = 0xff;
 543
 544                     *(p_picture->p[1].p_pixels +
 545                      (p_picture->p[1].i_lines - i_line /2 -1 -k/2 ) *
 546                      p_picture->p[1].i_pitch +
 547                     ( ( i_band_width * i + j ) /2  ) )
 548                                     = 0x00;
 549
 550                    if( 0x04 * (i_line + k ) - 0x0f > 0 )
 551                    {
 552                        if ( 0x04 * (i_line + k ) -0x0f < 0xff)
 553                            *(p_picture->p[2].p_pixels  +
 554                             (p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
 555                              p_picture->p[2].i_pitch +
 556                              ( ( i_band_width * i + j ) /2  ) )
 557                                     = ( 0x04 * ( i_line + k ) ) -0x0f ;
 558                        else
 559                            *(p_picture->p[2].p_pixels  +
 560                             (p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
 561                              p_picture->p[2].i_pitch +
 562                              ( ( i_band_width * i + j ) /2  ) )
 563                                     = 0xff;
 564                    }
 565                    else
 566                    {
 567                         *(p_picture->p[2].p_pixels  +
 568                          (p_picture->p[2].i_lines - i_line /2 - 1 -k/2 ) *
 569                          p_picture->p[2].i_pitch +
 570                          ( ( i_band_width * i + j ) /2  ) )
 571                                = 0x10 ;
 572                    }
 573                }
 574             }
 575         }
 576         if(height[i] * i_amp > p_effect->i_height)
 577             height[i] = floor(p_effect->i_height / i_amp );
 578
 579         for(i_line = 0 ; i_line < i_amp * height[i]; i_line ++ )
 580         {
 581             for( j = 0 ; j< i_band_width - i_separ ; j++)
 582             {
 583                *(p_picture->p[0].p_pixels +
 584                  (p_picture->p[0].i_lines - i_line -1) *
 585                   p_picture->p[0].i_pitch + (i_band_width*i +j) ) = 0xff;
 586
 587                 *(p_picture->p[1].p_pixels +
 588                  (p_picture->p[1].i_lines - i_line /2 -1) *
 589                  p_picture->p[1].i_pitch +
 590                  ( ( i_band_width * i + j ) /2  ) ) = 0x00;
 591
 592                if( 0x04 * i_line - 0x0f > 0 )
 593                {
 594                     if( 0x04 * i_line - 0x0f < 0xff )
 595                          *(p_picture->p[2].p_pixels  +
 596                           (p_picture->p[2].i_lines - i_line /2 - 1) *
 597                            p_picture->p[2].i_pitch +
 598                            ( ( i_band_width * i + j ) /2  ) ) =
 599                                ( 0x04 * i_line) -0x0f ;
 600                     else
 601                          *(p_picture->p[2].p_pixels  +
 602                           (p_picture->p[2].i_lines - i_line /2 - 1) *
 603                            p_picture->p[2].i_pitch +
 604                            ( ( i_band_width * i + j ) /2  ) ) =
 605                                        0xff;
 606                }
 607                else
 608                {
 609                     *(p_picture->p[2].p_pixels  +
 610                      (p_picture->p[2].i_lines - i_line /2 - 1) *
 611                      p_picture->p[2].i_pitch +
 612                      ( ( i_band_width * i + j ) /2  ) ) =
 613                             0x10 ;
 614                }
 615             }
 616         }
 617         }
 618     }
 619
 620     band_sep_angle = 360.0 / i_nb_bands;
 621     section_sep_angle = 360.0 / i_sections;
 622     if( i_peak_height < 1 )
 623         i_peak_height = 1;
 624     max_band_length = p_picture->p[0].i_lines / 2 - ( i_rad + i_peak_height + 1 );
 625
 626     i_band_width = floor( 360 / i_nb_bands - i_separ );
 627     if( i_band_width < 1 )
 628         i_band_width = 1;
 629
 630     for( c = 0 ; c < i_sections ; c++ )
 631     for( i = 0 ; i < (i_nb_bands / i_sections) ; i++ )
 632     {
 633         /* DO A PEAK */
 634         if( peaks[i] > 0 && i_peak )
 635         {
 636             if( peaks[i] >= p_effect->i_height )
 637                 peaks[i] = p_effect->i_height - 2;
 638             i_line = peaks[i];
 639
 640             /* circular line pattern(so color blend is more visible) */
 641             for( j = 0 ; j < i_peak_height ; j++ )
 642             {
 643                 x = p_picture->p[0].i_pitch / 2;
 644                 y = p_picture->p[0].i_lines / 2;
 645                 xx = x;
 646                 yy = y;
 647                 for( k = 0 ; k < (i_band_width + i_extra_width) ; k++ )
 648                 {
 649                     x = xx;
 650                     y = yy;
 651                     a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) + k )
 652                         * 3.141592 / 180.0;
 653                     x += (double)( cos(a) * (double)( i_line + j + i_rad ) );
 654                     y += (double)( -sin(a) * (double)( i_line + j + i_rad ) );
 655
 656                     *(p_picture->p[0].p_pixels + x + y * p_picture->p[0].i_pitch
 657                     ) = 255;/* Y(R,G,B); */
 658
 659                     x /= 2;
 660                     y /= 2;
 661
 662                     *(p_picture->p[1].p_pixels + x + y * p_picture->p[1].i_pitch
 663                     - p_picture->p[1].i_pitch
 664                     ) = 0;/* U(R,G,B); */
 665
 666                     if( 0x04 * (i_line + k ) - 0x0f > 0 )
 667                     {
 668                         if ( 0x04 * (i_line + k ) -0x0f < 0xff)
 669                             *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 670                             - p_picture->p[2].i_pitch
 671                             ) = ( 0x04 * ( i_line + k ) ) -(color1-1);/* -V(R,G,B); */
 672                         else
 673                             *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 674                             - p_picture->p[2].i_pitch
 675                             ) = 255;/* V(R,G,B); */
 676                     }
 677                     else
 678                     {
 679                         *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 680                         - p_picture->p[2].i_pitch
 681                         ) = color1;/* V(R,G,B); */
 682                     }
 683                 }
 684             }
 685         }
 686
 687         if( (height[i] * i_amp) > p_effect->i_height )
 688             height[i] = floor( p_effect->i_height / i_amp );
 689
 690         /* DO BASE OF BAND (mostly makes a circle) */
 691         if( i_show_base != 0 )
 692         {
 693             x = p_picture->p[0].i_pitch / 2;
 694             y = p_picture->p[0].i_lines / 2;
 695
 696             a =  ( (i+1) * band_sep_angle + section_sep_angle * (c+1) )
 697                 * 3.141592 / 180.0;
 698             x += (double)( cos(a) * (double)i_rad );/* newb-forceful casting */
 699             y += (double)( -sin(a) * (double)i_rad );
 700
 701             *(p_picture->p[0].p_pixels + x + y * p_picture->p[0].i_pitch
 702             ) = 255;/* Y(R,G,B); */
 703
 704             x /= 2;
 705             y /= 2;
 706
 707             *(p_picture->p[1].p_pixels + x + y * p_picture->p[1].i_pitch
 708             - p_picture->p[1].i_pitch
 709             ) = 0;/* U(R,G,B); */
 710
 711             if( 0x04 * i_line - 0x0f > 0 )
 712             {
 713                 if( 0x04 * i_line -0x0f < 0xff)
 714                     *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 715                     - p_picture->p[2].i_pitch
 716                     ) = ( 0x04 * i_line) -(color1-1);/* -V(R,G,B); */
 717                 else
 718                     *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 719                     - p_picture->p[2].i_pitch
 720                     ) = 255;/* V(R,G,B); */
 721             }
 722             else
 723             {
 724                 *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 725                 - p_picture->p[2].i_pitch
 726                 ) = color1;/* V(R,G,B); */
 727             }
 728         }
 729
 730         /* DO A BAND */
 731         if( i_show_bands != 0 )
 732         for( j = 0 ; j < i_band_width ; j++ )
 733         {
 734             x = p_picture->p[0].i_pitch / 2;
 735             y = p_picture->p[0].i_lines / 2;
 736             xx = x;
 737             yy = y;
 738             a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) + j )
 739                 * 3.141592/180.0;
 740
 741             for( k = (i_rad+1) ; k < max_band_length ; k++ )
 742             {
 743                 if( (k-i_rad) > height[i] )
 744                     break;/* uhh.. */
 745
 746                 x = xx;
 747                 y = yy;
 748                 x += (double)( cos(a) * (double)k );/* newbed! */
 749                 y += (double)( -sin(a) * (double)k );
 750
 751                 *(p_picture->p[0].p_pixels + x + y * p_picture->p[0].i_pitch
 752                 ) = 255;
 753
 754                 x /= 2;
 755                 y /= 2;
 756
 757                 *(p_picture->p[1].p_pixels + x + y * p_picture->p[1].i_pitch
 758                 - p_picture->p[1].i_pitch
 759                 ) = 0;
 760
 761                 if( 0x04 * i_line - 0x0f > 0 )
 762                 {
 763                     if ( 0x04 * i_line -0x0f < 0xff)
 764                         *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 765                         - p_picture->p[2].i_pitch
 766                         ) = ( 0x04 * i_line) -(color1-1);
 767                     else
 768                         *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 769                         - p_picture->p[2].i_pitch
 770                         ) = 255;
 771                 }
 772                 else
 773                 {
 774                     *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
 775                     - p_picture->p[2].i_pitch
 776                     ) = color1;
 777                 }
 778             }
 779         }
 780     }
 781
 782     fft_close( p_state );
 783
 784     if( p_s16_buff != NULL )
 785     {
 786         free( p_s16_buff );
 787         p_s16_buff = NULL;
 788     }
 789
 790     if(height) free(height);
 791
 792     if(psz_parse) free(psz_parse);
 793
 794     return 0;
 795 }
 796
 797
 798 /*****************************************************************************
 799  * scope_Run: scope effect
 800  *****************************************************************************/
 801 int scope_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
 802               aout_buffer_t * p_buffer , picture_t * p_picture)
 803 {
 804     int i_index;
 805     float *p_sample ;
 806     uint8_t *ppp_area[2][3];
 807
 808
 809         for( i_index = 0 ; i_index < 2 ; i_index++ )
 810         {
 811             int j;
 812             for( j = 0 ; j < 3 ; j++ )
 813             {
 814                 ppp_area[i_index][j] =
 815                     p_picture->p[j].p_pixels + i_index * p_picture->p[j].i_lines
 816                                 / 2 * p_picture->p[j].i_pitch;
 817             }
 818         }
 819
 820         for( i_index = 0, p_sample = (float *)p_buffer->p_buffer;
 821              i_index < p_effect->i_width;
 822              i_index++ )
 823         {
 824             uint8_t i_value;
 825
 826             /* Left channel */
 827             i_value =  (*p_sample++ +1) * 127;
 828             *(ppp_area[0][0]
 829                + p_picture->p[0].i_pitch * i_index / p_effect->i_width
 830                + p_picture->p[0].i_lines * i_value / 512
 831                    * p_picture->p[0].i_pitch) = 0xbf;
 832             *(ppp_area[0][1]
 833                 + p_picture->p[1].i_pitch * i_index / p_effect->i_width
 834                 + p_picture->p[1].i_lines * i_value / 512
 835                    * p_picture->p[1].i_pitch) = 0xff;
 836
 837
 838            /* Right channel */
 839            i_value = ( *p_sample++ +1 ) * 127;
 840            *(ppp_area[1][0]
 841               + p_picture->p[0].i_pitch * i_index / p_effect->i_width
 842               + p_picture->p[0].i_lines * i_value / 512
 843                  * p_picture->p[0].i_pitch) = 0x9f;
 844            *(ppp_area[1][2]
 845               + p_picture->p[2].i_pitch * i_index / p_effect->i_width
 846               + p_picture->p[2].i_lines * i_value / 512
 847                 * p_picture->p[2].i_pitch) = 0xdd;
 848         }
 849         return 0;
 850 }
 851
 852 /*****************************************************************************
 853  * blur_Run:  blur effect
 854  *****************************************************************************/
 855 #if 0
 856   /* This code is totally crappy */
 857 int blur_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
 858               aout_buffer_t * p_buffer , picture_t * p_picture)
 859 {
 860     uint8_t * p_pictures;
 861     int i,j;
 862     int i_size;   /* Total size of one image */
 863
 864     i_size = (p_picture->p[0].i_pitch * p_picture->p[0].i_lines +
 865               p_picture->p[1].i_pitch * p_picture->p[1].i_lines +
 866               p_picture->p[2].i_pitch * p_picture->p[2].i_lines );
 867
 868     if( !p_effect->p_data )
 869     {
 870         p_effect->p_data=(void *)malloc( 5 * i_size *sizeof(uint8_t));
 871
 872         if( !p_effect->p_data)
 873         {
 874             msg_Err(p_aout,"Out of memory");
 875             return -1;
 876         }
 877         p_pictures = (uint8_t *)p_effect->p_data;
 878     }
 879     else
 880     {
 881         p_pictures =(uint8_t *)p_effect->p_data;
 882     }
 883
 884     for( i = 0 ; i < 5 ; i++)
 885     {
 886         for ( j = 0 ; j< p_picture->p[0].i_pitch * p_picture->p[0].i_lines; i++)
 887             p_picture->p[0].p_pixels[j] =
 888                     p_pictures[i * i_size + j] * (100 - 20 * i) /100 ;
 889         for ( j = 0 ; j< p_picture->p[1].i_pitch * p_picture->p[1].i_lines; i++)
 890             p_picture->p[1].p_pixels[j] =
 891                     p_pictures[i * i_size +
 892                     p_picture->p[0].i_pitch * p_picture->p[0].i_lines + j ];
 893         for ( j = 0 ; j< p_picture->p[2].i_pitch * p_picture->p[2].i_lines; i++)
 894             p_picture->p[2].p_pixels[j] =
 895                     p_pictures[i * i_size +
 896                     p_picture->p[0].i_pitch * p_picture->p[0].i_lines +
 897                     p_picture->p[1].i_pitch * p_picture->p[1].i_lines
 898                     + j ];
 899     }
 900
 901     memcpy ( &p_pictures[ i_size ] , &p_pictures[0] , 4 * i_size * sizeof(uint8_t) );
 902 }
 903 #endif