git.sesse.net Git - vlc/blob - modules/codec/flac.c

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