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 = malloc(sizeof(*p_sys)) ) == NULL )
 218         return VLC_ENOMEM;
 219
 220     /* Misc init */
 221     aout_DateSet( &p_sys->end_date, 0 );
 222     p_sys->i_state = STATE_NOSYNC;
 223     p_sys->b_stream_info = false;
 224     p_sys->p_block=NULL;
 225     p_sys->bytestream = block_BytestreamInit();
 226
 227 #ifdef USE_LIBFLAC
 228     /* Take care of flac init */
 229     if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
 230     {
 231         msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
 232         free( p_sys );
 233         return VLC_EGENERIC;
 234     }
 235
 236 #ifdef USE_NEW_FLAC_API
 237     if( FLAC__stream_decoder_init_stream( p_sys->p_flac,
 238                                           DecoderReadCallback,
 239                                           NULL,
 240                                           NULL,
 241                                           NULL,
 242                                           NULL,
 243                                           DecoderWriteCallback,
 244                                           DecoderMetadataCallback,
 245                                           DecoderErrorCallback,
 246                                           p_dec )
 247         != FLAC__STREAM_DECODER_INIT_STATUS_OK )
 248     {
 249         msg_Err( p_dec, "FLAC__stream_decoder_init_stream() failed" );
 250         FLAC__stream_decoder_delete( p_sys->p_flac );
 251         free( p_sys );
 252         return VLC_EGENERIC;
 253     }
 254 #else
 255     FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
 256                                             DecoderReadCallback );
 257     FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
 258                                              DecoderWriteCallback );
 259     FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
 260                                                 DecoderMetadataCallback );
 261     FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
 262                                              DecoderErrorCallback );
 263     FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
 264
 265     FLAC__stream_decoder_init( p_sys->p_flac );
 266 #endif
 267 #endif
 268
 269     /* Set output properties */
 270     p_dec->fmt_out.i_cat = AUDIO_ES;
 271     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
 272
 273     /* Set callbacks */
 274 #ifdef USE_LIBFLAC
 275     p_dec->pf_decode_audio = DecodeBlock;
 276 #endif
 277
 278     return VLC_SUCCESS;
 279 }
 280
 281 static int OpenPacketizer( vlc_object_t *p_this )
 282 {
 283     decoder_t *p_dec = (decoder_t*)p_this;
 284     es_format_t es_save = p_dec->fmt_out;
 285     int i_ret;
 286
 287     /* */
 288     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
 289
 290     i_ret = OpenDecoder( p_this );
 291     p_dec->pf_decode_audio = NULL;
 292     p_dec->pf_packetize    = PacketizeBlock;
 293
 294     /* Set output properties */
 295     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
 296
 297     if( i_ret != VLC_SUCCESS )
 298     {
 299         es_format_Clean( &p_dec->fmt_out );
 300         p_dec->fmt_out = es_save;
 301     }
 302     return i_ret;
 303 }
 304
 305 /*****************************************************************************
 306  * CloseDecoder: flac decoder destruction
 307  *****************************************************************************/
 308 static void CloseDecoder( vlc_object_t *p_this )
 309 {
 310     decoder_t *p_dec = (decoder_t *)p_this;
 311     decoder_sys_t *p_sys = p_dec->p_sys;
 312
 313 #ifdef USE_LIBFLAC
 314     FLAC__stream_decoder_finish( p_sys->p_flac );
 315     FLAC__stream_decoder_delete( p_sys->p_flac );
 316 #endif
 317
 318     free( p_sys->p_block );
 319     free( p_sys );
 320 }
 321
 322 /*****************************************************************************
 323  * ProcessHeader: process Flac header.
 324  *****************************************************************************/
 325 static void ProcessHeader( decoder_t *p_dec )
 326 {
 327     decoder_sys_t *p_sys = p_dec->p_sys;
 328
 329 #ifdef USE_LIBFLAC
 330     if( !p_dec->fmt_in.i_extra ) return;
 331
 332     /* Decode STREAMINFO */
 333     msg_Dbg( p_dec, "decode STREAMINFO" );
 334     p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra );
 335     memcpy( p_sys->p_block->p_buffer, p_dec->fmt_in.p_extra,
 336             p_dec->fmt_in.i_extra );
 337     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
 338     msg_Dbg( p_dec, "STREAMINFO decoded" );
 339
 340 #else
 341     bs_t bs;
 342
 343     if( !p_dec->fmt_in.i_extra ) return;
 344
 345     bs_init( &bs, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
 346
 347     p_sys->stream_info.min_blocksize = bs_read( &bs, 16 );
 348     p_sys->stream_info.max_blocksize = bs_read( &bs, 16 );
 349
 350     p_sys->stream_info.min_framesize = bs_read( &bs, 24 );
 351     p_sys->stream_info.max_framesize = bs_read( &bs, 24 );
 352
 353     p_sys->stream_info.sample_rate = bs_read( &bs, 20 );
 354     p_sys->stream_info.channels = bs_read( &bs, 3 ) + 1;
 355     p_sys->stream_info.bits_per_sample = bs_read( &bs, 5 ) + 1;
 356 #endif
 357
 358     if( !p_sys->b_stream_info ) return;
 359
 360     if( p_dec->fmt_out.i_codec == VLC_FOURCC('f','l','a','c') )
 361     {
 362         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 363         p_dec->fmt_out.p_extra =
 364             realloc( p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
 365         memcpy( p_dec->fmt_out.p_extra,
 366                 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
 367     }
 368 }
 369
 370 /****************************************************************************
 371  * PacketizeBlock: the whole thing
 372  ****************************************************************************
 373  * This function is called just after the thread is launched.
 374  ****************************************************************************/
 375 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
 376 {
 377     decoder_sys_t *p_sys = p_dec->p_sys;
 378     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
 379     block_t *p_sout_block;
 380
 381     if( !pp_block || !*pp_block ) return NULL;
 382
 383     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 384     {
 385         if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
 386         {
 387             p_sys->i_state = STATE_NOSYNC;
 388             block_BytestreamEmpty( &p_sys->bytestream );
 389         }
 390         aout_DateSet( &p_sys->end_date, 0 );
 391         block_Release( *pp_block );
 392         return NULL;
 393     }
 394
 395     if( !p_sys->b_stream_info ) ProcessHeader( p_dec );
 396
 397     if( p_sys->stream_info.channels > 6 )
 398     {
 399         msg_Err( p_dec, "This stream uses too many audio channels" );
 400         return NULL;
 401     }
 402
 403     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
 404     {
 405         /* We've just started the stream, wait for the first PTS. */
 406         block_Release( *pp_block );
 407         return NULL;
 408     }
 409     else if( !aout_DateGet( &p_sys->end_date ) )
 410     {
 411         /* The first PTS is as good as anything else. */
 412         p_sys->i_rate = p_dec->fmt_out.audio.i_rate;
 413         aout_DateInit( &p_sys->end_date, p_sys->i_rate );
 414         aout_DateSet( &p_sys->end_date, (*pp_block)->i_pts );
 415     }
 416
 417     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 418
 419     while( 1 )
 420     {
 421         switch( p_sys->i_state )
 422         {
 423         case STATE_NOSYNC:
 424             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
 425                    == VLC_SUCCESS )
 426             {
 427                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 428                 {
 429                     p_sys->i_state = STATE_SYNC;
 430                     break;
 431                 }
 432                 block_SkipByte( &p_sys->bytestream );
 433             }
 434             if( p_sys->i_state != STATE_SYNC )
 435             {
 436                 block_BytestreamFlush( &p_sys->bytestream );
 437
 438                 /* Need more data */
 439                 return NULL;
 440             }
 441
 442         case STATE_SYNC:
 443             /* New frame, set the Presentation Time Stamp */
 444             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
 445             if( p_sys->i_pts != 0 &&
 446                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
 447             {
 448                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
 449             }
 450             p_sys->i_state = STATE_HEADER;
 451
 452         case STATE_HEADER:
 453             /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
 454             if( block_PeekBytes( &p_sys->bytestream, p_header,
 455                                  MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
 456             {
 457                 /* Need more data */
 458                 return NULL;
 459             }
 460
 461             /* Check if frame is valid and get frame info */
 462             p_sys->i_frame_length = SyncInfo( p_dec, p_header,
 463                                               &p_sys->i_channels,
 464                                               &p_sys->i_channels_conf,
 465                                               &p_sys->i_rate,
 466                                               &p_sys->i_bits_per_sample );
 467             if( !p_sys->i_frame_length )
 468             {
 469                 msg_Dbg( p_dec, "emulated sync word" );
 470                 block_SkipByte( &p_sys->bytestream );
 471                 p_sys->i_state = STATE_NOSYNC;
 472                 break;
 473             }
 474             if( p_sys->i_rate != p_dec->fmt_out.audio.i_rate )
 475             {
 476                 p_dec->fmt_out.audio.i_rate = p_sys->i_rate;
 477                 aout_DateInit( &p_sys->end_date, p_sys->i_rate );
 478             }
 479             p_sys->i_state = STATE_NEXT_SYNC;
 480             p_sys->i_frame_size = 1;
 481
 482         case STATE_NEXT_SYNC:
 483             /* TODO: If pp_block == NULL, flush the buffer without checking the
 484              * next sync word */
 485
 486             /* Check if next expected frame contains the sync word */
 487             while( block_PeekOffsetBytes( &p_sys->bytestream,
 488                                           p_sys->i_frame_size, p_header,
 489                                           MAX_FLAC_HEADER_SIZE )
 490                    == VLC_SUCCESS )
 491             {
 492                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 493                 {
 494                     /* Check if frame is valid and get frame info */
 495                     int i_frame_length =
 496                         SyncInfo( p_dec, p_header,
 497                                   &p_sys->i_channels,
 498                                   &p_sys->i_channels_conf,
 499                                   &p_sys->i_rate,
 500                                   &p_sys->i_bits_per_sample );
 501
 502                     if( i_frame_length )
 503                     {
 504                         p_sys->i_state = STATE_SEND_DATA;
 505                         break;
 506                     }
 507                 }
 508                 p_sys->i_frame_size++;
 509             }
 510
 511             if( p_sys->i_state != STATE_SEND_DATA )
 512             {
 513                 /* Need more data */
 514                 return NULL;
 515             }
 516
 517         case STATE_SEND_DATA:
 518             p_sout_block = block_New( p_dec, p_sys->i_frame_size );
 519
 520             /* Copy the whole frame into the buffer. When we reach this point
 521              * we already know we have enough data available. */
 522             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
 523                             p_sys->i_frame_size );
 524
 525             /* Make sure we don't reuse the same pts twice */
 526             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
 527                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
 528
 529             /* So p_block doesn't get re-added several times */
 530             *pp_block = block_BytestreamPop( &p_sys->bytestream );
 531
 532             p_sys->i_state = STATE_NOSYNC;
 533
 534             /* Date management */
 535             p_sout_block->i_pts =
 536                 p_sout_block->i_dts = aout_DateGet( &p_sys->end_date );
 537             aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
 538             p_sout_block->i_length =
 539                 aout_DateGet( &p_sys->end_date ) - p_sout_block->i_pts;
 540
 541             return p_sout_block;
 542         }
 543     }
 544
 545     return NULL;
 546 }
 547
 548 #ifdef USE_LIBFLAC
 549 /****************************************************************************
 550  * DecodeBlock: the whole thing
 551  ****************************************************************************/
 552 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 553 {
 554     decoder_sys_t *p_sys = p_dec->p_sys;
 555
 556     if( !pp_block || !*pp_block ) return NULL;
 557
 558     p_sys->p_aout_buffer = 0;
 559     if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
 560     {
 561         if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
 562         {
 563             decoder_state_error( p_dec,
 564                 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
 565             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 566         }
 567
 568         /* If the decoder is in the "aborted" state,
 569          * FLAC__stream_decoder_process_single() won't return an error. */
 570         if( FLAC__stream_decoder_get_state(p_dec->p_sys->p_flac)
 571             == FLAC__STREAM_DECODER_ABORTED )
 572         {
 573             FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 574         }
 575
 576         block_Release( p_sys->p_block );
 577         p_sys->p_block = NULL;
 578     }
 579
 580     return p_sys->p_aout_buffer;
 581 }
 582
 583 /*****************************************************************************
 584  * DecoderReadCallback: called by libflac when it needs more data
 585  *****************************************************************************/
 586 static FLAC__StreamDecoderReadStatus
 587 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
 588                      unsigned *bytes, void *client_data )
 589 {
 590     VLC_UNUSED(decoder);
 591     decoder_t *p_dec = (decoder_t *)client_data;
 592     decoder_sys_t *p_sys = p_dec->p_sys;
 593
 594     if( p_sys->p_block && p_sys->p_block->i_buffer )
 595     {
 596         *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
 597         memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
 598         p_sys->p_block->i_buffer -= *bytes;
 599         p_sys->p_block->p_buffer += *bytes;
 600     }
 601     else
 602     {
 603         *bytes = 0;
 604         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 605     }
 606
 607     return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 608 }
 609
 610 /*****************************************************************************
 611  * DecoderWriteCallback: called by libflac to output decoded samples
 612  *****************************************************************************/
 613 static FLAC__StreamDecoderWriteStatus
 614 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 615                       const FLAC__Frame *frame,
 616                       const FLAC__int32 *const buffer[], void *client_data )
 617 {
 618     VLC_UNUSED(decoder);
 619     decoder_t *p_dec = (decoder_t *)client_data;
 620     decoder_sys_t *p_sys = p_dec->p_sys;
 621
 622     p_sys->p_aout_buffer =
 623         decoder_NewAudioBuffer( p_dec, frame->header.blocksize );
 624
 625     if( p_sys->p_aout_buffer == NULL )
 626         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 627
 628     switch( frame->header.bits_per_sample )
 629     {
 630     case 16:
 631         Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 632                       frame->header.channels, frame->header.blocksize );
 633         break;
 634     case 24:
 635         Interleave24( (int8_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 636                       frame->header.channels, frame->header.blocksize );
 637         break;
 638     default:
 639         Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 640                       frame->header.channels, frame->header.blocksize );
 641     }
 642
 643     /* Date management (already done by packetizer) */
 644     p_sys->p_aout_buffer->start_date = p_sys->p_block->i_pts;
 645     p_sys->p_aout_buffer->end_date =
 646         p_sys->p_block->i_pts + p_sys->p_block->i_length;
 647
 648     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 649 }
 650
 651 /*****************************************************************************
 652  * DecoderMetadataCallback: called by libflac to when it encounters metadata
 653  *****************************************************************************/
 654 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 655                                      const FLAC__StreamMetadata *metadata,
 656                                      void *client_data )
 657 {
 658     VLC_UNUSED(decoder);
 659     decoder_t *p_dec = (decoder_t *)client_data;
 660     decoder_sys_t *p_sys = p_dec->p_sys;
 661
 662     if( p_dec->pf_decode_audio )
 663     {
 664         switch( metadata->data.stream_info.bits_per_sample )
 665         {
 666         case 8:
 667             p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
 668             break;
 669         case 16:
 670             p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
 671             break;
 672         case 24:
 673             p_dec->fmt_out.i_codec = AOUT_FMT_S24_NE;
 674             break;
 675         default:
 676             msg_Dbg( p_dec, "strange bit/sample value: %d",
 677                      metadata->data.stream_info.bits_per_sample );
 678             p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
 679             break;
 680         }
 681     }
 682
 683     /* Setup the format */
 684     p_dec->fmt_out.audio.i_rate     = metadata->data.stream_info.sample_rate;
 685     p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
 686     p_dec->fmt_out.audio.i_physical_channels =
 687         p_dec->fmt_out.audio.i_original_channels =
 688             pi_channels_maps[metadata->data.stream_info.channels];
 689     p_dec->fmt_out.audio.i_bitspersample =
 690         metadata->data.stream_info.bits_per_sample;
 691
 692     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
 693
 694     msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
 695              p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
 696              p_dec->fmt_out.audio.i_bitspersample );
 697
 698     p_sys->b_stream_info = true;
 699     p_sys->stream_info = metadata->data.stream_info;
 700
 701     return;
 702 }
 703
 704 /*****************************************************************************
 705  * DecoderErrorCallback: called when the libflac decoder encounters an error
 706  *****************************************************************************/
 707 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 708                                   FLAC__StreamDecoderErrorStatus status,
 709                                   void *client_data )
 710 {
 711     VLC_UNUSED(decoder);
 712     decoder_t *p_dec = (decoder_t *)client_data;
 713
 714     switch( status )
 715     {
 716     case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
 717         msg_Warn( p_dec, "an error in the stream caused the decoder to "
 718                  "lose synchronization." );
 719         break;
 720     case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
 721         msg_Err( p_dec, "the decoder encountered a corrupted frame header." );
 722         break;
 723     case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
 724         msg_Err( p_dec, "frame's data did not match the CRC in the "
 725                  "footer." );
 726         break;
 727     default:
 728         msg_Err( p_dec, "got decoder error: %d", status );
 729     }
 730
 731     FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 732     return;
 733 }
 734
 735 /*****************************************************************************
 736  * Interleave: helper function to interleave channels
 737  *****************************************************************************/
 738 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 739                           int i_nb_channels, int i_samples )
 740 {
 741     int i, j;
 742     for ( j = 0; j < i_samples; j++ )
 743     {
 744         for ( i = 0; i < i_nb_channels; i++ )
 745         {
 746             p_out[j * i_nb_channels + i] = pp_in[i][j];
 747         }
 748     }
 749 }
 750
 751 static void Interleave24( int8_t *p_out, const int32_t * const *pp_in,
 752                           int i_nb_channels, int i_samples )
 753 {
 754     int i, j;
 755     for ( j = 0; j < i_samples; j++ )
 756     {
 757         for ( i = 0; i < i_nb_channels; i++ )
 758         {
 759 #ifdef WORDS_BIGENDIAN
 760             p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i][j] >> 16) & 0xff;
 761             p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i][j] >> 8 ) & 0xff;
 762             p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i][j] >> 0 ) & 0xff;
 763 #else
 764             p_out[3*(j * i_nb_channels + i)+2] = (pp_in[i][j] >> 16) & 0xff;
 765             p_out[3*(j * i_nb_channels + i)+1] = (pp_in[i][j] >> 8 ) & 0xff;
 766             p_out[3*(j * i_nb_channels + i)+0] = (pp_in[i][j] >> 0 ) & 0xff;
 767 #endif
 768         }
 769     }
 770 }
 771
 772 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 773                           int i_nb_channels, int i_samples )
 774 {
 775     int i, j;
 776     for ( j = 0; j < i_samples; j++ )
 777     {
 778         for ( i = 0; i < i_nb_channels; i++ )
 779         {
 780             p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
 781         }
 782     }
 783 }
 784
 785 /*****************************************************************************
 786  * decoder_state_error: print meaningful error messages
 787  *****************************************************************************/
 788 static void decoder_state_error( decoder_t *p_dec,
 789                                  FLAC__StreamDecoderState state )
 790 {
 791     switch ( state )
 792     {
 793     case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
 794         msg_Dbg( p_dec, "the decoder is ready to search for metadata." );
 795         break;
 796     case FLAC__STREAM_DECODER_READ_METADATA:
 797         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
 798                  "reading metadata." );
 799         break;
 800     case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
 801         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
 802                  "searching for the frame sync code." );
 803         break;
 804     case FLAC__STREAM_DECODER_READ_FRAME:
 805         msg_Dbg( p_dec, "the decoder is ready to or is in the process of "
 806                  "reading a frame." );
 807         break;
 808     case FLAC__STREAM_DECODER_END_OF_STREAM:
 809         msg_Dbg( p_dec, "the decoder has reached the end of the stream." );
 810         break;
 811 #ifdef USE_NEW_FLAC_API
 812     case FLAC__STREAM_DECODER_OGG_ERROR:
 813         msg_Err( p_dec, "error occurred in the Ogg layer." );
 814         break;
 815     case FLAC__STREAM_DECODER_SEEK_ERROR:
 816         msg_Err( p_dec, "error occurred while seeking." );
 817         break;
 818 #endif
 819     case FLAC__STREAM_DECODER_ABORTED:
 820         msg_Warn( p_dec, "the decoder was aborted by the read callback." );
 821         break;
 822 #ifndef USE_NEW_FLAC_API
 823     case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
 824         msg_Warn( p_dec, "the decoder encountered reserved fields in use "
 825                  "in the stream." );
 826         break;
 827 #endif
 828     case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
 829         msg_Err( p_dec, "error when allocating memory." );
 830         break;
 831 #ifndef USE_NEW_FLAC_API
 832     case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
 833         msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
 834                  "decoder was already initialized, usually because "
 835                  "FLAC__stream_decoder_finish() was not called." );
 836         break;
 837     case FLAC__STREAM_DECODER_INVALID_CALLBACK:
 838         msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
 839                  "all callbacks being set." );
 840         break;
 841 #endif
 842     case FLAC__STREAM_DECODER_UNINITIALIZED:
 843         msg_Err( p_dec, "decoder in uninitialized state." );
 844         break;
 845     default:
 846         msg_Warn(p_dec, "unknown error" );
 847     }
 848 }
 849 #endif
 850
 851 /*****************************************************************************
 852  * SyncInfo: parse FLAC sync info
 853  *****************************************************************************/
 854 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
 855                      unsigned int * pi_channels,
 856                      unsigned int * pi_channels_conf,
 857                      unsigned int * pi_sample_rate,
 858                      int * pi_bits_per_sample )
 859 {
 860     decoder_sys_t *p_sys = p_dec->p_sys;
 861     int i_header, i_temp, i_read;
 862     unsigned i_blocksize = 0;
 863     int 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