Mac OS X gui: Don't try to change the interface from a non-main thread. (Should fix...
[vlc.git] / modules / visualization / goom.c
1 /*****************************************************************************
2  * goom.c: based on libgoom (see http://ios.free.fr/?page=projet&quoi=1)
3  *****************************************************************************
4  * Copyright (C) 2003 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@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  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>                                      /* malloc(), free() */
29 #include <string.h>                                              /* strdup() */
30 #include <errno.h>
31
32 #include <vlc/vlc.h>
33 #include <vlc_aout.h>
34 #include <vlc_vout.h>
35 #include <vlc_block.h>
36 #include <vlc_input.h>
37
38 #ifdef USE_GOOM_TREE
39 #   ifdef OLD_GOOM
40 #       include "goom_core.h"
41 #       define PluginInfo void
42 #       define goom_update(a,b,c,d,e,f) goom_update(b,c,d,e,f)
43 #       define goom_close(a) goom_close()
44 #       define goom_init(a,b) NULL; goom_init(a,b,0); goom_set_font(0,0,0)
45 #   else
46 #       include "goom.h"
47 #   endif
48 #else
49 #   include <goom/goom.h>
50 #endif
51
52 /*****************************************************************************
53  * Module descriptor
54  *****************************************************************************/
55 static int  Open         ( vlc_object_t * );
56 static void Close        ( vlc_object_t * );
57
58 #define WIDTH_TEXT N_("Goom display width")
59 #define HEIGHT_TEXT N_("Goom display height")
60 #define RES_LONGTEXT N_("This allows you to set the resolution of the " \
61   "Goom display (bigger resolution will be prettier but more CPU intensive).")
62
63 #define SPEED_TEXT N_("Goom animation speed")
64 #define SPEED_LONGTEXT N_("This allows you to set the animation speed " \
65   "(between 1 and 10, defaults to 6).")
66
67 #define MAX_SPEED 10
68
69 vlc_module_begin();
70     set_shortname( _("Goom"));
71     set_description( _("Goom effect") );
72     set_category( CAT_AUDIO );
73     set_subcategory( SUBCAT_AUDIO_VISUAL );
74     set_capability( "visualization", 0 );
75     add_integer( "goom-width", 320, NULL,
76                  WIDTH_TEXT, RES_LONGTEXT, VLC_FALSE );
77     add_integer( "goom-height", 240, NULL,
78                  HEIGHT_TEXT, RES_LONGTEXT, VLC_FALSE );
79     add_integer( "goom-speed", 6, NULL,
80                  SPEED_TEXT, SPEED_LONGTEXT, VLC_FALSE );
81     set_callbacks( Open, Close );
82     add_shortcut( "goom" );
83 vlc_module_end();
84
85 /*****************************************************************************
86  * Local prototypes
87  *****************************************************************************/
88 #define MAX_BLOCKS 100
89 #define GOOM_DELAY 400000
90
91 typedef struct
92 {
93     VLC_COMMON_MEMBERS
94     vout_thread_t *p_vout;
95
96     char          *psz_title;
97
98     vlc_mutex_t   lock;
99     vlc_cond_t    wait;
100
101     /* Audio properties */
102     int i_channels;
103
104     /* Audio samples queue */
105     block_t       *pp_blocks[MAX_BLOCKS];
106     int           i_blocks;
107
108     audio_date_t  date;
109
110 } goom_thread_t;
111
112 typedef struct aout_filter_sys_t
113 {
114     goom_thread_t *p_thread;
115
116 } aout_filter_sys_t;
117
118 static void DoWork   ( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
119                        aout_buffer_t * );
120
121 static void Thread   ( vlc_object_t * );
122
123 static char *TitleGet( vlc_object_t * );
124
125 /*****************************************************************************
126  * Open: open a scope effect plugin
127  *****************************************************************************/
128 static int Open( vlc_object_t *p_this )
129 {
130     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
131     aout_filter_sys_t *p_sys;
132     goom_thread_t     *p_thread;
133     vlc_value_t       width, height;
134     video_format_t    fmt = {0};
135
136     if ( p_filter->input.i_format != VLC_FOURCC('f','l','3','2' )
137          || p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
138     {
139         msg_Warn( p_filter, "bad input or output format" );
140         return VLC_EGENERIC;
141     }
142     if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
143     {
144         msg_Warn( p_filter, "input and output formats are not similar" );
145         return VLC_EGENERIC;
146     }
147
148     p_filter->pf_do_work = DoWork;
149     p_filter->b_in_place = 1;
150
151     /* Allocate structure */
152     p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
153
154     /* Create goom thread */
155     p_sys->p_thread = p_thread =
156         vlc_object_create( p_filter, sizeof( goom_thread_t ) );
157     vlc_object_attach( p_thread, p_this );
158
159     var_Create( p_thread, "goom-width", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
160     var_Get( p_thread, "goom-width", &width );
161     var_Create( p_thread, "goom-height", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
162     var_Get( p_thread, "goom-height", &height );
163
164     fmt.i_width = fmt.i_visible_width = width.i_int;
165     fmt.i_height = fmt.i_visible_height = height.i_int;
166     fmt.i_chroma = VLC_FOURCC('R','V','3','2');
167     fmt.i_aspect = VOUT_ASPECT_FACTOR * width.i_int/height.i_int;
168     fmt.i_sar_num = fmt.i_sar_den = 1;
169
170     p_thread->p_vout = vout_Request( p_filter, NULL, &fmt );
171     if( p_thread->p_vout == NULL )
172     {
173         msg_Err( p_filter, "no suitable vout module" );
174         vlc_object_detach( p_thread );
175         vlc_object_destroy( p_thread );
176         free( p_sys );
177         return VLC_EGENERIC;
178     }
179     vlc_mutex_init( p_filter, &p_thread->lock );
180     vlc_cond_init( p_filter, &p_thread->wait );
181
182     p_thread->i_blocks = 0;
183     aout_DateInit( &p_thread->date, p_filter->output.i_rate );
184     aout_DateSet( &p_thread->date, 0 );
185     p_thread->i_channels = aout_FormatNbChannels( &p_filter->input );
186
187     p_thread->psz_title = TitleGet( VLC_OBJECT( p_filter ) );
188
189     if( vlc_thread_create( p_thread, "Goom Update Thread", Thread,
190                            VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
191     {
192         msg_Err( p_filter, "cannot lauch goom thread" );
193         vout_Destroy( p_thread->p_vout );
194         vlc_mutex_destroy( &p_thread->lock );
195         vlc_cond_destroy( &p_thread->wait );
196         if( p_thread->psz_title ) free( p_thread->psz_title );
197         vlc_object_detach( p_thread );
198         vlc_object_destroy( p_thread );
199         free( p_sys );
200         return VLC_EGENERIC;
201     }
202
203     return VLC_SUCCESS;
204 }
205
206 /*****************************************************************************
207  * DoWork: process samples buffer
208  *****************************************************************************
209  * This function queues the audio buffer to be processed by the goom thread
210  *****************************************************************************/
211 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
212                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
213 {
214     aout_filter_sys_t *p_sys = p_filter->p_sys;
215     block_t *p_block;
216
217     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
218     p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes;
219
220     /* Queue sample */
221     vlc_mutex_lock( &p_sys->p_thread->lock );
222     if( p_sys->p_thread->i_blocks == MAX_BLOCKS )
223     {
224         vlc_mutex_unlock( &p_sys->p_thread->lock );
225         return;
226     }
227
228     p_block = block_New( p_sys->p_thread, p_in_buf->i_nb_bytes );
229     if( !p_block ) return;
230     memcpy( p_block->p_buffer, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
231     p_block->i_pts = p_in_buf->start_date;
232
233     p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks++] = p_block;
234
235     vlc_cond_signal( &p_sys->p_thread->wait );
236     vlc_mutex_unlock( &p_sys->p_thread->lock );
237 }
238
239 /*****************************************************************************
240  * float to s16 conversion
241  *****************************************************************************/
242 static inline int16_t FloatToInt16( float f )
243 {
244     if( f >= 1.0 )
245         return 32767;
246     else if( f < -1.0 )
247         return -32768;
248     else
249         return (int16_t)( f * 32768.0 );
250 }
251
252 /*****************************************************************************
253  * Fill buffer
254  *****************************************************************************/
255 static int FillBuffer( int16_t *p_data, int *pi_data,
256                        audio_date_t *pi_date, audio_date_t *pi_date_end,
257                        goom_thread_t *p_this )
258 {
259     int i_samples = 0;
260     block_t *p_block;
261
262     while( *pi_data < 512 )
263     {
264         if( !p_this->i_blocks ) return VLC_EGENERIC;
265
266         p_block = p_this->pp_blocks[0];
267         i_samples = __MIN( 512 - *pi_data, p_block->i_buffer /
268                            sizeof(float) / p_this->i_channels );
269
270         /* Date management */
271         if( p_block->i_pts > 0 &&
272             p_block->i_pts != aout_DateGet( pi_date_end ) )
273         {
274            aout_DateSet( pi_date_end, p_block->i_pts );
275         }
276         p_block->i_pts = 0;
277
278         aout_DateIncrement( pi_date_end, i_samples );
279
280         while( i_samples > 0 )
281         {
282             float *p_float = (float *)p_block->p_buffer;
283
284             p_data[*pi_data] = FloatToInt16( p_float[0] );
285             if( p_this->i_channels > 1 )
286                 p_data[512 + *pi_data] = FloatToInt16( p_float[1] );
287
288             (*pi_data)++;
289             p_block->p_buffer += (sizeof(float) * p_this->i_channels);
290             p_block->i_buffer -= (sizeof(float) * p_this->i_channels);
291             i_samples--;
292         }
293
294         if( !p_block->i_buffer )
295         {
296             block_Release( p_block );
297             p_this->i_blocks--;
298             if( p_this->i_blocks )
299                 memmove( p_this->pp_blocks, p_this->pp_blocks + 1,
300                          p_this->i_blocks * sizeof(block_t *) );
301         }
302     }
303
304     *pi_date = *pi_date_end;
305     *pi_data = 0;
306     return VLC_SUCCESS;
307 }
308
309 /*****************************************************************************
310  * Thread:
311  *****************************************************************************/
312 static void Thread( vlc_object_t *p_this )
313 {
314     goom_thread_t *p_thread = (goom_thread_t*)p_this;
315     vlc_value_t width, height, speed;
316     audio_date_t i_pts;
317     int16_t p_data[2][512];
318     int i_data = 0, i_count = 0;
319     PluginInfo *p_plugin_info;
320
321     var_Get( p_this, "goom-width", &width );
322     var_Get( p_this, "goom-height", &height );
323
324     var_Create( p_thread, "goom-speed", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
325     var_Get( p_thread, "goom-speed", &speed );
326     speed.i_int = MAX_SPEED - speed.i_int;
327     if( speed.i_int < 0 ) speed.i_int = 0;
328
329     p_plugin_info = goom_init( width.i_int, height.i_int );
330
331     while( !p_thread->b_die )
332     {
333         uint32_t  *plane;
334         picture_t *p_pic;
335
336         /* goom_update is damn slow, so just copy data and release the lock */
337         vlc_mutex_lock( &p_thread->lock );
338         if( FillBuffer( (int16_t *)p_data, &i_data, &i_pts,
339                         &p_thread->date, p_thread ) != VLC_SUCCESS )
340             vlc_cond_wait( &p_thread->wait, &p_thread->lock );
341         vlc_mutex_unlock( &p_thread->lock );
342
343         /* Speed selection */
344         if( speed.i_int && (++i_count % (speed.i_int+1)) ) continue;
345
346         /* Frame dropping if necessary */
347         if( aout_DateGet( &i_pts ) + GOOM_DELAY <= mdate() ) continue;
348
349         plane = goom_update( p_plugin_info, p_data, 0, 0.0,
350                              p_thread->psz_title, NULL );
351
352         if( p_thread->psz_title )
353         {
354             free( p_thread->psz_title );
355             p_thread->psz_title = NULL;
356         }
357
358         while( !( p_pic = vout_CreatePicture( p_thread->p_vout, 0, 0, 0 ) ) &&
359                !p_thread->b_die )
360         {
361             msleep( VOUT_OUTMEM_SLEEP );
362         }
363
364         if( p_pic == NULL ) break;
365
366         memcpy( p_pic->p[0].p_pixels, plane, width.i_int * height.i_int * 4 );
367         vout_DatePicture( p_thread->p_vout, p_pic,
368                           aout_DateGet( &i_pts ) + GOOM_DELAY );
369         vout_DisplayPicture( p_thread->p_vout, p_pic );
370     }
371
372     goom_close( p_plugin_info );
373 }
374
375 /*****************************************************************************
376  * Close: close the plugin
377  *****************************************************************************/
378 static void Close( vlc_object_t *p_this )
379 {
380     aout_filter_t     *p_filter = (aout_filter_t *)p_this;
381     aout_filter_sys_t *p_sys = p_filter->p_sys;
382
383     /* Stop Goom Thread */
384     p_sys->p_thread->b_die = VLC_TRUE;
385
386     vlc_mutex_lock( &p_sys->p_thread->lock );
387     vlc_cond_signal( &p_sys->p_thread->wait );
388     vlc_mutex_unlock( &p_sys->p_thread->lock );
389
390     vlc_thread_join( p_sys->p_thread );
391
392     /* Free data */
393     vout_Request( p_filter, p_sys->p_thread->p_vout, 0 );
394     vlc_mutex_destroy( &p_sys->p_thread->lock );
395     vlc_cond_destroy( &p_sys->p_thread->wait );
396     vlc_object_detach( p_sys->p_thread );
397
398     while( p_sys->p_thread->i_blocks-- )
399     {
400         block_Release( p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks] );
401     }
402
403     vlc_object_destroy( p_sys->p_thread );
404
405     free( p_sys );
406 }
407
408 static char *TitleGet( vlc_object_t *p_this )
409 {
410     char *psz_title = NULL;
411     input_thread_t *p_input =
412         vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
413
414     if( p_input )
415     {
416         if( input_GetItem(p_input)->p_meta->psz_title &&
417                 *input_GetItem(p_input)->p_meta->psz_title )
418         {
419             psz_title = strdup( input_GetItem(p_input)->p_meta->psz_title );
420         }
421         else
422         {
423             char *psz = strrchr( input_GetItem(p_input)->psz_uri, '/' );
424
425             if( psz )
426             {
427                 psz++;
428             }
429             else
430             {
431                 psz = input_GetItem(p_input)->psz_uri;
432             }
433             if( psz && *psz )
434             {
435                 psz_title = strdup( psz );
436             }
437         }
438         vlc_object_release( p_input );
439     }
440
441     return psz_title;
442 }