git.sesse.net Git - vlc/blob - src/audio_output/aout_u8.c

   1 /*****************************************************************************
   2  * aout_u8.c: 8 bit unsigned audio output functions
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000, 2001 VideoLAN
   5  * $Id: aout_u8.c,v 1.5 2001/05/15 16:19:42 sam Exp $
   6  *
   7  * Authors: Michel Kaempf <maxx@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include "defs.h"
  28
  29 #include <stdio.h>                                           /* "intf_msg.h" */
  30 #include <stdlib.h>                            /* calloc(), malloc(), free() */
  31
  32 #include "config.h"
  33 #include "common.h"
  34 #include "threads.h"
  35 #include "mtime.h"                             /* mtime_t, mdate(), msleep() */
  36
  37 #include "intf_msg.h"                        /* intf_DbgMsg(), intf_ErrMsg() */
  38
  39 #include "audio_output.h"
  40 #include "aout_common.h"
  41
  42 /*****************************************************************************
  43  * Local prototypes
  44  *****************************************************************************/
  45 static void U8MonoPlay   ( aout_thread_t * p_aout, aout_fifo_t * p_fifo );
  46 static void U8StereoPlay ( aout_thread_t * p_aout, aout_fifo_t * p_fifo );
  47
  48 /*****************************************************************************
  49  * Functions
  50  *****************************************************************************/
  51 void aout_U8MonoThread( aout_thread_t * p_aout )
  52 {
  53     int i_fifo;
  54     long l_buffer, l_buffer_limit, l_bytes;
  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
  62         for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
  63         {
  64             if( p_aout->fifo[i_fifo].b_die )
  65             {
  66                 aout_FreeFifo( &p_aout->fifo[i_fifo] );
  67             }
  68             else
  69             {
  70                 U8MonoPlay( p_aout, &p_aout->fifo[i_fifo] );
  71             }
  72         }
  73
  74         vlc_mutex_unlock( &p_aout->fifos_lock );
  75
  76         l_buffer_limit = p_aout->l_units; /* p_aout->b_stereo == 0 */
  77
  78         for ( l_buffer = 0; l_buffer < l_buffer_limit; l_buffer++ )
  79         {
  80             ((u8 *)p_aout->buffer)[l_buffer] = (u8)( ( (p_aout->s32_buffer[l_buffer] / AOUT_MAX_FIFOS / 256 ) + 128 ) * p_aout->i_volume / 256 );
  81             p_aout->s32_buffer[l_buffer] = 0;
  82         }
  83
  84         l_bytes = p_aout->pf_getbufinfo( p_aout, l_buffer_limit );
  85         p_aout->date = mdate() + ((((mtime_t)(l_bytes / 1 )) * 1000000) / ((mtime_t)p_aout->l_rate)); /* sizeof(u8) << (p_aout->b_stereo) == 1 */
  86         p_aout->pf_play( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
  87         if ( l_bytes > (l_buffer_limit * sizeof(u8) * 2) ) /* There are 2 channels (left & right) */
  88         {
  89             msleep( p_aout->l_msleep );
  90         }
  91     }
  92
  93     vlc_mutex_lock( &p_aout->fifos_lock );
  94
  95     for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
  96     {
  97         aout_FreeFifo( &p_aout->fifo[i_fifo] );
  98     }
  99
 100     vlc_mutex_unlock( &p_aout->fifos_lock );
 101 }
 102
 103 void aout_U8StereoThread( aout_thread_t * p_aout )
 104 {
 105     int i_fifo;
 106     long l_buffer, l_buffer_limit, l_bytes;
 107
 108     /* As the s32_buffer was created with calloc(), we don't have to set this
 109      * memory to zero and we can immediately jump into the thread's loop */
 110     while ( ! p_aout->b_die )
 111     {
 112         vlc_mutex_lock( &p_aout->fifos_lock );
 113
 114         for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
 115         {
 116             if( p_aout->fifo[i_fifo].b_die )
 117             {
 118                 aout_FreeFifo( &p_aout->fifo[i_fifo] );
 119             }
 120             else
 121             {
 122                 U8StereoPlay( p_aout, &p_aout->fifo[i_fifo] );
 123             }
 124         }
 125
 126         vlc_mutex_unlock( &p_aout->fifos_lock );
 127
 128         l_buffer_limit = p_aout->l_units  << 1 ; /* p_aout->b_stereo == 1 */
 129
 130         for ( l_buffer = 0; l_buffer < l_buffer_limit; l_buffer++ )
 131         {
 132             ((u8 *)p_aout->buffer)[l_buffer] = (u8)( ( (p_aout->s32_buffer[l_buffer] / AOUT_MAX_FIFOS / 256) + 128 ) * p_aout->i_volume / 256 );
 133             p_aout->s32_buffer[l_buffer] = 0;
 134         }
 135         l_bytes = p_aout->pf_getbufinfo( p_aout, l_buffer_limit );
 136         p_aout->date = mdate() + ((((mtime_t)(l_bytes / 2 )) * 1000000) / ((mtime_t)p_aout->l_rate)); /* sizeof(u8) << (p_aout->b_stereo) == 2 */
 137         p_aout->pf_play( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
 138         if ( l_bytes > (l_buffer_limit * sizeof(u8)) )
 139         {
 140             msleep( p_aout->l_msleep );
 141         }
 142     }
 143
 144     vlc_mutex_lock( &p_aout->fifos_lock );
 145
 146     for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
 147     {
 148         aout_FreeFifo( &p_aout->fifo[i_fifo] );
 149     }
 150
 151     vlc_mutex_unlock( &p_aout->fifos_lock );
 152 }
 153
 154 /* Following functions are local */
 155
 156 static void U8MonoPlay( aout_thread_t * p_aout, aout_fifo_t * p_fifo )
 157 {
 158     long l_buffer = 0;
 159     long l_buffer_limit, l_units;
 160
 161     switch ( p_fifo->i_type )
 162     {
 163     case AOUT_EMPTY_FIFO:
 164
 165         break;
 166
 167     case AOUT_INTF_MONO_FIFO:
 168
 169         if ( p_fifo->l_units > p_aout->l_units )
 170         {
 171             /* p_aout->b_stereo == 0 */
 172             while ( l_buffer < (p_aout->l_units) )
 173             {
 174                 p_aout->s32_buffer[l_buffer++] +=
 175                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 176                 p_aout->s32_buffer[l_buffer++] +=
 177                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 178                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 179             }
 180             p_fifo->l_units -= p_aout->l_units;
 181         }
 182         else
 183         {
 184             /* p_aout->b_stereo == 0 */
 185             while ( l_buffer < (p_fifo->l_units) )
 186             {
 187                 p_aout->s32_buffer[l_buffer++] +=
 188                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 189                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 190             }
 191             free( p_fifo->buffer ); /* !! */
 192             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 193             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 194         }
 195         break;
 196
 197     case AOUT_INTF_STEREO_FIFO:
 198
 199         if ( p_fifo->l_units > p_aout->l_units )
 200         {
 201             /* p_aout->b_stereo == 0 */
 202             while ( l_buffer < (p_aout->l_units) )
 203             {
 204                 /* I mix half left - half right */
 205                 p_aout->s32_buffer[l_buffer++] +=
 206                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 207                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 208                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 209             }
 210             p_fifo->l_units -= p_aout->l_units;
 211         }
 212         else
 213         {
 214             /* p_aout->b_stereo == 0 */
 215             while ( l_buffer < (p_fifo->l_units) )
 216             {
 217                 /* I mix half left - half right */
 218                 p_aout->s32_buffer[l_buffer++] +=
 219                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 220                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 221                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 222             }
 223             free( p_fifo->buffer ); /* !! */
 224             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 225             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 226         }
 227         break;
 228
 229     case AOUT_ADEC_MONO_FIFO:
 230
 231         l_units = p_aout->l_units;
 232
 233         while ( l_units > 0 )
 234         {
 235             if ( !p_fifo->b_next_frame )
 236             {
 237                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 238                 {
 239                     break;
 240                 }
 241             }
 242
 243             if ( p_fifo->l_units > l_units )
 244             {
 245                 /* p_aout->b_stereo == 0 */
 246                 l_buffer_limit = p_aout->l_units;
 247
 248                 while ( l_buffer < l_buffer_limit )
 249                 {
 250                     p_aout->s32_buffer[l_buffer++] +=
 251                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 252
 253                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 254                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 255                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 256                     {
 257                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 258                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 259                     }
 260                 }
 261                 p_fifo->l_units -= l_units;
 262                 break;
 263             }
 264             else
 265             {
 266                 /* p_aout->b_stereo == 0 */
 267                 l_buffer_limit = l_buffer + (p_fifo->l_units);
 268
 269                 while ( l_buffer < l_buffer_limit )
 270                 {
 271                     p_aout->s32_buffer[l_buffer++] +=
 272                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 273
 274                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 275                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 276                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 277                     {
 278                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 279                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 280                     }
 281                 }
 282                 l_units -= p_fifo->l_units;
 283
 284                 vlc_mutex_lock( &p_fifo->data_lock );
 285                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 286                 vlc_cond_signal( &p_fifo->data_wait );
 287                 vlc_mutex_unlock( &p_fifo->data_lock );
 288
 289                 /* p_fifo->b_start_frame = 1; */
 290                 p_fifo->l_next_frame += 1;
 291                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 292                 p_fifo->b_next_frame = 0;
 293             }
 294         }
 295         break;
 296
 297     case AOUT_ADEC_STEREO_FIFO:
 298
 299         l_units = p_aout->l_units;
 300
 301         while ( l_units > 0 )
 302         {
 303             if ( !p_fifo->b_next_frame )
 304             {
 305                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 306                 {
 307                     break;
 308                 }
 309             }
 310
 311             if ( p_fifo->l_units > l_units )
 312             {
 313                 /* p_aout->b_stereo == 0 */
 314                 l_buffer_limit = p_aout->l_units;
 315
 316                 while ( l_buffer < l_buffer_limit )
 317                 {
 318                     /* I mix half left - half right */
 319                     p_aout->s32_buffer[l_buffer++] +=
 320                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 321                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 322
 323                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 324                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 325                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 326                     {
 327                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 328                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 329                     }
 330                 }
 331                 p_fifo->l_units -= l_units;
 332                 break;
 333             }
 334             else
 335             {
 336                 /* p_aout->b_stereo == 0 */
 337                 l_buffer_limit = l_buffer + (p_fifo->l_units);
 338
 339                 while ( l_buffer < l_buffer_limit )
 340                 {
 341                     /* I mix half left - half right */
 342                     p_aout->s32_buffer[l_buffer++] +=
 343                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 344                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 345
 346                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 347                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 348                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 349                     {
 350                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 351                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 352                     }
 353                 }
 354                 l_units -= p_fifo->l_units;
 355
 356                 vlc_mutex_lock( &p_fifo->data_lock );
 357                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 358                 vlc_cond_signal( &p_fifo->data_wait );
 359                 vlc_mutex_unlock( &p_fifo->data_lock );
 360
 361                 /* p_fifo->b_start_frame = 1; */
 362                 p_fifo->l_next_frame += 1;
 363                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 364                 p_fifo->b_next_frame = 0;
 365             }
 366         }
 367         break;
 368
 369     default:
 370
 371         intf_DbgMsg("aout debug: unknown fifo type (%i)", p_fifo->i_type);
 372
 373         break;
 374     }
 375 }
 376
 377 static void U8StereoPlay( aout_thread_t * p_aout, aout_fifo_t * p_fifo )
 378 {
 379     long l_buffer = 0;
 380     long l_buffer_limit, l_units;
 381
 382     switch ( p_fifo->i_type )
 383     {
 384     case AOUT_EMPTY_FIFO:
 385
 386         break;
 387
 388     case AOUT_INTF_MONO_FIFO:
 389
 390         if ( p_fifo->l_units > p_aout->l_units )
 391         {
 392             while ( l_buffer < (p_aout->l_units << 1) ) /* p_aout->b_stereo == 1 */
 393             {
 394                 p_aout->s32_buffer[l_buffer++] +=
 395                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 396                 p_aout->s32_buffer[l_buffer++] +=
 397                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 398                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 399             }
 400             p_fifo->l_units -= p_aout->l_units;
 401         }
 402         else
 403         {
 404             while ( l_buffer < (p_fifo->l_units << 1) ) /* p_aout->b_stereo == 1 */
 405             {
 406                 p_aout->s32_buffer[l_buffer++] +=
 407                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 408                 p_aout->s32_buffer[l_buffer++] +=
 409                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 410                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 411             }
 412             free( p_fifo->buffer ); /* !! */
 413             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 414             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 415         }
 416         break;
 417
 418     case AOUT_INTF_STEREO_FIFO:
 419
 420         if ( p_fifo->l_units > p_aout->l_units )
 421         {
 422             while ( l_buffer < (p_aout->l_units << 1) ) /* p_aout->b_stereo == 1 */
 423             {
 424                 p_aout->s32_buffer[l_buffer++] +=
 425                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 426                 p_aout->s32_buffer[l_buffer++] +=
 427                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 428                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 429             }
 430             p_fifo->l_units -= p_aout->l_units;
 431         }
 432         else
 433         {
 434             while ( l_buffer < (p_fifo->l_units << 1) ) /* p_aout->b_stereo == 1 */
 435             {
 436                 p_aout->s32_buffer[l_buffer++] +=
 437                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 438                 p_aout->s32_buffer[l_buffer++] +=
 439                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 440                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 441             }
 442             free( p_fifo->buffer ); /* !! */
 443             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 444             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 445         }
 446         break;
 447
 448     case AOUT_ADEC_MONO_FIFO:
 449
 450         l_units = p_aout->l_units;
 451
 452         while ( l_units > 0 )
 453         {
 454             if ( !p_fifo->b_next_frame )
 455             {
 456                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 457                 {
 458                     break;
 459                 }
 460             }
 461
 462             if ( p_fifo->l_units > l_units )
 463             {
 464                 l_buffer_limit = p_aout->l_units << 1; /* p_aout->b_stereo == 1 */
 465                 while ( l_buffer < l_buffer_limit )
 466                 {
 467                     p_aout->s32_buffer[l_buffer++] +=
 468                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 469                     p_aout->s32_buffer[l_buffer++] +=
 470                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 471
 472                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 473                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 474                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 475                     {
 476                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 477                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 478                     }
 479                 }
 480                 p_fifo->l_units -= l_units;
 481                 break;
 482             }
 483             else
 484             {
 485                 /* p_aout->b_stereo == 1 */
 486                 l_buffer_limit = l_buffer + (p_fifo->l_units << 1);
 487
 488                 while ( l_buffer < l_buffer_limit )
 489                 {
 490                     p_aout->s32_buffer[l_buffer++] +=
 491                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 492                     p_aout->s32_buffer[l_buffer++] +=
 493                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 494
 495                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 496                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 497                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 498                     {
 499                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 500                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 501                     }
 502                 }
 503                 l_units -= p_fifo->l_units;
 504
 505                 vlc_mutex_lock( &p_fifo->data_lock );
 506                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 507                 vlc_cond_signal( &p_fifo->data_wait );
 508                 vlc_mutex_unlock( &p_fifo->data_lock );
 509
 510                 /* p_fifo->b_start_frame = 1; */
 511                 p_fifo->l_next_frame += 1;
 512                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 513                 p_fifo->b_next_frame = 0;
 514             }
 515         }
 516         break;
 517
 518     case AOUT_ADEC_STEREO_FIFO:
 519
 520         l_units = p_aout->l_units;
 521
 522         while ( l_units > 0 )
 523         {
 524             if ( !p_fifo->b_next_frame )
 525             {
 526                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 527                 {
 528                     break;
 529                 }
 530             }
 531
 532             if ( p_fifo->l_units > l_units )
 533             {
 534                 l_buffer_limit = p_aout->l_units << 1; /* p_aout->b_stereo == 1 */
 535                 while ( l_buffer < l_buffer_limit )
 536                 {
 537                     p_aout->s32_buffer[l_buffer++] +=
 538                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 539                     p_aout->s32_buffer[l_buffer++] +=
 540                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 541
 542                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 543                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 544                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 545                     {
 546                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 547                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 548                     }
 549                 }
 550                 p_fifo->l_units -= l_units;
 551                 break;
 552             }
 553             else
 554             {
 555                 /* p_aout->b_stereo == 1 */
 556                 l_buffer_limit = l_buffer + (p_fifo->l_units << 1);
 557
 558                 while ( l_buffer < l_buffer_limit )
 559                 {
 560                     p_aout->s32_buffer[l_buffer++] +=
 561                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 562                     p_aout->s32_buffer[l_buffer++] +=
 563                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 564
 565                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 566                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 567                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 568                     {
 569                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 570                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 571                     }
 572                 }
 573                 l_units -= p_fifo->l_units;
 574
 575                 vlc_mutex_lock( &p_fifo->data_lock );
 576                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 577                 vlc_cond_signal( &p_fifo->data_wait );
 578                 vlc_mutex_unlock( &p_fifo->data_lock );
 579
 580                 /* p_fifo->b_start_frame = 1; */
 581                 p_fifo->l_next_frame += 1;
 582                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 583                 p_fifo->b_next_frame = 0;
 584             }
 585         }
 586         break;
 587
 588     default:
 589         intf_DbgMsg("aout debug: unknown fifo type (%i)", p_fifo->i_type);
 590         break;
 591     }
 592 }
 593