* Desperate attempt to improve audio output ;
[vlc.git] / src / audio_output / aout_pcm.c
1 /*****************************************************************************
2  * aout_pcm.c: PCM audio output functions
3  *****************************************************************************
4  * Copyright (C) 1999-2002 VideoLAN
5  * $Id: aout_pcm.c,v 1.7 2002/05/19 00:34:54 massiot Exp $
6  *
7  * Authors: Michel Kaempf <maxx@via.ecp.fr>
8  *          Cyril Deguet <asmax@via.ecp.fr>
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 <stdio.h>                                           /* "intf_msg.h" */
29 #include <stdlib.h>                            /* calloc(), malloc(), free() */
30 #include <string.h>
31
32 #include <videolan/vlc.h>
33
34 #include "audio_output.h"
35 #include "aout_pcm.h"
36
37 /* Biggest difference allowed between scheduled playing date and actual date 
38    (in microseconds) */
39 #define MAX_DELTA 50000
40
41 /*****************************************************************************
42  * Local prototypes
43  *****************************************************************************/
44 static void FillBuffer( aout_thread_t * p_aout, aout_fifo_t * p_fifo );
45 static int  NextFrame ( aout_thread_t * p_aout, aout_fifo_t * p_fifo,
46                         mtime_t aout_date );
47
48  /*****************************************************************************
49  * Functions
50  *****************************************************************************/
51 void aout_PCMThread( aout_thread_t * p_aout )
52 {
53     int i_fifo;
54     int i_buffer, i_buffer_limit, i_units = 0;
55
56 #if defined(WIN32)
57     if( !SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL) )
58         intf_WarnMsg( 2, "aout warning: couldn't change priority of"
59                       "aout_PCMThread()" );
60 #endif
61
62     /* As the s32_buffer was created with calloc(), we don't have to set this
63      * memory to zero and we can immediately jump into the thread's loop */
64     while ( ! p_aout->b_die )
65     {
66         vlc_mutex_lock( &p_aout->fifos_lock );
67         for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
68         {
69             if( p_aout->fifo[i_fifo].b_die )
70             {
71                 aout_FreeFifo( &p_aout->fifo[i_fifo] );
72             }
73             else
74             {
75                 FillBuffer( p_aout, &p_aout->fifo[i_fifo] );
76             }
77         }
78         vlc_mutex_unlock( &p_aout->fifos_lock );
79
80         i_buffer_limit = p_aout->i_units * p_aout->i_channels;
81
82         switch ( p_aout->i_format )
83         {
84         case AOUT_FMT_U8:
85             for ( i_buffer = 0; i_buffer < i_buffer_limit; i_buffer++ )
86             {
87                 ((u8*)p_aout->buffer)[i_buffer] = (u8)(
88                   (p_aout->s32_buffer[i_buffer] / AOUT_MAX_FIFOS / 256 + 128)
89                      * p_aout->i_volume / 256);
90                  p_aout->s32_buffer[i_buffer] = 0;
91             }
92             break;
93
94         case AOUT_FMT_S8:
95             for ( i_buffer = 0; i_buffer < i_buffer_limit; i_buffer++ )
96             {
97                 ((s8*)p_aout->buffer)[i_buffer] = (s8)(
98                   p_aout->s32_buffer[i_buffer] / AOUT_MAX_FIFOS / 256
99                      * p_aout->i_volume / 256);
100                  p_aout->s32_buffer[i_buffer] = 0;
101             }
102             break;
103
104         case AOUT_FMT_U16_LE:
105         case AOUT_FMT_U16_BE:
106             for ( i_buffer = 0; i_buffer < i_buffer_limit; i_buffer++ )
107             {
108                 ((u16*)p_aout->buffer)[i_buffer] = (u16)(
109                   (p_aout->s32_buffer[i_buffer] / AOUT_MAX_FIFOS + 128)
110                      * p_aout->i_volume / 256);
111                  p_aout->s32_buffer[i_buffer] = 0;
112             }
113             break;
114
115         case AOUT_FMT_S16_LE:
116         case AOUT_FMT_S16_BE:
117             for ( i_buffer = 0; i_buffer < i_buffer_limit; i_buffer++ )
118             {
119                 ((s16*)p_aout->buffer)[i_buffer] = (s16)(
120                   p_aout->s32_buffer[i_buffer] / AOUT_MAX_FIFOS
121                      * p_aout->i_volume / 256);
122                  p_aout->s32_buffer[i_buffer] = 0;
123             }
124             break;
125         }
126
127         switch ( p_aout->i_format )
128         {
129         case AOUT_FMT_U8:
130         case AOUT_FMT_S8:
131             i_units = p_aout->pf_getbufinfo( p_aout, i_buffer_limit );
132
133             p_aout->date = mdate() + ((((mtime_t)((i_units +
134                 p_aout->i_latency) / p_aout->i_channels)) * 1000000) /
135                 ((mtime_t)p_aout->i_rate)) + p_main->i_desync;
136
137             p_aout->pf_play( p_aout, (byte_t *)p_aout->buffer,
138                              i_buffer_limit );
139             break;
140
141         case AOUT_FMT_U16_LE:
142         case AOUT_FMT_U16_BE:
143         case AOUT_FMT_S16_LE:
144         case AOUT_FMT_S16_BE:
145             i_units = p_aout->pf_getbufinfo( p_aout, i_buffer_limit * 2 ) / 2;
146
147             p_aout->date = mdate() + ((((mtime_t)((i_units +
148                 p_aout->i_latency / 2) / p_aout->i_channels)) * 1000000) /
149                 ((mtime_t)p_aout->i_rate)) + p_main->i_desync;
150
151             p_aout->pf_play( p_aout, (byte_t *)p_aout->buffer,
152                              i_buffer_limit * 2 );
153             break;
154         }
155
156         /* Sleep until there is only AOUT_BUFFER_DURATION/2 worth of audio
157          * left to play in the aout plugin, then we can start refill the
158          * plugin's buffer */
159         if( i_units > (i_buffer_limit/2) )
160             msleep( (i_units - i_buffer_limit/2) * AOUT_BUFFER_DURATION
161                     / i_buffer_limit );
162     }
163
164     vlc_mutex_lock( &p_aout->fifos_lock );
165     for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
166     {
167         aout_FreeFifo( &p_aout->fifo[i_fifo] );
168     }
169     vlc_mutex_unlock( &p_aout->fifos_lock );
170 }
171
172 /* Following functions are local */
173
174 /*****************************************************************************
175  * InitializeIncrement: change i_x/i_y to i_a+i_b/i_c
176  *****************************************************************************/
177 static inline void InitializeIncrement( aout_increment_t * p_inc,
178                                         int i_x, int i_y )
179 {
180     p_inc->i_r = -i_y;
181     p_inc->i_a = 0;
182
183     while ( i_x >= i_y )
184     {
185         p_inc->i_a++;
186         i_x -= i_y;
187     }
188
189     p_inc->i_b = i_x;
190     p_inc->i_c = i_y;
191 }
192
193 /*****************************************************************************
194  * UpdateIncrement
195  *****************************************************************************/
196 static inline void UpdateIncrement( aout_increment_t * p_inc, int * pi_integer )
197 {
198     if( (p_inc->i_r += p_inc->i_b) >= 0 )
199     {
200         *pi_integer += p_inc->i_a + 1;
201         p_inc->i_r -= p_inc->i_c;
202     }
203     else
204     {
205         *pi_integer += p_inc->i_a;
206     }
207 }
208
209 /*****************************************************************************
210  * FillBuffer: Read data from decoder fifo, and put it in S32_buffer
211  *****************************************************************************/
212 static void FillBuffer( aout_thread_t * p_aout, aout_fifo_t * p_fifo )
213 {
214     int i_buffer = 0;
215     int i_buffer_limit, i_units;
216
217     switch ( p_fifo->i_format )
218     {
219     case AOUT_FIFO_PCM:
220
221         i_units = p_aout->i_units;
222
223         /* While there are empty frames in the buffer, fill them */
224         while ( i_units > 0 )
225         {
226             /* If there is no next frame, wait for one */
227             if( !p_fifo->b_next_frame )
228             {
229                 if( NextFrame(p_aout, p_fifo, p_aout->date + 
230                         ((((mtime_t)(i_buffer >> 1)) * 1000000) / 
231                         ((mtime_t)p_aout->i_rate))) )
232                 {
233                     break;
234                 }
235             }
236
237             i_buffer_limit = p_aout->i_units * p_aout->i_channels;
238
239             while ( i_buffer < i_buffer_limit )
240             {
241                 /* FIXME: make this more generic */
242                 if( p_aout->i_channels == 2 )
243                 {
244                     p_aout->s32_buffer[i_buffer++] +=
245                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->i_unit] );
246                     p_aout->s32_buffer[i_buffer++] +=
247                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->i_unit+1] );
248                 }
249                 else if( p_aout->i_channels == 1 )
250                 {
251                     p_aout->s32_buffer[i_buffer++] +=
252                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->i_unit] );
253                 }
254                 else
255                 {
256                     intf_ErrMsg( "aout error: unsupported number of channels" );
257                 }
258
259                 UpdateIncrement(&p_fifo->unit_increment, &p_fifo->i_unit);
260
261                 if( p_fifo->i_unit >= p_fifo->i_unit_limit )
262                 {
263                     p_fifo->i_unit -= p_fifo->i_unit_limit;
264                 }
265             }
266  
267             if( p_fifo->i_units > i_units )
268             {
269                 p_fifo->i_units -= i_units;
270                 break;
271             }
272             else
273             {
274                 i_units -= p_fifo->i_units;
275
276                 vlc_mutex_lock( &p_fifo->data_lock );
277                 p_fifo->i_start_frame = p_fifo->i_next_frame;
278              /* p_fifo->b_start_frame = 1; */
279                 p_fifo->i_next_frame = AOUT_FIFO_INC( p_fifo->i_next_frame );
280                 p_fifo->b_next_frame = 0;
281                 vlc_cond_signal( &p_fifo->data_wait );
282                 vlc_mutex_unlock( &p_fifo->data_lock );
283
284             }
285         }
286         break;
287
288     default:
289         break;
290     }
291 }
292
293 static int NextFrame( aout_thread_t * p_aout, aout_fifo_t * p_fifo,
294                       mtime_t aout_date )
295 {
296     int i_units, i_units_dist, i_rate;
297     mtime_t i_delta;    
298
299     /* We take the lock */
300     vlc_mutex_lock( &p_fifo->data_lock );
301     if ( p_fifo->b_die )
302     {
303         vlc_mutex_unlock( &p_fifo->data_lock );
304         return( -1 );
305     }
306
307     /* Are we looking for a dated start frame ? */
308     if ( !p_fifo->b_start_frame )
309     {
310         while ( p_fifo->i_start_frame != p_fifo->i_end_frame )
311         {
312             if ( p_fifo->date[p_fifo->i_start_frame] != LAST_MDATE )
313             {
314                 p_fifo->b_start_frame = 1;
315                 p_fifo->i_next_frame = AOUT_FIFO_INC( p_fifo->i_start_frame );
316                 p_fifo->i_unit = p_fifo->i_start_frame * 
317                         (p_fifo->i_frame_size / p_fifo->i_channels);
318                 break;
319             }
320             p_fifo->i_start_frame = AOUT_FIFO_INC( p_fifo->i_start_frame );
321         }
322
323         if ( p_fifo->i_start_frame == p_fifo->i_end_frame )
324         {
325             vlc_mutex_unlock( &p_fifo->data_lock );
326             return( -1 );
327         }
328     }
329
330     /* We are looking for the next dated frame */
331     /* FIXME : is the output fifo full ?? -- pretty unlikely given its size */
332     while ( !p_fifo->b_next_frame )
333     {
334         while ( p_fifo->i_next_frame != p_fifo->i_end_frame )
335         {
336             if ( p_fifo->date[p_fifo->i_next_frame] != LAST_MDATE )
337             {
338                 p_fifo->b_next_frame = 1;
339                 break;
340             }
341             p_fifo->i_next_frame = AOUT_FIFO_INC( p_fifo->i_next_frame );
342         }
343
344         while ( p_fifo->i_next_frame == p_fifo->i_end_frame )
345         {
346             vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock );
347             if ( p_fifo->b_die )
348             {
349                 vlc_mutex_unlock( &p_fifo->data_lock );
350                 return( -1 );
351             }
352         }
353     }
354
355     i_units = ((p_fifo->i_next_frame - p_fifo->i_start_frame) & AOUT_FIFO_SIZE)
356                * (p_fifo->i_frame_size / p_fifo->i_channels);
357
358     i_delta = aout_date - p_fifo->date[p_fifo->i_start_frame];
359
360     /* Resample if delta is too long */
361     if( abs(i_delta) > MAX_DELTA )
362     {
363         i_rate = p_fifo->i_rate + (i_delta / 256);
364     }
365     else
366     {
367         i_rate = p_fifo->i_rate;
368     }
369
370     InitializeIncrement( &p_fifo->unit_increment, i_rate, p_aout->i_rate );
371
372     /* Calculate how many units we're going to write */
373     i_units_dist = p_fifo->i_unit - p_fifo->i_start_frame
374                                 * (p_fifo->i_frame_size / p_fifo->i_channels);
375
376     /* Manage the fifo wrapping */
377     if( i_units_dist > p_fifo->i_unit_limit / 2 )
378     {
379         i_units -= (i_units_dist - p_fifo->i_unit_limit);
380     }
381     else if( i_units_dist < - p_fifo->i_unit_limit / 2 )
382     {
383         i_units -= (i_units_dist + p_fifo->i_unit_limit);
384     }
385     else
386     {
387         i_units -= i_units_dist;
388     }
389
390     p_fifo->i_units = 1 + ( i_units * p_aout->i_rate / i_rate );
391
392     /* We release the lock before leaving */
393     vlc_mutex_unlock( &p_fifo->data_lock );
394     return( 0 );
395 }
396