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