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