Add a visualization module using libprojectM.
[vlc.git] / modules / visualization / projectm.cpp
1 /*****************************************************************************
2  * projectm: visualization module based on libprojectM
3  *****************************************************************************
4  * Copyright (C) 2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: RĂ©mi Duraffort <ivoire@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by the Free
11  * Software Foundation; either version 2 of the License, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful, but WITHOUT
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
17  * more details.
18  *
19  * You should have received a copy of the GNU General Public License along with
20  * this program; if not, write to the Free Software Foundation, Inc., 51
21  * Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <vlc_common.h>
29 #include <vlc_plugin.h>
30 #include <vlc_aout.h>
31 #include <vlc_vout.h>
32
33 #include <libprojectM/projectM.hpp>
34
35
36 /*****************************************************************************
37  * Module descriptor
38  *****************************************************************************/
39 static int  Open         ( vlc_object_t * );
40 static void Close        ( vlc_object_t * );
41
42 #define CONFIG_TEXT N_("projectM configuration file")
43 #define CONFIG_LONGTEXT N_("File that will be used to configure the projectM " \
44                            "module.")
45
46 #define WIDTH_TEXT N_("Video width")
47 #define WIDTH_LONGTEXT N_("The width of the video window, in pixels.")
48
49 #define HEIGHT_TEXT N_("Video height")
50 #define HEIGHT_LONGTEXT N_("The height of the video window, in pixels.")
51
52 vlc_module_begin ()
53     set_shortname( N_("projectM"))
54     set_description( N_("libprojectM effect") )
55     set_capability( "visualization", 0 )
56     set_category( CAT_AUDIO )
57     set_subcategory( SUBCAT_AUDIO_VISUAL )
58     add_file( "projectm-config", "/usr/share/projectM/config.inp", NULL,
59                 CONFIG_TEXT, CONFIG_LONGTEXT, true )
60     add_integer( "projectm-width", 640, NULL, WIDTH_TEXT, WIDTH_LONGTEXT,
61                  false )
62     add_integer( "projectm-height", 480, NULL, HEIGHT_TEXT, HEIGHT_LONGTEXT,
63                  false )
64     add_shortcut( "projectm" )
65     set_callbacks( Open, Close )
66 vlc_module_end ()
67
68
69 /*****************************************************************************
70  * Local prototypes
71  *****************************************************************************/
72 typedef struct
73 {
74     VLC_COMMON_MEMBERS
75
76     /* video output module and opengl provider */
77     vout_thread_t *p_opengl;
78     module_t      *p_module;
79
80     /* libprojectM objects */
81     projectM      *p_projectm;
82     char          *psz_config;
83
84     /* Window size */
85     int i_width;
86     int i_height;
87
88     /* audio info */
89     int i_channels;
90     float *p_buffer;
91     int   i_buffer_size;
92     int   i_nb_samples;
93
94     vlc_mutex_t lock;
95 } projectm_thread_t;
96
97
98 struct aout_filter_sys_t
99 {
100     projectm_thread_t *p_thread;
101 };
102
103
104 static void DoWork( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
105                     aout_buffer_t * );
106 static void* Thread( vlc_object_t * );
107
108
109 /**
110  * Init the openGL context
111  * p_thread: projectm thread object
112  * @return VLC_SUCCESS or vlc error codes
113  */
114 static int initOpenGL( projectm_thread_t *p_thread )
115 {
116     p_thread->p_opengl = (vout_thread_t *)vlc_object_create( p_thread,
117                                                     sizeof( vout_thread_t ) );
118     if( !p_thread->p_opengl )
119         return VLC_ENOMEM;
120
121     vlc_object_attach( p_thread->p_opengl, p_thread );
122
123     /* Initialize the opengl object */
124     video_format_Setup( &p_thread->p_opengl->fmt_in, VLC_CODEC_RGB32,
125                         640, 460, 1 );
126     p_thread->p_opengl->i_window_width = p_thread->i_width;
127     p_thread->p_opengl->i_window_height = p_thread->i_height;
128     p_thread->p_opengl->render.i_width = p_thread->i_width;
129     p_thread->p_opengl->render.i_height = p_thread->i_height;
130     p_thread->p_opengl->render.i_aspect = VOUT_ASPECT_FACTOR;
131     p_thread->p_opengl->b_fullscreen = false;
132     p_thread->p_opengl->i_alignment = 0;
133     p_thread->p_opengl->fmt_in.i_sar_num = 1;
134     p_thread->p_opengl->fmt_in.i_sar_den = 1;
135     p_thread->p_opengl->fmt_render = p_thread->p_opengl->fmt_in;
136
137     /* Ask for the opengl provider */
138     p_thread->p_module = module_need( p_thread->p_opengl, "opengl provider",
139                                       NULL, false );
140     if( !p_thread->p_module )
141     {
142         msg_Err( p_thread, "unable to initialize OpenGL" );
143         vlc_object_detach( p_thread->p_opengl );
144         vlc_object_release( p_thread->p_opengl );
145         return VLC_EGENERIC;
146     }
147
148     return VLC_SUCCESS;
149 }
150
151
152 /**
153  * Open the module
154  * @param p_this: the filter object
155  * @return VLC_SUCCESS or vlc error codes
156  */
157 static int Open( vlc_object_t * p_this )
158 {
159     aout_filter_t       *p_filter = (aout_filter_t *)p_this;
160     aout_filter_sys_t   *p_sys;
161     projectm_thread_t   *p_thread;
162
163     /* Test the audio format */
164     if( p_filter->input.i_format != VLC_CODEC_FL32 ||
165         p_filter->output.i_format != VLC_CODEC_FL32 )
166     {
167         msg_Warn( p_filter, "bad input or output format" );
168         return VLC_EGENERIC;
169     }
170     if( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
171     {
172         msg_Warn( p_filter, "input and outut are not similar" );
173         return VLC_EGENERIC;
174     }
175
176     p_filter->pf_do_work = DoWork;
177     p_filter->b_in_place = true;
178
179     p_sys = p_filter->p_sys = (aout_filter_sys_t*)malloc( sizeof( *p_sys ) );
180     if( !p_sys )
181         return VLC_ENOMEM;
182
183     /* Create the object for the thread */
184     p_sys->p_thread = p_thread = (projectm_thread_t *)
185                     vlc_object_create( p_filter, sizeof( projectm_thread_t ) );
186     vlc_object_attach( p_sys->p_thread, p_filter );
187     p_thread->i_width  = var_CreateGetInteger( p_filter, "projectm-width" );
188     p_thread->i_height = var_CreateGetInteger( p_filter, "projectm-height" );
189
190     /* Create the openGL provider */
191     int i_ret = initOpenGL( p_sys->p_thread );
192     if( i_ret != VLC_SUCCESS )
193     {
194         vlc_object_detach( p_sys->p_thread );
195         vlc_object_release( p_sys->p_thread );
196         free( p_sys );
197         return i_ret;
198     }
199
200     p_thread->i_channels = aout_FormatNbChannels( &p_filter->input );
201     p_thread->psz_config = var_CreateGetString( p_filter, "projectm-config" );
202     vlc_mutex_init( &p_thread->lock );
203     p_thread->p_buffer = NULL;
204     p_thread->i_buffer_size = 0;
205     p_thread->i_nb_samples = 0;
206
207     /* Create the thread */
208     if( vlc_thread_create( p_thread, "projectm update thread", Thread,
209                            VLC_THREAD_PRIORITY_LOW ) )
210     {
211         msg_Err( p_filter, "cannot launch the projectm thread" );
212         vlc_object_detach( p_thread );
213         vlc_object_release( p_thread );
214         free (p_sys );
215         return VLC_EGENERIC;
216     }
217
218     return VLC_SUCCESS;
219 }
220
221
222 /**
223  * Close the module
224  * @param p_this: the filter object
225  */
226 static void Close( vlc_object_t *p_this )
227 {
228     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
229     aout_filter_sys_t *p_sys = p_filter->p_sys;
230     projectm_thread_t *p_thread = p_sys->p_thread;
231
232     /* Stop the thread */
233     vlc_object_kill( p_thread );
234     vlc_thread_join( p_thread );
235
236     /* Free the ressources */
237     vlc_mutex_destroy( &p_thread->lock );
238     free( p_thread->p_buffer );
239     free( p_thread->psz_config );
240
241     vlc_object_detach( p_thread );
242     vlc_object_release( p_thread );
243
244     free( p_sys );
245 }
246
247
248 /**
249  * Do the actual work with the new sample
250  * @param p_aout: audio output object
251  * @param p_filter: filter object
252  * @param p_in_buf: input buffer
253  * @param p_out_buf: output buffer
254  */
255 static void DoWork( aout_instance_t *p_aout, aout_filter_t *p_filter,
256                     aout_buffer_t *p_in_buf, aout_buffer_t *p_out_buf )
257 {
258     projectm_thread_t *p_thread = p_filter->p_sys->p_thread;
259
260     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
261     p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
262
263     vlc_mutex_lock( &p_thread->lock );
264     if( p_thread->i_buffer_size > 0 )
265     {
266         p_thread->p_buffer[0] = 0;
267         p_thread->i_nb_samples = __MIN( p_thread->i_buffer_size,
268                                         p_in_buf->i_nb_samples );
269         for( int i = 0; i < p_thread->i_nb_samples; i++ )
270             p_thread->p_buffer[i] = p_in_buf->p_buffer[i];
271     }
272
273     vlc_mutex_unlock( &p_thread->lock );
274
275     return;
276 }
277
278
279 /**
280  * ProjectM update thread which do the rendering
281  * @param p_this: the p_thread object
282  */
283 static void* Thread( vlc_object_t *p_this )
284 {
285     /* we don't want to be interupted in this thread */
286     int cancel = vlc_savecancel();
287     projectm_thread_t *p_thread = (projectm_thread_t *)p_this;
288
289     /* Initialize the opengl provider for this thread */
290     p_thread->p_opengl->pf_init( p_thread->p_opengl );
291
292     /* Create the projectM object */
293     p_thread->p_projectm = new projectM( p_thread->psz_config );
294     p_thread->i_buffer_size = p_thread->p_projectm->pcm()->maxsamples;
295     p_thread->p_buffer = (float*)malloc( p_thread->i_buffer_size *
296                                          sizeof( float ) );
297
298     /* TODO: Give to projectm the name of the input
299     p_thread->p_projectm->projectM_setTitle( "" ); */
300
301     /* Reset the dislay to get the right size */
302     p_thread->p_projectm->projectM_resetGL( p_thread->i_width,
303                                             p_thread->i_height );
304
305     while( vlc_object_alive( p_thread ) )
306     {
307         /* Render the image and swap the buffers */
308         vlc_mutex_lock( &p_thread->lock );
309         if( p_thread->i_nb_samples > 0 )
310             p_thread->p_projectm->pcm()->addPCMfloat( p_thread->p_buffer,
311                                                       p_thread->i_nb_samples );
312
313         p_thread->p_projectm->renderFrame();
314         p_thread->p_opengl->pf_swap( p_thread->p_opengl );
315         vlc_mutex_unlock( &p_thread->lock );
316
317         /* TODO: use a fps limiter */
318         msleep( 1000 );
319     }
320
321
322     /* Cleanup */
323     delete p_thread->p_projectm;
324
325     /* Free the openGL provider */
326     module_unneed( p_thread->p_opengl, p_thread->p_module );
327     vlc_object_detach( p_thread->p_opengl );
328     vlc_object_release( p_thread->p_opengl );
329
330
331     vlc_restorecancel( cancel );
332     return NULL;
333 }