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