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.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