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.2 2001/03/21 13:42:34 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->vol / 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     intf_DbgMsg("adec debug: running audio output U8_S_thread (%p) (pid == %i)", p_aout, getpid());
 109
 110     /* As the s32_buffer was created with calloc(), we don't have to set this
 111      * memory to zero and we can immediately jump into the thread's loop */
 112     while ( ! p_aout->b_die )
 113     {
 114         vlc_mutex_lock( &p_aout->fifos_lock );
 115
 116         for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
 117         {
 118             if( p_aout->fifo[i_fifo].b_die )
 119             {
 120                 aout_FreeFifo( &p_aout->fifo[i_fifo] );
 121             }
 122             else
 123             {
 124                 U8StereoPlay( p_aout, &p_aout->fifo[i_fifo] );
 125             }
 126         }
 127
 128         vlc_mutex_unlock( &p_aout->fifos_lock );
 129
 130         l_buffer_limit = p_aout->l_units  << 1 ; /* p_aout->b_stereo == 1 */
 131
 132         for ( l_buffer = 0; l_buffer < l_buffer_limit; l_buffer++ )
 133         {
 134             ((u8 *)p_aout->buffer)[l_buffer] = (u8)( ( (p_aout->s32_buffer[l_buffer] / AOUT_MAX_FIFOS / 256) + 128 ) * p_aout->vol / 256 );
 135             p_aout->s32_buffer[l_buffer] = 0;
 136         }
 137         l_bytes = p_aout->pf_getbufinfo( p_aout, l_buffer_limit );
 138         p_aout->date = mdate() + ((((mtime_t)(l_bytes / 2 )) * 1000000) / ((mtime_t)p_aout->l_rate)); /* sizeof(u8) << (p_aout->b_stereo) == 2 */
 139         p_aout->pf_play( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
 140         if ( l_bytes > (l_buffer_limit * sizeof(u8)) )
 141         {
 142             msleep( p_aout->l_msleep );
 143         }
 144     }
 145
 146     vlc_mutex_lock( &p_aout->fifos_lock );
 147
 148     for ( i_fifo = 0; i_fifo < AOUT_MAX_FIFOS; i_fifo++ )
 149     {
 150         aout_FreeFifo( &p_aout->fifo[i_fifo] );
 151     }
 152
 153     vlc_mutex_unlock( &p_aout->fifos_lock );
 154 }
 155
 156 /* Following functions are local */
 157
 158 static void U8MonoPlay( aout_thread_t * p_aout, aout_fifo_t * p_fifo )
 159 {
 160     long l_buffer = 0;
 161     long l_buffer_limit, l_units;
 162
 163     switch ( p_fifo->i_type )
 164     {
 165     case AOUT_EMPTY_FIFO:
 166
 167         break;
 168
 169     case AOUT_INTF_MONO_FIFO:
 170
 171         if ( p_fifo->l_units > p_aout->l_units )
 172         {
 173             /* p_aout->b_stereo == 0 */
 174             while ( l_buffer < (p_aout->l_units) )
 175             {
 176                 p_aout->s32_buffer[l_buffer++] +=
 177                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 178                 p_aout->s32_buffer[l_buffer++] +=
 179                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 180                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 181             }
 182             p_fifo->l_units -= p_aout->l_units;
 183         }
 184         else
 185         {
 186             /* p_aout->b_stereo == 0 */
 187             while ( l_buffer < (p_fifo->l_units) )
 188             {
 189                 p_aout->s32_buffer[l_buffer++] +=
 190                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 191                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 192             }
 193             free( p_fifo->buffer ); /* !! */
 194             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 195             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 196         }
 197         break;
 198
 199     case AOUT_INTF_STEREO_FIFO:
 200
 201         if ( p_fifo->l_units > p_aout->l_units )
 202         {
 203             /* p_aout->b_stereo == 0 */
 204             while ( l_buffer < (p_aout->l_units) )
 205             {
 206                 /* I mix half left - half right */
 207                 p_aout->s32_buffer[l_buffer++] +=
 208                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 209                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 210                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 211             }
 212             p_fifo->l_units -= p_aout->l_units;
 213         }
 214         else
 215         {
 216             /* p_aout->b_stereo == 0 */
 217             while ( l_buffer < (p_fifo->l_units) )
 218             {
 219                 /* I mix half left - half right */
 220                 p_aout->s32_buffer[l_buffer++] +=
 221                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 222                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 223                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 224             }
 225             free( p_fifo->buffer ); /* !! */
 226             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 227             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 228         }
 229         break;
 230
 231     case AOUT_ADEC_MONO_FIFO:
 232
 233         l_units = p_aout->l_units;
 234
 235         while ( l_units > 0 )
 236         {
 237             if ( !p_fifo->b_next_frame )
 238             {
 239                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 240                 {
 241                     break;
 242                 }
 243             }
 244
 245             if ( p_fifo->l_units > l_units )
 246             {
 247                 /* p_aout->b_stereo == 0 */
 248                 l_buffer_limit = p_aout->l_units;
 249
 250                 while ( l_buffer < l_buffer_limit )
 251                 {
 252                     p_aout->s32_buffer[l_buffer++] +=
 253                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 254
 255                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 256                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 257                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 258                     {
 259                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 260                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 261                     }
 262                 }
 263                 p_fifo->l_units -= l_units;
 264                 break;
 265             }
 266             else
 267             {
 268                 /* p_aout->b_stereo == 0 */
 269                 l_buffer_limit = l_buffer + (p_fifo->l_units);
 270
 271                 while ( l_buffer < l_buffer_limit )
 272                 {
 273                     p_aout->s32_buffer[l_buffer++] +=
 274                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 275
 276                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 277                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 278                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 279                     {
 280                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 281                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 282                     }
 283                 }
 284                 l_units -= p_fifo->l_units;
 285
 286                 vlc_mutex_lock( &p_fifo->data_lock );
 287                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 288                 vlc_cond_signal( &p_fifo->data_wait );
 289                 vlc_mutex_unlock( &p_fifo->data_lock );
 290
 291                 /* p_fifo->b_start_frame = 1; */
 292                 p_fifo->l_next_frame += 1;
 293                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 294                 p_fifo->b_next_frame = 0;
 295             }
 296         }
 297         break;
 298
 299     case AOUT_ADEC_STEREO_FIFO:
 300
 301         l_units = p_aout->l_units;
 302
 303         while ( l_units > 0 )
 304         {
 305             if ( !p_fifo->b_next_frame )
 306             {
 307                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 308                 {
 309                     break;
 310                 }
 311             }
 312
 313             if ( p_fifo->l_units > l_units )
 314             {
 315                 /* p_aout->b_stereo == 0 */
 316                 l_buffer_limit = p_aout->l_units;
 317
 318                 while ( l_buffer < l_buffer_limit )
 319                 {
 320                     /* I mix half left - half right */
 321                     p_aout->s32_buffer[l_buffer++] +=
 322                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 323                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 324
 325                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 326                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 327                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 328                     {
 329                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 330                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 331                     }
 332                 }
 333                 p_fifo->l_units -= l_units;
 334                 break;
 335             }
 336             else
 337             {
 338                 /* p_aout->b_stereo == 0 */
 339                 l_buffer_limit = l_buffer + (p_fifo->l_units);
 340
 341                 while ( l_buffer < l_buffer_limit )
 342                 {
 343                     /* I mix half left - half right */
 344                     p_aout->s32_buffer[l_buffer++] +=
 345                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] ) / 2 +
 346                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] ) / 2;
 347
 348                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 349                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 350                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 351                     {
 352                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 353                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 354                     }
 355                 }
 356                 l_units -= p_fifo->l_units;
 357
 358                 vlc_mutex_lock( &p_fifo->data_lock );
 359                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 360                 vlc_cond_signal( &p_fifo->data_wait );
 361                 vlc_mutex_unlock( &p_fifo->data_lock );
 362
 363                 /* p_fifo->b_start_frame = 1; */
 364                 p_fifo->l_next_frame += 1;
 365                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 366                 p_fifo->b_next_frame = 0;
 367             }
 368         }
 369         break;
 370
 371     default:
 372
 373         intf_DbgMsg("aout debug: unknown fifo type (%i)", p_fifo->i_type);
 374
 375         break;
 376     }
 377 }
 378
 379 static void U8StereoPlay( aout_thread_t * p_aout, aout_fifo_t * p_fifo )
 380 {
 381     long l_buffer = 0;
 382     long l_buffer_limit, l_units;
 383
 384     switch ( p_fifo->i_type )
 385     {
 386     case AOUT_EMPTY_FIFO:
 387
 388         break;
 389
 390     case AOUT_INTF_MONO_FIFO:
 391
 392         if ( p_fifo->l_units > p_aout->l_units )
 393         {
 394             while ( l_buffer < (p_aout->l_units << 1) ) /* p_aout->b_stereo == 1 */
 395             {
 396                 p_aout->s32_buffer[l_buffer++] +=
 397                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 398                 p_aout->s32_buffer[l_buffer++] +=
 399                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 400                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 401             }
 402             p_fifo->l_units -= p_aout->l_units;
 403         }
 404         else
 405         {
 406             while ( l_buffer < (p_fifo->l_units << 1) ) /* p_aout->b_stereo == 1 */
 407             {
 408                 p_aout->s32_buffer[l_buffer++] +=
 409                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 410                 p_aout->s32_buffer[l_buffer++] +=
 411                     (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 412                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 413             }
 414             free( p_fifo->buffer ); /* !! */
 415             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 416             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 417         }
 418         break;
 419
 420     case AOUT_INTF_STEREO_FIFO:
 421
 422         if ( p_fifo->l_units > p_aout->l_units )
 423         {
 424             while ( l_buffer < (p_aout->l_units << 1) ) /* p_aout->b_stereo == 1 */
 425             {
 426                 p_aout->s32_buffer[l_buffer++] +=
 427                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 428                 p_aout->s32_buffer[l_buffer++] +=
 429                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 430                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 431             }
 432             p_fifo->l_units -= p_aout->l_units;
 433         }
 434         else
 435         {
 436             while ( l_buffer < (p_fifo->l_units << 1) ) /* p_aout->b_stereo == 1 */
 437             {
 438                 p_aout->s32_buffer[l_buffer++] +=
 439                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 440                 p_aout->s32_buffer[l_buffer++] +=
 441                     (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 442                 UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 443             }
 444             free( p_fifo->buffer ); /* !! */
 445             p_fifo->i_type = AOUT_EMPTY_FIFO; /* !! */
 446             intf_DbgMsg("aout debug: audio output fifo (%p) destroyed", p_fifo); /* !! */
 447         }
 448         break;
 449
 450     case AOUT_ADEC_MONO_FIFO:
 451
 452         l_units = p_aout->l_units;
 453
 454         while ( l_units > 0 )
 455         {
 456             if ( !p_fifo->b_next_frame )
 457             {
 458                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 459                 {
 460                     break;
 461                 }
 462             }
 463
 464             if ( p_fifo->l_units > l_units )
 465             {
 466                 l_buffer_limit = p_aout->l_units << 1; /* p_aout->b_stereo == 1 */
 467                 while ( l_buffer < l_buffer_limit )
 468                 {
 469                     p_aout->s32_buffer[l_buffer++] +=
 470                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 471                     p_aout->s32_buffer[l_buffer++] +=
 472                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 473
 474                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 475                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 476                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 477                     {
 478                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 479                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 480                     }
 481                 }
 482                 p_fifo->l_units -= l_units;
 483                 break;
 484             }
 485             else
 486             {
 487                 /* p_aout->b_stereo == 1 */
 488                 l_buffer_limit = l_buffer + (p_fifo->l_units << 1);
 489
 490                 while ( l_buffer < l_buffer_limit )
 491                 {
 492                     p_aout->s32_buffer[l_buffer++] +=
 493                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 494                     p_aout->s32_buffer[l_buffer++] +=
 495                         (s32)( ((s16 *)p_fifo->buffer)[p_fifo->l_unit] );
 496
 497                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 498                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 0 */
 499                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0)) )
 500                     {
 501                         p_fifo->l_unit -= /* p_fifo->b_stereo == 0 */
 502                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 0));
 503                     }
 504                 }
 505                 l_units -= p_fifo->l_units;
 506
 507                 vlc_mutex_lock( &p_fifo->data_lock );
 508                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 509                 vlc_cond_signal( &p_fifo->data_wait );
 510                 vlc_mutex_unlock( &p_fifo->data_lock );
 511
 512                 /* p_fifo->b_start_frame = 1; */
 513                 p_fifo->l_next_frame += 1;
 514                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 515                 p_fifo->b_next_frame = 0;
 516             }
 517         }
 518         break;
 519
 520     case AOUT_ADEC_STEREO_FIFO:
 521
 522         l_units = p_aout->l_units;
 523
 524         while ( l_units > 0 )
 525         {
 526             if ( !p_fifo->b_next_frame )
 527             {
 528                 if ( NextFrame(p_aout, p_fifo, p_aout->date + ((((mtime_t)(l_buffer >> 1)) * 1000000) / ((mtime_t)p_aout->l_rate))) )
 529                 {
 530                     break;
 531                 }
 532             }
 533
 534             if ( p_fifo->l_units > l_units )
 535             {
 536                 l_buffer_limit = p_aout->l_units << 1; /* p_aout->b_stereo == 1 */
 537                 while ( l_buffer < l_buffer_limit )
 538                 {
 539                     p_aout->s32_buffer[l_buffer++] +=
 540                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 541                     p_aout->s32_buffer[l_buffer++] +=
 542                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 543
 544                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 545                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 546                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 547                     {
 548                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 549                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 550                     }
 551                 }
 552                 p_fifo->l_units -= l_units;
 553                 break;
 554             }
 555             else
 556             {
 557                 /* p_aout->b_stereo == 1 */
 558                 l_buffer_limit = l_buffer + (p_fifo->l_units << 1);
 559
 560                 while ( l_buffer < l_buffer_limit )
 561                 {
 562                     p_aout->s32_buffer[l_buffer++] +=
 563                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit] );
 564                     p_aout->s32_buffer[l_buffer++] +=
 565                         (s32)( ((s16 *)p_fifo->buffer)[2*p_fifo->l_unit+1] );
 566
 567                     UPDATE_INCREMENT( p_fifo->unit_increment, p_fifo->l_unit )
 568                     if ( p_fifo->l_unit >= /* p_fifo->b_stereo == 1 */
 569                          ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1)) )
 570                     {
 571                         p_fifo->l_unit -= /* p_fifo->b_stereo == 1 */
 572                             ((AOUT_FIFO_SIZE + 1) * (p_fifo->l_frame_size >> 1));
 573                     }
 574                 }
 575                 l_units -= p_fifo->l_units;
 576
 577                 vlc_mutex_lock( &p_fifo->data_lock );
 578                 p_fifo->l_start_frame = p_fifo->l_next_frame;
 579                 vlc_cond_signal( &p_fifo->data_wait );
 580                 vlc_mutex_unlock( &p_fifo->data_lock );
 581
 582                 /* p_fifo->b_start_frame = 1; */
 583                 p_fifo->l_next_frame += 1;
 584                 p_fifo->l_next_frame &= AOUT_FIFO_SIZE;
 585                 p_fifo->b_next_frame = 0;
 586             }
 587         }
 588         break;
 589
 590     default:
 591         intf_DbgMsg("aout debug: unknown fifo type (%i)", p_fifo->i_type);
 592         break;
 593     }
 594 }
 595