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