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