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