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