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