modules/demux/caf.c

   1 /*****************************************************************************
   2  * caf.c: Core Audio File Format demuxer
   3  *****************************************************************************
   4  * Copyright (C) 2013 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Matthias Keiser <matthias@tristan-inc.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31 #include <math.h>
  32 #include <limits.h>
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_demux.h>
  36 #include <vlc_codecs.h>
  37
  38 /* TODO:
  39  *
  40  * - handle channel layout
  41  * - 64 bit float LPCM is broken (sound has artifacts with little endian, only silence plays for big endian).
  42  */
  43
  44 /*****************************************************************************
  45  * Module descriptor
  46  *****************************************************************************/
  47 static int  Open    ( vlc_object_t * );
  48 static void Close  ( vlc_object_t * );
  49
  50 vlc_module_begin ()
  51 set_category( CAT_INPUT )
  52 set_subcategory( SUBCAT_INPUT_DEMUX )
  53 set_description( N_( "CAF demuxer" ))
  54 set_capability( "demux", 140 )
  55 set_callbacks( Open, Close )
  56 add_shortcut( "caf" )
  57 vlc_module_end ()
  58
  59 /*****************************************************************************
  60  * Local prototypes
  61  *****************************************************************************/
  62 static int Demux  ( demux_t * );
  63 static int Control( demux_t *, int i_query, va_list args );
  64
  65 typedef struct frame_span_t
  66 {
  67     uint64_t i_frames;
  68     uint64_t i_samples;
  69     uint64_t i_bytes;
  70     uint64_t i_desc_bytes;
  71 } frame_span_t;
  72
  73 typedef struct packet_table_t
  74 {
  75     uint64_t i_num_packets;
  76     uint64_t i_num_valid_frames;
  77     uint32_t i_num_priming_frames;
  78     uint32_t i_num_remainder_frames;
  79     uint64_t i_descriptions_start;
  80 } packet_table_t;
  81
  82 struct demux_sys_t
  83 {
  84     es_format_t  fmt;
  85     es_out_id_t *es;
  86
  87     uint64_t i_data_offset;
  88     uint64_t i_data_size;
  89
  90     frame_span_t position;
  91     packet_table_t packet_table;
  92 };
  93
  94 /*
  95  We use this value to indicate that the data section extends until the end of the file.
  96 */
  97 static const uint64_t kCHUNK_SIZE_EOF = UINT64_C( 0xffffffffffffffff );
  98
  99 /*****************************************************************************
 100  * Various Utility Functions
 101  *****************************************************************************/
 102
 103 /* ParseVarLenInteger parses a var length integer as found in the packet descriptions
 104  (and in the aac magic cookie). In theorie a var length integer could be bigger than
 105  an uint64_t, but I think it's unlikely to ever be a problem... */
 106
 107 static int ParseVarLenInteger( const uint8_t *p_buff, size_t i_buff_len, uint64_t *pi_value_out, uint32_t *i_len_out )
 108 {
 109     *i_len_out = 0;
 110
 111     uint64_t i_value = 0;
 112     bool finished = false;
 113
 114     for( uint32_t i = 0; i < i_buff_len; i++ )
 115     {
 116         if( (( i_value >> 32 ) << 7 ) > UINT32_MAX )
 117         {
 118             return VLC_EGENERIC; /* overflow */
 119         }
 120         uint8_t i_byte = p_buff[i];
 121         i_value = ( i_value << 7 ) | ( i_byte & 0x7f );
 122
 123         ( *i_len_out )++;
 124
 125         if( !( i_byte & 0x80 ))
 126         {
 127             finished = true;
 128             break;
 129         }
 130     }
 131
 132     if( !finished )
 133     {
 134         return VLC_EGENERIC;
 135     }
 136
 137     *pi_value_out = i_value;
 138
 139     return VLC_SUCCESS;
 140 }
 141
 142 /* Utility function that reads a big endian double from the input buffer. */
 143
 144 static inline double GetDBLBE( const uint8_t *p )
 145 {
 146     union
 147     {
 148         uint64_t uint64;
 149         double dbl;
 150     } u_64;
 151
 152     u_64.uint64 = GetQWBE( p );
 153     return u_64.dbl;
 154 }
 155
 156 /* Utility function that reads a big endian signed 32 bit integer into an unsigned 32 bit variable.
 157    If the read value is negative, this function returns an error.
 158  */
 159
 160 static inline int ReadBEInt32ToUInt32( const uint8_t *p, uint32_t *i_out )
 161 {
 162     uint32_t i_value = GetDWBE( p );
 163
 164     if( i_value > INT32_MAX ) return VLC_EGENERIC;
 165
 166     *i_out = i_value;
 167     return VLC_SUCCESS;
 168 }
 169
 170 /* Utility function that reads a big endian signed 64 bit integer into an unsigned 64 bit variable.
 171    If the read value is negative, this function returns an error.
 172 */
 173
 174 static inline int ReadBEInt64ToUInt64( const uint8_t *p, uint64_t *i_out )
 175 {
 176     uint64_t i_value = GetQWBE( p );
 177
 178     if( i_value > INT64_MAX ) return VLC_EGENERIC;
 179
 180     *i_out = i_value;
 181     return VLC_SUCCESS;
 182 }
 183
 184 static inline bool NeedsPacketTable( demux_sys_t *p_sys )
 185 {
 186     return ( !p_sys->fmt.audio.i_bytes_per_frame || !p_sys->fmt.audio.i_frame_length );
 187 }
 188
 189 static uint64_t TotalNumFrames( demux_t *p_demux )
 190 {
 191     demux_sys_t *p_sys = p_demux->p_sys;
 192
 193     if( !NeedsPacketTable( p_sys ))
 194     {
 195         uint64_t i_data_size;
 196
 197         if( p_sys->i_data_size != kCHUNK_SIZE_EOF)
 198         {
 199             i_data_size = p_sys->i_data_size;
 200         }
 201         else
 202         {
 203             int64_t i_stream_size = stream_Size( p_demux->s );
 204             if(i_stream_size >= 0 && (uint64_t)i_stream_size >= p_sys->i_data_offset)
 205                 i_data_size = i_stream_size - p_sys->i_data_offset;
 206             else
 207                 i_data_size = 0;
 208         }
 209
 210         return i_data_size / p_sys->fmt.audio.i_bytes_per_frame;
 211     }
 212     else
 213     {
 214         return p_sys->packet_table.i_num_packets;
 215     }
 216 }
 217
 218 static uint64_t TotalNumSamples( demux_t *p_demux )
 219 {
 220     demux_sys_t *p_sys = p_demux->p_sys;
 221
 222     if( !NeedsPacketTable( p_sys ))
 223     {
 224         return TotalNumFrames( p_demux ) * p_sys->fmt.audio.i_frame_length;
 225     }
 226     else
 227     {
 228         return p_sys->packet_table.i_num_valid_frames + p_sys->packet_table.i_num_priming_frames +
 229                 p_sys->packet_table.i_num_remainder_frames;
 230     }
 231 }
 232
 233 static inline vlc_fourcc_t ReadFOURCC( const uint8_t *p )
 234 {
 235     return VLC_FOURCC( p[0], p[1], p[2], p[3] );
 236 }
 237
 238 /*****************************************************************************
 239  * FrameSpan Functions
 240  *****************************************************************************
 241  *  A FrameSpan structure contains the relationship between a number of
 242  frames, the number of samples they contain, the amount of data they
 243  use, and the length of their packet descriptions (if any).
 244  *****************************************************************************/
 245
 246 /* FrameSpanAddSpan adds span2 to span1 */
 247
 248 static inline void FrameSpanAddSpan( frame_span_t *span1, frame_span_t *span2 )
 249 {
 250     span1->i_frames += span2->i_frames;
 251     span1->i_samples += span2->i_samples;
 252     span1->i_bytes += span2->i_bytes;
 253     span1->i_desc_bytes += span2->i_desc_bytes;
 254 }
 255
 256 /* Adds the frame that is described at i_desc_offset to span */
 257
 258 static int FrameSpanAddDescription( demux_t *p_demux, uint64_t i_desc_offset, frame_span_t *span )
 259 {
 260     demux_sys_t *p_sys  = p_demux->p_sys;
 261
 262     /* Avoid seeking + peeking for simple case (PCM) */
 263     if( p_sys->fmt.audio.i_bytes_per_frame && p_sys->fmt.audio.i_frame_length )
 264     {
 265         span->i_bytes += p_sys->fmt.audio.i_bytes_per_frame;
 266         span->i_samples += p_sys->fmt.audio.i_frame_length;
 267         span->i_frames++;
 268         return VLC_SUCCESS;
 269     }
 270
 271     uint32_t i_desc_size = 0;
 272
 273     if( vlc_stream_Seek( p_demux->s, p_sys->packet_table.i_descriptions_start + i_desc_offset ))
 274     {
 275         msg_Err( p_demux, "Couldn't seek packet description." );
 276         return VLC_EGENERIC;
 277     }
 278
 279     const uint8_t *p_peek;
 280     int i_peek_len = vlc_stream_Peek( p_demux->s, &p_peek, 2 * 10 );
 281     /* Peeking the maximum number of bytes that two 64 bit numbers could use
 282      * (( 64 + 6 ) / 7 = 10). */
 283     if( i_peek_len < 0 )
 284         i_peek_len = 0;
 285
 286     if( p_sys->fmt.audio.i_bytes_per_frame )
 287     {
 288         span->i_bytes += p_sys->fmt.audio.i_bytes_per_frame;
 289     }
 290     else
 291     {
 292         uint64_t i_size;
 293         uint32_t i_this_int;
 294         if( ParseVarLenInteger( p_peek, i_peek_len, &i_size, &i_this_int ))
 295         {
 296             return VLC_EGENERIC;
 297         }
 298
 299         i_desc_size += i_this_int;
 300         span->i_bytes += i_size;
 301     }
 302
 303     if( p_sys->fmt.audio.i_frame_length )
 304     {
 305         span->i_samples += p_sys->fmt.audio.i_frame_length;
 306     }
 307     else
 308     {
 309         if( i_desc_size >= (unsigned)i_peek_len )
 310         {
 311             return VLC_EGENERIC;
 312         }
 313
 314         uint64_t i_num_samples;
 315         uint32_t i_this_int;
 316         if( ParseVarLenInteger( p_peek + i_desc_size, i_peek_len - i_desc_size, &i_num_samples, &i_this_int ))
 317         {
 318             return VLC_EGENERIC;
 319         }
 320
 321         i_desc_size += i_this_int;
 322         span->i_samples += i_num_samples;
 323     }
 324     span->i_desc_bytes += i_desc_size;
 325     span->i_frames++;
 326
 327     return VLC_SUCCESS;
 328 }
 329
 330 /* FrameSpanGetTime returns the time span represented by the frame span. */
 331
 332 static inline mtime_t FrameSpanGetTime( frame_span_t *span, uint32_t i_sample_rate )
 333 {
 334     if( !i_sample_rate )
 335         return 0;
 336
 337     return ( span->i_samples * CLOCK_FREQ ) / i_sample_rate + 1;
 338 }
 339
 340 /* SetSpanWithSample returns the span from the beginning of the file up to and
 341  including the specified sample. This works at frame granularity, so the
 342  returned span may not represent the exact target sample.
 343  Since we might have to lineraly search the packet descriptions, this is a
 344  potentially slow operation! */
 345
 346 static int SetSpanWithSample( demux_t *p_demux, frame_span_t *p_span, uint64_t i_target_sample )
 347 {
 348     demux_sys_t *p_sys = p_demux->p_sys;
 349
 350     uint64_t i_num_frames = TotalNumFrames( p_demux );
 351
 352     if( !NeedsPacketTable( p_sys ))
 353     {
 354         uint64_t i_frame = i_target_sample / p_sys->fmt.audio.i_frame_length;
 355         uint64_t i_remaining = i_target_sample - i_frame * p_sys->fmt.audio.i_frame_length;
 356         if( i_remaining > ( p_sys->fmt.audio.i_frame_length / 2 ))
 357             i_frame++;
 358
 359         if( i_frame > i_num_frames )
 360             i_frame = i_num_frames;
 361
 362         p_span->i_frames = i_frame;
 363         p_span->i_samples = i_frame * p_sys->fmt.audio.i_frame_length;
 364         p_span->i_bytes = i_frame * p_sys->fmt.audio.i_bytes_per_frame;
 365         p_span->i_desc_bytes = 0;
 366     }
 367     else
 368     {
 369         *p_span = (frame_span_t){0};
 370         frame_span_t prev_span;
 371
 372         while( p_span->i_samples < i_target_sample && p_span->i_frames < i_num_frames )
 373         {
 374             prev_span = *p_span;
 375
 376             if( FrameSpanAddDescription( p_demux, p_span->i_desc_bytes, p_span ))
 377                 return VLC_EGENERIC;
 378
 379             if( p_span->i_samples >= i_target_sample )
 380             {
 381                 uint64_t i_this_samples = p_span->i_samples - prev_span.i_samples;
 382
 383                 if( i_target_sample - prev_span.i_samples < i_this_samples / 2 )
 384                     *p_span = prev_span;
 385
 386                 break;
 387             }
 388         }
 389     }
 390
 391     return VLC_SUCCESS;
 392 }
 393
 394 /*****************************************************************************
 395  * CAF Parsing Functions
 396  *****************************************************************************/
 397
 398 /* The NextChunk function returns the four char code and the (sanitized) size at the current file position.
 399    Upon return the file position points to the start of the chunk payload.
 400    Note that the ReadXXXChunk functions expect the chunk to size to be sanitized
 401    (i.e. they don't check if it is bigger than INT64_MAX, but note the special case of the 'data' chunk, which can be kCHUNK_SIZE_EOF).
 402  */
 403
 404 static int NextChunk( demux_t *p_demux, vlc_fourcc_t *p_fcc, uint64_t *pi_size )
 405 {
 406     uint8_t p_read[12];
 407
 408     if( vlc_stream_Read( p_demux->s, p_read, 12 ) < 12 )
 409         return VLC_EGENERIC;
 410
 411     *p_fcc = ReadFOURCC( p_read );
 412     uint64_t i_size = GetQWBE( p_read + 4 );
 413
 414     /* We accept no negativ sizes for chunks, except -1 for the data chunk. */
 415
 416     if( i_size > INT64_MAX )
 417     {
 418         if( *p_fcc == VLC_FOURCC( 'd', 'a', 't', 'a' ) && i_size == UINT64_C( -1 ))
 419             i_size = kCHUNK_SIZE_EOF;
 420         else
 421             return VLC_EGENERIC;
 422     }
 423
 424     *pi_size = i_size;
 425
 426     return VLC_SUCCESS;
 427 }
 428
 429 static int ReadDescChunk( demux_t *p_demux )
 430 {
 431     demux_sys_t *p_sys = p_demux->p_sys;
 432
 433     const uint8_t *p_peek;
 434
 435     if ( vlc_stream_Peek( p_demux->s, &p_peek, 8 + 6 * 4 ) < ( 8 + 6 * 4 ))
 436     {
 437         return VLC_EGENERIC;
 438     }
 439
 440     vlc_fourcc_t i_fmt = ReadFOURCC( p_peek + 8 );
 441     uint32_t i_fmt_flags = GetDWBE( p_peek + 12 );
 442
 443     uint32_t i_bits_per_channel = GetDWBE( p_peek + 28 );
 444     uint32_t i_bytes_per_packet = GetDWBE( p_peek + 16 );
 445     uint32_t i_frames_per_packet = GetDWBE( p_peek + 20 );
 446     uint32_t i_channels_per_frame = GetDWBE( p_peek + 24 );
 447
 448     if( i_fmt == VLC_CODEC_DVD_LPCM )
 449     {
 450         if( !i_frames_per_packet || !i_channels_per_frame )
 451         {
 452             msg_Err( p_demux, "Absurd LPCM parameters (frames_per_packet: %u, channels_per_frame: %u).", i_frames_per_packet, i_channels_per_frame );
 453             return VLC_EGENERIC;
 454         }
 455
 456         uint32_t i_unpacked_bits_per_sample = ( i_bytes_per_packet / i_frames_per_packet / i_channels_per_frame ) * 8;
 457
 458         bool b_is_float = !!( i_fmt_flags & ( 1 << 0 ) );
 459         bool b_is_be = !( i_fmt_flags & ( 1 << 1 ) );
 460
 461         vlc_fourcc_t i_basic_codec = 0;
 462
 463         if( !b_is_float )
 464         {
 465             i_basic_codec = b_is_be ? VLC_FOURCC( 't', 'w', 'o', 's' ) : VLC_FOURCC( 's', 'o', 'w', 't' );
 466             es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( i_basic_codec, i_unpacked_bits_per_sample ));
 467         }
 468         else
 469         {
 470             if( i_bits_per_channel == 32 )
 471                 i_basic_codec = b_is_be ? VLC_CODEC_F32B : VLC_CODEC_F32L;
 472             else if( i_bits_per_channel == 64 )
 473                 i_basic_codec = b_is_be ? VLC_CODEC_F64B : VLC_CODEC_F64L;
 474
 475             if( i_basic_codec )
 476                 es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( i_basic_codec, i_bits_per_channel ));
 477         }
 478     }
 479     else if( i_fmt == VLC_FOURCC( 'a', 'a', 'c', ' ' ))
 480     {
 481         const uint32_t kMP4Audio_AAC_LC_ObjectType = 2;
 482
 483         if( i_fmt_flags != kMP4Audio_AAC_LC_ObjectType )
 484         {
 485             msg_Warn( p_demux, "The only documented format flag for aac is 2 (kMP4Audio_AAC_LC_ObjectType), but is %i. Continuing anyways.", i_fmt_flags );
 486         }
 487
 488         es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( VLC_CODEC_MP4A, 0 ));
 489
 490     }
 491     else
 492     {
 493         es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( i_fmt, 0 ));
 494     }
 495
 496     if( !p_sys->fmt.i_codec )
 497     {
 498         msg_Err( p_demux, "could not determine codec" );
 499         return VLC_EGENERIC;
 500     }
 501
 502     double d_rate = round( GetDBLBE( p_peek ));
 503
 504     if( d_rate <= 0 || d_rate > UINT_MAX )
 505         return VLC_EGENERIC;
 506
 507     p_sys->fmt.audio.i_rate = (unsigned int)lround( d_rate );
 508     p_sys->fmt.audio.i_channels = i_channels_per_frame;
 509     p_sys->fmt.audio.i_bytes_per_frame = i_bytes_per_packet; /* "mBytesPerPacket" in Apple parlance */
 510     p_sys->fmt.audio.i_frame_length = i_frames_per_packet; /* "mFramesPerPacket" in Apple parlance */
 511     p_sys->fmt.audio.i_bitspersample = i_bits_per_channel; /* mBitsPerChannel */
 512     p_sys->fmt.audio.i_blockalign = i_bytes_per_packet;
 513     p_sys->fmt.i_bitrate = i_bits_per_channel * p_sys->fmt.audio.i_rate * i_channels_per_frame;
 514
 515     return VLC_SUCCESS;
 516 }
 517
 518 /*  This is lifted from cafdec.c in libavformat (function read_kuki_chunk). Appearantly the
 519     alac library expects the cookie to be of length 36, but current alac files
 520     have a cookie length of 24.
 521  */
 522 static int ProcessALACCookie( demux_t *p_demux, const uint8_t *p, uint64_t i_size )
 523 {
 524     demux_sys_t *p_sys = p_demux->p_sys;
 525
 526     const unsigned int kALAC_NEW_KUKI_SIZE = 24;
 527     const unsigned int kALAC_LIB_REQ_KUKI_SIZE = 36;
 528     int i_extra;
 529
 530     if( i_size == kALAC_NEW_KUKI_SIZE || i_size == kALAC_LIB_REQ_KUKI_SIZE )
 531     {
 532         i_extra = kALAC_LIB_REQ_KUKI_SIZE;
 533     }
 534     else
 535     {
 536         msg_Warn( p_demux, "Unknown alac magic cookie. Passing it on to the decoder as is and hoping for the best." );
 537         i_extra = ( int )i_size;
 538     }
 539
 540     p_sys->fmt.i_extra = i_extra;
 541     p_sys->fmt.p_extra = malloc( i_extra );
 542
 543     if( !p_sys->fmt.p_extra )
 544         return VLC_ENOMEM;
 545
 546     uint8_t *p_extra = ( uint8_t * )p_sys->fmt.p_extra;
 547
 548     if( i_size == kALAC_NEW_KUKI_SIZE )
 549     {
 550         SetDWBE( p_extra, 36 );
 551         memcpy( p_extra + 4, "alac", 4 );
 552         SetDWBE( p_extra + 8, 0 );
 553         memcpy( p_extra + 12, p, 24 );
 554     }
 555     else
 556     {
 557         memcpy( p_sys->fmt.p_extra, p, i_size );
 558     }
 559
 560     return VLC_SUCCESS;
 561 }
 562
 563 /* Helper functions for AAC cookie processing. */
 564
 565 static inline bool AACCookieGetTag( uint8_t *p_tag, const uint8_t *p, uint64_t *p_offset, uint64_t i_size )
 566 {
 567     if( *p_offset + 1 > i_size )
 568         return false;
 569
 570     *p_tag = *( p + *p_offset );
 571     *p_offset += 1;
 572
 573     return true;
 574 }
 575
 576 static inline bool AACCookieTagLen( uint64_t *p_tag_len, const uint8_t *p, uint64_t *p_offset, uint64_t i_size )
 577 {
 578     uint32_t i_int_size;
 579
 580     if( ParseVarLenInteger( p + *p_offset, i_size - *p_offset, p_tag_len, &i_int_size ))
 581         return false;
 582
 583     *p_offset += i_int_size;
 584
 585     return true;
 586 }
 587
 588 static inline bool AACCookieChkLen( int64_t i_length, uint64_t i_size, uint64_t i_offset )
 589 {
 590     return ( i_offset + i_length <= i_size );
 591 }
 592
 593 /*  This is lifted from libmp4.c in the mp4 demuxer module (function MP4_ReadBox_esds). The aac
 594     library only want a subset of the magic cookie ("decoder specific info"), so we have to parse it.
 595  */
 596 static int ProcessAACCookie( demux_t *p_demux, const uint8_t *p, uint64_t i_size )
 597 {
 598     const uint8_t kAAC_ES_DESCR_TAG = 3;
 599     const uint8_t kAAC_DEC_CONFIG_DESCR_TAG = 4;
 600     const uint8_t kAAC_DEC_SPEC_INFO_TAG = 5;
 601
 602     demux_sys_t *p_sys = p_demux->p_sys;
 603
 604     uint64_t i_offset = 0;
 605     uint64_t i_kuki_size = 0;
 606     uint64_t i_tag_len;
 607     uint8_t i_tag;
 608
 609     if( !AACCookieGetTag( &i_tag, p, &i_offset, i_size )) goto aac_kuki_finish;
 610
 611     if( i_tag == kAAC_ES_DESCR_TAG )
 612     {
 613
 614         if( !AACCookieTagLen( &i_tag_len, p, &i_offset, i_size )) goto aac_kuki_finish;
 615
 616         if( !AACCookieChkLen( 3, i_size, i_offset )) goto aac_kuki_finish;
 617         i_offset += 2; /* don't care (ES ID) */
 618         uint8_t i_flags = *( p + i_offset++ );
 619
 620         if( i_flags&0x80 )
 621         {
 622             if( !AACCookieChkLen( 2, i_size, i_offset )) goto aac_kuki_finish;
 623             i_offset += 2; /* don't care (dependance) */
 624         }
 625         if( i_flags&0x40 )
 626         {
 627             if( !AACCookieChkLen( 1, i_size, i_offset )) goto aac_kuki_finish;
 628             uint8_t i_url_len = *( p + i_offset++ );
 629             i_offset += i_url_len; /* don't care (url) */
 630         }
 631         if( i_flags&0x20 )
 632         {
 633             if( !AACCookieChkLen( 2, i_size, i_offset )) goto aac_kuki_finish;
 634             i_offset += 2; /* don't care (OCR) */
 635         }
 636
 637         if( !AACCookieGetTag( &i_tag, p, &i_offset, i_size )) goto aac_kuki_finish;
 638     }
 639
 640     if( i_tag != kAAC_DEC_CONFIG_DESCR_TAG )
 641         goto aac_kuki_finish;
 642
 643     if( !AACCookieTagLen( &i_tag_len, p, &i_offset, i_size )) goto aac_kuki_finish;
 644
 645     if( !AACCookieChkLen( 1 + 1 + 3 + 4 + 4, i_size, i_offset )) goto aac_kuki_finish;
 646     i_offset += ( 1 + 1 + 3 + 4 + 4 ); /* don't care */
 647
 648     if( !AACCookieGetTag( &i_tag, p, &i_offset, i_size )) goto aac_kuki_finish;
 649
 650     if( i_tag != kAAC_DEC_SPEC_INFO_TAG ) /* this is the one we need */
 651         goto aac_kuki_finish;
 652
 653     if( !AACCookieTagLen( &i_tag_len, p, &i_offset, i_size )) goto aac_kuki_finish;
 654
 655     if( i_offset + i_tag_len > i_size )
 656         goto aac_kuki_finish;
 657
 658     i_kuki_size = i_tag_len;
 659
 660 aac_kuki_finish:
 661
 662     if( !i_kuki_size )
 663     {
 664         msg_Warn( p_demux, "Error parsing aac cookie. Passing it on to the decoder as is and hoping for the best." );
 665         i_kuki_size = i_size;
 666         i_offset = 0;
 667     }
 668
 669     p_sys->fmt.i_extra = (int)i_kuki_size;
 670     p_sys->fmt.p_extra = malloc( i_kuki_size );
 671
 672     if( !p_sys->fmt.p_extra )
 673     {
 674         return VLC_ENOMEM;
 675     }
 676
 677     memcpy( p_sys->fmt.p_extra, p + i_offset, i_kuki_size );
 678
 679     return VLC_SUCCESS;
 680 }
 681
 682 static int ReadKukiChunk( demux_t *p_demux, uint64_t i_size )
 683 {
 684     demux_sys_t *p_sys = p_demux->p_sys;
 685     const uint8_t *p_peek;
 686
 687     /* vlc_stream_Peek can't handle sizes bigger than INT32_MAX, and also p_sys->fmt.i_extra is of type 'int'*/
 688     if( i_size > INT32_MAX )
 689     {
 690         msg_Err( p_demux, "Magic Cookie chunk too big" );
 691         return VLC_EGENERIC;
 692     }
 693
 694     if( (unsigned int)vlc_stream_Peek( p_demux->s, &p_peek, (int)i_size ) < i_size )
 695     {
 696         msg_Err( p_demux, "Couldn't peek extra data" );
 697         return VLC_EGENERIC;
 698     }
 699
 700     if( p_sys->fmt.i_codec  == VLC_CODEC_ALAC )
 701     {
 702         int error = ProcessALACCookie( p_demux, p_peek, i_size );
 703         if( error ) return error;
 704     }
 705     else if( p_sys->fmt.i_codec == VLC_CODEC_MP4A )
 706     {
 707         int error = ProcessAACCookie( p_demux, p_peek, i_size );
 708         if( error ) return error;
 709     }
 710     else
 711     {
 712         p_sys->fmt.i_extra = (int)i_size;
 713         p_sys->fmt.p_extra = malloc( i_size );
 714
 715         if( !p_sys->fmt.p_extra )
 716         {
 717             return VLC_ENOMEM;
 718         }
 719         memcpy( p_sys->fmt.p_extra, p_peek, p_sys->fmt.i_extra );
 720     }
 721
 722     return VLC_SUCCESS;
 723 }
 724
 725 static int ReadDataChunk( demux_t *p_demux, uint64_t i_size )
 726 {
 727     if( i_size < 4 )
 728         return VLC_EGENERIC;
 729
 730     demux_sys_t *p_sys = p_demux->p_sys;
 731
 732     p_sys->i_data_offset = vlc_stream_Tell( p_demux->s ) + 4; /* skip edit count */
 733     p_sys->i_data_size = i_size == kCHUNK_SIZE_EOF ? kCHUNK_SIZE_EOF : ( i_size - 4 );
 734
 735     return VLC_SUCCESS;
 736 }
 737
 738 static int ReadPaktChunk( demux_t *p_demux )
 739 {
 740     demux_sys_t *p_sys = p_demux->p_sys;
 741
 742     const uint8_t *p_peek;
 743
 744     if ( vlc_stream_Peek( p_demux->s, &p_peek, 8 + 8 + 4 + 4 ) < ( 8 + 8 + 4 + 4 ))
 745     {
 746         msg_Err( p_demux, "Couldn't peek packet descriptions" );
 747         return VLC_EGENERIC;
 748     }
 749
 750     if( ReadBEInt64ToUInt64( p_peek, &p_sys->packet_table.i_num_packets ))
 751     {
 752         msg_Err( p_demux, "Invalid packet table: i_num_packets is negative.");
 753         return VLC_EGENERIC;
 754     }
 755     if( ReadBEInt64ToUInt64( p_peek + 8, &p_sys->packet_table.i_num_valid_frames ))
 756     {
 757         msg_Err( p_demux, "Invalid packet table: i_num_valid_frames is negative.");
 758         return VLC_EGENERIC;
 759     }
 760     if( ReadBEInt32ToUInt32( p_peek + 16, &p_sys->packet_table.i_num_priming_frames ))
 761     {
 762         msg_Err( p_demux, "Invalid packet table: i_num_priming_frames is negative.");
 763         return VLC_EGENERIC;
 764     }
 765     if( ReadBEInt32ToUInt32( p_peek + 20, &p_sys->packet_table.i_num_remainder_frames ))
 766     {
 767         msg_Err( p_demux, "Invalid packet table: i_num_remainder_frames is negative.");
 768         return VLC_EGENERIC;
 769     }
 770
 771     p_sys->packet_table.i_descriptions_start = vlc_stream_Tell( p_demux->s ) + 24;
 772
 773     return VLC_SUCCESS;
 774 }
 775
 776 /*****************************************************************************
 777  * Open
 778  *****************************************************************************/
 779 static int Open( vlc_object_t *p_this )
 780 {
 781     int i_error = VLC_SUCCESS;
 782
 783     demux_t     *p_demux = (demux_t*)p_this;
 784     demux_sys_t *p_sys;
 785
 786     const uint8_t *p_peek;
 787
 788     if( vlc_stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )
 789         return VLC_EGENERIC;
 790
 791     /* Is it a caf file? */
 792     if( memcmp( p_peek, "caff", 4 ))
 793         return VLC_EGENERIC;
 794
 795     /* check file version (we only handle version 1) */
 796     uint16_t i_version = GetWBE( p_peek + 4 );
 797     if( i_version != 1 )
 798     {
 799         msg_Dbg( p_demux, "Unknown caf file version %d.", i_version );
 800         return VLC_EGENERIC;
 801     }
 802
 803     /* check file flags (must be 0) */
 804     uint16_t i_flags = GetWBE( p_peek + 6 );
 805     if( i_flags != 0 )
 806     {
 807         msg_Dbg( p_demux, "Unknown caf file flags %d.", i_flags );
 808         return VLC_EGENERIC;
 809     }
 810
 811     if( vlc_stream_Read( p_demux->s, NULL, 8 ) < 8 )
 812         return VLC_EGENERIC; /* This would be very strange since we justed peeked at these bytes. */
 813
 814     p_demux->p_sys = calloc( 1, sizeof( demux_sys_t ));
 815     if( !p_demux->p_sys ) return VLC_ENOMEM;
 816
 817     /* From this point on, we have to free p_sys if we return an error (e.g. "goto caf_open_end") */
 818
 819     p_sys = p_demux->p_sys;
 820     es_format_Init( &p_sys->fmt, AUDIO_ES, 0 );
 821
 822     vlc_fourcc_t i_fcc;
 823     uint64_t i_size;
 824     uint64_t i_idx = 0;
 825
 826     while( NextChunk( p_demux, &i_fcc, &i_size ) == VLC_SUCCESS )
 827     {
 828         bool b_handled = true;
 829
 830         switch ( i_fcc )
 831         {
 832             case VLC_FOURCC( 'd', 'e', 's', 'c' ):
 833
 834                 if( i_idx != 0 )
 835                 {
 836                     msg_Err( p_demux, "The audio description chunk must be the first chunk in a caf file." );
 837                     i_error = VLC_EGENERIC;
 838                     goto caf_open_end;
 839                 }
 840
 841                 i_error = ReadDescChunk( p_demux );
 842                 break;
 843
 844             case VLC_FOURCC( 'd', 'a', 't', 'a' ):
 845
 846                 i_error = ReadDataChunk( p_demux, i_size );
 847                 break;
 848
 849             case VLC_FOURCC( 'p', 'a', 'k', 't' ):
 850
 851                 i_error = ReadPaktChunk( p_demux );
 852                 break;
 853
 854             case VLC_FOURCC( 'k', 'u', 'k', 'i' ):
 855
 856                 i_error = ReadKukiChunk( p_demux, i_size );
 857                 break;
 858
 859             default:
 860
 861                 b_handled = false;
 862                 break;
 863         }
 864
 865         if( i_error )
 866             goto caf_open_end;
 867
 868         if( b_handled )
 869             msg_Dbg( p_demux, "Found '%4.4s' chunk.", ( char * )&i_fcc );
 870         else
 871             msg_Dbg( p_demux, "Ignoring '%4.4s' chunk.", ( char * )&i_fcc );
 872
 873         if( i_size == kCHUNK_SIZE_EOF )
 874             break;
 875
 876         if( vlc_stream_Seek( p_demux->s, vlc_stream_Tell( p_demux->s ) + i_size ) != VLC_SUCCESS )
 877             break;
 878
 879         i_idx++;
 880     }
 881
 882     if ( !p_sys->i_data_offset || p_sys->fmt.i_cat != AUDIO_ES ||
 883         ( NeedsPacketTable( p_sys ) && !p_sys->packet_table.i_descriptions_start ))
 884     {
 885         msg_Err( p_demux, "Did not find all necessary chunks." );
 886         i_error = VLC_EGENERIC;
 887         goto caf_open_end;
 888     }
 889
 890     p_sys->es = es_out_Add( p_demux->out, &p_sys->fmt );
 891
 892     if( !p_sys->es )
 893     {
 894         msg_Err( p_demux, "Could not add elementary stream." );
 895         i_error = VLC_EGENERIC;
 896         goto caf_open_end;
 897     }
 898
 899 caf_open_end:
 900
 901     if( i_error )
 902     {
 903         free( p_sys->fmt.p_extra );
 904         free( p_sys  );
 905
 906         if( vlc_stream_Seek( p_demux->s, 0 ))
 907         {
 908             msg_Warn(p_demux, "Could not reset stream position to 0.");
 909         }
 910     }
 911     else
 912     {
 913         p_demux->pf_control = Control;
 914         p_demux->pf_demux = Demux;
 915     }
 916
 917     return i_error;
 918 }
 919
 920 /*****************************************************************************
 921  * Demux:
 922  *****************************************************************************/
 923 static int Demux( demux_t *p_demux )
 924 {
 925     demux_sys_t *p_sys = p_demux->p_sys;
 926     block_t     *p_block;
 927
 928     if( p_sys->i_data_size != kCHUNK_SIZE_EOF && p_sys->position.i_bytes >= p_sys->i_data_size )
 929     {
 930         /* EOF */
 931         return 0;
 932     }
 933
 934     frame_span_t advance = (frame_span_t){0};
 935
 936     /* we will read 50ms at once */
 937     uint64_t i_req_samples = __MAX( p_sys->fmt.audio.i_rate / 20, 1 );
 938
 939     if( !NeedsPacketTable( p_sys )) /* PCM/IMA4 */
 940     {
 941         int64_t i_req_frames = ( i_req_samples + ( p_sys->fmt.audio.i_frame_length - 1 )) / p_sys->fmt.audio.i_frame_length;
 942
 943         if( p_sys->i_data_size != kCHUNK_SIZE_EOF && ( p_sys->position.i_bytes + i_req_frames * p_sys->fmt.audio.i_bytes_per_frame ) > p_sys->i_data_size )
 944         {
 945             i_req_frames = ( p_sys->i_data_size - p_sys->position.i_frames * p_sys->fmt.audio.i_bytes_per_frame ) / p_sys->fmt.audio.i_bytes_per_frame;
 946         }
 947
 948         advance.i_frames = i_req_frames;
 949         advance.i_samples = i_req_frames * p_sys->fmt.audio.i_frame_length;
 950         advance.i_bytes = p_sys->fmt.audio.i_bytes_per_frame * advance.i_frames;
 951     }
 952     else /* use packet table */
 953     {
 954         do
 955         {
 956             if( FrameSpanAddDescription( p_demux, p_sys->position.i_desc_bytes + advance.i_desc_bytes, &advance ))
 957                 break;
 958         }
 959         while (( i_req_samples > advance.i_samples ) && ( p_sys->position.i_frames + advance.i_frames ) < p_sys->packet_table.i_num_packets );
 960     }
 961
 962     if( !advance.i_frames )
 963     {
 964         msg_Err( p_demux, "Unexpected end of file" );
 965         return -1;
 966     }
 967
 968     if( vlc_stream_Seek( p_demux->s, p_sys->i_data_offset + p_sys->position.i_bytes ))
 969     {
 970         if( p_sys->i_data_size == kCHUNK_SIZE_EOF)
 971             return 0;
 972
 973         msg_Err( p_demux, "cannot seek data" );
 974         return -1;
 975     }
 976
 977     p_block = vlc_stream_Block( p_demux->s, (int)advance.i_bytes );
 978     if( p_block == NULL )
 979     {
 980         msg_Err( p_demux, "cannot read data" );
 981         return -1;
 982     }
 983
 984     p_block->i_dts =
 985     p_block->i_pts = VLC_TS_0 + FrameSpanGetTime( &p_sys->position, p_sys->fmt.audio.i_rate );
 986
 987     FrameSpanAddSpan( &p_sys->position, &advance );
 988
 989     /* set PCR */
 990     es_out_SetPCR( p_demux->out, p_block->i_pts );
 991
 992     es_out_Send( p_demux->out, p_sys->es, p_block );
 993
 994     return 1;
 995 }
 996
 997 /*****************************************************************************
 998  * Control:
 999  *****************************************************************************/
1000 static int Control( demux_t *p_demux, int i_query, va_list args )
1001 {
1002     int64_t i64, *pi64, i_sample;
1003     double f, *pf;
1004     frame_span_t position;
1005
1006     demux_sys_t *p_sys  = p_demux->p_sys;
1007     uint64_t i_num_samples = TotalNumSamples( p_demux );
1008
1009     switch( i_query )
1010     {
1011         case DEMUX_CAN_SEEK:
1012             *va_arg( args, bool * ) = true;
1013             return VLC_SUCCESS;
1014
1015         case DEMUX_GET_LENGTH:
1016             pi64 = va_arg( args, int64_t * );
1017             *pi64 = CLOCK_FREQ * ( i_num_samples / p_sys->fmt.audio.i_rate );
1018             return VLC_SUCCESS;
1019
1020         case DEMUX_GET_TIME:
1021             pi64 = va_arg( args, int64_t * );
1022             *pi64 = CLOCK_FREQ * ( p_sys->position.i_samples / p_sys->fmt.audio.i_rate );
1023             return VLC_SUCCESS;
1024
1025         case DEMUX_GET_POSITION:
1026             pf = va_arg( args, double * );
1027             *pf = i_num_samples ? (double)p_sys->position.i_samples / (double)i_num_samples : 0.0;
1028             return VLC_SUCCESS;
1029
1030         case DEMUX_SET_POSITION:
1031             f = va_arg( args, double );
1032             i_sample = f * i_num_samples;
1033             if( SetSpanWithSample( p_demux, &position, i_sample ))
1034                 return VLC_EGENERIC;
1035             p_sys->position = position;
1036             return VLC_SUCCESS;
1037
1038         case DEMUX_SET_TIME:
1039             i64 = va_arg( args, int64_t );
1040             i_sample = i64 * p_sys->fmt.audio.i_rate / INT64_C( 1000000 );
1041             if( SetSpanWithSample( p_demux, &position, i_sample ))
1042                 return VLC_EGENERIC;
1043             p_sys->position = position;
1044             return VLC_SUCCESS;
1045
1046         case DEMUX_GET_META:
1047             return vlc_stream_Control( p_demux->s, STREAM_GET_META, args );
1048
1049         default:
1050             return VLC_EGENERIC;
1051     }
1052
1053     return VLC_EGENERIC;
1054 }
1055
1056 /*****************************************************************************
1057  * Close
1058  *****************************************************************************/
1059 static void Close( vlc_object_t *p_this )
1060 {
1061     demux_t     *p_demux = (demux_t*)p_this;
1062     demux_sys_t *p_sys = p_demux->p_sys;
1063
1064     es_out_Del( p_demux->out, p_sys->es );
1065
1066     free( p_sys->fmt.p_extra );
1067     free( p_sys );
1068 }