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