git.sesse.net Git - vlc/blob - modules/codec/lpcm.c

   1 /*****************************************************************************
   2  * lpcm.c: lpcm decoder/packetizer module
   3  *****************************************************************************
   4  * Copyright (C) 1999-2008 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Henri Fallon <henri@videolan.org>
   9  *          Christophe Massiot <massiot@via.ecp.fr>
  10  *          Gildas Bazin <gbazin@videolan.org>
  11  *          Lauren Aimar <fenrir _AT_ videolan _DOT_ org >
  12  *          Steinar H. Gunderson <steinar+vlc@gunderson.no>
  13  *
  14  * This program is free software; you can redistribute it and/or modify it
  15  * under the terms of the GNU Lesser General Public License as published by
  16  * the Free Software Foundation; either version 2.1 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  22  * GNU Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * along with this program; if not, write to the Free Software Foundation,
  26  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  27  *****************************************************************************/
  28
  29 /*****************************************************************************
  30  * Preamble
  31  *****************************************************************************/
  32 #ifdef HAVE_CONFIG_H
  33 # include "config.h"
  34 #endif
  35
  36 #include <vlc_common.h>
  37 #include <vlc_plugin.h>
  38 #include <vlc_codec.h>
  39 #include <vlc_aout.h>
  40 #include <unistd.h>
  41 #include <assert.h>
  42
  43 /*****************************************************************************
  44  * Module descriptor
  45  *****************************************************************************/
  46 static int  OpenDecoder   ( vlc_object_t * );
  47 static int  OpenPacketizer( vlc_object_t * );
  48 static void CloseCommon   ( vlc_object_t * );
  49
  50 #ifdef ENABLE_SOUT
  51 static int  OpenEncoder   ( vlc_object_t * );
  52 static void CloseEncoder  ( vlc_object_t * );
  53 static block_t *EncodeFrames( encoder_t *, block_t * );
  54 #endif
  55
  56 vlc_module_begin ()
  57
  58     set_category( CAT_INPUT )
  59     set_subcategory( SUBCAT_INPUT_ACODEC )
  60     set_description( N_("Linear PCM audio decoder") )
  61     set_capability( "decoder", 100 )
  62     set_callbacks( OpenDecoder, CloseCommon )
  63
  64     add_submodule ()
  65     set_description( N_("Linear PCM audio packetizer") )
  66     set_capability( "packetizer", 100 )
  67     set_callbacks( OpenPacketizer, CloseCommon )
  68
  69 #ifdef ENABLE_SOUT
  70     add_submodule ()
  71     set_description( N_("Linear PCM audio encoder") )
  72     set_capability( "encoder", 100 )
  73     set_callbacks( OpenEncoder, CloseEncoder )
  74     add_shortcut( "lpcm" )
  75 #endif
  76
  77 vlc_module_end ()
  78
  79
  80 /*****************************************************************************
  81  * decoder_sys_t : lpcm decoder descriptor
  82  *****************************************************************************/
  83 struct decoder_sys_t
  84 {
  85     /* Module mode */
  86     bool b_packetizer;
  87
  88     /*
  89      * Output properties
  90      */
  91     date_t   end_date;
  92
  93     /* */
  94     unsigned i_header_size;
  95     int      i_type;
  96     uint8_t  i_chans_to_reorder;
  97     uint8_t  pi_chan_table[AOUT_CHAN_MAX];
  98 };
  99
 100 #ifdef ENABLE_SOUT
 101 struct encoder_sys_t
 102 {
 103     int     i_channels;
 104     int     i_rate;
 105
 106     int     i_frame_samples;
 107     uint8_t *p_buffer;
 108     int     i_buffer_used;
 109     int     i_frame_num;
 110 };
 111 #endif
 112
 113 /*
 114  * LPCM DVD header :
 115  * - number of frames in this packet (8 bits)
 116  * - first access unit (16 bits) == 0x0003 ?
 117  * - emphasis (1 bit)
 118  * - mute (1 bit)
 119  * - reserved (1 bit)
 120  * - current frame (5 bits)
 121  * - quantisation (2 bits) 0 == 16bps, 1 == 20bps, 2 == 24bps, 3 == illegal
 122  * - frequency (2 bits) 0 == 48 kHz, 1 == 96 kHz, 2 == 44.1 kHz, 3 == 32 kHz
 123  * - reserved (1 bit)
 124  * - number of channels - 1 (3 bits) 1 == 2 channels
 125  * - dynamic range (8 bits) 0x80 == neutral
 126  *
 127  * LPCM DVD-A header (http://dvd-audio.sourceforge.net/spec/aob.shtml)
 128  * - continuity counter (8 bits, clipped to 0x00-0x1f)
 129  * - header size (16 bits)
 130  * - byte pointer to start of first audio frame.
 131  * - unknown (8bits, 0x10 for stereo, 0x00 for surround)
 132  * - sample size (4+4 bits)
 133  * - samplerate (4+4 bits)
 134  * - unknown (8 bits)
 135  * - group assignment (8 bits)
 136  * - unknown (8 bits)
 137  * - padding(variable)
 138  *
 139  * LPCM BD header :
 140  * - unknown (16 bits)
 141  * - number of channels (4 bits)
 142  * - frequency (4 bits)
 143  * - bits per sample (2 bits)
 144  * - unknown (6 bits)
 145  *
 146  * LPCM WIDI header
 147  * refers http://www.dvdforum.org/images/Guideline1394V10R0_20020911.pdf
 148   * - sub stream id (8 bits) = 0xa0
 149  * - frame header count (8 bits) = 0x06
 150  * [ 0b0000000 (7 bits)
 151  * - audio emphasis (1 bit) ] (8 bits)
 152  * [ qz word length (2 bits) 0x00 == 16bits
 153  * - sampling freq (3 bits) 0b001 == 44.1K, 0b010 == 48K Hz
 154  * - channels count(3 bits) ] (8 bits) 0b000 == dual mono, 0b001 == stereo
 155  * follows: LPCM data (15360 bits/1920 bytes)
 156  */
 157
 158 #define LPCM_VOB_HEADER_LEN (6)
 159 #define LPCM_AOB_HEADER_LEN (11)
 160 #define LPCM_BD_HEADER_LEN (4)
 161 #define LPCM_WIDI_HEADER_LEN (4)
 162
 163 enum
 164 {
 165     LPCM_VOB,
 166     LPCM_AOB,
 167     LPCM_BD,
 168     LPCM_WIDI,
 169 };
 170
 171 typedef struct
 172 {
 173     unsigned i_channels;
 174     bool     b_used;
 175     unsigned pi_position[6];
 176 } aob_group_t;
 177
 178 /*****************************************************************************
 179  * Local prototypes
 180  *****************************************************************************/
 181 static block_t *DecodeFrame  ( decoder_t *, block_t ** );
 182
 183 /* */
 184 static int VobHeader( unsigned *pi_rate,
 185                       unsigned *pi_channels, unsigned *pi_original_channels,
 186                       unsigned *pi_bits,
 187                       const uint8_t *p_header );
 188 static void VobExtract( block_t *, block_t *, unsigned i_bits );
 189 /* */
 190 static int AobHeader( unsigned *pi_rate,
 191                       unsigned *pi_channels, unsigned *pi_layout,
 192                       unsigned *pi_bits,
 193                       unsigned *pi_padding,
 194                       aob_group_t g[2],
 195                       const uint8_t *p_header );
 196 static void AobExtract( block_t *, block_t *, unsigned i_bits, aob_group_t p_group[2] );
 197 /* */
 198 static int BdHeader( decoder_sys_t *p_sys,
 199                      unsigned *pi_rate,
 200                      unsigned *pi_channels,
 201                      unsigned *pi_channels_padding,
 202                      unsigned *pi_original_channels,
 203                      unsigned *pi_bits,
 204                      const uint8_t *p_header );
 205 static void BdExtract( block_t *, block_t *, unsigned, unsigned, unsigned, unsigned );
 206 /* */
 207 static int WidiHeader( unsigned *pi_rate,
 208                        unsigned *pi_channels, unsigned *pi_original_channels,
 209                        unsigned *pi_bits,
 210                        const uint8_t *p_header );
 211
 212 /*****************************************************************************
 213  * OpenCommon:
 214  *****************************************************************************/
 215 static int OpenCommon( vlc_object_t *p_this, bool b_packetizer )
 216 {
 217     decoder_t *p_dec = (decoder_t*)p_this;
 218     decoder_sys_t *p_sys;
 219     int i_type;
 220     int i_header_size;
 221
 222     switch( p_dec->fmt_in.i_codec )
 223     {
 224     /* DVD LPCM */
 225     case VLC_CODEC_DVD_LPCM:
 226         i_type = LPCM_VOB;
 227         i_header_size = LPCM_VOB_HEADER_LEN;
 228         break;
 229     /* DVD-Audio LPCM */
 230     case VLC_CODEC_DVDA_LPCM:
 231         i_type = LPCM_AOB;
 232         i_header_size = LPCM_AOB_HEADER_LEN;
 233         break;
 234     /* BD LPCM */
 235     case VLC_CODEC_BD_LPCM:
 236         i_type = LPCM_BD;
 237         i_header_size = LPCM_BD_HEADER_LEN;
 238         break;
 239     /* WIDI LPCM */
 240     case VLC_CODEC_WIDI_LPCM:
 241         i_type = LPCM_WIDI;
 242         i_header_size = LPCM_WIDI_HEADER_LEN;
 243         break;
 244     default:
 245         return VLC_EGENERIC;
 246     }
 247
 248     /* Allocate the memory needed to store the decoder's structure */
 249     if( ( p_dec->p_sys = p_sys = malloc(sizeof(decoder_sys_t)) ) == NULL )
 250         return VLC_ENOMEM;
 251
 252     /* Misc init */
 253     p_sys->b_packetizer = b_packetizer;
 254     date_Set( &p_sys->end_date, 0 );
 255     p_sys->i_type = i_type;
 256     p_sys->i_header_size = i_header_size;
 257     p_sys->i_chans_to_reorder = 0;
 258
 259     /* Set output properties */
 260     p_dec->fmt_out.i_cat = AUDIO_ES;
 261
 262     if( b_packetizer )
 263     {
 264         switch( i_type )
 265         {
 266         case LPCM_VOB:
 267             p_dec->fmt_out.i_codec = VLC_CODEC_DVD_LPCM;
 268             break;
 269         case LPCM_AOB:
 270             p_dec->fmt_out.i_codec = VLC_CODEC_DVDA_LPCM;
 271             break;
 272         case LPCM_WIDI:
 273             p_dec->fmt_out.i_codec = VLC_CODEC_WIDI_LPCM;
 274             break;
 275         default:
 276             vlc_assert_unreachable();
 277         case LPCM_BD:
 278             p_dec->fmt_out.i_codec = VLC_CODEC_BD_LPCM;
 279             break;
 280         }
 281     }
 282     else
 283     {
 284         switch( p_dec->fmt_out.audio.i_bitspersample )
 285         {
 286         case 24:
 287         case 20:
 288             p_dec->fmt_out.i_codec = VLC_CODEC_S32N;
 289             p_dec->fmt_out.audio.i_bitspersample = 32;
 290             break;
 291         default:
 292             p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
 293             p_dec->fmt_out.audio.i_bitspersample = 16;
 294             break;
 295         }
 296     }
 297
 298     /* Set callback */
 299     p_dec->pf_decode_audio = DecodeFrame;
 300     p_dec->pf_packetize    = DecodeFrame;
 301
 302     return VLC_SUCCESS;
 303 }
 304 static int OpenDecoder( vlc_object_t *p_this )
 305 {
 306     return OpenCommon( p_this, false );
 307 }
 308 static int OpenPacketizer( vlc_object_t *p_this )
 309 {
 310     return OpenCommon( p_this, true );
 311 }
 312
 313 /*****************************************************************************
 314  * DecodeFrame: decodes an lpcm frame.
 315  ****************************************************************************
 316  * Beware, this function must be fed with complete frames (PES packet).
 317  *****************************************************************************/
 318 static block_t *DecodeFrame( decoder_t *p_dec, block_t **pp_block )
 319 {
 320     decoder_sys_t *p_sys = p_dec->p_sys;
 321     block_t       *p_block;
 322     unsigned int  i_rate = 0, i_original_channels = 0, i_channels = 0, i_bits = 0;
 323     int           i_frame_length;
 324
 325     if( !pp_block || !*pp_block ) return NULL;
 326
 327     p_block = *pp_block;
 328     *pp_block = NULL; /* So the packet doesn't get re-sent */
 329
 330     /* Date management */
 331     if( p_block->i_pts > VLC_TS_INVALID &&
 332         p_block->i_pts != date_Get( &p_sys->end_date ) )
 333     {
 334         date_Set( &p_sys->end_date, p_block->i_pts );
 335     }
 336
 337     if( !date_Get( &p_sys->end_date ) )
 338     {
 339         /* We've just started the stream, wait for the first PTS. */
 340         block_Release( p_block );
 341         return NULL;
 342     }
 343
 344     if( p_block->i_buffer <= p_sys->i_header_size )
 345     {
 346         msg_Err(p_dec, "frame is too short");
 347         block_Release( p_block );
 348         return NULL;
 349     }
 350
 351     int i_ret;
 352     unsigned i_channels_padding = 0;
 353     unsigned i_padding = 0;
 354     aob_group_t p_aob_group[2];
 355     switch( p_sys->i_type )
 356     {
 357     case LPCM_VOB:
 358         i_ret = VobHeader( &i_rate, &i_channels, &i_original_channels, &i_bits,
 359                            p_block->p_buffer );
 360         break;
 361     case LPCM_AOB:
 362         i_ret = AobHeader( &i_rate, &i_channels, &i_original_channels, &i_bits, &i_padding,
 363                            p_aob_group,
 364                            p_block->p_buffer );
 365         break;
 366     case LPCM_BD:
 367         i_ret = BdHeader( p_sys, &i_rate, &i_channels, &i_channels_padding, &i_original_channels, &i_bits,
 368                           p_block->p_buffer );
 369         break;
 370     case LPCM_WIDI:
 371         i_ret = WidiHeader( &i_rate, &i_channels, &i_original_channels, &i_bits,
 372                             p_block->p_buffer );
 373         break;
 374     default:
 375         abort();
 376     }
 377
 378     if( i_ret || p_block->i_buffer <= p_sys->i_header_size + i_padding )
 379     {
 380         msg_Warn( p_dec, "no frame sync or too small frame" );
 381         block_Release( p_block );
 382         return NULL;
 383     }
 384
 385     /* Set output properties */
 386     if( p_dec->fmt_out.audio.i_rate != i_rate )
 387     {
 388         date_Init( &p_sys->end_date, i_rate, 1 );
 389         date_Set( &p_sys->end_date, p_block->i_pts );
 390     }
 391     p_dec->fmt_out.audio.i_rate = i_rate;
 392     p_dec->fmt_out.audio.i_channels = i_channels;
 393     p_dec->fmt_out.audio.i_original_channels = i_original_channels;
 394     p_dec->fmt_out.audio.i_physical_channels = i_original_channels;
 395
 396     i_frame_length = (p_block->i_buffer - p_sys->i_header_size - i_padding) /
 397                      (i_channels + i_channels_padding) * 8 / i_bits;
 398
 399     if( p_sys->b_packetizer )
 400     {
 401         p_block->i_pts = p_block->i_dts = date_Get( &p_sys->end_date );
 402         p_block->i_length =
 403             date_Increment( &p_sys->end_date, i_frame_length ) -
 404             p_block->i_pts;
 405
 406         /* Just pass on the incoming frame */
 407         return p_block;
 408     }
 409     else
 410     {
 411         /* */
 412         if( i_bits == 16 )
 413         {
 414             p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
 415             p_dec->fmt_out.audio.i_bitspersample = 16;
 416         }
 417         else
 418         {
 419             p_dec->fmt_out.i_codec = VLC_CODEC_S32N;
 420             p_dec->fmt_out.audio.i_bitspersample = 32;
 421         }
 422
 423         /* */
 424         block_t *p_aout_buffer;
 425         p_aout_buffer = decoder_NewAudioBuffer( p_dec, i_frame_length );
 426         if( !p_aout_buffer )
 427             return NULL;
 428
 429         p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
 430         p_aout_buffer->i_length =
 431             date_Increment( &p_sys->end_date, i_frame_length )
 432             - p_aout_buffer->i_pts;
 433
 434         p_block->p_buffer += p_sys->i_header_size + i_padding;
 435         p_block->i_buffer -= p_sys->i_header_size + i_padding;
 436
 437         switch( p_sys->i_type )
 438         {
 439         case LPCM_WIDI:
 440         case LPCM_VOB:
 441             VobExtract( p_aout_buffer, p_block, i_bits );
 442             break;
 443         case LPCM_AOB:
 444             AobExtract( p_aout_buffer, p_block, i_bits, p_aob_group );
 445             break;
 446         default:
 447             vlc_assert_unreachable();
 448         case LPCM_BD:
 449             BdExtract( p_aout_buffer, p_block, i_frame_length, i_channels, i_channels_padding, i_bits );
 450             break;
 451         }
 452
 453         if( p_sys->i_chans_to_reorder )
 454         {
 455             aout_ChannelReorder( p_aout_buffer->p_buffer, p_aout_buffer->i_buffer,
 456                                  p_sys->i_chans_to_reorder, p_sys->pi_chan_table,
 457                                  p_dec->fmt_out.i_codec );
 458         }
 459
 460         block_Release( p_block );
 461         return p_aout_buffer;
 462     }
 463 }
 464
 465 /*****************************************************************************
 466  * CloseCommon : lpcm decoder destruction
 467  *****************************************************************************/
 468 static void CloseCommon( vlc_object_t *p_this )
 469 {
 470     decoder_t *p_dec = (decoder_t*)p_this;
 471     free( p_dec->p_sys );
 472 }
 473
 474 #ifdef ENABLE_SOUT
 475 /*****************************************************************************
 476  * OpenEncoder: lpcm encoder construction
 477  *****************************************************************************/
 478 static int OpenEncoder( vlc_object_t *p_this )
 479 {
 480     encoder_t *p_enc = (encoder_t *)p_this;
 481     encoder_sys_t *p_sys;
 482
 483     /* We only support DVD LPCM yet. */
 484     if( p_enc->fmt_out.i_codec != VLC_CODEC_DVD_LPCM )
 485         return VLC_EGENERIC;
 486
 487     if( p_enc->fmt_in.audio.i_rate != 48000 &&
 488         p_enc->fmt_in.audio.i_rate != 96000 &&
 489         p_enc->fmt_in.audio.i_rate != 44100 &&
 490         p_enc->fmt_in.audio.i_rate != 32000 )
 491     {
 492         msg_Err( p_enc, "DVD LPCM supports only sample rates of 48, 96, 44.1 or 32 kHz" );
 493         return VLC_EGENERIC;
 494     }
 495
 496     if( p_enc->fmt_in.audio.i_channels > 8 )
 497     {
 498         msg_Err( p_enc, "DVD LPCM supports a maximum of eight channels" );
 499         return VLC_EGENERIC;
 500     }
 501
 502     /* Allocate the memory needed to store the encoder's structure */
 503     if( ( p_enc->p_sys = p_sys =
 504           (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
 505         return VLC_ENOMEM;
 506
 507     /* In DVD LCPM, a frame is always 150 PTS ticks. */
 508     p_sys->i_frame_samples = p_enc->fmt_in.audio.i_rate * 150 / 90000;
 509     p_sys->p_buffer = xmalloc(p_sys->i_frame_samples
 510                             * p_enc->fmt_in.audio.i_channels * 16);
 511     p_sys->i_buffer_used = 0;
 512     p_sys->i_frame_num = 0;
 513
 514     p_sys->i_channels = p_enc->fmt_in.audio.i_channels;
 515     p_sys->i_rate = p_enc->fmt_in.audio.i_rate;
 516
 517     p_enc->pf_encode_audio = EncodeFrames;
 518     p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 519
 520     p_enc->fmt_in.audio.i_bitspersample = 16;
 521     p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
 522
 523     p_enc->fmt_out.i_bitrate =
 524         p_enc->fmt_in.audio.i_channels *
 525         p_enc->fmt_in.audio.i_rate *
 526         p_enc->fmt_in.audio.i_bitspersample *
 527         (p_sys->i_frame_samples + LPCM_VOB_HEADER_LEN) /
 528         p_sys->i_frame_samples;
 529
 530     return VLC_SUCCESS;
 531 }
 532
 533 /*****************************************************************************
 534  * CloseEncoder: lpcm encoder destruction
 535  *****************************************************************************/
 536 static void CloseEncoder ( vlc_object_t *p_this )
 537 {
 538     encoder_t     *p_enc = (encoder_t *)p_this;
 539     encoder_sys_t *p_sys = p_enc->p_sys;
 540
 541     free( p_sys->p_buffer );
 542     free( p_sys );
 543 }
 544
 545 /*****************************************************************************
 546  * EncodeFrames: encode zero or more LCPM audio packets
 547  *****************************************************************************/
 548 static block_t *EncodeFrames( encoder_t *p_enc, block_t *p_aout_buf )
 549 {
 550     encoder_sys_t *p_sys = p_enc->p_sys;
 551     block_t *p_first_block = NULL, *p_last_block = NULL;
 552
 553     if( !p_aout_buf || !p_aout_buf->i_buffer ) return NULL;
 554
 555     const int i_num_frames = ( p_sys->i_buffer_used + p_aout_buf->i_nb_samples ) /
 556         p_sys->i_frame_samples;
 557     const int i_leftover_samples = ( p_sys->i_buffer_used + p_aout_buf->i_nb_samples ) %
 558         p_sys->i_frame_samples;
 559     const int i_frame_size = p_sys->i_frame_samples * p_sys->i_channels * 2 + LPCM_VOB_HEADER_LEN;
 560     const int i_start_offset = -p_sys->i_buffer_used;
 561
 562     uint8_t i_freq_code = 0;
 563
 564     switch( p_sys->i_rate ) {
 565     case 48000:
 566         i_freq_code = 0;
 567         break;
 568     case 96000:
 569         i_freq_code = 1;
 570         break;
 571     case 44100:
 572         i_freq_code = 2;
 573         break;
 574     case 32000:
 575         i_freq_code = 3;
 576         break;
 577     default:
 578         vlc_assert_unreachable();
 579     }
 580
 581     int i_bytes_consumed = 0;
 582
 583     for ( int i = 0; i < i_num_frames; ++i )
 584     {
 585         block_t *p_block = block_Alloc( i_frame_size );
 586         if( !p_block )
 587             return NULL;
 588
 589         uint8_t *frame = (uint8_t *)p_block->p_buffer;
 590         frame[0] = 1;  /* one frame in packet */
 591         frame[1] = 0;
 592         frame[2] = 0;  /* no first access unit */
 593         frame[3] = (p_sys->i_frame_num + i) & 0x1f;  /* no emphasis, no mute */
 594         frame[4] = (i_freq_code << 4) | (p_sys->i_channels - 1);
 595         frame[5] = 0x80;  /* neutral dynamic range */
 596
 597         const int i_consume_samples = p_sys->i_frame_samples - p_sys->i_buffer_used;
 598         const int i_kept_bytes = p_sys->i_buffer_used * p_sys->i_channels * 2;
 599         const int i_consume_bytes = i_consume_samples * p_sys->i_channels * 2;
 600
 601 #ifdef WORDS_BIGENDIAN
 602         memcpy( frame + 6, p_sys->p_buffer, i_kept_bytes );
 603         memcpy( frame + 6 + i_kept_bytes, p_aout_buf->p_buffer + i_bytes_consumed,
 604                 i_consume_bytes );
 605 #else
 606         swab( p_sys->p_buffer, frame + 6, i_kept_bytes );
 607         swab( p_aout_buf->p_buffer + i_bytes_consumed, frame + 6 + i_kept_bytes,
 608               i_consume_bytes );
 609 #endif
 610
 611         p_sys->i_frame_num++;
 612         p_sys->i_buffer_used = 0;
 613         i_bytes_consumed += i_consume_bytes;
 614
 615         /* We need to find i_length by means of next_pts due to possible roundoff errors. */
 616         mtime_t this_pts = p_aout_buf->i_pts +
 617             (i * p_sys->i_frame_samples + i_start_offset) * CLOCK_FREQ / p_sys->i_rate;
 618         mtime_t next_pts = p_aout_buf->i_pts +
 619             ((i + 1) * p_sys->i_frame_samples + i_start_offset) * CLOCK_FREQ / p_sys->i_rate;
 620
 621         p_block->i_pts = p_block->i_dts = this_pts;
 622         p_block->i_length = next_pts - this_pts;
 623
 624         if( !p_first_block )
 625             p_first_block = p_last_block = p_block;
 626         else
 627             p_last_block = p_last_block->p_next = p_block;
 628     }
 629
 630     memcpy( p_sys->p_buffer,
 631             p_aout_buf->p_buffer + i_bytes_consumed,
 632             i_leftover_samples * p_sys->i_channels * 2 );
 633     p_sys->i_buffer_used = i_leftover_samples;
 634
 635     return p_first_block;
 636 }
 637 #endif
 638
 639 /*****************************************************************************
 640  *
 641  *****************************************************************************/
 642 static int VobHeader( unsigned *pi_rate,
 643                       unsigned *pi_channels, unsigned *pi_original_channels,
 644                       unsigned *pi_bits,
 645                       const uint8_t *p_header )
 646 {
 647     const uint8_t i_header = p_header[4];
 648
 649     switch( (i_header >> 4) & 0x3 )
 650     {
 651     case 0:
 652         *pi_rate = 48000;
 653         break;
 654     case 1:
 655         *pi_rate = 96000;
 656         break;
 657     case 2:
 658         *pi_rate = 44100;
 659         break;
 660     case 3:
 661         *pi_rate = 32000;
 662         break;
 663     }
 664
 665     *pi_channels = (i_header & 0x7) + 1;
 666     switch( *pi_channels - 1 )
 667     {
 668     case 0:
 669         *pi_original_channels = AOUT_CHAN_CENTER;
 670         break;
 671     case 1:
 672         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 673         break;
 674     case 2:
 675         /* This is unsure. */
 676         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_LFE;
 677         break;
 678     case 3:
 679         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 680                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 681         break;
 682     case 4:
 683         /* This is unsure. */
 684         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 685                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 686                                | AOUT_CHAN_LFE;
 687         break;
 688     case 5:
 689         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 690                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 691                                | AOUT_CHAN_CENTER | AOUT_CHAN_LFE;
 692         break;
 693     case 6:
 694         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 695                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 696                                | AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT
 697                                | AOUT_CHAN_MIDDLERIGHT;
 698         break;
 699     case 7:
 700         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 701                                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 702                                | AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT
 703                                | AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_LFE;
 704         break;
 705     }
 706
 707     switch( (i_header >> 6) & 0x3 )
 708     {
 709     case 2:
 710         *pi_bits = 24;
 711         break;
 712     case 1:
 713         *pi_bits = 20;
 714         break;
 715     case 0:
 716     default:
 717         *pi_bits = 16;
 718         break;
 719     }
 720
 721     /* Check frame sync and drop it. */
 722     if( p_header[5] != 0x80 )
 723         return -1;
 724     return 0;
 725 }
 726
 727 static const unsigned p_aob_group1[21][6] = {
 728     { AOUT_CHAN_CENTER, 0 },
 729     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 730     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 731     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 732     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 733     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 734     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 735     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 736     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 737     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 738     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 739     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 740     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, 0 },
 741     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,   0 },
 742     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,   0 },
 743     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,   0 },
 744     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,   0 },
 745     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,   0 },
 746     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0  },
 747     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0  },
 748     { AOUT_CHAN_LEFT,   AOUT_CHAN_RIGHT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0  },
 749 };
 750 static const unsigned p_aob_group2[21][6] = {
 751     { 0 },
 752     { 0 },
 753     { AOUT_CHAN_REARCENTER, 0 },
 754     { AOUT_CHAN_REARLEFT,   AOUT_CHAN_REARRIGHT,    0 },
 755     { AOUT_CHAN_LFE,        0 },
 756     { AOUT_CHAN_LFE,        AOUT_CHAN_REARCENTER,   0 },
 757     { AOUT_CHAN_LFE,        AOUT_CHAN_REARLEFT,     AOUT_CHAN_REARRIGHT,    0 },
 758     { AOUT_CHAN_CENTER,     0 },
 759     { AOUT_CHAN_CENTER,     AOUT_CHAN_REARCENTER, 0 },
 760     { AOUT_CHAN_CENTER,     AOUT_CHAN_REARLEFT,   AOUT_CHAN_REARRIGHT,    0 },
 761     { AOUT_CHAN_CENTER,     AOUT_CHAN_LFE,        0 },
 762     { AOUT_CHAN_CENTER,     AOUT_CHAN_LFE,        AOUT_CHAN_REARCENTER,   0 },
 763     { AOUT_CHAN_CENTER,     AOUT_CHAN_LFE,        AOUT_CHAN_REARLEFT,     AOUT_CHAN_REARRIGHT,    0 },
 764     { AOUT_CHAN_REARCENTER, 0 },
 765     { AOUT_CHAN_REARLEFT,   AOUT_CHAN_REARRIGHT,    0 },
 766     { AOUT_CHAN_LFE,        0 },
 767     { AOUT_CHAN_LFE,        AOUT_CHAN_REARCENTER,   0 },
 768     { AOUT_CHAN_LFE,        AOUT_CHAN_REARLEFT,     AOUT_CHAN_REARRIGHT,    0 },
 769     { AOUT_CHAN_LFE,        0 },
 770     { AOUT_CHAN_CENTER,     0 },
 771     { AOUT_CHAN_CENTER,     AOUT_CHAN_LFE,          0 },
 772 };
 773
 774 static int AobHeader( unsigned *pi_rate,
 775                       unsigned *pi_channels, unsigned *pi_layout,
 776                       unsigned *pi_bits,
 777                       unsigned *pi_padding,
 778                       aob_group_t g[2],
 779                       const uint8_t *p_header )
 780 {
 781     const unsigned i_header_size = GetWBE( &p_header[1] );
 782     if( i_header_size + 3 < LPCM_AOB_HEADER_LEN )
 783         return VLC_EGENERIC;
 784
 785     *pi_padding = 3+i_header_size - LPCM_AOB_HEADER_LEN;
 786
 787     const int i_index_size_g1 = (p_header[6] >> 4) & 0x0f;
 788     const int i_index_size_g2 = (p_header[6]     ) & 0x0f;
 789     const int i_index_rate_g1 = (p_header[7] >> 4) & 0x0f;
 790     const int i_index_rate_g2 = (p_header[7]     ) & 0x0f;
 791     const int i_assignment     = p_header[9];
 792
 793     /* Validate */
 794     if( i_index_size_g1 > 0x02 ||
 795         ( i_index_size_g2 != 0x0f && i_index_size_g2 > 0x02 ) )
 796         return VLC_EGENERIC;
 797     if( (i_index_rate_g1 & 0x07) > 0x02 ||
 798         ( i_index_rate_g2 != 0x0f && (i_index_rate_g1 & 0x07) > 0x02 ) )
 799         return VLC_EGENERIC;
 800     if( i_assignment > 20 )
 801         return VLC_EGENERIC;
 802
 803     /* */
 804     *pi_bits = 16 + 4 * i_index_size_g1;
 805     if( i_index_rate_g1 & 0x08 )
 806         *pi_rate = 44100 << (i_index_rate_g1 & 0x07);
 807     else
 808         *pi_rate = 48000 << (i_index_rate_g1 & 0x07);
 809
 810
 811     /* Group1 */
 812     unsigned i_channels1 = 0;
 813     unsigned i_layout1 = 0;
 814     for( int i = 0; p_aob_group1[i_assignment][i] != 0; i++ )
 815     {
 816         i_channels1++;
 817         i_layout1 |= p_aob_group1[i_assignment][i];
 818     }
 819     /* Group2 */
 820     unsigned i_channels2 = 0;
 821     unsigned i_layout2 = 0;
 822     if( i_index_size_g2 != 0x0f && i_index_rate_g2 != 0x0f )
 823     {
 824         for( int i = 0; p_aob_group2[i_assignment][i] != 0; i++ )
 825         {
 826             i_channels2++;
 827             i_layout2 |= p_aob_group2[i_assignment][i];
 828         }
 829         assert( (i_layout1 & i_layout2) == 0 );
 830     }
 831     /* It is enabled only when presents and compatible wih group1 */
 832     const bool b_group2_used = i_index_size_g1 == i_index_size_g2 &&
 833                                i_index_rate_g1 == i_index_rate_g2;
 834
 835     /* */
 836     *pi_channels = i_channels1 + ( b_group2_used ? i_channels2 : 0 );
 837     *pi_layout   = i_layout1   | ( b_group2_used ? i_layout2   : 0 );
 838
 839     /* */
 840     for( unsigned i = 0; i < 2; i++ )
 841     {
 842         const unsigned *p_aob = i == 0 ? p_aob_group1[i_assignment] :
 843                                          p_aob_group2[i_assignment];
 844         g[i].i_channels = i == 0 ? i_channels1 :
 845                                    i_channels2;
 846
 847         g[i].b_used = i == 0 || b_group2_used;
 848         if( !g[i].b_used )
 849             continue;
 850         for( unsigned j = 0; j < g[i].i_channels; j++ )
 851         {
 852             g[i].pi_position[j] = 0;
 853             for( int k = 0; pi_vlc_chan_order_wg4[k] != 0; k++ )
 854             {
 855                 const unsigned i_channel = pi_vlc_chan_order_wg4[k];
 856                 if( i_channel == p_aob[j] )
 857                     break;
 858                 if( (*pi_layout) & i_channel )
 859                     g[i].pi_position[j]++;
 860             }
 861         }
 862     }
 863     return VLC_SUCCESS;
 864 }
 865
 866 static const uint32_t pi_8channels_in[] =
 867 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,
 868   AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT,
 869   AOUT_CHAN_MIDDLERIGHT, AOUT_CHAN_LFE, 0 };
 870
 871 static const uint32_t pi_7channels_in[] =
 872 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,
 873   AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT,
 874   AOUT_CHAN_MIDDLERIGHT, 0 };
 875
 876 static const uint32_t pi_6channels_in[] =
 877 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,
 878   AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, AOUT_CHAN_LFE, 0 };
 879
 880 static const uint32_t pi_5channels_in[] =
 881 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_CENTER,
 882   AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_MIDDLERIGHT, 0 };
 883
 884 static const uint32_t pi_4channels_in[] =
 885 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT,
 886   AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0 };
 887
 888 static const uint32_t pi_3channels_in[] =
 889 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT,
 890   AOUT_CHAN_CENTER, 0 };
 891
 892
 893 static int BdHeader( decoder_sys_t *p_sys,
 894                      unsigned *pi_rate,
 895                      unsigned *pi_channels,
 896                      unsigned *pi_channels_padding,
 897                      unsigned *pi_original_channels,
 898                      unsigned *pi_bits,
 899                      const uint8_t *p_header )
 900 {
 901     const uint32_t h = GetDWBE( p_header );
 902     const uint32_t *pi_channels_in = NULL;
 903     switch( ( h & 0xf000) >> 12 )
 904     {
 905     case 1:
 906         *pi_channels = 1;
 907         *pi_original_channels = AOUT_CHAN_CENTER;
 908         break;
 909     case 3:
 910         *pi_channels = 2;
 911         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 912         break;
 913     case 4:
 914         *pi_channels = 3;
 915         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER;
 916         pi_channels_in = pi_3channels_in;
 917         break;
 918     case 5:
 919         *pi_channels = 3;
 920         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARCENTER;
 921         break;
 922     case 6:
 923         *pi_channels = 4;
 924         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 925                                 AOUT_CHAN_REARCENTER;
 926         break;
 927     case 7:
 928         *pi_channels = 4;
 929         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
 930                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 931         pi_channels_in = pi_4channels_in;
 932         break;
 933     case 8:
 934         *pi_channels = 5;
 935         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 936                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
 937         pi_channels_in = pi_5channels_in;
 938         break;
 939     case 9:
 940         *pi_channels = 6;
 941         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 942                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 943                                 AOUT_CHAN_LFE;
 944         pi_channels_in = pi_6channels_in;
 945         break;
 946     case 10:
 947         *pi_channels = 7;
 948         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 949                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 950                                 AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT;
 951         pi_channels_in = pi_7channels_in;
 952         break;
 953     case 11:
 954         *pi_channels = 8;
 955         *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
 956                                 AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
 957                                 AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT |
 958                                 AOUT_CHAN_LFE;
 959         pi_channels_in = pi_8channels_in;
 960         break;
 961
 962     default:
 963         return -1;
 964     }
 965     *pi_channels_padding = *pi_channels & 1;
 966
 967     switch( (h >> 6) & 0x03 )
 968     {
 969     case 1:
 970         *pi_bits = 16;
 971         break;
 972     case 2: /* 20 bits but samples are stored on 24 bits */
 973     case 3: /* 24 bits */
 974         *pi_bits = 24;
 975         break;
 976     default:
 977         return -1;
 978     }
 979     switch( (h >> 8) & 0x0f )
 980     {
 981     case 1:
 982         *pi_rate = 48000;
 983         break;
 984     case 4:
 985         *pi_rate = 96000;
 986         break;
 987     case 5:
 988         *pi_rate = 192000;
 989         break;
 990     default:
 991         return -1;
 992     }
 993
 994     if( pi_channels_in )
 995     {
 996         p_sys->i_chans_to_reorder =
 997             aout_CheckChannelReorder( pi_channels_in, NULL,
 998                                       *pi_original_channels,
 999                                       p_sys->pi_chan_table );
1000     }
1001
1002     return 0;
1003 }
1004
1005 static int WidiHeader( unsigned *pi_rate,
1006                        unsigned *pi_channels, unsigned *pi_original_channels,
1007                        unsigned *pi_bits,
1008                        const uint8_t *p_header )
1009 {
1010     if ( p_header[0] != 0xa0 || p_header[1] != 0x06 )
1011         return -1;
1012
1013     switch( ( p_header[3] & 0x38 ) >> 3 )
1014     {
1015     case 0x01: //0b001
1016         *pi_rate = 44100;
1017         break;
1018     case 0x02: //0b010
1019         *pi_rate = 48000;
1020         break;
1021     default:
1022         return -1;
1023     }
1024
1025     if( p_header[3] >> 6 != 0 )
1026         return -1;
1027     else
1028         *pi_bits = 16;
1029
1030     *pi_channels = (p_header[3] & 0x7) + 1;
1031
1032     *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
1033
1034     return 0;
1035 }
1036
1037 static void VobExtract( block_t *p_aout_buffer, block_t *p_block,
1038                         unsigned i_bits )
1039 {
1040     /* 20/24 bits LPCM use special packing */
1041     if( i_bits == 24 )
1042     {
1043         uint32_t *p_out = (uint32_t *)p_aout_buffer->p_buffer;
1044
1045         while( p_block->i_buffer / 12 )
1046         {
1047             /* Sample 1 */
1048             *(p_out++) = (p_block->p_buffer[ 0] << 24)
1049                        | (p_block->p_buffer[ 1] << 16)
1050                        | (p_block->p_buffer[ 8] <<  8);
1051             /* Sample 2 */
1052             *(p_out++) = (p_block->p_buffer[ 2] << 24)
1053                        | (p_block->p_buffer[ 3] << 16)
1054                        | (p_block->p_buffer[ 9] <<  8);
1055             /* Sample 3 */
1056             *(p_out++) = (p_block->p_buffer[ 4] << 24)
1057                        | (p_block->p_buffer[ 5] << 16)
1058                        | (p_block->p_buffer[10] <<  8);
1059             /* Sample 4 */
1060             *(p_out++) = (p_block->p_buffer[ 6] << 24)
1061                        | (p_block->p_buffer[ 7] << 16)
1062                        | (p_block->p_buffer[11] <<  8);
1063
1064             p_block->i_buffer -= 12;
1065             p_block->p_buffer += 12;
1066         }
1067     }
1068     else if( i_bits == 20 )
1069     {
1070         uint32_t *p_out = (uint32_t *)p_aout_buffer->p_buffer;
1071
1072         while( p_block->i_buffer / 10 )
1073         {
1074             /* Sample 1 */
1075             *(p_out++) = ( p_block->p_buffer[0]         << 24)
1076                        | ( p_block->p_buffer[1]         << 16)
1077                        | ((p_block->p_buffer[8] & 0xF0) <<  8);
1078             /* Sample 2 */
1079             *(p_out++) = ( p_block->p_buffer[2]         << 24)
1080                        | ( p_block->p_buffer[3]         << 16)
1081                        | ((p_block->p_buffer[8] & 0x0F) << 12);
1082             /* Sample 3 */
1083             *(p_out++) = ( p_block->p_buffer[4]         << 24)
1084                        | ( p_block->p_buffer[5]         << 16)
1085                        | ((p_block->p_buffer[9] & 0xF0) <<  8);
1086             /* Sample 4 */
1087             *(p_out++) = ( p_block->p_buffer[6]         << 24)
1088                        | ( p_block->p_buffer[7]         << 16)
1089                        | ((p_block->p_buffer[9] & 0x0F) << 12);
1090
1091             p_block->i_buffer -= 10;
1092             p_block->p_buffer += 10;
1093         }
1094     }
1095     else
1096     {
1097         assert( i_bits == 16 );
1098 #ifdef WORDS_BIGENDIAN
1099         memcpy( p_aout_buffer->p_buffer, p_block->p_buffer, p_block->i_buffer );
1100 #else
1101         swab( p_block->p_buffer, p_aout_buffer->p_buffer, p_block->i_buffer );
1102 #endif
1103     }
1104 }
1105 static void AobExtract( block_t *p_aout_buffer,
1106                         block_t *p_block, unsigned i_bits, aob_group_t p_group[2] )
1107 {
1108     const unsigned i_channels = p_group[0].i_channels +
1109                                 ( p_group[1].b_used ? p_group[1].i_channels : 0 );
1110     uint8_t *p_out = p_aout_buffer->p_buffer;
1111
1112     while( p_block->i_buffer > 0 )
1113     {
1114         for( int i = 0; i < 2; i++ )
1115         {
1116             const aob_group_t *g = &p_group[1-i];
1117             const unsigned int i_group_size = 2 * g->i_channels * i_bits / 8;
1118
1119             if( p_block->i_buffer < i_group_size )
1120             {
1121                 p_block->i_buffer = 0;
1122                 break;
1123             }
1124             for( unsigned n = 0; n < 2; n++ )
1125             {
1126                 for( unsigned j = 0; j < g->i_channels && g->b_used; j++ )
1127                 {
1128                     const int i_src = n * g->i_channels + j;
1129                     const int i_dst = n * i_channels + g->pi_position[j];
1130
1131                     if( i_bits == 24 )
1132                     {
1133                         p_out[3*i_dst+0] = p_block->p_buffer[2*i_src+0];
1134                         p_out[3*i_dst+1] = p_block->p_buffer[2*i_src+1];
1135                         p_out[3*i_dst+2] = p_block->p_buffer[4*g->i_channels+i_src];
1136                     }
1137                     else if( i_bits == 20 )
1138                     {
1139                         p_out[3*i_dst+0] = p_block->p_buffer[2*i_src+0];
1140                         p_out[3*i_dst+1] = p_block->p_buffer[2*i_src+1];
1141                         if( n == 0 )
1142                             p_out[3*i_dst+2] = (p_block->p_buffer[4*g->i_channels+i_src]     ) & 0xf0;
1143                         else
1144                             p_out[3*i_dst+2] = (p_block->p_buffer[4*g->i_channels+i_src] << 4) & 0xf0;
1145                     }
1146                     else
1147                     {
1148                         assert( i_bits == 16 );
1149                         p_out[2*i_dst+0] = p_block->p_buffer[2*i_src+0];
1150                         p_out[2*i_dst+1] = p_block->p_buffer[2*i_src+1];
1151                     }
1152                 }
1153             }
1154
1155             p_block->i_buffer -= i_group_size;
1156             p_block->p_buffer += i_group_size;
1157         }
1158         /* */
1159         p_out += (i_bits == 16 ? 2 : 3) * i_channels * 2;
1160
1161     }
1162 }
1163 static void BdExtract( block_t *p_aout_buffer, block_t *p_block,
1164                        unsigned i_frame_length,
1165                        unsigned i_channels, unsigned i_channels_padding,
1166                        unsigned i_bits )
1167 {
1168     if( i_bits != 16 || i_channels_padding > 0 )
1169     {
1170         uint8_t *p_src = p_block->p_buffer;
1171         uint8_t *p_dst = p_aout_buffer->p_buffer;
1172         int dst_inc = ((i_bits == 16) ? 2 : 4) * i_channels;
1173
1174         while( i_frame_length > 0 )
1175         {
1176 #ifdef WORDS_BIGENDIAN
1177             memcpy( p_dst, p_src, i_channels * i_bits / 8 );
1178 #else
1179             if (i_bits == 16) {
1180                 swab( p_src, p_dst, (i_channels + i_channels_padding) * i_bits / 8 );
1181             } else {
1182                 for (unsigned i = 0; i < i_channels; ++i) {
1183                     p_dst[i * 4] = 0;
1184                     p_dst[1 + (i * 4)] = p_src[2 + (i * 3)];
1185                     p_dst[2 + (i * 4)] = p_src[1 + (i * 3)];
1186                     p_dst[3 + (i * 4)] = p_src[i * 3];
1187                 }
1188             }
1189 #endif
1190             p_src += (i_channels + i_channels_padding) * i_bits / 8;
1191             p_dst += dst_inc;
1192             i_frame_length--;
1193         }
1194     }
1195     else
1196     {
1197 #ifdef WORDS_BIGENDIAN
1198         memcpy( p_aout_buffer->p_buffer, p_block->p_buffer, p_block->i_buffer );
1199 #else
1200         swab( p_block->p_buffer, p_aout_buffer->p_buffer, p_block->i_buffer );
1201 #endif
1202     }
1203 }
1204