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