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