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