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