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

   1 /*****************************************************************************
   2  * flac.c: flac decoder/packetizer/encoder module making use of libflac
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@videolan.org>
   8  *          Sigmund Augdal <sigmunau@idi.ntnu.no>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #include <vlc/vlc.h>
  30 #include <vlc/decoder.h>
  31
  32 #ifdef HAVE_FLAC_STREAM_DECODER_H
  33 #   include <FLAC/stream_decoder.h>
  34 #   include <FLAC/stream_encoder.h>
  35 #   define USE_LIBFLAC
  36 #endif
  37
  38 #include "vlc_block_helper.h"
  39 #include "vlc_bits.h"
  40
  41 #define MAX_FLAC_HEADER_SIZE 16
  42
  43 /*****************************************************************************
  44  * decoder_sys_t : FLAC decoder descriptor
  45  *****************************************************************************/
  46 struct decoder_sys_t
  47 {
  48     /*
  49      * Input properties
  50      */
  51     int i_state;
  52
  53     block_bytestream_t bytestream;
  54
  55     /*
  56      * Input/Output properties
  57      */
  58     block_t *p_block;
  59     aout_buffer_t *p_aout_buffer;
  60
  61     /*
  62      * FLAC properties
  63      */
  64 #ifdef USE_LIBFLAC
  65     FLAC__StreamDecoder *p_flac;
  66     FLAC__StreamMetadata_StreamInfo stream_info;
  67 #else
  68     struct
  69     {
  70         unsigned min_blocksize, max_blocksize;
  71         unsigned min_framesize, max_framesize;
  72         unsigned sample_rate;
  73         unsigned channels;
  74         unsigned bits_per_sample;
  75
  76     } stream_info;
  77 #endif
  78     vlc_bool_t b_stream_info;
  79
  80     /*
  81      * Common properties
  82      */
  83     audio_date_t end_date;
  84     mtime_t i_pts;
  85
  86     int i_frame_size, i_frame_length, i_bits_per_sample;
  87     unsigned int i_rate, i_channels, i_channels_conf;
  88 };
  89
  90 enum {
  91
  92     STATE_NOSYNC,
  93     STATE_SYNC,
  94     STATE_HEADER,
  95     STATE_NEXT_SYNC,
  96     STATE_GET_DATA,
  97     STATE_SEND_DATA
  98 };
  99
 100 static int pi_channels_maps[6] =
 101 {
 102     0,
 103     AOUT_CHAN_CENTER,
 104     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 105     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
 106     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
 107      | AOUT_CHAN_REARRIGHT,
 108     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 109      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
 110 };
 111
 112 /*****************************************************************************
 113  * Local prototypes
 114  *****************************************************************************/
 115 static int  OpenDecoder   ( vlc_object_t * );
 116 static int  OpenPacketizer( vlc_object_t * );
 117 static void CloseDecoder  ( vlc_object_t * );
 118
 119 #ifdef USE_LIBFLAC
 120 static int OpenEncoder   ( vlc_object_t * );
 121 static void CloseEncoder ( vlc_object_t * );
 122 #endif
 123
 124 #ifdef USE_LIBFLAC
 125 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
 126 #endif
 127 static block_t *PacketizeBlock( decoder_t *, block_t ** );
 128
 129 static int SyncInfo( decoder_t *, uint8_t *, int *, int *, int *,int * );
 130
 131
 132 #ifdef USE_LIBFLAC
 133 static FLAC__StreamDecoderReadStatus
 134 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
 135                      FLAC__byte buffer[], unsigned *bytes, void *client_data );
 136
 137 static FLAC__StreamDecoderWriteStatus
 138 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 139                       const FLAC__Frame *frame,
 140                       const FLAC__int32 *const buffer[], void *client_data );
 141
 142 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 143                                      const FLAC__StreamMetadata *metadata,
 144                                      void *client_data );
 145 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 146                                   FLAC__StreamDecoderErrorStatus status,
 147                                   void *client_data);
 148
 149 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 150                           int i_nb_channels, int i_samples );
 151 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 152                           int i_nb_channels, int i_samples );
 153
 154 static void decoder_state_error( decoder_t *p_dec,
 155                                  FLAC__StreamDecoderState state );
 156 #endif
 157
 158 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
 159 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
 160
 161 /*****************************************************************************
 162  * Module descriptor
 163  *****************************************************************************/
 164 vlc_module_begin();
 165
 166     set_category( CAT_INPUT );
 167     set_subcategory( SUBCAT_INPUT_ACODEC );
 168
 169 #ifdef USE_LIBFLAC
 170     set_description( _("Flac audio decoder") );
 171     set_capability( "decoder", 100 );
 172     set_callbacks( OpenDecoder, CloseDecoder );
 173
 174     add_submodule();
 175     set_description( _("Flac audio encoder") );
 176     set_capability( "encoder", 100 );
 177     set_callbacks( OpenEncoder, CloseEncoder );
 178
 179     add_submodule();
 180 #endif
 181     set_description( _("Flac audio packetizer") );
 182     set_capability( "packetizer", 100 );
 183     set_callbacks( OpenPacketizer, CloseDecoder );
 184
 185     add_shortcut( "flac" );
 186 vlc_module_end();
 187
 188 /*****************************************************************************
 189  * OpenDecoder: probe the decoder and return score
 190  *****************************************************************************/
 191 static int OpenDecoder( vlc_object_t *p_this )
 192 {
 193     decoder_t *p_dec = (decoder_t*)p_this;
 194     decoder_sys_t *p_sys;
 195
 196     if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
 197     {
 198         return VLC_EGENERIC;
 199     }
 200
 201     /* Allocate the memory needed to store the decoder's structure */
 202     if( ( p_dec->p_sys = p_sys =
 203           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 204     {
 205         msg_Err( p_dec, "out of memory" );
 206         return VLC_EGENERIC;
 207     }
 208
 209     /* Misc init */
 210     aout_DateSet( &p_sys->end_date, 0 );
 211     p_sys->i_state = STATE_NOSYNC;
 212     p_sys->b_stream_info = VLC_FALSE;
 213
 214     p_sys->bytestream = block_BytestreamInit( p_dec );
 215
 216 #ifdef USE_LIBFLAC
 217     /* Take care of flac init */
 218     if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
 219     {
 220         msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
 221         free( p_sys );
 222         return VLC_EGENERIC;
 223     }
 224
 225     FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
 226                                             DecoderReadCallback );
 227     FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
 228                                              DecoderWriteCallback );
 229     FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
 230                                                 DecoderMetadataCallback );
 231     FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
 232                                              DecoderErrorCallback );
 233     FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
 234
 235     FLAC__stream_decoder_init( p_sys->p_flac );
 236 #endif
 237
 238     /* Set output properties */
 239     p_dec->fmt_out.i_cat = AUDIO_ES;
 240     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
 241
 242     /* Set callbacks */
 243 #ifdef USE_LIBFLAC
 244     p_dec->pf_decode_audio = DecodeBlock;
 245 #endif
 246     p_dec->pf_packetize    = PacketizeBlock;
 247
 248     return VLC_SUCCESS;
 249 }
 250
 251 static int OpenPacketizer( vlc_object_t *p_this )
 252 {
 253     decoder_t *p_dec = (decoder_t*)p_this;
 254     int i_ret;
 255
 256     /* Hmmm, mem leak ?*/
 257     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
 258
 259     i_ret = OpenDecoder( p_this );
 260
 261     /* Set output properties */
 262     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
 263
 264     if( i_ret != VLC_SUCCESS ) return i_ret;
 265
 266     return i_ret;
 267 }
 268
 269 /*****************************************************************************
 270  * CloseDecoder: flac decoder destruction
 271  *****************************************************************************/
 272 static void CloseDecoder( vlc_object_t *p_this )
 273 {
 274     decoder_t *p_dec = (decoder_t *)p_this;
 275     decoder_sys_t *p_sys = p_dec->p_sys;
 276
 277 #ifdef USE_LIBFLAC
 278     FLAC__stream_decoder_finish( p_sys->p_flac );
 279     FLAC__stream_decoder_delete( p_sys->p_flac );
 280 #endif
 281
 282     if( p_sys->p_block ) free( p_sys->p_block );
 283     free( p_sys );
 284 }
 285
 286 /*****************************************************************************
 287  * ProcessHeader: processe Flac header.
 288  *****************************************************************************/
 289 static void ProcessHeader( decoder_t *p_dec )
 290 {
 291     decoder_sys_t *p_sys = p_dec->p_sys;
 292
 293 #ifdef USE_LIBFLAC
 294     if( !p_dec->fmt_in.i_extra ) return;
 295
 296     /* Decode STREAMINFO */
 297     msg_Dbg( p_dec, "decode STREAMINFO" );
 298     p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
 299     memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
 300             p_dec->fmt_in.i_extra );
 301     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
 302     msg_Dbg( p_dec, "STREAMINFO decoded" );
 303
 304 #else
 305     bs_t bs;
 306
 307     if( !p_dec->fmt_in.i_extra ) return;
 308
 309     bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
 310
 311     p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
 312     p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
 313
 314     p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
 315     p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
 316
 317     p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
 318     p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
 319     p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
 320 #endif
 321
 322     if( !p_sys->b_stream_info ) return;
 323
 324     if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
 325     {
 326         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 327         p_dec->fmt_out.p_extra =
 328             realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
 329         memcpy( p_dec->fmt_out.p_extra,
 330                 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
 331     }
 332 }
 333
 334 /****************************************************************************
 335  * PacketizeBlock: the whole thing
 336  ****************************************************************************
 337  * This function is called just after the thread is launched.
 338  ****************************************************************************/
 339 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
 340 {
 341     decoder_sys_t *p_sys = p_dec->p_sys;
 342     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
 343     block_t *p_sout_block;
 344
 345     if( !pp_block || !*pp_block ) return NULL;
 346
 347     if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
 348
 349     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
 350     {
 351         /* We've just started the stream, wait for the first PTS. */
 352         block_Release( *pp_block );
 353         return NULL;
 354     }
 355     else if( !aout_DateGet( &p_sys->end_date ) )
 356     {
 357         /* The first PTS is as good as anything else. */
 358         aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
 359     }
 360
 361     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 362     {
 363         p_sys->i_state = STATE_NOSYNC;
 364     }
 365
 366     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 367
 368     while( 1 )
 369     {
 370         switch( p_sys->i_state )
 371         {
 372         case STATE_NOSYNC:
 373             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
 374                    == VLC_SUCCESS )
 375             {
 376                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 377                 {
 378                     p_sys->i_state = STATE_SYNC;
 379                     break;
 380                 }
 381                 block_SkipByte( &p_sys->bytestream );
 382             }
 383             if( p_sys->i_state != STATE_SYNC )
 384             {
 385                 block_BytestreamFlush( &p_sys->bytestream );
 386
 387                 /* Need more data */
 388                 return NULL;
 389             }
 390
 391         case STATE_SYNC:
 392             /* New frame, set the Presentation Time Stamp */
 393             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
 394             if( p_sys->i_pts != 0 &&
 395                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
 396             {
 397                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
 398             }
 399             p_sys->i_state = STATE_HEADER;
 400
 401         case STATE_HEADER:
 402             /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
 403             if( block_PeekBytes( &p_sys->bytestream, p_header,
 404                                  MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
 405             {
 406                 /* Need more data */
 407                 return NULL;
 408             }
 409
 410             /* Check if frame is valid and get frame info */
 411             p_sys->i_frame_length = SyncInfo( p_dec, p_header,
 412                                               &p_sys->i_channels,
 413                                               &p_sys->i_channels_conf,
 414                                               &p_sys->i_rate,
 415                                               &p_sys->i_bits_per_sample );
 416             if( !p_sys->i_frame_length )
 417             {
 418                 msg_Dbg( p_dec, "emulated sync word" );
 419                 block_SkipByte( &p_sys->bytestream );
 420                 p_sys->i_state = STATE_NOSYNC;
 421                 break;
 422             }
 423             if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
 424             {
 425                 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
 426                 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
 427             }
 428             p_sys->i_state = STATE_NEXT_SYNC;
 429             p_sys->i_frame_size = 1;
 430
 431         case STATE_NEXT_SYNC:
 432             /* TODO: If pp_block == NULL, flush the buffer without checking the
 433              * next sync word */
 434
 435             /* Check if next expected frame contains the sync word */
 436             while( block_PeekOffsetBytes( &p_sys->bytestream,
 437                                           p_sys->i_frame_size, p_header,
 438                                           MAX_FLAC_HEADER_SIZE )
 439                    == VLC_SUCCESS )
 440             {
 441                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 442                 {
 443                     /* Check if frame is valid and get frame info */
 444                     int i_frame_length =
 445                         SyncInfo( p_dec, p_header,
 446                                   &p_sys->i_channels,
 447                                   &p_sys->i_channels_conf,
 448                                   &p_sys->i_rate,
 449                                   &p_sys->i_bits_per_sample );
 450
 451                     if( i_frame_length )
 452                     {
 453                         p_sys->i_state = STATE_SEND_DATA;
 454                         break;
 455                     }
 456                 }
 457                 p_sys->i_frame_size++;
 458             }
 459
 460             if( p_sys->i_state != STATE_SEND_DATA )
 461             {
 462                 /* Need more data */
 463                 return NULL;
 464             }
 465
 466         case STATE_SEND_DATA:
 467             p_sout_block = block_New( p_dec, p_sys->i_frame_size );
 468
 469             /* Copy the whole frame into the buffer. When we reach this point
 470              * we already know we have enough data available. */
 471             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
 472                             p_sys->i_frame_size );
 473
 474             /* Make sure we don't reuse the same pts twice */
 475             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
 476                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
 477
 478             /* So p_block doesn't get re-added several times */
 479             *pp_block = block_BytestreamPop( &p_sys->bytestream );
 480
 481             p_sys->i_state = STATE_NOSYNC;
 482
 483             /* Date management */
 484             p_sout_block->i_pts =
 485                 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
 486             aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
 487             p_sout_block->i_length =
 488                 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
 489
 490             return p_sout_block;
 491         }
 492     }
 493
 494     return NULL;
 495 }
 496
 497 #ifdef USE_LIBFLAC
 498 /****************************************************************************
 499  * DecodeBlock: the whole thing
 500  ****************************************************************************/
 501 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 502 {
 503     decoder_sys_t *p_sys = p_dec->p_sys;
 504
 505     if( !pp_block || !*pp_block ) return NULL;
 506
 507     p_sys->p_aout_buffer = 0;
 508     if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
 509     {
 510         if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
 511         {
 512             decoder_state_error( p_dec,
 513                 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
 514             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 515         }
 516
 517         /* If the decoder is in the "aborted" state,
 518          * FLAC__stream_decoder_process_single() won't return an error. */
 519         if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
 520             == FLAC__STREAM_DECODER_ABORTED )
 521         {
 522             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 523         }
 524
 525         block_Release( p_sys->p_block );
 526         p_sys->p_block = NULL;
 527     }
 528
 529     return p_sys->p_aout_buffer;
 530 }
 531
 532 /*****************************************************************************
 533  * DecoderReadCallback: called by libflac when it needs more data
 534  *****************************************************************************/
 535 static FLAC__StreamDecoderReadStatus
 536 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
 537                      unsigned *bytes, void *client_data )
 538 {
 539     decoder_t *p_dec = (decoder_t *)client_data;
 540     decoder_sys_t *p_sys = p_dec->p_sys;
 541
 542     if( p_sys->p_block && p_sys->p_block->i_buffer )
 543     {
 544         *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
 545         memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
 546         p_sys->p_block->i_buffer -= *bytes;
 547         p_sys->p_block->p_buffer += *bytes;
 548     }
 549     else
 550     {
 551         *bytes = 0;
 552         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 553     }
 554
 555     return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 556 }
 557
 558 /*****************************************************************************
 559  * DecoderWriteCallback: called by libflac to output decoded samples
 560  *****************************************************************************/
 561 static FLAC__StreamDecoderWriteStatus
 562 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 563                       const FLAC__Frame *frame,
 564                       const FLAC__int32 *const buffer[], void *client_data )
 565 {
 566     decoder_t *p_dec = (decoder_t *)client_data;
 567     decoder_sys_t *p_sys = p_dec->p_sys;
 568
 569     p_sys->p_aout_buffer =
 570         p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
 571
 572     if( p_sys->p_aout_buffer == NULL )
 573         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 574
 575     switch( frame->header.bits_per_sample )
 576     {
 577     case 16:
 578         Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 579                       frame->header.channels, frame->header.blocksize );
 580         break;
 581     default:
 582         Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 583                       frame->header.channels, frame->header.blocksize );
 584     }
 585
 586     /* Date management (already done by packetizer) */
 587     p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
 588     p_sys->p_aout_buffer->end_date =
 589         p_sys->p_block->i_pts + p_sys->p_block->i_length;
 590
 591     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 592 }
 593
 594 /*****************************************************************************
 595  * DecoderMetadataCallback: called by libflac to when it encounters metadata
 596  *****************************************************************************/
 597 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 598                                      const FLAC__StreamMetadata *metadata,
 599                                      void *client_data )
 600 {
 601     decoder_t *p_dec = (decoder_t *)client_data;
 602     decoder_sys_t *p_sys = p_dec->p_sys;
 603
 604     switch( metadata->data.stream_info.bits_per_sample )
 605     {
 606     case 8:
 607         p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
 608         break;
 609     case 16:
 610         p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
 611         break;
 612     default:
 613         msg_Dbg( p_dec, "strange bit/sample value: %d",
 614                  metadata->data.stream_info.bits_per_sample );
 615         p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
 616         break;
 617     }
 618
 619     /* Setup the format */
 620     p_dec->fmt_out.audio.i_rate     = metadata->data.stream_info.sample_rate;
 621     p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
 622     p_dec->fmt_out.audio.i_physical_channels =
 623         p_dec->fmt_out.audio.i_original_channels =
 624             pi_channels_maps[metadata->data.stream_info.channels];
 625     p_dec->fmt_out.audio.i_bitspersample =
 626         metadata->data.stream_info.bits_per_sample;
 627
 628     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
 629
 630     msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
 631              p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
 632              p_dec->fmt_out.audio.i_bitspersample );
 633
 634     p_sys->b_stream_info = VLC_TRUE;
 635     p_sys->stream_info = metadata->data.stream_info;
 636
 637     return;
 638 }
 639
 640 /*****************************************************************************
 641  * DecoderErrorCallback: called when the libflac decoder encounters an error
 642  *****************************************************************************/
 643 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 644                                   FLAC__StreamDecoderErrorStatus status,
 645                                   void *client_data )
 646 {
 647     decoder_t *p_dec = (decoder_t *)client_data;
 648
 649     switch( status )
 650     {
 651     case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
 652         msg_Err( p_dec, "an error in the stream caused the decoder to "
 653                  "lose synchronization." );
 654         break;
 655     case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
 656         msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
 657         break;
 658     case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
 659         msg_Err( p_dec, "frame's data did not match the CRC in the "
 660                  "footer." );
 661         break;
 662     default:
 663         msg_Err( p_dec, "got decoder error: %d", status );
 664     }
 665
 666     FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 667     return;
 668 }
 669
 670 /*****************************************************************************
 671  * Interleave: helper function to interleave channels
 672  *****************************************************************************/
 673 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 674                           int i_nb_channels, int i_samples )
 675 {
 676     int i, j;
 677     for ( j = 0; j < i_samples; j++ )
 678     {
 679         for ( i = 0; i < i_nb_channels; i++ )
 680         {
 681             p_out[j * i_nb_channels + i] = pp_in[i][j];
 682         }
 683     }
 684 }
 685 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 686                           int i_nb_channels, int i_samples )
 687 {
 688     int i, j;
 689     for ( j = 0; j < i_samples; j++ )
 690     {
 691         for ( i = 0; i < i_nb_channels; i++ )
 692         {
 693             p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
 694         }
 695     }
 696 }
 697
 698 /*****************************************************************************
 699  * decoder_state_error: print meaningful error messages
 700  *****************************************************************************/
 701 static void decoder_state_error( decoder_t *p_dec,
 702                                  FLAC__StreamDecoderState state )
 703 {
 704     switch ( state )
 705     {
 706     case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
 707         msg_Err( p_dec, "the decoder is ready to search for metadata." );
 708         break;
 709     case FLAC__STREAM_DECODER_READ_METADATA:
 710         msg_Err( p_dec, "the decoder is ready to or is in the process of "
 711                  "reading metadata." );
 712         break;
 713     case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
 714         msg_Err( p_dec, "the decoder is ready to or is in the process of "
 715                  "searching for the frame sync code." );
 716         break;
 717     case FLAC__STREAM_DECODER_READ_FRAME:
 718         msg_Err( p_dec, "the decoder is ready to or is in the process of "
 719                  "reading a frame." );
 720         break;
 721     case FLAC__STREAM_DECODER_END_OF_STREAM:
 722         msg_Err( p_dec, "the decoder has reached the end of the stream." );
 723         break;
 724     case FLAC__STREAM_DECODER_ABORTED:
 725         msg_Err( p_dec, "the decoder was aborted by the read callback." );
 726         break;
 727     case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
 728         msg_Err( p_dec, "the decoder encountered reserved fields in use "
 729                  "in the stream." );
 730         break;
 731     case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
 732         msg_Err( p_dec, "error when allocating memory." );
 733         break;
 734     case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
 735         msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
 736                  "decoder was already initialized, usually because "
 737                  "FLAC__stream_decoder_finish() was not called." );
 738         break;
 739     case FLAC__STREAM_DECODER_INVALID_CALLBACK:
 740         msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
 741                  "all callbacks being set." );
 742         break;
 743     case FLAC__STREAM_DECODER_UNINITIALIZED:
 744         msg_Err( p_dec, "decoder in uninitialized state." );
 745         break;
 746     default:
 747         msg_Err(p_dec, "unknown error" );
 748     }
 749 }
 750 #endif
 751
 752 /*****************************************************************************
 753  * SyncInfo: parse FLAC sync info
 754  *****************************************************************************/
 755 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
 756                      int * pi_channels, int * pi_channels_conf,
 757                      int * pi_sample_rate, int * pi_bits_per_sample )
 758 {
 759     decoder_sys_t *p_sys = p_dec->p_sys;
 760     int i_header, i_temp, i_read;
 761     int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
 762     uint64_t i_sample_number = 0;
 763
 764     vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
 765         p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
 766     vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
 767         p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
 768
 769     /* Check syncword */
 770     if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
 771
 772     /* Check there is no emulated sync code in the rest of the header */
 773     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
 774
 775     /* Find blocksize (framelength) */
 776     switch( i_temp = p_buf[2] >> 4 )
 777     {
 778     case 0:
 779         if( b_fixed_blocksize )
 780             i_blocksize = p_sys->stream_info.min_blocksize;
 781         else return 0; /* We can't do anything with this */
 782         break;
 783
 784     case 1:
 785         i_blocksize = 192;
 786         break;
 787
 788     case 2:
 789     case 3:
 790     case 4:
 791     case 5:
 792         i_blocksize = 576 << (i_temp - 2);
 793         break;
 794
 795     case 6:
 796     case 7:
 797         i_blocksize_hint = i_temp;
 798         break;
 799
 800     case 8:
 801     case 9:
 802     case 10:
 803     case 11:
 804     case 12:
 805     case 13:
 806     case 14:
 807     case 15:
 808         i_blocksize = 256 << (i_temp - 8);
 809         break;
 810     }
 811
 812     /* Find samplerate */
 813     switch( i_temp = p_buf[2] & 0x0f )
 814     {
 815     case 0:
 816         if( p_sys->b_stream_info )
 817             *pi_sample_rate = p_sys->stream_info.sample_rate;
 818         else return 0; /* We can't do anything with this */
 819         break;
 820
 821     case 1:
 822     case 2:
 823     case 3:
 824         return 0;
 825         break;
 826
 827     case 4:
 828         *pi_sample_rate = 8000;
 829         break;
 830
 831     case 5:
 832         *pi_sample_rate = 16000;
 833         break;
 834
 835     case 6:
 836         *pi_sample_rate = 22050;
 837         break;
 838
 839     case 7:
 840         *pi_sample_rate = 24000;
 841         break;
 842
 843     case 8:
 844         *pi_sample_rate = 32000;
 845         break;
 846
 847     case 9:
 848         *pi_sample_rate = 44100;
 849         break;
 850
 851     case 10:
 852         *pi_sample_rate = 48000;
 853         break;
 854
 855     case 11:
 856         *pi_sample_rate = 96000;
 857         break;
 858
 859     case 12:
 860     case 13:
 861     case 14:
 862         i_sample_rate_hint = i_temp;
 863         break;
 864
 865     case 15:
 866         return 0;
 867     }
 868
 869     /* Find channels */
 870     i_temp = (unsigned)(p_buf[3] >> 4);
 871     if( i_temp & 8 )
 872     {
 873 #ifdef USE_LIBFLAC
 874         int i_channel_assignment; /* ??? */
 875
 876         switch( i_temp & 7 )
 877         {
 878         case 0:
 879             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
 880             break;
 881         case 1:
 882             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
 883             break;
 884         case 2:
 885             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
 886             break;
 887         default:
 888             return 0;
 889             break;
 890         }
 891 #endif
 892
 893         *pi_channels = 2;
 894     }
 895     else
 896     {
 897         *pi_channels = i_temp + 1;
 898         *pi_channels_conf = pi_channels_maps[ *pi_channels ];
 899     }
 900
 901     /* Find bits per sample */
 902     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
 903     {
 904     case 0:
 905         if( p_sys->b_stream_info )
 906             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
 907         else
 908             return 0;
 909         break;
 910
 911     case 1:
 912         *pi_bits_per_sample = 8;
 913         break;
 914
 915     case 2:
 916         *pi_bits_per_sample = 12;
 917         break;
 918
 919     case 4:
 920         *pi_bits_per_sample = 16;
 921         break;
 922
 923     case 5:
 924         *pi_bits_per_sample = 20;
 925         break;
 926
 927     case 6:
 928         *pi_bits_per_sample = 24;
 929         break;
 930
 931     case 3:
 932     case 7:
 933         return 0;
 934         break;
 935     }
 936
 937     /* Zero padding bit */
 938     if( p_buf[3] & 0x01 ) return 0;
 939
 940     /* End of fixed size header */
 941     i_header = 4;
 942
 943     /* Find Sample/Frame number */
 944     if( i_blocksize_hint && b_variable_blocksize )
 945     {
 946         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 947         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
 948     }
 949     else
 950     {
 951         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 952         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
 953
 954         if( p_sys->b_stream_info )
 955             i_sample_number *= p_sys->stream_info.min_blocksize;
 956     }
 957
 958     i_header += i_read;
 959
 960     /* Read blocksize */
 961     if( i_blocksize_hint )
 962     {
 963         int i_val1 = p_buf[i_header++];
 964         if( i_blocksize_hint == 7 )
 965         {
 966             int i_val2 = p_buf[i_header++];
 967             i_val1 = (i_val1 << 8) | i_val2;
 968         }
 969         i_blocksize = i_val1 + 1;
 970     }
 971
 972     /* Read sample rate */
 973     if( i_sample_rate_hint )
 974     {
 975         int i_val1 = p_buf[i_header++];
 976         if( i_sample_rate_hint != 12 )
 977         {
 978             int i_val2 = p_buf[i_header++];
 979             i_val1 = (i_val1 << 8) | i_val2;
 980         }
 981         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
 982         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
 983         else *pi_sample_rate = i_val1 * 10;
 984     }
 985
 986     /* Check the CRC-8 byte */
 987     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
 988     {
 989         return 0;
 990     }
 991
 992     return i_blocksize;
 993 }
 994
 995 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
 996 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
 997 {
 998     uint64_t i_result = 0;
 999     unsigned i, j;
1000
1001     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1002     {
1003         i_result = p_buf[0];
1004         i = 0;
1005     }
1006     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1007     {
1008         i_result = p_buf[0] & 0x1F;
1009         i = 1;
1010     }
1011     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1012     {
1013         i_result = p_buf[0] & 0x0F;
1014         i = 2;
1015     }
1016     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1017     {
1018         i_result = p_buf[0] & 0x07;
1019         i = 3;
1020     }
1021     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1022     {
1023         i_result = p_buf[0] & 0x03;
1024         i = 4;
1025     }
1026     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1027     {
1028         i_result = p_buf[0] & 0x01;
1029         i = 5;
1030     }
1031     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1032     {
1033         i_result = 0;
1034         i = 6;
1035     }
1036     else {
1037         return I64C(0xffffffffffffffff);
1038     }
1039
1040     for( j = 1; j <= i; j++ )
1041     {
1042         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1043         {
1044             return I64C(0xffffffffffffffff);
1045         }
1046         i_result <<= 6;
1047         i_result |= (p_buf[j] & 0x3F);
1048     }
1049
1050     *pi_read = i;
1051     return i_result;
1052 }
1053
1054 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1055 static uint8_t const flac_crc8_table[256] = {
1056         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1057         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1058         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1059         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1060         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1061         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1062         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1063         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1064         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1065         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1066         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1067         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1068         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1069         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1070         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1071         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1072         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1073         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1074         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1075         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1076         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1077         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1078         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1079         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1080         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1081         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1082         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1083         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1084         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1085         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1086         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1087         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1088 };
1089
1090 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1091 {
1092     uint8_t crc = 0;
1093
1094     while(len--)
1095         crc = flac_crc8_table[crc ^ *data++];
1096
1097     return crc;
1098 }
1099
1100 #ifdef USE_LIBFLAC
1101 /*****************************************************************************
1102  * encoder_sys_t : flac encoder descriptor
1103  *****************************************************************************/
1104 struct encoder_sys_t
1105 {
1106     /*
1107      * Input properties
1108      */
1109     int i_headers;
1110
1111     int i_samples_delay;
1112     int i_channels;
1113
1114     FLAC__int32 *p_buffer;
1115     int         i_buffer;
1116
1117     block_t *p_chain;
1118
1119     /*
1120      * FLAC properties
1121      */
1122     FLAC__StreamEncoder *p_flac;
1123     FLAC__StreamMetadata_StreamInfo stream_info;
1124
1125     /*
1126      * Common properties
1127      */
1128     mtime_t i_pts;
1129 };
1130
1131 #define STREAMINFO_SIZE 38
1132
1133 static block_t *Encode( encoder_t *, aout_buffer_t * );
1134
1135 static FLAC__StreamEncoderWriteStatus
1136 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1137                       const FLAC__byte buffer[],
1138                       unsigned bytes, unsigned samples,
1139                       unsigned current_frame, void *client_data );
1140
1141 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1142                                      const FLAC__StreamMetadata *metadata,
1143                                      void *client_data );
1144
1145 /*****************************************************************************
1146  * OpenEncoder: probe the encoder and return score
1147  *****************************************************************************/
1148 static int OpenEncoder( vlc_object_t *p_this )
1149 {
1150     encoder_t *p_enc = (encoder_t *)p_this;
1151     encoder_sys_t *p_sys;
1152
1153     if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1154         !p_enc->b_force )
1155     {
1156         return VLC_EGENERIC;
1157     }
1158
1159     /* Allocate the memory needed to store the decoder's structure */
1160     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1161     {
1162         msg_Err( p_enc, "out of memory" );
1163         return VLC_EGENERIC;
1164     }
1165     p_enc->p_sys = p_sys;
1166     p_enc->pf_encode_audio = Encode;
1167     p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1168
1169     p_sys->i_headers = 0;
1170     p_sys->p_buffer = 0;
1171     p_sys->i_buffer = 0;
1172     p_sys->i_samples_delay = 0;
1173
1174     /* Create flac encoder */
1175     p_sys->p_flac = FLAC__stream_encoder_new();
1176
1177     FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1178     FLAC__stream_encoder_set_channels( p_sys->p_flac,
1179                                        p_enc->fmt_in.audio.i_channels );
1180     FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1181                                           p_enc->fmt_in.audio.i_rate );
1182     FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1183     p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1184
1185     FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1186         EncoderWriteCallback );
1187     FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1188         EncoderMetadataCallback );
1189     FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1190
1191     /* Get and store the STREAMINFO metadata block as a p_extra */
1192     p_sys->p_chain = 0;
1193     FLAC__stream_encoder_init( p_sys->p_flac );
1194
1195     return VLC_SUCCESS;
1196 }
1197
1198 /****************************************************************************
1199  * Encode: the whole thing
1200  ****************************************************************************
1201  * This function spits out ogg packets.
1202  ****************************************************************************/
1203 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1204 {
1205     encoder_sys_t *p_sys = p_enc->p_sys;
1206     block_t *p_chain;
1207     int i;
1208
1209     p_sys->i_pts = p_aout_buf->start_date -
1210                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1211                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1212
1213     p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1214
1215     /* Convert samples to FLAC__int32 */
1216     if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1217     {
1218         p_sys->p_buffer =
1219             realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1220         p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1221     }
1222
1223     for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1224     {
1225         p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1226     }
1227
1228     FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1229                                               p_aout_buf->i_nb_samples );
1230
1231     p_chain = p_sys->p_chain;
1232     p_sys->p_chain = 0;
1233
1234     return p_chain;
1235 }
1236
1237 /*****************************************************************************
1238  * CloseEncoder: encoder destruction
1239  *****************************************************************************/
1240 static void CloseEncoder( vlc_object_t *p_this )
1241 {
1242     encoder_t *p_enc = (encoder_t *)p_this;
1243     encoder_sys_t *p_sys = p_enc->p_sys;
1244
1245     FLAC__stream_encoder_delete( p_sys->p_flac );
1246
1247     if( p_sys->p_buffer ) free( p_sys->p_buffer );
1248     free( p_sys );
1249 }
1250
1251 /*****************************************************************************
1252  * EncoderMetadataCallback: called by libflac to output metadata
1253  *****************************************************************************/
1254 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1255                                      const FLAC__StreamMetadata *metadata,
1256                                      void *client_data )
1257 {
1258     encoder_t *p_enc = (encoder_t *)client_data;
1259
1260     msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1261     return;
1262 }
1263
1264 /*****************************************************************************
1265  * EncoderWriteCallback: called by libflac to output encoded samples
1266  *****************************************************************************/
1267 static FLAC__StreamEncoderWriteStatus
1268 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1269                       const FLAC__byte buffer[],
1270                       unsigned bytes, unsigned samples,
1271                       unsigned current_frame, void *client_data )
1272 {
1273     encoder_t *p_enc = (encoder_t *)client_data;
1274     encoder_sys_t *p_sys = p_enc->p_sys;
1275     block_t *p_block;
1276
1277     if( samples == 0 )
1278     {
1279         if( p_sys->i_headers == 1 )
1280         {
1281             msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1282
1283             /* Backup the STREAMINFO metadata block */
1284             p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1285             p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1286             memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1287             memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1288                     STREAMINFO_SIZE );
1289
1290             /* Fake this as the last metadata block */
1291             ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1292         }
1293         p_sys->i_headers++;
1294         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1295     }
1296
1297     p_block = block_New( p_enc, bytes );
1298     memcpy( p_block->p_buffer, buffer, bytes );
1299
1300     p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1301
1302     p_sys->i_samples_delay -= samples;
1303
1304     p_block->i_length = (mtime_t)1000000 *
1305         (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1306
1307     /* Update pts */
1308     p_sys->i_pts += p_block->i_length;
1309
1310     block_ChainAppend( &p_sys->p_chain, p_block );
1311
1312     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1313 }
1314 #endif