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