]> git.sesse.net Git - vlc/blobdiff - modules/codec/lpcm.c
Used VLC_CODEC_* and i_original_fourcc when applicable.
[vlc] / modules / codec / lpcm.c
index da120967d3454c64812573a03016af861f019b2c..74b3d366e586388f7b078318f72df25b8e2782cc 100644 (file)
@@ -1,17 +1,20 @@
 /*****************************************************************************
- * lpcm.c: lpcm decoder module
+ * lpcm.c: lpcm decoder/packetizer module
  *****************************************************************************
- * Copyright (C) 1999-2001 VideoLAN
- * $Id: lpcm.c,v 1.7 2002/11/14 22:38:47 massiot Exp $
+ * Copyright (C) 1999-2008 the VideoLAN team
+ * $Id$
  *
  * Authors: Samuel Hocevar <sam@zoy.org>
  *          Henri Fallon <henri@videolan.org>
+ *          Christophe Massiot <massiot@via.ecp.fr>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *          Lauren Aimar <fenrir _AT_ videolan _DOT_ org >
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
-#include <stdlib.h>                                      /* malloc(), free() */
-#include <string.h>                                    /* memcpy(), memset() */
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
 
-#include <vlc/vlc.h>
-#include <vlc/aout.h>
-#include <vlc/decoder.h>
-#include <input_ext-dec.h>
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_codec.h>
+#include <vlc_aout.h>
+#include <assert.h>
 
-#ifdef HAVE_UNISTD_H
-#   include <unistd.h>                                           /* getpid() */
-#endif
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+static int  OpenDecoder   ( vlc_object_t * );
+static int  OpenPacketizer( vlc_object_t * );
+static void CloseCommon   ( vlc_object_t * );
+
+vlc_module_begin ()
+
+    set_category( CAT_INPUT )
+    set_subcategory( SUBCAT_INPUT_ACODEC )
+    set_description( N_("Linear PCM audio decoder") )
+    set_capability( "decoder", 100 )
+    set_callbacks( OpenDecoder, CloseCommon )
+
+    add_submodule ()
+    set_description( N_("Linear PCM audio packetizer") )
+    set_capability( "packetizer", 100 )
+    set_callbacks( OpenPacketizer, CloseCommon )
+
+vlc_module_end ()
 
-#define LPCM_FRAME_NB 502
 
 /*****************************************************************************
- * dec_thread_t : lpcm decoder thread descriptor
+ * decoder_sys_t : lpcm decoder descriptor
  *****************************************************************************/
-typedef struct dec_thread_t
+struct decoder_sys_t
 {
-    /*
-     * Thread properties
-     */
-    vlc_thread_t        thread_id;                /* id for thread functions */
-
-    /*
-     * Input properties
-     */
-    decoder_fifo_t *    p_fifo;                /* stores the PES stream data */
-    bit_stream_t        bit_stream;
-    int                 sync_ptr;         /* sync ptr from lpcm magic header */
+    /* Module mode */
+    bool b_packetizer;
 
     /*
      * Output properties
      */
-    aout_instance_t        *p_aout;
-    aout_input_t           *p_aout_input;
-    audio_sample_format_t   output_format;
-    audio_date_t            end_date;
-} dec_thread_t;
+    audio_date_t end_date;
+
+    /* */
+    unsigned i_header_size;
+    bool b_dvd;
+};
+
+/*
+ * LPCM DVD header :
+ * - frame number (8 bits)
+ * - unknown (16 bits) == 0x0003 ?
+ * - unknown (4 bits)
+ * - current frame (4 bits)
+ * - unknown (2 bits)
+ * - frequency (2 bits) 0 == 48 kHz, 1 == 32 kHz, 2 == ?, 3 == ?
+ * - unknown (1 bit)
+ * - number of channels - 1 (3 bits) 1 == 2 channels
+ * - start code (8 bits) == 0x80
+ *
+ * LPCM BD header :
+ * - unkown (16 bits)
+ * - number of channels (4 bits)
+ * - frequency (4 bits)
+ * - bits per sample (2 bits)
+ * - unknown (6 bits)
+ */
+
+#define LPCM_DVD_HEADER_LEN (6)
+#define LPCM_BD_HEADER_LEN (4)
 
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-static int  OpenDecoder    ( vlc_object_t * );
-static int  RunDecoder     ( decoder_fifo_t * );
+static void *DecodeFrame  ( decoder_t *, block_t ** );
+static int DvdHeader( unsigned *pi_rate,
+                      unsigned *pi_channels, unsigned *pi_original_channels,
+                      unsigned *pi_bits,
+                      const uint8_t *p_header );
+static void DvdExtract( aout_buffer_t *, block_t *, unsigned i_bits );
 
-       void DecodeFrame    ( dec_thread_t * );
-// static int  InitThread     ( dec_thread_t * );
-static void EndThread      ( dec_thread_t * );
+static int BdHeader( unsigned *pi_rate,
+                     unsigned *pi_channels, unsigned *pi_original_channels,
+                     unsigned *pi_bits,
+                     const uint8_t *p_header );
+static void BdExtract( aout_buffer_t *, block_t * );
 
-/*****************************************************************************
- * Module descriptor
- *****************************************************************************/
-vlc_module_begin();
-    set_description( _("linear PCM audio parser") );
-    set_capability( "decoder", 100 );
-    set_callbacks( OpenDecoder, NULL );
-vlc_module_end();
 
 /*****************************************************************************
- * OpenDecoder: probe the decoder and return score
+ * OpenCommon:
  *****************************************************************************/
-static int OpenDecoder( vlc_object_t *p_this )
+static int OpenCommon( vlc_object_t *p_this, bool b_packetizer )
 {
-    decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
+    decoder_t *p_dec = (decoder_t*)p_this;
+    decoder_sys_t *p_sys;
+    bool b_dvd;
 
-    if( p_fifo->i_fourcc != VLC_FOURCC('l','p','c','m')
-         && p_fifo->i_fourcc != VLC_FOURCC('l','p','c','b') )
-    {   
+    switch( p_dec->fmt_in.i_codec )
+    {
+    /* DVD LPCM */
+    case VLC_CODEC_DVD_LPCM:
+        b_dvd = true;
+        break;
+    /* BD LPCM */
+    case VLC_CODEC_BD_LPCM:
+        b_dvd = false;
+        break;
+    default:
         return VLC_EGENERIC;
     }
-    
-    p_fifo->pf_run = RunDecoder;
+
+    /* Allocate the memory needed to store the decoder's structure */
+    if( ( p_dec->p_sys = p_sys = malloc(sizeof(decoder_sys_t)) ) == NULL )
+        return VLC_ENOMEM;
+
+    /* Misc init */
+    p_sys->b_packetizer = b_packetizer;
+    aout_DateSet( &p_sys->end_date, 0 );
+    p_sys->i_header_size = b_dvd ? LPCM_DVD_HEADER_LEN : LPCM_BD_HEADER_LEN;
+    p_sys->b_dvd = b_dvd;
+
+    /* Set output properties */
+    p_dec->fmt_out.i_cat = AUDIO_ES;
+
+    if( b_packetizer )
+    {
+        p_dec->fmt_out.i_codec = b_dvd ? VLC_CODEC_DVD_LPCM : VLC_CODEC_BD_LPCM;
+    }
+    else
+    {
+        switch( p_dec->fmt_out.audio.i_bitspersample )
+        {
+        case 24:
+        case 20:
+            p_dec->fmt_out.i_codec = VLC_CODEC_S24B;
+            p_dec->fmt_out.audio.i_bitspersample = 24;
+            break;
+        default:
+            p_dec->fmt_out.i_codec = VLC_CODEC_S16B;
+            p_dec->fmt_out.audio.i_bitspersample = 16;
+            break;
+        }
+    }
+
+    /* Set callback */
+    p_dec->pf_decode_audio = (aout_buffer_t *(*)(decoder_t *, block_t **))
+        DecodeFrame;
+    p_dec->pf_packetize    = (block_t *(*)(decoder_t *, block_t **))
+        DecodeFrame;
+
     return VLC_SUCCESS;
 }
+static int OpenDecoder( vlc_object_t *p_this )
+{
+    return OpenCommon( p_this, false );
+}
+static int OpenPacketizer( vlc_object_t *p_this )
+{
+    return OpenCommon( p_this, true );
+}
 
 /*****************************************************************************
- * RunDecoder: the lpcm decoder
+ * DecodeFrame: decodes an lpcm frame.
+ ****************************************************************************
+ * Beware, this function must be fed with complete frames (PES packet).
  *****************************************************************************/
-static int RunDecoder( decoder_fifo_t * p_fifo )
+static void *DecodeFrame( decoder_t *p_dec, block_t **pp_block )
 {
-    dec_thread_t *   p_dec;
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    block_t       *p_block;
+    unsigned int  i_rate = 0, i_original_channels = 0, i_channels = 0, i_bits = 0;
+    int           i_frame_length;
 
-    /* Allocate the memory needed to store the thread's structure */
-    if( (p_dec = (dec_thread_t *)malloc (sizeof(dec_thread_t)) )
-            == NULL) 
+    if( !pp_block || !*pp_block ) return NULL;
+
+    p_block = *pp_block;
+    *pp_block = NULL; /* So the packet doesn't get re-sent */
+
+    /* Date management */
+    if( p_block->i_pts > 0 &&
+        p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
     {
-        msg_Err( p_fifo, "out of memory" );
-        DecoderError( p_fifo );
-        return -1;
+        aout_DateSet( &p_sys->end_date, p_block->i_pts );
     }
 
-    /* Initialize the thread properties */
-    p_dec->p_fifo = p_fifo;
+    if( !aout_DateGet( &p_sys->end_date ) )
+    {
+        /* We've just started the stream, wait for the first PTS. */
+        block_Release( p_block );
+        return NULL;
+    }
 
-    /* Init the bitstream */
-    if( InitBitstream( &p_dec->bit_stream, p_dec->p_fifo,
-                       NULL, NULL ) != VLC_SUCCESS )
+    if( p_block->i_buffer <= p_sys->i_header_size )
     {
-        msg_Err( p_fifo, "cannot initialize bitstream" );
-        DecoderError( p_fifo );
-        EndThread( p_dec );
-        return -1;
+        msg_Err(p_dec, "frame is too short");
+        block_Release( p_block );
+        return NULL;
     }
-   
-    /* FIXME : I suppose the number of channel and sampling rate 
-     * are somewhere in the headers */
-    p_dec->output_format.i_format = VLC_FOURCC('s','1','6','b');
-    p_dec->output_format.i_physical_channels
-           = p_dec->output_format.i_original_channels
-           = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
-    p_dec->output_format.i_rate = 48000;
-    
-    aout_DateInit( &p_dec->end_date, 48000 );
-    p_dec->p_aout = NULL;
-    p_dec->p_aout_input = aout_DecNew( p_dec->p_fifo,
-                                       &p_dec->p_aout,
-                                       &p_dec->output_format );
 
-    if ( p_dec->p_aout_input == NULL )
+    int i_ret;
+    if( p_sys->b_dvd )
+        i_ret = DvdHeader( &i_rate, &i_channels, &i_original_channels, &i_bits,
+                           p_block->p_buffer );
+    else
+        i_ret = BdHeader( &i_rate, &i_channels, &i_original_channels, &i_bits,
+                          p_block->p_buffer );
+
+    if( i_ret )
     {
-        msg_Err( p_dec->p_fifo, "failed to create aout fifo" );
-        p_dec->p_fifo->b_error = 1;
-        EndThread( p_dec );
-        return( -1 );
+        msg_Warn( p_dec, "no frame sync" );
+        block_Release( p_block );
+        return NULL;
     }
 
-    /* lpcm decoder thread's main loop */
-    while ( (!p_dec->p_fifo->b_die) && (!p_dec->p_fifo->b_error) )
+    /* Set output properties */
+    if( p_dec->fmt_out.audio.i_rate != i_rate )
     {
-        DecodeFrame(p_dec);
+        aout_DateInit( &p_sys->end_date, i_rate );
+        aout_DateSet( &p_sys->end_date, p_block->i_pts );
     }
+    p_dec->fmt_out.audio.i_rate = i_rate;
+    p_dec->fmt_out.audio.i_channels = i_channels;
+    p_dec->fmt_out.audio.i_original_channels = i_original_channels;
+    p_dec->fmt_out.audio.i_physical_channels = i_original_channels & AOUT_CHAN_PHYSMASK;
+
+    i_frame_length = (p_block->i_buffer - p_sys->i_header_size) / i_channels * 8 / i_bits;
 
-    /* If b_error is set, the lpcm decoder thread enters the error loop */
-    if ( p_dec->p_fifo->b_error )
+    if( p_sys->b_packetizer )
     {
-        DecoderError( p_dec->p_fifo );
+        p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
+        p_block->i_length =
+            aout_DateIncrement( &p_sys->end_date, i_frame_length ) -
+            p_block->i_pts;
+
+        /* Just pass on the incoming frame */
+        return p_block;
     }
+    else
+    {
+        /* */
+        if( i_bits == 16 )
+        {
+            p_dec->fmt_out.i_codec = VLC_CODEC_S16B;
+            p_dec->fmt_out.audio.i_bitspersample = 16;
+        }
+        else
+        {
+            p_dec->fmt_out.i_codec = VLC_CODEC_S24B;
+            p_dec->fmt_out.audio.i_bitspersample = 24;
+        }
 
-    /* End of the lpcm decoder thread */
-    EndThread( p_dec );
+        /* */
+        aout_buffer_t *p_aout_buffer;
+        p_aout_buffer = decoder_NewAudioBuffer( p_dec, i_frame_length );
+        if( !p_aout_buffer )
+            return NULL;
 
-    return 0;
+        p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
+        p_aout_buffer->end_date =
+            aout_DateIncrement( &p_sys->end_date, i_frame_length );
+
+        p_block->p_buffer += p_sys->i_header_size;
+        p_block->i_buffer -= p_sys->i_header_size;
+
+        if( p_sys->b_dvd )
+            DvdExtract( p_aout_buffer, p_block, i_bits );
+        else
+            BdExtract( p_aout_buffer, p_block );
+
+        block_Release( p_block );
+        return p_aout_buffer;
+    }
+}
+
+/*****************************************************************************
+ * CloseCommon : lpcm decoder destruction
+ *****************************************************************************/
+static void CloseCommon( vlc_object_t *p_this )
+{
+    decoder_t *p_dec = (decoder_t*)p_this;
+    free( p_dec->p_sys );
 }
 
 /*****************************************************************************
- * DecodeFrame: decodes a frame.
+ *
  *****************************************************************************/
-void DecodeFrame( dec_thread_t * p_dec )
+static int DvdHeader( unsigned *pi_rate,
+                      unsigned *pi_channels, unsigned *pi_original_channels,
+                      unsigned *pi_bits,
+                      const uint8_t *p_header )
 {
-    aout_buffer_t *    p_aout_buffer;
-    mtime_t     i_pts;
+    const uint8_t i_header = p_header[4];
 
-    NextPTS( &p_dec->bit_stream, &i_pts, NULL );
-    
-    if( i_pts != 0 && i_pts != aout_DateGet( &p_dec->end_date ) )
+    switch( (i_header >> 4) & 0x3 )
     {
-        aout_DateSet( &p_dec->end_date, i_pts );
+    case 0:
+        *pi_rate = 48000;
+        break;
+    case 1:
+        *pi_rate = 96000;
+        break;
+    case 2:
+        *pi_rate = 44100;
+        break;
+    case 3:
+        *pi_rate = 32000;
+        break;
     }
-    
-    p_aout_buffer = aout_DecNewBuffer( p_dec->p_aout,
-                                       p_dec->p_aout_input,
-                                       LPCM_FRAME_NB );
-    
-    if( !p_aout_buffer )
+
+    *pi_channels = (i_header & 0x7) + 1;
+    switch( *pi_channels - 1 )
     {
-        msg_Err( p_dec->p_fifo, "cannot get aout buffer" );
-        p_dec->p_fifo->b_error = 1;
-        return;
+    case 0:
+        *pi_original_channels = AOUT_CHAN_CENTER;
+        break;
+    case 1:
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
+        break;
+    case 2:
+        /* This is unsure. */
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_LFE;
+        break;
+    case 3:
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
+                               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
+        break;
+    case 4:
+        /* This is unsure. */
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
+                               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
+                               | AOUT_CHAN_LFE;
+        break;
+    case 5:
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
+                               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
+                               | AOUT_CHAN_CENTER | AOUT_CHAN_LFE;
+        break;
+    case 6:
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
+                               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
+                               | AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT
+                               | AOUT_CHAN_MIDDLERIGHT;
+        break;
+    case 7:
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
+                               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
+                               | AOUT_CHAN_CENTER | AOUT_CHAN_MIDDLELEFT
+                               | AOUT_CHAN_MIDDLERIGHT | AOUT_CHAN_LFE;
+        break;
     }
-    
-    p_aout_buffer->start_date = aout_DateGet( &p_dec->end_date );
-    p_aout_buffer->end_date = aout_DateIncrement( &p_dec->end_date,
-                                                   LPCM_FRAME_NB );
 
-    /* Look for sync word - should be 0x0180 */
-    RealignBits( &p_dec->bit_stream );
-    while ( (GetBits( &p_dec->bit_stream, 16 ) ) != 0x0180 && 
-             (!p_dec->p_fifo->b_die) && (!p_dec->p_fifo->b_error));
+    switch( (i_header >> 6) & 0x3 )
+    {
+    case 2:
+        *pi_bits = 24;
+        break;
+    case 1:
+        *pi_bits = 20;
+        break;
+    case 0:
+    default:
+        *pi_bits = 16;
+        break;
+    }
 
-    GetChunk( &p_dec->bit_stream, p_aout_buffer->p_buffer, 
-              LPCM_FRAME_NB * 4);
+    /* Check frame sync and drop it. */
+    if( p_header[5] != 0x80 )
+        return -1;
+    return 0;
+}
+static int BdHeader( unsigned *pi_rate,
+                     unsigned *pi_channels, unsigned *pi_original_channels,
+                     unsigned *pi_bits,
+                     const uint8_t *p_header )
+{
+    const uint32_t h = GetDWBE( p_header );
+    switch( ( h & 0xf000) >> 12 )
+    {
+    case 1:
+        *pi_channels = 1;
+        *pi_original_channels = AOUT_CHAN_CENTER;
+        break;
+    case 3:
+        *pi_channels = 2;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
+        break;
+    case 4:
+        *pi_channels = 3;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER;
+        break;
+    case 5:
+        *pi_channels = 3;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARCENTER;
+        break;
+    case 6:
+        *pi_channels = 4;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
+                                AOUT_CHAN_REARCENTER;
+        break;
+    case 7:
+        *pi_channels = 4;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT |
+                                AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
+        break;
+    case 8:
+        *pi_channels = 5;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
+                                AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
+        break;
+    case 9:
+        *pi_channels = 6;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
+                                AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
+                                AOUT_CHAN_LFE;
+        break;
+    case 10:
+        *pi_channels = 7;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
+                                AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
+                                AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT;
+        break;
+    case 11:
+        *pi_channels = 8;
+        *pi_original_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER |
+                                AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT |
+                                AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT |
+                                AOUT_CHAN_LFE;
+        break;
 
-    if( p_dec->p_fifo->b_die )
+    default:
+        return -1;
+    }
+    switch( (h >> 6) & 0x03 )
     {
-        aout_DecDeleteBuffer( p_dec->p_aout, p_dec->p_aout_input,
-                              p_aout_buffer );
-        return;
+    case 1:
+        *pi_bits = 16;
+        break;
+    case 2: /* 20 bits but samples are stored on 24 bits */
+    case 3: /* 24 bits */
+        *pi_bits = 24;
+        break;
+    default:
+        return -1;
     }
-
-    aout_DecPlay( p_dec->p_aout, p_dec->p_aout_input, 
-                  p_aout_buffer );
+    switch( (h >> 8) & 0x0f ) 
+    {
+    case 1:
+        *pi_rate = 48000;
+        break;
+    case 4:
+        *pi_rate = 96000;
+        break;
+    case 5:
+        *pi_rate = 192000;
+        break;
+    default:
+        return -1;
+    }
+    return 0;
 }
 
-/*****************************************************************************
- * EndThread : lpcm decoder thread destruction
- *****************************************************************************/
-static void EndThread( dec_thread_t * p_dec )
+static void DvdExtract( aout_buffer_t *p_aout_buffer, block_t *p_block,
+                        unsigned i_bits )
 {
-    if( p_dec->p_aout_input != NULL )
+    uint8_t *p_out = p_aout_buffer->p_buffer;
+
+    /* 20/24 bits LPCM use special packing */
+    if( i_bits == 24 )
     {
-        aout_DecDelete( p_dec->p_aout, p_dec->p_aout_input );
+        while( p_block->i_buffer / 12 )
+        {
+            /* Sample 1 */
+            p_out[0] = p_block->p_buffer[0];
+            p_out[1] = p_block->p_buffer[1];
+            p_out[2] = p_block->p_buffer[8];
+            /* Sample 2 */
+            p_out[3] = p_block->p_buffer[2];
+            p_out[4] = p_block->p_buffer[3];
+            p_out[5] = p_block->p_buffer[9];
+            /* Sample 3 */
+            p_out[6] = p_block->p_buffer[4];
+            p_out[7] = p_block->p_buffer[5];
+            p_out[8] = p_block->p_buffer[10];
+            /* Sample 4 */
+            p_out[9] = p_block->p_buffer[6];
+            p_out[10] = p_block->p_buffer[7];
+            p_out[11] = p_block->p_buffer[11];
+
+            p_block->i_buffer -= 12;
+            p_block->p_buffer += 12;
+            p_out += 12;
+        }
     }
+    else if( i_bits == 20 )
+    {
+        while( p_block->i_buffer / 10 )
+        {
+            /* Sample 1 */
+            p_out[0] = p_block->p_buffer[0];
+            p_out[1] = p_block->p_buffer[1];
+            p_out[2] = p_block->p_buffer[8] & 0xF0;
+            /* Sample 2 */
+            p_out[3] = p_block->p_buffer[2];
+            p_out[4] = p_block->p_buffer[3];
+            p_out[5] = p_block->p_buffer[8] << 4;
+            /* Sample 3 */
+            p_out[6] = p_block->p_buffer[4];
+            p_out[7] = p_block->p_buffer[5];
+            p_out[8] = p_block->p_buffer[9] & 0xF0;
+            /* Sample 4 */
+            p_out[9] = p_block->p_buffer[6];
+            p_out[10] = p_block->p_buffer[7];
+            p_out[11] = p_block->p_buffer[9] << 4;
 
-    CloseBitstream( &p_dec->bit_stream );
-    free( p_dec );
+            p_block->i_buffer -= 10;
+            p_block->p_buffer += 10;
+            p_out += 12;
+        }
+    }
+    else
+    {
+        assert( i_bits == 16 );
+        memcpy( p_out, p_block->p_buffer, p_block->i_buffer );
+    }
+}
+static void BdExtract( aout_buffer_t *p_aout_buffer, block_t *p_block )
+{
+    memcpy( p_aout_buffer->p_buffer, p_block->p_buffer, p_block->i_buffer );
 }
+
+