git.sesse.net Git - vlc/blob - modules/visualization/galaktos/plugin.c

   1 /*****************************************************************************
   2  * plugin.c:
   3  *****************************************************************************
   4  * Copyright (C) 2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Cyril Deguet <asmax@videolan.org>
   8  *          Implementation of the winamp plugin MilkDrop
   9  *          based on projectM http://xmms-projectm.sourceforge.net
  10  *          and SciVi http://xmms-scivi.sourceforge.net
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #include "plugin.h"
  32 #include "main.h"
  33 #include "PCM.h"
  34 #include "video_init.h"
  35 #include <GL/glu.h>
  36
  37 #include <vlc_input.h>
  38 #include <vlc_playlist.h>
  39 #include <vlc_plugin.h>
  40
  41 /*****************************************************************************
  42  * Module descriptor
  43  *****************************************************************************/
  44 static int  Open         ( vlc_object_t * );
  45 static void Close        ( vlc_object_t * );
  46
  47 vlc_module_begin();
  48     set_description( N_("GaLaktos visualization plugin") );
  49     set_capability( "visualization", 0 );
  50     set_callbacks( Open, Close );
  51     add_shortcut( "galaktos" );
  52 vlc_module_end();
  53
  54 /*****************************************************************************
  55  * Local prototypes
  56  *****************************************************************************/
  57 typedef struct aout_filter_sys_t
  58 {
  59     galaktos_thread_t *p_thread;
  60
  61 } aout_filter_sys_t;
  62
  63 static void DoWork   ( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
  64                        aout_buffer_t * );
  65
  66 static void* Thread   ( vlc_object_t * );
  67
  68 static char *TitleGet( vlc_object_t * );
  69
  70
  71 extern GLuint RenderTargetTextureID;
  72
  73 /*****************************************************************************
  74  * Open: open a scope effect plugin
  75  *****************************************************************************/
  76 static int Open( vlc_object_t *p_this )
  77 {
  78     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
  79     aout_filter_sys_t *p_sys;
  80     galaktos_thread_t *p_thread;
  81
  82     if ( p_filter->input.i_format != VLC_FOURCC('f','l','3','2' )
  83          || p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
  84     {
  85         msg_Warn( p_filter, "bad input or output format" );
  86         return VLC_EGENERIC;
  87     }
  88     if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
  89     {
  90         msg_Warn( p_filter, "input and output formats are not similar" );
  91         return VLC_EGENERIC;
  92     }
  93
  94     p_filter->pf_do_work = DoWork;
  95     p_filter->b_in_place = 1;
  96
  97     /* Allocate structure */
  98     p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
  99
 100     /* Create galaktos thread */
 101     p_sys->p_thread = p_thread =
 102         vlc_object_create( p_filter, sizeof( galaktos_thread_t ) );
 103     vlc_object_attach( p_thread, p_this );
 104
 105 /*
 106     var_Create( p_thread, "galaktos-width", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 107     var_Get( p_thread, "galaktos-width", &width );
 108     var_Create( p_thread, "galaktos-height", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 109     var_Get( p_thread, "galaktos-height", &height );
 110 */
 111     p_thread->i_cur_sample = 0;
 112     bzero( p_thread->p_data, 2*2*512 );
 113
 114     p_thread->i_width = 600;
 115     p_thread->i_height = 600;
 116     p_thread->b_fullscreen = 0;
 117     galaktos_init( p_thread );
 118
 119     p_thread->i_channels = aout_FormatNbChannels( &p_filter->input );
 120
 121     p_thread->psz_title = TitleGet( VLC_OBJECT( p_filter ) );
 122
 123     if( vlc_thread_create( p_thread, "galaktos update thread", Thread,
 124                            VLC_THREAD_PRIORITY_LOW, false ) )
 125     {
 126         msg_Err( p_filter, "cannot lauch galaktos thread" );
 127         free( p_thread->psz_title );
 128         vlc_object_detach( p_thread );
 129         vlc_object_release( p_thread );
 130         free( p_sys );
 131         return VLC_EGENERIC;
 132     }
 133
 134     return VLC_SUCCESS;
 135 }
 136
 137 /*****************************************************************************
 138  * float to s16 conversion
 139  *****************************************************************************/
 140 static inline int16_t FloatToInt16( float f )
 141 {
 142     if( f >= 1.0 )
 143         return 32767;
 144     else if( f < -1.0 )
 145         return -32768;
 146     else
 147         return (int16_t)( f * 32768.0 );
 148 }
 149
 150 /*****************************************************************************
 151  * DoWork: process samples buffer
 152  *****************************************************************************
 153  * This function queues the audio buffer to be processed by the galaktos thread
 154  *****************************************************************************/
 155 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
 156                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
 157 {
 158     int i_samples;
 159     int i_channels;
 160     float *p_float;
 161     galaktos_thread_t *p_thread = p_filter->p_sys->p_thread;
 162
 163     p_float = (float *)p_in_buf->p_buffer;
 164     i_channels = p_thread->i_channels;
 165
 166     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
 167     p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
 168
 169     for( i_samples = p_in_buf->i_nb_samples; i_samples > 0; i_samples-- )
 170     {
 171         int i_cur_sample = p_thread->i_cur_sample;
 172
 173         p_thread->p_data[0][i_cur_sample] = FloatToInt16( p_float[0] );
 174         if( i_channels > 1 )
 175         {
 176             p_thread->p_data[1][i_cur_sample] = FloatToInt16( p_float[1] );
 177         }
 178         p_float += i_channels;
 179
 180         if( ++(p_thread->i_cur_sample) == 512 )
 181         {
 182             addPCM( p_thread->p_data );
 183             p_thread->i_cur_sample = 0;
 184         }
 185     }
 186 }
 187
 188 /*****************************************************************************
 189  * Thread:
 190  *****************************************************************************/
 191 static void* Thread( vlc_object_t *p_this )
 192 {
 193     galaktos_thread_t *p_thread = (galaktos_thread_t*)p_this;
 194
 195     int count=0;
 196     double realfps=0,fpsstart=0;
 197     int timed=0;
 198     int timestart=0;
 199     int mspf=0;
 200
 201     /* Get on OpenGL provider */
 202     p_thread->p_opengl =
 203         (vout_thread_t *)vlc_object_create( p_this, VLC_OBJECT_OPENGL );
 204     if( p_thread->p_opengl == NULL )
 205         return NULL;
 206     vlc_object_attach( p_thread->p_opengl, p_this );
 207
 208     /* Initialize vout parameters */
 209     vout_InitFormat( &p_thread->p_opengl->fmt_in,
 210                      VLC_FOURCC('R','V','3','2'),
 211                      p_thread->i_width, p_thread->i_height, 1 );
 212     p_thread->p_opengl->i_window_width = p_thread->i_width;
 213     p_thread->p_opengl->i_window_height = p_thread->i_height;
 214     p_thread->p_opengl->render.i_width = p_thread->i_width;
 215     p_thread->p_opengl->render.i_height = p_thread->i_width;
 216     p_thread->p_opengl->render.i_aspect = VOUT_ASPECT_FACTOR;
 217     p_thread->p_opengl->b_scale = true;
 218     p_thread->p_opengl->b_fullscreen = false;
 219     p_thread->p_opengl->i_alignment = 0;
 220     p_thread->p_opengl->fmt_in.i_sar_num = 1;
 221     p_thread->p_opengl->fmt_in.i_sar_den = 1;
 222     p_thread->p_opengl->fmt_render = p_thread->p_opengl->fmt_in;
 223
 224     p_thread->p_module =
 225         module_Need( p_thread->p_opengl, "opengl provider", NULL, 0 );
 226     if( p_thread->p_module == NULL )
 227     {
 228         msg_Err( p_thread, "unable to initialize OpenGL" );
 229         vlc_object_detach( p_thread->p_opengl );
 230         vlc_object_release( p_thread->p_opengl );
 231         return NULL;
 232     }
 233
 234     p_thread->p_opengl->pf_init( p_thread->p_opengl );
 235
 236     setup_opengl( p_thread->i_width, p_thread->i_height );
 237     CreateRenderTarget(512, &RenderTargetTextureID, NULL);
 238
 239     timestart=mdate()/1000;
 240
 241     while( vlc_object_alive (p_thread) )
 242     {
 243         mspf = 1000 / 60;
 244         if( galaktos_update( p_thread ) == 1 )
 245         {
 246             vlc_object_kill( p_thread );
 247         }
 248         free( p_thread->psz_title );
 249         p_thread->psz_title = NULL;
 250
 251         if (++count%100==0)
 252         {
 253             realfps=100/((mdate()/1000-fpsstart)/1000);
 254  //           printf("%f\n",realfps);
 255             fpsstart=mdate()/1000;
 256         }
 257         //framerate limiter
 258         timed=mspf-(mdate()/1000-timestart);
 259       //   printf("%d,%d\n",time,mspf);
 260         if (timed>0) msleep(1000*timed);
 261     //     printf("Limiter %d\n",(mdate()/1000-timestart));
 262         timestart=mdate()/1000;
 263     }
 264
 265     /* Free the openGL provider */
 266     module_Unneed( p_thread->p_opengl, p_thread->p_module );
 267     vlc_object_detach( p_thread->p_opengl );
 268     vlc_object_release( p_thread->p_opengl );
 269     return NULL;
 270 }
 271
 272 /*****************************************************************************
 273  * Close: close the plugin
 274  *****************************************************************************/
 275 static void Close( vlc_object_t *p_this )
 276 {
 277     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
 278     aout_filter_sys_t *p_sys = p_filter->p_sys;
 279
 280     /* Stop galaktos Thread */
 281     vlc_object_kill( p_sys->p_thread );
 282
 283     galaktos_done( p_sys->p_thread );
 284
 285     vlc_thread_join( p_sys->p_thread );
 286
 287     /* Free data */
 288     vlc_object_detach( p_sys->p_thread );
 289     vlc_object_release( p_sys->p_thread );
 290
 291     free( p_sys );
 292 }
 293
 294 static char *TitleGet( vlc_object_t *p_this )
 295 {
 296     char *psz_title = NULL;
 297     input_thread_t *p_input =
 298         vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
 299
 300     if( p_input )
 301     {
 302         char *psz_orig = input_item_GetURI( input_GetItem( p_input ) );
 303         char *psz = strrchr( psz_orig, '/' );
 304
 305         if( psz )
 306         {
 307             psz++;
 308         }
 309         else
 310         {
 311             psz = psz_orig;
 312         }
 313         if( psz && *psz )
 314         {
 315             psz_title = strdup( psz );
 316         }
 317         free( psz_orig );
 318         vlc_object_release( p_input );
 319     }
 320
 321     return psz_title;
 322 }