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