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