开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
effects.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：35k
源码类别：

midi

开发平台：

Unix_Linux

effects.c：源码内容
  1. /*****************************************************************************
  2.  * effects.c : Effects for the visualization system
  3.  *****************************************************************************
  4.  * Copyright (C) 2002-2009 the VideoLAN team
  5.  * $Id: 267611ab55a7e137ade406b105f291ccdc2b1f7f $
  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.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <vlc_common.h>
  33. #include <vlc_vout.h>
  34. #include <vlc_aout.h>
  36. #include "visual.h"
  37. #include <math.h>
  39. #include "fft.h"
  41. #define PEAK_SPEED 1
  42. #define BAR_DECREASE_SPEED 5
  44. #define GRAD_ANGLE_MIN 0.2
  45. #define GRAD_ANGLE_MAX 0.5
  46. #define GRAD_INCR 0.01
  48. /*****************************************************************************
  49.  * dummy_Run
  50.  *****************************************************************************/
  51. int dummy_Run( visual_effect_t * p_effect, aout_instance_t *p_aout,
  52.                aout_buffer_t * p_buffer , picture_t * p_picture)
  53. {
  54.     VLC_UNUSED(p_effect); VLC_UNUSED(p_aout); VLC_UNUSED(p_buffer);
  55.     VLC_UNUSED(p_picture);
  56.     return 0;
  57. }
  59. /*****************************************************************************
  60.  * spectrum_Run: spectrum analyser
  61.  *****************************************************************************/
  62. int spectrum_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
  63.                  aout_buffer_t * p_buffer , picture_t * p_picture)
  64. {
  65.     spectrum_data *p_data = p_effect->p_data;
  66.     float p_output[FFT_BUFFER_SIZE];  /* Raw FFT Result  */
  67.     int *height;                      /* Bar heights */
  68.     int *peaks;                       /* Peaks */
  69.     int *prev_heights;                /* Previous bar heights */
  70.     int i_80_bands;                   /* number of bands : 80 if true else 20 */
  71.     int i_nb_bands;                   /* number of bands : 80 or 20 */
  72.     int i_band_width;                 /* width of bands */
  73.     int i_start;                      /* first band horizontal position */
  74.     int i_peak;                       /* Should we draw peaks ? */
  76.     /* Horizontal scale for 20-band equalizer */
  77.     const int xscale1[]={0,1,2,3,4,5,6,7,8,11,15,20,27,
  78.                         36,47,62,82,107,141,184,255};
  80.     /* Horizontal scale for 80-band equalizer */
  81.     const int xscale2[] =
  82.     {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
  83.      19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,
  84.      35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
  85.      52,53,54,55,56,57,58,59,61,63,67,72,77,82,87,93,99,105,
  86.      110,115,121,130,141,152,163,174,185,200,255};
  87.     const int *xscale;
  89.     fft_state *p_state;                 /* internal FFT data */
  91.     int i , j , y , k;
  92.     int i_line;
  93.     int16_t p_dest[FFT_BUFFER_SIZE];      /* Adapted FFT result */
  94.     int16_t p_buffer1[FFT_BUFFER_SIZE];   /* Buffer on which we perform
  95.                                              the FFT (first channel) */
  97.     float *p_buffl =                     /* Original buffer */
  98.             (float*)p_buffer->p_buffer;
  100.     int16_t  *p_buffs;                    /* int16_t converted buffer */
  101.     int16_t  *p_s16_buff;                 /* int16_t converted buffer */
  103.     p_s16_buff = malloc( p_buffer->i_nb_samples * p_effect->i_nb_chans * sizeof(int16_t));
  104.     if( !p_s16_buff )
  105.         return -1;
  107.     p_buffs = p_s16_buff;
  108.     i_80_bands = config_GetInt ( p_aout, "visual-80-bands" );
  109.     i_peak     = config_GetInt ( p_aout, "visual-peaks" );
  111.     if( i_80_bands != 0)
  112.     {
  113.         xscale = xscale2;
  114.         i_nb_bands = 80;
  115.     }
  116.     else
  117.     {
  118.         xscale = xscale1;
  119.         i_nb_bands = 20;
  120.     }
  122.     if( !p_data )
  123.     {
  124.         p_effect->p_data = p_data = malloc( sizeof( spectrum_data ) );
  125.         if( !p_data )
  126.         {
  127.             free( p_s16_buff );
  128.             return -1;
  129.         }
  131.         p_data->peaks = calloc( 80, sizeof(int) );
  132.         p_data->prev_heights = calloc( 80, sizeof(int) );
  134.         peaks = ( int * )p_data->peaks;
  135.         prev_heights = ( int * )p_data->prev_heights;
  136.     }
  137.     else
  138.     {
  139.         peaks = (int *)p_data->peaks;
  140.         prev_heights = (int *)p_data->prev_heights;
  141.     }
  144.     height = malloc( i_nb_bands * sizeof(int) );
  145.     if( !height )
  146.     {
  147.         free( p_s16_buff );
  148.         return -1;
  149.     }
  150.     /* Convert the buffer to int16_t  */
  151.     /* Pasted from float32tos16.c */
  152.     for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
  153.     {
  154.         union { float f; int32_t i; } u;
  155.         u.f = *p_buffl + 384.0;
  156.         if(u.i >  0x43c07fff ) * p_buffs = 32767;
  157.         else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
  158.         else *p_buffs = u.i - 0x43c00000;
  160.         p_buffl++ ; p_buffs++ ;
  161.     }
  162.     p_state  = visual_fft_init();
  163.     if( !p_state)
  164.     {
  165.         free( height );
  166.         free( p_s16_buff );
  167.         msg_Err(p_aout,"unable to initialize FFT transform");
  168.         return -1;
  169.     }
  170.     p_buffs = p_s16_buff;
  171.     for ( i = 0 ; i < FFT_BUFFER_SIZE ; i++)
  172.     {
  173.         p_output[i]  = 0;
  174.         p_buffer1[i] = *p_buffs;
  176.         p_buffs += p_effect->i_nb_chans;
  177.         if( p_buffs >= &p_s16_buff[p_buffer->i_nb_samples * p_effect->i_nb_chans] )
  178.             p_buffs = p_s16_buff;
  180.     }
  181.     fft_perform( p_buffer1, p_output, p_state);
  182.     for( i = 0; i< FFT_BUFFER_SIZE ; i++ )
  183.         p_dest[i] = p_output[i] *  ( 2 ^ 16 ) / ( ( FFT_BUFFER_SIZE / 2 * 32768 ) ^ 2 );
  185.     /* Compute the horizontal position of the first band */
  186.     i_band_width = floor( p_effect->i_width / i_nb_bands);
  187.     i_start = ( p_effect->i_width - i_band_width * i_nb_bands ) / 2;
  189.     for ( i = 0 ; i < i_nb_bands ;i++)
  190.     {
  191.         /* We search the maximum on one scale */
  192.         for( j = xscale[i], y = 0; j< xscale[ i + 1 ]; j++ )
  193.         {
  194.             if ( p_dest[j] > y )
  195.                  y = p_dest[j];
  196.         }
  197.         /* Calculate the height of the bar */
  198.         if( y != 0 )
  199.         {
  200.             height[i] = log( y ) * 30;
  201.             if( height[i] > 380 )
  202.                 height[i] = 380;
  203.         }
  204.         else
  205.             height[ i ] = 0;
  207.         /* Draw the bar now */
  209.         if( height[i] > peaks[i] )
  210.         {
  211.             peaks[i] = height[i];
  212.         }
  213.         else if( peaks[i] > 0 )
  214.         {
  215.             peaks[i] -= PEAK_SPEED;
  216.             if( peaks[i] < height[i] )
  217.             {
  218.                 peaks[i] = height[i];
  219.             }
  220.             if( peaks[i] < 0 )
  221.             {
  222.                 peaks[i] = 0;
  223.             }
  224.         }
  226.         /* Decrease the bars if needed */
  227.         if( height[i] <= prev_heights[i] - BAR_DECREASE_SPEED )
  228.         {
  229.             height[i] = prev_heights[i];
  230.             height[i] -= BAR_DECREASE_SPEED;
  231.         }
  232.         prev_heights[i] = height[i];
  234.         if( peaks[i] > 0 && i_peak )
  235.         {
  236.             if( peaks[i] >= p_effect->i_height )
  237.                 peaks[i] = p_effect->i_height - 2;
  238.             i_line = peaks[i];
  240.             for( j = 0; j < i_band_width - 1; j++ )
  241.             {
  242.                for( k = 0; k < 3; k ++ )
  243.                {
  244.                    /* Draw the peak */
  245.                    *(p_picture->p[0].p_pixels +
  246.                     ( p_effect->i_height - i_line -1 -k ) *
  247.                      p_picture->p[0].i_pitch +
  248.                      ( i_start + i_band_width*i + j ) )
  249.                                     = 0xff;
  251.                    *(p_picture->p[1].p_pixels +
  252.                     ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  253.                      p_picture->p[1].i_pitch +
  254.                      ( ( i_start + i_band_width * i + j ) /2  ) )
  255.                                     = 0x00;
  257.                    if( i_line + k - 0x0f > 0 )
  258.                    {
  259.                        if ( i_line + k - 0x0f < 0xff )
  260.                            *(p_picture->p[2].p_pixels  +
  261.                             ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  262.                              p_picture->p[2].i_pitch +
  263.                              ( ( i_start + i_band_width * i + j ) /2  ) )
  264.                                     = ( i_line + k ) - 0x0f;
  265.                        else
  266.                            *(p_picture->p[2].p_pixels  +
  267.                             ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  268.                              p_picture->p[2].i_pitch +
  269.                              ( ( i_start + i_band_width * i + j ) /2  ) )
  270.                                     = 0xff;
  271.                    }
  272.                    else
  273.                    {
  274.                         *(p_picture->p[2].p_pixels  +
  275.                          ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  276.                          p_picture->p[2].i_pitch +
  277.                          ( ( i_start + i_band_width * i + j ) /2  ) )
  278.                                = 0x10 ;
  279.                    }
  280.                }
  281.             }
  282.         }
  284.         if(height[i] > p_effect->i_height)
  285.             height[i] = floor(p_effect->i_height );
  287.         for( i_line = 0; i_line < height[i]; i_line++ )
  288.         {
  289.             for( j = 0 ; j < i_band_width - 1; j++)
  290.             {
  291.                *(p_picture->p[0].p_pixels +
  292.                  (p_effect->i_height - i_line - 1) *
  293.                   p_picture->p[0].i_pitch +
  294.                   ( i_start + i_band_width*i + j ) ) = 0xff;
  296.                *(p_picture->p[1].p_pixels +
  297.                  ( ( p_effect->i_height - i_line ) / 2 - 1) *
  298.                  p_picture->p[1].i_pitch +
  299.                  ( ( i_start + i_band_width * i + j ) /2  ) ) = 0x00;
  301.                if( i_line - 0x0f > 0 )
  302.                {
  303.                     if( i_line - 0x0f < 0xff )
  304.                          *(p_picture->p[2].p_pixels  +
  305.                            ( ( p_effect->i_height - i_line ) / 2 - 1) *
  306.                            p_picture->p[2].i_pitch +
  307.                            ( ( i_start + i_band_width * i + j ) /2  ) ) =
  308.                                i_line - 0x0f;
  309.                     else
  310.                          *(p_picture->p[2].p_pixels  +
  311.                            ( ( p_effect->i_height - i_line ) / 2  - 1) *
  312.                            p_picture->p[2].i_pitch +
  313.                            ( ( i_start + i_band_width * i + j ) /2  ) ) =
  314.                                        0xff;
  315.                }
  316.                else
  317.                {
  318.                     *(p_picture->p[2].p_pixels  +
  319.                       ( ( p_effect->i_height - i_line ) / 2  - 1) *
  320.                       p_picture->p[2].i_pitch +
  321.                       ( ( i_start + i_band_width * i + j ) /2  ) ) =
  322.                             0x10;
  323.                }
  324.             }
  325.         }
  326.     }
  328.     fft_close( p_state );
  330.     free( p_s16_buff );
  331.     free( height );
  333.     return 0;
  334. }
  337. /*****************************************************************************
  338.  * spectrometer_Run: derivative spectrum analysis
  339.  *****************************************************************************/
  340. int spectrometer_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
  341.                  aout_buffer_t * p_buffer , picture_t * p_picture)
  342. {
  343. #define Y(R,G,B) ((uint8_t)( (R * .299) + (G * .587) + (B * .114) ))
  344. #define U(R,G,B) ((uint8_t)( (R * -.169) + (G * -.332) + (B * .500) + 128 ))
  345. #define V(R,G,B) ((uint8_t)( (R * .500) + (G * -.419) + (B * -.0813) + 128 ))
  346.     float p_output[FFT_BUFFER_SIZE];  /* Raw FFT Result  */
  347.     int *height;                      /* Bar heights */
  348.     int *peaks;                       /* Peaks */
  349.     int i_80_bands;                   /* number of bands : 80 if true else 20 */
  350.     int i_nb_bands;                   /* number of bands : 80 or 20 */
  351.     int i_band_width;                 /* width of bands */
  352.     int i_separ;                      /* Should we let blanks ? */
  353.     int i_amp;                        /* Vertical amplification */
  354.     int i_peak;                       /* Should we draw peaks ? */
  356.     int i_original;          /* original spectrum graphic routine */
  357.     int i_rad;               /* radius of circle of base of bands */
  358.     int i_sections;          /* sections of spectranalysis */
  359.     int i_extra_width;       /* extra width on peak */
  360.     int i_peak_height;       /* height of peak */
  361.     int c;                   /* sentinel container of total spectral sections */
  362.     double band_sep_angle;   /* angled separation between beginning of each band */
  363.     double section_sep_angle;/* "   "    '     "    '    "     "    spectrum section */
  364.     int max_band_length;     /* try not to go out of screen */
  365.     int i_show_base;         /* Should we draw base of circle ? */
  366.     int i_show_bands;        /* Should we draw bands ? */
  367.     //int i_invert_bands;      /* do the bands point inward ? */
  368.     double a;                /* for various misc angle situations in radians */
  369.     int x,y,xx,yy;           /* various misc x/y */
  370.     char color1;             /* V slide on a YUV color cube */
  371.     //char color2;             /* U slide.. ?  color2 fade color ? */
  373.     /* Horizontal scale for 20-band equalizer */
  374.     const int xscale1[]={0,1,2,3,4,5,6,7,8,11,15,20,27,
  375.                         36,47,62,82,107,141,184,255};
  377.     /* Horizontal scale for 80-band equalizer */
  378.     const int xscale2[] =
  379.     {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
  380.      19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,
  381.      35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
  382.      52,53,54,55,56,57,58,59,61,63,67,72,77,82,87,93,99,105,
  383.      110,115,121,130,141,152,163,174,185,200,255};
  384.     const int *xscale;
  385.     const double y_scale =  3.60673760222;  /* (log 256) */
  387.     fft_state *p_state;                 /* internal FFT data */
  389.     int i , j , k;
  390.     int i_line;
  391.     int16_t p_dest[FFT_BUFFER_SIZE];      /* Adapted FFT result */
  392.     int16_t p_buffer1[FFT_BUFFER_SIZE];   /* Buffer on which we perform
  393.                                              the FFT (first channel) */
  394.     float *p_buffl =                     /* Original buffer */
  395.             (float*)p_buffer->p_buffer;
  397.     int16_t  *p_buffs;                    /* int16_t converted buffer */
  398.     int16_t  *p_s16_buff;                /* int16_t converted buffer */
  400.     i_line = 0;
  402.     p_s16_buff = malloc( p_buffer->i_nb_samples * p_effect->i_nb_chans * sizeof(int16_t) );
  403.     if( !p_s16_buff )
  404.         return -1;
  406.     p_buffs = p_s16_buff;
  407.     i_original     = config_GetInt ( p_aout, "spect-show-original" );
  408.     i_80_bands     = config_GetInt ( p_aout, "spect-80-bands" );
  409.     i_separ        = config_GetInt ( p_aout, "spect-separ" );
  410.     i_amp          = config_GetInt ( p_aout, "spect-amp" );
  411.     i_peak         = config_GetInt ( p_aout, "spect-show-peaks" );
  412.     i_show_base    = config_GetInt ( p_aout, "spect-show-base" );
  413.     i_show_bands   = config_GetInt ( p_aout, "spect-show-bands" );
  414.     i_rad          = config_GetInt ( p_aout, "spect-radius" );
  415.     i_sections     = config_GetInt ( p_aout, "spect-sections" );
  416.     i_extra_width  = config_GetInt ( p_aout, "spect-peak-width" );
  417.     i_peak_height  = config_GetInt ( p_aout, "spect-peak-height" );
  418.     color1         = config_GetInt ( p_aout, "spect-color" );
  420.     if( i_80_bands != 0)
  421.     {
  422.         xscale = xscale2;
  423.         i_nb_bands = 80;
  424.     }
  425.     else
  426.     {
  427.         xscale = xscale1;
  428.         i_nb_bands = 20;
  429.     }
  431.     if( !p_effect->p_data )
  432.     {
  433.         p_effect->p_data=(void *)malloc( 80 * sizeof(int) );
  434.         if( !p_effect->p_data )
  435.         {
  436.             free( p_s16_buff );
  437.             return -1;
  438.         }
  439.         peaks = (int *)p_effect->p_data;
  440.         for( i = 0 ; i < i_nb_bands ; i++ )
  441.         {
  442.            peaks[i] = 0;
  443.         }
  444.     }
  445.     else
  446.     {
  447.         peaks =(int *)p_effect->p_data;
  448.     }
  450.     height = (int *)malloc( i_nb_bands * sizeof(int) );
  451.     if( !height)
  452.     {
  453.         free( p_effect->p_data );
  454.         free( p_s16_buff );
  455.         return -1;
  456.     }
  458.     /* Convert the buffer to int16_t  */
  459.     /* Pasted from float32tos16.c */
  460.     for (i = p_buffer->i_nb_samples * p_effect->i_nb_chans; i--; )
  461.     {
  462.         union { float f; int32_t i; } u;
  463.         u.f = *p_buffl + 384.0;
  464.         if(u.i >  0x43c07fff ) * p_buffs = 32767;
  465.         else if ( u.i < 0x43bf8000 ) *p_buffs = -32768;
  466.         else *p_buffs = u.i - 0x43c00000;
  468.         p_buffl++ ; p_buffs++ ;
  469.     }
  470.     p_state  = visual_fft_init();
  471.     if( !p_state)
  472.     {
  473.         msg_Err(p_aout,"unable to initialize FFT transform");
  474.         free( height );
  475.         free( p_effect->p_data );
  476.         free( p_s16_buff );
  477.         return -1;
  478.     }
  479.     p_buffs = p_s16_buff;
  480.     for ( i = 0 ; i < FFT_BUFFER_SIZE; i++)
  481.     {
  482.         p_output[i]    = 0;
  483.         p_buffer1[i] = *p_buffs;
  485.         p_buffs += p_effect->i_nb_chans;
  486.         if( p_buffs >= &p_s16_buff[p_buffer->i_nb_samples * p_effect->i_nb_chans] )
  487.             p_buffs = p_s16_buff;
  488.     }
  489.     fft_perform( p_buffer1, p_output, p_state);
  490.     for(i= 0; i< FFT_BUFFER_SIZE ; i++ )
  491.         p_dest[i] = ( (int) sqrt( p_output [ i ] ) ) >> 8;
  493.     i_nb_bands *= i_sections;
  495.     for ( i = 0 ; i< i_nb_bands/i_sections ;i++)
  496.     {
  497.         /* We search the maximum on one scale */
  498.         for( j = xscale[i] , y=0 ; j< xscale[ i + 1 ] ; j++ )
  499.         {
  500.             if ( p_dest[j] > y )
  501.                  y = p_dest[j];
  502.         }
  503.         /* Calculate the height of the bar */
  504.         y >>=7;/* remove some noise */
  505.         if( y != 0)
  506.         {
  507.             height[i] = (int)log(y)* y_scale;
  508.                if(height[i] > 150)
  509.                   height[i] = 150;
  510.         }
  511.         else
  512.         {
  513.             height[i] = 0 ;
  514.         }
  516.         /* Draw the bar now */
  517.         i_band_width = floor( p_effect->i_width / (i_nb_bands/i_sections)) ;
  519.         if( i_amp * height[i] > peaks[i])
  520.         {
  521.             peaks[i] = i_amp * height[i];
  522.         }
  523.         else if (peaks[i] > 0 )
  524.         {
  525.             peaks[i] -= PEAK_SPEED;
  526.             if( peaks[i] < i_amp * height[i] )
  527.             {
  528.                 peaks[i] = i_amp * height[i];
  529.             }
  530.             if( peaks[i] < 0 )
  531.             {
  532.                 peaks[i] = 0;
  533.             }
  534.         }
  536.         if( i_original != 0 )
  537.         {
  538.         if( peaks[i] > 0 && i_peak )
  539.         {
  540.             if( peaks[i] >= p_effect->i_height )
  541.                 peaks[i] = p_effect->i_height - 2;
  542.             i_line = peaks[i];
  544.             for( j = 0 ; j< i_band_width - i_separ; j++)
  545.             {
  546.                for( k = 0 ; k< 3 ; k ++)
  547.                {
  548.                    //* Draw the peak
  549.                      *(p_picture->p[0].p_pixels +
  550.                     (p_effect->i_height - i_line -1 -k ) *
  551.                      p_picture->p[0].i_pitch + (i_band_width*i +j) )
  552.                                     = 0xff;
  554.                     *(p_picture->p[1].p_pixels +
  555.                      ( ( p_effect->i_height - i_line ) / 2 -1 -k/2 ) *
  556.                      p_picture->p[1].i_pitch +
  557.                     ( ( i_band_width * i + j ) /2  ) )
  558.                                     = 0x00;
  560.                    if( 0x04 * (i_line + k ) - 0x0f > 0 )
  561.                    {
  562.                        if ( 0x04 * (i_line + k ) -0x0f < 0xff)
  563.                            *(p_picture->p[2].p_pixels  +
  564.                             ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  565.                              p_picture->p[2].i_pitch +
  566.                              ( ( i_band_width * i + j ) /2  ) )
  567.                                     = ( 0x04 * ( i_line + k ) ) -0x0f ;
  568.                        else
  569.                            *(p_picture->p[2].p_pixels  +
  570.                             ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  571.                              p_picture->p[2].i_pitch +
  572.                              ( ( i_band_width * i + j ) /2  ) )
  573.                                     = 0xff;
  574.                    }
  575.                    else
  576.                    {
  577.                         *(p_picture->p[2].p_pixels  +
  578.                          ( ( p_effect->i_height - i_line ) / 2 - 1 -k/2 ) *
  579.                          p_picture->p[2].i_pitch +
  580.                          ( ( i_band_width * i + j ) /2  ) )
  581.                                = 0x10 ;
  582.                    }
  583.                }
  584.             }
  585.         }
  586.         if(height[i] * i_amp > p_effect->i_height)
  587.             height[i] = floor(p_effect->i_height / i_amp );
  589.         for(i_line = 0 ; i_line < i_amp * height[i]; i_line ++ )
  590.         {
  591.             for( j = 0 ; j< i_band_width - i_separ ; j++)
  592.             {
  593.                *(p_picture->p[0].p_pixels +
  594.                  (p_effect->i_height - i_line -1) *
  595.                   p_picture->p[0].i_pitch + (i_band_width*i +j) ) = 0xff;
  597.                 *(p_picture->p[1].p_pixels +
  598.                  ( ( p_effect->i_height - i_line ) / 2 -1) *
  599.                  p_picture->p[1].i_pitch +
  600.                  ( ( i_band_width * i + j ) /2  ) ) = 0x00;
  602.                if( 0x04 * i_line - 0x0f > 0 )
  603.                {
  604.                     if( 0x04 * i_line - 0x0f < 0xff )
  605.                          *(p_picture->p[2].p_pixels  +
  606.                           ( ( p_effect->i_height - i_line ) / 2 - 1) *
  607.                            p_picture->p[2].i_pitch +
  608.                            ( ( i_band_width * i + j ) /2  ) ) =
  609.                                ( 0x04 * i_line) -0x0f ;
  610.                     else
  611.                          *(p_picture->p[2].p_pixels  +
  612.                           ( ( p_effect->i_height - i_line ) / 2 - 1) *
  613.                            p_picture->p[2].i_pitch +
  614.                            ( ( i_band_width * i + j ) /2  ) ) =
  615.                                        0xff;
  616.                }
  617.                else
  618.                {
  619.                     *(p_picture->p[2].p_pixels  +
  620.                      ( ( p_effect->i_height - i_line ) / 2 - 1) *
  621.                      p_picture->p[2].i_pitch +
  622.                      ( ( i_band_width * i + j ) /2  ) ) =
  623.                             0x10 ;
  624.                }
  625.             }
  626.         }
  627.         }
  628.     }
  630.     band_sep_angle = 360.0 / i_nb_bands;
  631.     section_sep_angle = 360.0 / i_sections;
  632.     if( i_peak_height < 1 )
  633.         i_peak_height = 1;
  634.     max_band_length = p_effect->i_height / 2 - ( i_rad + i_peak_height + 1 );
  636.     i_band_width = floor( 360 / i_nb_bands - i_separ );
  637.     if( i_band_width < 1 )
  638.         i_band_width = 1;
  640.     for( c = 0 ; c < i_sections ; c++ )
  641.     for( i = 0 ; i < (i_nb_bands / i_sections) ; i++ )
  642.     {
  643.         /* DO A PEAK */
  644.         if( peaks[i] > 0 && i_peak )
  645.         {
  646.             if( peaks[i] >= p_effect->i_height )
  647.                 peaks[i] = p_effect->i_height - 2;
  648.             i_line = peaks[i];
  650.             /* circular line pattern(so color blend is more visible) */
  651.             for( j = 0 ; j < i_peak_height ; j++ )
  652.             {
  653.                 //x = p_picture->p[0].i_pitch / 2;
  654.                 x = p_effect->i_width / 2;
  655.                 y = p_effect->i_height / 2;
  656.                 xx = x;
  657.                 yy = y;
  658.                 for( k = 0 ; k < (i_band_width + i_extra_width) ; k++ )
  659.                 {
  660.                     x = xx;
  661.                     y = yy;
  662.                     a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) + k )
  663.                         * 3.141592 / 180.0;
  664.                     x += (double)( cos(a) * (double)( i_line + j + i_rad ) );
  665.                     y += (double)( -sin(a) * (double)( i_line + j + i_rad ) );
  667.                     *(p_picture->p[0].p_pixels + x + y * p_picture->p[0].i_pitch
  668.                     ) = 255;/* Y(R,G,B); */
  670.                     x /= 2;
  671.                     y /= 2;
  673.                     *(p_picture->p[1].p_pixels + x + y * p_picture->p[1].i_pitch
  674.                     ) = 0;/* U(R,G,B); */
  676.                     if( 0x04 * (i_line + k ) - 0x0f > 0 )
  677.                     {
  678.                         if ( 0x04 * (i_line + k ) -0x0f < 0xff)
  679.                             *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  680.                             ) = ( 0x04 * ( i_line + k ) ) -(color1-1);/* -V(R,G,B); */
  681.                         else
  682.                             *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  683.                             ) = 255;/* V(R,G,B); */
  684.                     }
  685.                     else
  686.                     {
  687.                         *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  688.                         ) = color1;/* V(R,G,B); */
  689.                     }
  690.                 }
  691.             }
  692.         }
  694.         if( (height[i] * i_amp) > p_effect->i_height )
  695.             height[i] = floor( p_effect->i_height / i_amp );
  697.         /* DO BASE OF BAND (mostly makes a circle) */
  698.         if( i_show_base != 0 )
  699.         {
  700.             //x = p_picture->p[0].i_pitch / 2;
  701.             x = p_effect->i_width / 2;
  702.             y = p_effect->i_height / 2;
  704.             a =  ( (i+1) * band_sep_angle + section_sep_angle * (c+1) )
  705.                 * 3.141592 / 180.0;
  706.             x += (double)( cos(a) * (double)i_rad );/* newb-forceful casting */
  707.             y += (double)( -sin(a) * (double)i_rad );
  709.             *(p_picture->p[0].p_pixels + x + y * p_picture->p[0].i_pitch
  710.             ) = 255;/* Y(R,G,B); */
  712.             x /= 2;
  713.             y /= 2;
  715.             *(p_picture->p[1].p_pixels + x + y * p_picture->p[1].i_pitch
  716.             ) = 0;/* U(R,G,B); */
  718.             if( 0x04 * i_line - 0x0f > 0 )
  719.             {
  720.                 if( 0x04 * i_line -0x0f < 0xff)
  721.                     *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  722.                     ) = ( 0x04 * i_line) -(color1-1);/* -V(R,G,B); */
  723.                 else
  724.                     *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  725.                     ) = 255;/* V(R,G,B); */
  726.             }
  727.             else
  728.             {
  729.                 *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  730.                 ) = color1;/* V(R,G,B); */
  731.             }
  732.         }
  734.         /* DO A BAND */
  735.         if( i_show_bands != 0 )
  736.         for( j = 0 ; j < i_band_width ; j++ )
  737.         {
  738.             x = p_effect->i_width / 2;
  739.             y = p_effect->i_height / 2;
  740.             xx = x;
  741.             yy = y;
  742.             a = ( (i+1) * band_sep_angle + section_sep_angle * (c+1) + j )
  743.                 * 3.141592/180.0;
  745.             for( k = (i_rad+1) ; k < max_band_length ; k++ )
  746.             {
  747.                 if( (k-i_rad) > height[i] )
  748.                     break;/* uhh.. */
  750.                 x = xx;
  751.                 y = yy;
  752.                 x += (double)( cos(a) * (double)k );/* newbed! */
  753.                 y += (double)( -sin(a) * (double)k );
  755.                 *(p_picture->p[0].p_pixels + x + y * p_picture->p[0].i_pitch
  756.                 ) = 255;
  758.                 x /= 2;
  759.                 y /= 2;
  761.                 *(p_picture->p[1].p_pixels + x + y * p_picture->p[1].i_pitch
  762.                 ) = 0;
  764.                 if( 0x04 * i_line - 0x0f > 0 )
  765.                 {
  766.                     if ( 0x04 * i_line -0x0f < 0xff)
  767.                         *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  768.                         ) = ( 0x04 * i_line) -(color1-1);
  769.                     else
  770.                         *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  771.                         ) = 255;
  772.                 }
  773.                 else
  774.                 {
  775.                     *(p_picture->p[2].p_pixels + x + y * p_picture->p[2].i_pitch
  776.                     ) = color1;
  777.                 }
  778.             }
  779.         }
  780.     }
  782.     fft_close( p_state );
  784.     free( p_s16_buff );
  785.     free( height );
  787.     return 0;
  788. }
  791. /*****************************************************************************
  792.  * scope_Run: scope effect
  793.  *****************************************************************************/
  794. int scope_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
  795.               aout_buffer_t * p_buffer , picture_t * p_picture)
  796. {
  797.     VLC_UNUSED(p_aout);
  798.     int i_index;
  799.     float *p_sample ;
  800.     uint8_t *ppp_area[2][3];
  803.         for( i_index = 0 ; i_index < 2 ; i_index++ )
  804.         {
  805.             int j;
  806.             for( j = 0 ; j < 3 ; j++ )
  807.             {
  808.                 ppp_area[i_index][j] =
  809.                     p_picture->p[j].p_pixels + i_index * p_picture->p[j].i_lines
  810.                                 / 2 * p_picture->p[j].i_pitch;
  811.             }
  812.         }
  814.         for( i_index = 0, p_sample = (float *)p_buffer->p_buffer;
  815.              i_index < __MIN( p_effect->i_width, p_buffer->i_nb_samples );
  816.              i_index++ )
  817.         {
  818.             uint8_t i_value;
  820.             /* Left channel */
  821.             i_value =  p_sample[p_effect->i_idx_left] * 127;
  822.             *(ppp_area[0][0]
  823.                + p_picture->p[0].i_pitch * i_index / p_effect->i_width
  824.                + p_picture->p[0].i_lines * i_value / 512
  825.                    * p_picture->p[0].i_pitch) = 0xbf;
  826.             *(ppp_area[0][1]
  827.                 + p_picture->p[1].i_pitch * i_index / p_effect->i_width
  828.                 + p_picture->p[1].i_lines * i_value / 512
  829.                    * p_picture->p[1].i_pitch) = 0xff;
  832.            /* Right channel */
  833.            i_value = p_sample[p_effect->i_idx_right] * 127;
  834.            *(ppp_area[1][0]
  835.               + p_picture->p[0].i_pitch * i_index / p_effect->i_width
  836.               + p_picture->p[0].i_lines * i_value / 512
  837.                  * p_picture->p[0].i_pitch) = 0x9f;
  838.            *(ppp_area[1][2]
  839.               + p_picture->p[2].i_pitch * i_index / p_effect->i_width
  840.               + p_picture->p[2].i_lines * i_value / 512
  841.                 * p_picture->p[2].i_pitch) = 0xdd;
  843.            p_sample += p_effect->i_nb_chans;
  844.         }
  845.         return 0;
  846. }
  849. /*****************************************************************************
  850.  * vuMeter_Run: vu meter effect
  851.  *****************************************************************************/
  852. int vuMeter_Run(visual_effect_t * p_effect, aout_instance_t *p_aout,
  853.               aout_buffer_t * p_buffer , picture_t * p_picture)
  854. {
  855.         VLC_UNUSED(p_aout);
  856.         int i, j;
  857.         float i_value_l = 0;
  858.         float i_value_r = 0;
  860.         /* Compute the peack values */
  861.         for ( i = 0 ; i < p_buffer->i_nb_samples; i++ )
  862.         {
  863.                 const float *p_sample = (float *)p_buffer->p_buffer;
  864.                 float ch;
  866.                 ch = p_sample[p_effect->i_idx_left] * 256;
  867.                 if (ch > i_value_l)
  868.                         i_value_l = ch;
  870.                 ch = p_sample[p_effect->i_idx_right] * 256;
  871.                 if (ch > i_value_r)
  872.                         i_value_r = ch;
  874.                 p_sample += p_effect->i_nb_chans;
  875.         }
  877.         i_value_l = abs(i_value_l);
  878.         i_value_r = abs(i_value_r);
  880.         /* Stay under maximum value admited */
  881.         if ( i_value_l > 200 * M_PI_2 )
  882.                 i_value_l = 200 * M_PI_2;
  883.         if ( i_value_r > 200 * M_PI_2 )
  884.                 i_value_r = 200 * M_PI_2;
  886.         float *i_value;
  888.         if( !p_effect->p_data )
  889.         {
  890.                 /* Allocate memory to save hand positions */
  891.                 p_effect->p_data = (void *)malloc( 2 * sizeof(float) );
  892.                 i_value = p_effect->p_data;
  893.                 i_value[0] = i_value_l;
  894.                 i_value[1] = i_value_r;
  895.         }
  896.         else
  897.         {
  898.                 /* Make the hands go down slowly if the current values are slower
  899.                 than the previous */
  900.                 i_value = p_effect->p_data;
  902.                 if ( i_value_l > i_value[0] - 6 )
  903.                         i_value[0] = i_value_l;
  904.                 else
  905.                         i_value[0] = i_value[0] - 6;
  907.                 if ( i_value_r > i_value[1] - 6 )
  908.                         i_value[1] = i_value_r;
  909.                 else
  910.                         i_value[1] = i_value[1] - 6;
  911.         }
  913.         int x, y, k;
  914.         float teta;
  915.         float teta_grad;
  917.         for ( j = 0; j < 2; j++ )
  918.         {
  919.                 /* Draw the two scales */
  920.                 k = 0;
  921.                 teta_grad = GRAD_ANGLE_MIN;
  922.                 for ( teta = -M_PI_4; teta <= M_PI_4; teta = teta + 0.003 )
  923.                 {
  924.                         for ( i = 140; i <= 150; i++ )
  925.                         {
  926.                                 y = i * cos(teta) + 20;
  927.                                 x = i * sin(teta) + 150 + 240 * j;
  928.                                 /* Compute the last color for the gradation */
  929.                                 if (teta >= teta_grad + GRAD_INCR && teta_grad <= GRAD_ANGLE_MAX)
  930.                                 {
  931.                                         teta_grad = teta_grad + GRAD_INCR;
  932.                                         k = k + 5;
  933.                                 }
  934.                                 *(p_picture->p[0].p_pixels +
  935.                                  (p_picture->p[0].i_lines - y - 1 ) * p_picture->p[0].i_pitch
  936.                                  + x ) = 0x45;
  937.                                 *(p_picture->p[1].p_pixels +
  938.                                  (p_picture->p[1].i_lines - y / 2 - 1 ) * p_picture->p[1].i_pitch
  939.                                  + x / 2 ) = 0x0;
  940.                                 *(p_picture->p[2].p_pixels +
  941.                                  (p_picture->p[2].i_lines - y / 2 - 1 ) * p_picture->p[2].i_pitch
  942.                                  + x / 2 ) = 0x4D + k;
  943.                         }
  944.                 }
  946.                 /* Draw the two hands */
  947.                 teta = (float)i_value[j] / 200 - M_PI_4;
  948.                 for ( i = 0; i <= 150; i++ )
  949.                 {
  950.                         y = i * cos(teta) + 20;
  951.                         x = i * sin(teta) + 150 + 240 * j;
  952.                         *(p_picture->p[0].p_pixels +
  953.                          (p_picture->p[0].i_lines - y - 1 ) * p_picture->p[0].i_pitch
  954.                          + x ) = 0xAD;
  955.                         *(p_picture->p[1].p_pixels +
  956.                          (p_picture->p[1].i_lines - y / 2 - 1 ) * p_picture->p[1].i_pitch
  957.                          + x / 2 ) = 0xFC;
  958.                         *(p_picture->p[2].p_pixels +
  959.                          (p_picture->p[2].i_lines - y / 2 - 1 ) * p_picture->p[2].i_pitch
  960.                          + x / 2 ) = 0xAC;
  961.                 }
  963.                 /* Draw the hand bases */
  964.                 for ( teta = -M_PI_2; teta <= M_PI_2 + 0.01; teta = teta + 0.003 )
  965.                 {
  966.                         for ( i = 0; i < 10; i++ )
  967.                         {
  968.                                 y = i * cos(teta) + 20;
  969.                                 x = i * sin(teta) + 150 + 240 * j;
  970.                                 *(p_picture->p[0].p_pixels +
  971.                                  (p_picture->p[0].i_lines - y - 1 ) * p_picture->p[0].i_pitch
  972.                                  + x ) = 0xFF;
  973.                                 *(p_picture->p[1].p_pixels +
  974.                                  (p_picture->p[1].i_lines - y / 2 - 1 ) * p_picture->p[1].i_pitch
  975.                                  + x / 2 ) = 0x80;
  976.                                 *(p_picture->p[2].p_pixels +
  977.                                  (p_picture->p[2].i_lines - y / 2 - 1 ) * p_picture->p[2].i_pitch
  978.                                  + x / 2 ) = 0x80;
  979.                         }
  980.                 }
  982.         }
  984.         return 0;
  985. }