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

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