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