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