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     int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
 864     uint64_t i_sample_number = 0;
 865
 866     bool b_variable_blocksize = ( p_sys->b_stream_info &&
 867         p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
 868     bool b_fixed_blocksize = ( p_sys->b_stream_info &&
 869         p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
 870
 871     /* Check syncword */
 872     if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
 873
 874     /* Check there is no emulated sync code in the rest of the header */
 875     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
 876
 877     /* Find blocksize (framelength) */
 878     switch( i_temp = p_buf[2] >> 4 )
 879     {
 880     case 0:
 881         if( b_fixed_blocksize )
 882             i_blocksize = p_sys->stream_info.min_blocksize;
 883         else return 0; /* We can't do anything with this */
 884         break;
 885
 886     case 1:
 887         i_blocksize = 192;
 888         break;
 889
 890     case 2:
 891     case 3:
 892     case 4:
 893     case 5:
 894         i_blocksize = 576 << (i_temp - 2);
 895         break;
 896
 897     case 6:
 898     case 7:
 899         i_blocksize_hint = i_temp;
 900         break;
 901
 902     case 8:
 903     case 9:
 904     case 10:
 905     case 11:
 906     case 12:
 907     case 13:
 908     case 14:
 909     case 15:
 910         i_blocksize = 256 << (i_temp - 8);
 911         break;
 912     }
 913
 914     /* Find samplerate */
 915     switch( i_temp = p_buf[2] & 0x0f )
 916     {
 917     case 0:
 918         if( p_sys->b_stream_info )
 919             *pi_sample_rate = p_sys->stream_info.sample_rate;
 920         else return 0; /* We can't do anything with this */
 921         break;
 922
 923     case 1:
 924     case 2:
 925     case 3:
 926         return 0;
 927         break;
 928
 929     case 4:
 930         *pi_sample_rate = 8000;
 931         break;
 932
 933     case 5:
 934         *pi_sample_rate = 16000;
 935         break;
 936
 937     case 6:
 938         *pi_sample_rate = 22050;
 939         break;
 940
 941     case 7:
 942         *pi_sample_rate = 24000;
 943         break;
 944
 945     case 8:
 946         *pi_sample_rate = 32000;
 947         break;
 948
 949     case 9:
 950         *pi_sample_rate = 44100;
 951         break;
 952
 953     case 10:
 954         *pi_sample_rate = 48000;
 955         break;
 956
 957     case 11:
 958         *pi_sample_rate = 96000;
 959         break;
 960
 961     case 12:
 962     case 13:
 963     case 14:
 964         i_sample_rate_hint = i_temp;
 965         break;
 966
 967     case 15:
 968         return 0;
 969     }
 970
 971     /* Find channels */
 972     i_temp = (unsigned)(p_buf[3] >> 4);
 973     if( i_temp & 8 )
 974     {
 975 #ifdef USE_LIBFLAC
 976         int i_channel_assignment; /* ??? */
 977
 978         switch( i_temp & 7 )
 979         {
 980         case 0:
 981             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
 982             break;
 983         case 1:
 984             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
 985             break;
 986         case 2:
 987             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
 988             break;
 989         default:
 990             return 0;
 991             break;
 992         }
 993 #endif
 994
 995         *pi_channels = 2;
 996     }
 997     else
 998     {
 999         *pi_channels = i_temp + 1;
1000         *pi_channels_conf = pi_channels_maps[ *pi_channels ];
1001     }
1002
1003     /* Find bits per sample */
1004     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
1005     {
1006     case 0:
1007         if( p_sys->b_stream_info )
1008             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
1009         else
1010             return 0;
1011         break;
1012
1013     case 1:
1014         *pi_bits_per_sample = 8;
1015         break;
1016
1017     case 2:
1018         *pi_bits_per_sample = 12;
1019         break;
1020
1021     case 4:
1022         *pi_bits_per_sample = 16;
1023         break;
1024
1025     case 5:
1026         *pi_bits_per_sample = 20;
1027         break;
1028
1029     case 6:
1030         *pi_bits_per_sample = 24;
1031         break;
1032
1033     case 3:
1034     case 7:
1035         return 0;
1036         break;
1037     }
1038
1039     /* Zero padding bit */
1040     if( p_buf[3] & 0x01 ) return 0;
1041
1042     /* End of fixed size header */
1043     i_header = 4;
1044
1045     /* Find Sample/Frame number */
1046     if( i_blocksize_hint && b_variable_blocksize )
1047     {
1048         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1049         if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1050     }
1051     else
1052     {
1053         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
1054         if( i_sample_number == INT64_C(0xffffffffffffffff) ) return 0;
1055
1056         if( p_sys->b_stream_info )
1057             i_sample_number *= p_sys->stream_info.min_blocksize;
1058     }
1059
1060     i_header += i_read;
1061
1062     /* Read blocksize */
1063     if( i_blocksize_hint )
1064     {
1065         int i_val1 = p_buf[i_header++];
1066         if( i_blocksize_hint == 7 )
1067         {
1068             int i_val2 = p_buf[i_header++];
1069             i_val1 = (i_val1 << 8) | i_val2;
1070         }
1071         i_blocksize = i_val1 + 1;
1072     }
1073
1074     /* Read sample rate */
1075     if( i_sample_rate_hint )
1076     {
1077         int i_val1 = p_buf[i_header++];
1078         if( i_sample_rate_hint != 12 )
1079         {
1080             int i_val2 = p_buf[i_header++];
1081             i_val1 = (i_val1 << 8) | i_val2;
1082         }
1083         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
1084         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
1085         else *pi_sample_rate = i_val1 * 10;
1086     }
1087
1088     /* Check the CRC-8 byte */
1089     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
1090     {
1091         return 0;
1092     }
1093
1094     /* Sanity check using stream info header when possible */
1095     if( p_sys->b_stream_info )
1096     {
1097         if( i_blocksize < p_sys->stream_info.min_blocksize ||
1098             i_blocksize > p_sys->stream_info.max_blocksize )
1099             return 0;
1100     }
1101     return i_blocksize;
1102 }
1103
1104 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
1105 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
1106 {
1107     uint64_t i_result = 0;
1108     unsigned i, j;
1109
1110     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
1111     {
1112         i_result = p_buf[0];
1113         i = 0;
1114     }
1115     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
1116     {
1117         i_result = p_buf[0] & 0x1F;
1118         i = 1;
1119     }
1120     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
1121     {
1122         i_result = p_buf[0] & 0x0F;
1123         i = 2;
1124     }
1125     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
1126     {
1127         i_result = p_buf[0] & 0x07;
1128         i = 3;
1129     }
1130     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
1131     {
1132         i_result = p_buf[0] & 0x03;
1133         i = 4;
1134     }
1135     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
1136     {
1137         i_result = p_buf[0] & 0x01;
1138         i = 5;
1139     }
1140     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
1141     {
1142         i_result = 0;
1143         i = 6;
1144     }
1145     else {
1146         return INT64_C(0xffffffffffffffff);
1147     }
1148
1149     for( j = 1; j <= i; j++ )
1150     {
1151         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
1152         {
1153             return INT64_C(0xffffffffffffffff);
1154         }
1155         i_result <<= 6;
1156         i_result |= (p_buf[j] & 0x3F);
1157     }
1158
1159     *pi_read = i;
1160     return i_result;
1161 }
1162
1163 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
1164 static const uint8_t flac_crc8_table[256] = {
1165         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1166         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1167         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1168         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1169         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1170         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1171         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1172         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1173         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1174         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1175         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1176         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1177         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1178         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1179         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1180         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1181         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1182         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1183         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1184         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1185         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1186         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1187         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1188         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1189         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1190         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1191         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1192         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1193         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1194         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1195         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1196         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1197 };
1198
1199 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
1200 {
1201     uint8_t crc = 0;
1202
1203     while(len--)
1204         crc = flac_crc8_table[crc ^ *data++];
1205
1206     return crc;
1207 }
1208
1209 #ifdef USE_LIBFLAC
1210 /*****************************************************************************
1211  * encoder_sys_t : flac encoder descriptor
1212  *****************************************************************************/
1213 struct encoder_sys_t
1214 {
1215     /*
1216      * Input properties
1217      */
1218     int i_headers;
1219
1220     int i_samples_delay;
1221     int i_channels;
1222
1223     FLAC__int32 *p_buffer;
1224     unsigned int i_buffer;
1225
1226     block_t *p_chain;
1227
1228     /*
1229      * FLAC properties
1230      */
1231     FLAC__StreamEncoder *p_flac;
1232     FLAC__StreamMetadata_StreamInfo stream_info;
1233
1234     /*
1235      * Common properties
1236      */
1237     mtime_t i_pts;
1238 };
1239
1240 #define STREAMINFO_SIZE 38
1241
1242 static block_t *Encode( encoder_t *, aout_buffer_t * );
1243
1244 static FLAC__StreamEncoderWriteStatus
1245 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1246                       const FLAC__byte buffer[],
1247                       unsigned bytes, unsigned samples,
1248                       unsigned current_frame, void *client_data );
1249
1250 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1251                                      const FLAC__StreamMetadata *metadata,
1252                                      void *client_data );
1253
1254 /*****************************************************************************
1255  * OpenEncoder: probe the encoder and return score
1256  *****************************************************************************/
1257 static int OpenEncoder( vlc_object_t *p_this )
1258 {
1259     encoder_t *p_enc = (encoder_t *)p_this;
1260     encoder_sys_t *p_sys;
1261
1262     if( p_enc->fmt_out.i_codec != VLC_FOURCC('f','l','a','c') &&
1263         !p_enc->b_force )
1264     {
1265         return VLC_EGENERIC;
1266     }
1267
1268     /* Allocate the memory needed to store the decoder's structure */
1269     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
1270         return VLC_ENOMEM;
1271     p_enc->p_sys = p_sys;
1272     p_enc->pf_encode_audio = Encode;
1273     p_enc->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
1274
1275     p_sys->i_headers = 0;
1276     p_sys->p_buffer = 0;
1277     p_sys->i_buffer = 0;
1278     p_sys->i_samples_delay = 0;
1279
1280     /* Create flac encoder */
1281     if( !(p_sys->p_flac = FLAC__stream_encoder_new()) )
1282     {
1283         msg_Err( p_enc, "FLAC__stream_encoder_new() failed" );
1284         free( p_sys );
1285         return VLC_EGENERIC;
1286     }
1287
1288     FLAC__stream_encoder_set_streamable_subset( p_sys->p_flac, 1 );
1289     FLAC__stream_encoder_set_channels( p_sys->p_flac,
1290                                        p_enc->fmt_in.audio.i_channels );
1291     FLAC__stream_encoder_set_sample_rate( p_sys->p_flac,
1292                                           p_enc->fmt_in.audio.i_rate );
1293     FLAC__stream_encoder_set_bits_per_sample( p_sys->p_flac, 16 );
1294     p_enc->fmt_in.i_codec = AOUT_FMT_S16_NE;
1295
1296     /* Get and store the STREAMINFO metadata block as a p_extra */
1297     p_sys->p_chain = 0;
1298
1299 #ifdef USE_NEW_FLAC_API
1300     if( FLAC__stream_encoder_init_stream( p_sys->p_flac,
1301                                           EncoderWriteCallback,
1302                                           NULL,
1303                                           NULL,
1304                                           EncoderMetadataCallback,
1305                                           p_enc )
1306         != FLAC__STREAM_ENCODER_INIT_STATUS_OK )
1307     {
1308         msg_Err( p_enc, "FLAC__stream_encoder_init_stream() failed" );
1309         FLAC__stream_encoder_delete( p_sys->p_flac );
1310         free( p_sys );
1311         return VLC_EGENERIC;
1312     }
1313 #else
1314     FLAC__stream_encoder_set_write_callback( p_sys->p_flac,
1315         EncoderWriteCallback );
1316     FLAC__stream_encoder_set_metadata_callback( p_sys->p_flac,
1317         EncoderMetadataCallback );
1318     FLAC__stream_encoder_set_client_data( p_sys->p_flac, p_enc );
1319
1320     FLAC__stream_encoder_init( p_sys->p_flac );
1321 #endif
1322
1323     return VLC_SUCCESS;
1324 }
1325
1326 /****************************************************************************
1327  * Encode: the whole thing
1328  ****************************************************************************
1329  * This function spits out ogg packets.
1330  ****************************************************************************/
1331 static block_t *Encode( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1332 {
1333     encoder_sys_t *p_sys = p_enc->p_sys;
1334     block_t *p_chain;
1335     unsigned int i;
1336
1337     p_sys->i_pts = p_aout_buf->start_date -
1338                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1339                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1340
1341     p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1342
1343     /* Convert samples to FLAC__int32 */
1344     if( p_sys->i_buffer < p_aout_buf->i_nb_bytes * 2 )
1345     {
1346         p_sys->p_buffer =
1347             realloc( p_sys->p_buffer, p_aout_buf->i_nb_bytes * 2 );
1348         p_sys->i_buffer = p_aout_buf->i_nb_bytes * 2;
1349     }
1350
1351     for( i = 0 ; i < p_aout_buf->i_nb_bytes / 2 ; i++ )
1352     {
1353         p_sys->p_buffer[i]= ((int16_t *)p_aout_buf->p_buffer)[i];
1354     }
1355
1356     FLAC__stream_encoder_process_interleaved( p_sys->p_flac, p_sys->p_buffer,
1357                                               p_aout_buf->i_nb_samples );
1358
1359     p_chain = p_sys->p_chain;
1360     p_sys->p_chain = 0;
1361
1362     return p_chain;
1363 }
1364
1365 /*****************************************************************************
1366  * CloseEncoder: encoder destruction
1367  *****************************************************************************/
1368 static void CloseEncoder( vlc_object_t *p_this )
1369 {
1370     encoder_t *p_enc = (encoder_t *)p_this;
1371     encoder_sys_t *p_sys = p_enc->p_sys;
1372
1373     FLAC__stream_encoder_delete( p_sys->p_flac );
1374
1375     free( p_sys->p_buffer );
1376     free( p_sys );
1377 }
1378
1379 /*****************************************************************************
1380  * EncoderMetadataCallback: called by libflac to output metadata
1381  *****************************************************************************/
1382 static void EncoderMetadataCallback( const FLAC__StreamEncoder *encoder,
1383                                      const FLAC__StreamMetadata *metadata,
1384                                      void *client_data )
1385 {
1386     VLC_UNUSED(encoder);
1387     encoder_t *p_enc = (encoder_t *)client_data;
1388
1389     msg_Err( p_enc, "MetadataCallback: %i", metadata->type );
1390     return;
1391 }
1392
1393 /*****************************************************************************
1394  * EncoderWriteCallback: called by libflac to output encoded samples
1395  *****************************************************************************/
1396 static FLAC__StreamEncoderWriteStatus
1397 EncoderWriteCallback( const FLAC__StreamEncoder *encoder,
1398                       const FLAC__byte buffer[],
1399                       unsigned bytes, unsigned samples,
1400                       unsigned current_frame, void *client_data )
1401 {
1402     VLC_UNUSED(encoder); VLC_UNUSED(current_frame);
1403     encoder_t *p_enc = (encoder_t *)client_data;
1404     encoder_sys_t *p_sys = p_enc->p_sys;
1405     block_t *p_block;
1406
1407     if( samples == 0 )
1408     {
1409         if( p_sys->i_headers == 1 )
1410         {
1411             msg_Dbg( p_enc, "Writing STREAMINFO: %i", bytes );
1412
1413             /* Backup the STREAMINFO metadata block */
1414             p_enc->fmt_out.i_extra = STREAMINFO_SIZE + 4;
1415             p_enc->fmt_out.p_extra = malloc( STREAMINFO_SIZE + 4 );
1416             memcpy( p_enc->fmt_out.p_extra, "fLaC", 4 );
1417             memcpy( ((uint8_t *)p_enc->fmt_out.p_extra) + 4, buffer,
1418                     STREAMINFO_SIZE );
1419
1420             /* Fake this as the last metadata block */
1421             ((uint8_t*)p_enc->fmt_out.p_extra)[4] |= 0x80;
1422         }
1423         p_sys->i_headers++;
1424         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1425     }
1426
1427     p_block = block_New( p_enc, bytes );
1428     memcpy( p_block->p_buffer, buffer, bytes );
1429
1430     p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1431
1432     p_sys->i_samples_delay -= samples;
1433
1434     p_block->i_length = (mtime_t)1000000 *
1435         (mtime_t)samples / (mtime_t)p_enc->fmt_in.audio.i_rate;
1436
1437     /* Update pts */
1438     p_sys->i_pts += p_block->i_length;
1439
1440     block_ChainAppend( &p_sys->p_chain, p_block );
1441
1442     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
1443 }
1444 #endif