1 /*****************************************************************************
2 * caf.c: Core Audio File Format demuxer
3 *****************************************************************************
4 * Copyright (C) 2013 VLC authors and VideoLAN
7 * Authors: Matthias Keiser <matthias@tristan-inc.com>
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.
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.
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 *****************************************************************************/
24 /*****************************************************************************
26 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_demux.h>
36 #include <vlc_codecs.h>
40 * - handle channel layout
41 * - 64 bit float LPCM is broken (sound has artifacts with little endian, only silence plays for big endian).
44 /*****************************************************************************
46 *****************************************************************************/
47 static int Open ( vlc_object_t * );
48 static void Close ( vlc_object_t * );
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 )
59 /*****************************************************************************
61 *****************************************************************************/
62 static int Demux ( demux_t * );
63 static int Control( demux_t *, int i_query, va_list args );
65 typedef struct frame_span_t
70 uint64_t i_desc_bytes;
73 typedef struct packet_table_t
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;
87 uint64_t i_data_offset;
90 frame_span_t position;
91 packet_table_t packet_table;
95 We use this value to indicate that the data section extends until the end of the file.
97 static const uint64_t kCHUNK_SIZE_EOF = UINT64_C( 0xffffffffffffffff );
99 /*****************************************************************************
100 * Various Utility Functions
101 *****************************************************************************/
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... */
107 static int ParseVarLenInteger( const uint8_t *p_buff, size_t i_buff_len, uint64_t *pi_value_out, uint32_t *i_len_out )
111 uint64_t i_value = 0;
112 bool finished = false;
114 for( uint32_t i = 0; i < i_buff_len; i++ )
116 if( (( i_value >> 32 ) << 7 ) > UINT32_MAX )
118 return VLC_EGENERIC; /* overflow */
120 uint8_t i_byte = p_buff[i];
121 i_value = ( i_value << 7 ) | ( i_byte & 0x7f );
125 if( !( i_byte & 0x80 ))
137 *pi_value_out = i_value;
142 /* Utility function that reads a big endian double from the input buffer. */
144 static inline double GetDBLBE( const uint8_t *p )
152 u_64.uint64 = GetQWBE( p );
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.
160 static inline int ReadBEInt32ToUInt32( const uint8_t *p, uint32_t *i_out )
162 uint32_t i_value = GetDWBE( p );
164 if( i_value > INT32_MAX ) return VLC_EGENERIC;
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.
174 static inline int ReadBEInt64ToUInt64( const uint8_t *p, uint64_t *i_out )
176 uint64_t i_value = GetQWBE( p );
178 if( i_value > INT64_MAX ) return VLC_EGENERIC;
184 static inline bool NeedsPacketTable( demux_sys_t *p_sys )
186 return ( !p_sys->fmt.audio.i_bytes_per_frame || !p_sys->fmt.audio.i_frame_length );
189 static uint64_t TotalNumFrames( demux_t *p_demux )
191 demux_sys_t *p_sys = p_demux->p_sys;
193 if( !NeedsPacketTable( p_sys ))
195 uint64_t i_data_size;
197 if( p_sys->i_data_size != kCHUNK_SIZE_EOF)
199 i_data_size = p_sys->i_data_size;
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;
210 return i_data_size / p_sys->fmt.audio.i_bytes_per_frame;
214 return p_sys->packet_table.i_num_packets;
218 static uint64_t TotalNumSamples( demux_t *p_demux )
220 demux_sys_t *p_sys = p_demux->p_sys;
222 if( !NeedsPacketTable( p_sys ))
224 return TotalNumFrames( p_demux ) * p_sys->fmt.audio.i_frame_length;
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;
233 static inline vlc_fourcc_t ReadFOURCC( const uint8_t *p )
235 return VLC_FOURCC( p[0], p[1], p[2], p[3] );
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 *****************************************************************************/
246 /* FrameSpanAddSpan adds span2 to span1 */
248 static inline void FrameSpanAddSpan( frame_span_t *span1, frame_span_t *span2 )
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;
256 /* Adds the frame that is described at i_desc_offset to span */
258 static int FrameSpanAddDescription( demux_t *p_demux, uint64_t i_desc_offset, frame_span_t *span )
260 demux_sys_t *p_sys = p_demux->p_sys;
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 )
265 span->i_bytes += p_sys->fmt.audio.i_bytes_per_frame;
266 span->i_samples += p_sys->fmt.audio.i_frame_length;
271 uint32_t i_desc_size = 0;
273 if( stream_Seek( p_demux->s, p_sys->packet_table.i_descriptions_start + i_desc_offset ))
275 msg_Err( p_demux, "Couldn't seek packet description." );
279 const uint8_t *p_peek;
280 uint32_t i_peek_len = stream_Peek( p_demux->s, &p_peek, 2 * 10 ); /* Peeking the maximum number of bytes that two 64 bit numbers could use (( 64 + 6 ) / 7 = 10 ). */
282 if( p_sys->fmt.audio.i_bytes_per_frame )
284 span->i_bytes += p_sys->fmt.audio.i_bytes_per_frame;
290 if( ParseVarLenInteger( p_peek, i_peek_len, &i_size, &i_this_int ))
295 i_desc_size += i_this_int;
296 span->i_bytes += i_size;
299 if( p_sys->fmt.audio.i_frame_length )
301 span->i_samples += p_sys->fmt.audio.i_frame_length;
305 if( i_desc_size >= i_peek_len )
310 uint64_t i_num_samples;
312 if( ParseVarLenInteger( p_peek + i_desc_size, i_peek_len - i_desc_size, &i_num_samples, &i_this_int ))
317 i_desc_size += i_this_int;
318 span->i_samples += i_num_samples;
320 span->i_desc_bytes += i_desc_size;
326 /* FrameSpanGetTime returns the time span represented by the frame span. */
328 static inline mtime_t FrameSpanGetTime( frame_span_t *span, uint32_t i_sample_rate )
333 return ( span->i_samples * CLOCK_FREQ ) / i_sample_rate + 1;
336 /* SetSpanWithSample returns the span from the beginning of the file up to and
337 including the specified sample. This works at frame granularity, so the
338 returned span may not represent the exact target sample.
339 Since we might have to lineraly search the packet descriptions, this is a
340 potentially slow operation! */
342 static int SetSpanWithSample( demux_t *p_demux, frame_span_t *p_span, uint64_t i_target_sample )
344 demux_sys_t *p_sys = p_demux->p_sys;
346 uint64_t i_num_frames = TotalNumFrames( p_demux );
348 if( !NeedsPacketTable( p_sys ))
350 uint64_t i_frame = i_target_sample / p_sys->fmt.audio.i_frame_length;
351 uint64_t i_remaining = i_target_sample - i_frame * p_sys->fmt.audio.i_frame_length;
352 if( i_remaining > ( p_sys->fmt.audio.i_frame_length / 2 ))
355 if( i_frame > i_num_frames )
356 i_frame = i_num_frames;
358 p_span->i_frames = i_frame;
359 p_span->i_samples = i_frame * p_sys->fmt.audio.i_frame_length;
360 p_span->i_bytes = i_frame * p_sys->fmt.audio.i_bytes_per_frame;
361 p_span->i_desc_bytes = 0;
365 *p_span = (frame_span_t){0};
366 frame_span_t prev_span;
368 while( p_span->i_samples < i_target_sample && p_span->i_frames < i_num_frames )
372 if( FrameSpanAddDescription( p_demux, p_span->i_desc_bytes, p_span ))
375 if( p_span->i_samples >= i_target_sample )
377 uint64_t i_this_samples = p_span->i_samples - prev_span.i_samples;
379 if( i_target_sample - prev_span.i_samples < i_this_samples / 2 )
390 /*****************************************************************************
391 * CAF Parsing Functions
392 *****************************************************************************/
394 /* The NextChunk function returns the four char code and the (sanitized) size at the current file position.
395 Upon return the file position points to the start of the chunk payload.
396 Note that the ReadXXXChunk functions expect the chunk to size to be sanitized
397 (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).
400 static int NextChunk( demux_t *p_demux, vlc_fourcc_t *p_fcc, uint64_t *pi_size )
404 if( stream_Read( p_demux->s, p_read, 12 ) < 12 )
407 *p_fcc = ReadFOURCC( p_read );
408 uint64_t i_size = GetQWBE( p_read + 4 );
410 /* We accept no negativ sizes for chunks, except -1 for the data chunk. */
412 if( i_size > INT64_MAX )
414 if( *p_fcc == VLC_FOURCC( 'd', 'a', 't', 'a' ) && i_size == UINT64_C( -1 ))
415 i_size = kCHUNK_SIZE_EOF;
425 static int ReadDescChunk( demux_t *p_demux )
427 demux_sys_t *p_sys = p_demux->p_sys;
429 const uint8_t *p_peek;
431 if ( stream_Peek( p_demux->s, &p_peek, 8 + 6 * 4 ) < ( 8 + 6 * 4 ))
436 vlc_fourcc_t i_fmt = ReadFOURCC( p_peek + 8 );
437 uint32_t i_fmt_flags = GetDWBE( p_peek + 12 );
439 uint32_t i_bits_per_channel = GetDWBE( p_peek + 28 );
440 uint32_t i_bytes_per_packet = GetDWBE( p_peek + 16 );
441 uint32_t i_frames_per_packet = GetDWBE( p_peek + 20 );
442 uint32_t i_channels_per_frame = GetDWBE( p_peek + 24 );
444 if( i_fmt == VLC_CODEC_DVD_LPCM )
446 if( !i_frames_per_packet || !i_channels_per_frame )
448 msg_Err( p_demux, "Absurd LPCM parameters (frames_per_packet: %u, channels_per_frame: %u).", i_frames_per_packet, i_channels_per_frame );
452 uint32_t i_unpacked_bits_per_sample = ( i_bytes_per_packet / i_frames_per_packet / i_channels_per_frame ) * 8;
454 bool b_is_float = !!( i_fmt_flags & ( 1 << 0 ) );
455 bool b_is_be = !( i_fmt_flags & ( 1 << 1 ) );
457 vlc_fourcc_t i_basic_codec = 0;
461 i_basic_codec = b_is_be ? VLC_FOURCC( 't', 'w', 'o', 's' ) : VLC_FOURCC( 's', 'o', 'w', 't' );
462 es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( i_basic_codec, i_unpacked_bits_per_sample ));
466 if( i_bits_per_channel == 32 )
467 i_basic_codec = b_is_be ? VLC_CODEC_F32B : VLC_CODEC_F32L;
468 else if( i_bits_per_channel == 64 )
469 i_basic_codec = b_is_be ? VLC_CODEC_F64B : VLC_CODEC_F64L;
472 es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( i_basic_codec, i_bits_per_channel ));
475 else if( i_fmt == VLC_FOURCC( 'a', 'a', 'c', ' ' ))
477 const uint32_t kMP4Audio_AAC_LC_ObjectType = 2;
479 if( i_fmt_flags != kMP4Audio_AAC_LC_ObjectType )
481 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 );
484 es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( VLC_CODEC_MP4A, 0 ));
489 es_format_Init( &p_sys->fmt, AUDIO_ES, vlc_fourcc_GetCodecAudio( i_fmt, 0 ));
492 if( !p_sys->fmt.i_codec )
494 msg_Err( p_demux, "could not determine codec" );
498 double d_rate = round( GetDBLBE( p_peek ));
500 if( d_rate <= 0 || d_rate > UINT_MAX )
503 p_sys->fmt.audio.i_rate = (unsigned int)lround( d_rate );
504 p_sys->fmt.audio.i_channels = i_channels_per_frame;
505 p_sys->fmt.audio.i_bytes_per_frame = i_bytes_per_packet; /* "mBytesPerPacket" in Apple parlance */
506 p_sys->fmt.audio.i_frame_length = i_frames_per_packet; /* "mFramesPerPacket" in Apple parlance */
507 p_sys->fmt.audio.i_bitspersample = i_bits_per_channel; /* mBitsPerChannel */
508 p_sys->fmt.audio.i_blockalign = i_bytes_per_packet;
509 p_sys->fmt.i_bitrate = i_bits_per_channel * p_sys->fmt.audio.i_rate * i_channels_per_frame;
514 /* This is lifted from cafdec.c in libavformat (function read_kuki_chunk). Appearantly the
515 alac library expects the cookie to be of length 36, but current alac files
516 have a cookie length of 24.
518 static int ProcessALACCookie( demux_t *p_demux, const uint8_t *p, uint64_t i_size )
520 demux_sys_t *p_sys = p_demux->p_sys;
522 const unsigned int kALAC_NEW_KUKI_SIZE = 24;
523 const unsigned int kALAC_LIB_REQ_KUKI_SIZE = 36;
526 if( i_size == kALAC_NEW_KUKI_SIZE || i_size == kALAC_LIB_REQ_KUKI_SIZE )
528 i_extra = kALAC_LIB_REQ_KUKI_SIZE;
532 msg_Warn( p_demux, "Unknown alac magic cookie. Passing it on to the decoder as is and hoping for the best." );
533 i_extra = ( int )i_size;
536 p_sys->fmt.i_extra = i_extra;
537 p_sys->fmt.p_extra = malloc( i_extra );
539 if( !p_sys->fmt.p_extra )
542 uint8_t *p_extra = ( uint8_t * )p_sys->fmt.p_extra;
544 if( i_size == kALAC_NEW_KUKI_SIZE )
546 SetDWBE( p_extra, 36 );
547 memcpy( p_extra + 4, "alac", 4 );
548 SetDWBE( p_extra + 8, 0 );
549 memcpy( p_extra + 12, p, 24 );
553 memcpy( p_sys->fmt.p_extra, p, i_size );
559 /* Helper functions for AAC cookie processing. */
561 static inline bool AACCookieGetTag( uint8_t *p_tag, const uint8_t *p, uint64_t *p_offset, uint64_t i_size )
563 if( *p_offset + 1 > i_size )
566 *p_tag = *( p + *p_offset );
572 static inline bool AACCookieTagLen( uint64_t *p_tag_len, const uint8_t *p, uint64_t *p_offset, uint64_t i_size )
576 if( ParseVarLenInteger( p + *p_offset, i_size - *p_offset, p_tag_len, &i_int_size ))
579 *p_offset += i_int_size;
584 static inline bool AACCookieChkLen( int64_t i_length, uint64_t i_size, uint64_t i_offset )
586 return ( i_offset + i_length <= i_size );
589 /* This is lifted from libmp4.c in the mp4 demuxer module (function MP4_ReadBox_esds). The aac
590 library only want a subset of the magic cookie ("decoder specific info"), so we have to parse it.
592 static int ProcessAACCookie( demux_t *p_demux, const uint8_t *p, uint64_t i_size )
594 const uint8_t kAAC_ES_DESCR_TAG = 3;
595 const uint8_t kAAC_DEC_CONFIG_DESCR_TAG = 4;
596 const uint8_t kAAC_DEC_SPEC_INFO_TAG = 5;
598 demux_sys_t *p_sys = p_demux->p_sys;
600 uint64_t i_offset = 0;
601 uint64_t i_kuki_size = 0;
605 if( !AACCookieGetTag( &i_tag, p, &i_offset, i_size )) goto aac_kuki_finish;
607 if( i_tag == kAAC_ES_DESCR_TAG )
610 if( !AACCookieTagLen( &i_tag_len, p, &i_offset, i_size )) goto aac_kuki_finish;
612 if( !AACCookieChkLen( 3, i_size, i_offset )) goto aac_kuki_finish;
613 i_offset += 2; /* don't care (ES ID) */
614 uint8_t i_flags = *( p + i_offset++ );
618 if( !AACCookieChkLen( 2, i_size, i_offset )) goto aac_kuki_finish;
619 i_offset += 2; /* don't care (dependance) */
623 if( !AACCookieChkLen( 1, i_size, i_offset )) goto aac_kuki_finish;
624 uint8_t i_url_len = *( p + i_offset++ );
625 i_offset += i_url_len; /* don't care (url) */
629 if( !AACCookieChkLen( 2, i_size, i_offset )) goto aac_kuki_finish;
630 i_offset += 2; /* don't care (OCR) */
633 if( !AACCookieGetTag( &i_tag, p, &i_offset, i_size )) goto aac_kuki_finish;
636 if( i_tag != kAAC_DEC_CONFIG_DESCR_TAG )
637 goto aac_kuki_finish;
639 if( !AACCookieTagLen( &i_tag_len, p, &i_offset, i_size )) goto aac_kuki_finish;
641 if( !AACCookieChkLen( 1 + 1 + 3 + 4 + 4, i_size, i_offset )) goto aac_kuki_finish;
642 i_offset += ( 1 + 1 + 3 + 4 + 4 ); /* don't care */
644 if( !AACCookieGetTag( &i_tag, p, &i_offset, i_size )) goto aac_kuki_finish;
646 if( i_tag != kAAC_DEC_SPEC_INFO_TAG ) /* this is the one we need */
647 goto aac_kuki_finish;
649 if( !AACCookieTagLen( &i_tag_len, p, &i_offset, i_size )) goto aac_kuki_finish;
651 if( i_offset + i_tag_len > i_size )
652 goto aac_kuki_finish;
654 i_kuki_size = i_tag_len;
660 msg_Warn( p_demux, "Error parsing aac cookie. Passing it on to the decoder as is and hoping for the best." );
661 i_kuki_size = i_size;
665 p_sys->fmt.i_extra = (int)i_kuki_size;
666 p_sys->fmt.p_extra = malloc( i_kuki_size );
668 if( !p_sys->fmt.p_extra )
673 memcpy( p_sys->fmt.p_extra, p + i_offset, i_kuki_size );
678 static int ReadKukiChunk( demux_t *p_demux, uint64_t i_size )
680 demux_sys_t *p_sys = p_demux->p_sys;
681 const uint8_t *p_peek;
683 /* stream_Peek can't handle sizes bigger than INT32_MAX, and also p_sys->fmt.i_extra is of type 'int'*/
684 if( i_size > INT32_MAX )
686 msg_Err( p_demux, "Magic Cookie chunk too big" );
690 if( (unsigned int)stream_Peek( p_demux->s, &p_peek, (int)i_size ) < i_size )
692 msg_Err( p_demux, "Couldn't peek extra data" );
696 if( p_sys->fmt.i_codec == VLC_CODEC_ALAC )
698 int error = ProcessALACCookie( p_demux, p_peek, i_size );
699 if( error ) return error;
701 else if( p_sys->fmt.i_codec == VLC_CODEC_MP4A )
703 int error = ProcessAACCookie( p_demux, p_peek, i_size );
704 if( error ) return error;
708 p_sys->fmt.i_extra = (int)i_size;
709 p_sys->fmt.p_extra = malloc( i_size );
711 if( !p_sys->fmt.p_extra )
715 memcpy( p_sys->fmt.p_extra, p_peek, p_sys->fmt.i_extra );
721 static int ReadDataChunk( demux_t *p_demux, uint64_t i_size )
726 demux_sys_t *p_sys = p_demux->p_sys;
728 p_sys->i_data_offset = stream_Tell( p_demux->s ) + 4; /* skip edit count */
729 p_sys->i_data_size = i_size == kCHUNK_SIZE_EOF ? kCHUNK_SIZE_EOF : ( i_size - 4 );
734 static int ReadPaktChunk( demux_t *p_demux )
736 demux_sys_t *p_sys = p_demux->p_sys;
738 const uint8_t *p_peek;
740 if ( stream_Peek( p_demux->s, &p_peek, 8 + 8 + 4 + 4 ) < ( 8 + 8 + 4 + 4 ))
742 msg_Err( p_demux, "Couldn't peek packet descriptions" );
746 if( ReadBEInt64ToUInt64( p_peek, &p_sys->packet_table.i_num_packets ))
748 msg_Err( p_demux, "Invalid packet table: i_num_packets is negative.");
751 if( ReadBEInt64ToUInt64( p_peek + 8, &p_sys->packet_table.i_num_valid_frames ))
753 msg_Err( p_demux, "Invalid packet table: i_num_valid_frames is negative.");
756 if( ReadBEInt32ToUInt32( p_peek + 16, &p_sys->packet_table.i_num_priming_frames ))
758 msg_Err( p_demux, "Invalid packet table: i_num_priming_frames is negative.");
761 if( ReadBEInt32ToUInt32( p_peek + 20, &p_sys->packet_table.i_num_remainder_frames ))
763 msg_Err( p_demux, "Invalid packet table: i_num_remainder_frames is negative.");
767 p_sys->packet_table.i_descriptions_start = stream_Tell( p_demux->s ) + 24;
772 /*****************************************************************************
774 *****************************************************************************/
775 static int Open( vlc_object_t *p_this )
777 int i_error = VLC_SUCCESS;
779 demux_t *p_demux = (demux_t*)p_this;
782 const uint8_t *p_peek;
784 if( stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )
787 /* Is it a caf file? */
788 if( memcmp( p_peek, "caff", 4 ))
791 /* check file version (we only handle version 1) */
792 uint16_t i_version = GetWBE( p_peek + 4 );
795 msg_Dbg( p_demux, "Unknown caf file version %d.", i_version );
799 /* check file flags (must be 0) */
800 uint16_t i_flags = GetWBE( p_peek + 6 );
803 msg_Dbg( p_demux, "Unknown caf file flags %d.", i_flags );
807 if( stream_Read( p_demux->s, NULL, 8 ) < 8 )
808 return VLC_EGENERIC; /* This would be very strange since we justed peeked at these bytes. */
810 p_demux->p_sys = calloc( 1, sizeof( demux_sys_t ));
811 if( !p_demux->p_sys ) return VLC_ENOMEM;
813 /* From this point on, we have to free p_sys if we return an error (e.g. "goto caf_open_end") */
815 p_sys = p_demux->p_sys;
816 es_format_Init( &p_sys->fmt, UNKNOWN_ES, 0 );
822 while( NextChunk( p_demux, &i_fcc, &i_size ) == VLC_SUCCESS )
824 bool b_handled = true;
828 case VLC_FOURCC( 'd', 'e', 's', 'c' ):
832 msg_Err( p_demux, "The audio description chunk must be the first chunk in a caf file." );
833 i_error = VLC_EGENERIC;
837 i_error = ReadDescChunk( p_demux );
840 case VLC_FOURCC( 'd', 'a', 't', 'a' ):
842 i_error = ReadDataChunk( p_demux, i_size );
845 case VLC_FOURCC( 'p', 'a', 'k', 't' ):
847 i_error = ReadPaktChunk( p_demux );
850 case VLC_FOURCC( 'k', 'u', 'k', 'i' ):
852 i_error = ReadKukiChunk( p_demux, i_size );
865 msg_Dbg( p_demux, "Found '%4.4s' chunk.", ( char * )&i_fcc );
867 msg_Dbg( p_demux, "Ignoring '%4.4s' chunk.", ( char * )&i_fcc );
869 if( i_size == kCHUNK_SIZE_EOF )
872 if( stream_Seek( p_demux->s, stream_Tell( p_demux->s ) + i_size ) != VLC_SUCCESS )
878 if ( !p_sys->i_data_offset || p_sys->fmt.i_cat != AUDIO_ES ||
879 ( NeedsPacketTable( p_sys ) && !p_sys->packet_table.i_descriptions_start ))
881 msg_Err( p_demux, "Did not find all necessary chunks." );
882 i_error = VLC_EGENERIC;
886 p_sys->es = es_out_Add( p_demux->out, &p_sys->fmt );
890 msg_Err( p_demux, "Could not add elementary stream." );
891 i_error = VLC_EGENERIC;
899 free( p_sys->fmt.p_extra );
902 if( stream_Seek( p_demux->s, 0 ))
904 msg_Warn(p_demux, "Could not reset stream position to 0.");
909 p_demux->pf_control = Control;
910 p_demux->pf_demux = Demux;
916 /*****************************************************************************
918 *****************************************************************************/
919 static int Demux( demux_t *p_demux )
921 demux_sys_t *p_sys = p_demux->p_sys;
924 if( p_sys->i_data_size != kCHUNK_SIZE_EOF && p_sys->position.i_bytes >= p_sys->i_data_size )
930 frame_span_t advance = (frame_span_t){0};
932 /* we will read 50ms at once */
933 uint64_t i_req_samples = __MAX( p_sys->fmt.audio.i_rate / 20, 1 );
935 if( !NeedsPacketTable( p_sys )) /* PCM/IMA4 */
937 int64_t i_req_frames = ( i_req_samples + ( p_sys->fmt.audio.i_frame_length - 1 )) / p_sys->fmt.audio.i_frame_length;
939 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 )
941 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;
944 advance.i_frames = i_req_frames;
945 advance.i_samples = i_req_frames * p_sys->fmt.audio.i_frame_length;
946 advance.i_bytes = p_sys->fmt.audio.i_bytes_per_frame * advance.i_frames;
948 else /* use packet table */
952 if( FrameSpanAddDescription( p_demux, p_sys->position.i_desc_bytes + advance.i_desc_bytes, &advance ))
955 while (( i_req_samples > advance.i_samples ) && ( p_sys->position.i_frames + advance.i_frames ) < p_sys->packet_table.i_num_packets );
958 if( !advance.i_frames )
960 msg_Err( p_demux, "Unexpected end of file" );
964 if( stream_Seek( p_demux->s, p_sys->i_data_offset + p_sys->position.i_bytes ))
966 if( p_sys->i_data_size == kCHUNK_SIZE_EOF)
969 msg_Err( p_demux, "cannot seek data" );
973 if(( p_block = stream_Block( p_demux->s, (int)advance.i_bytes )) == NULL )
975 msg_Err( p_demux, "cannot read data" );
980 p_block->i_pts = VLC_TS_0 + FrameSpanGetTime( &p_sys->position, p_sys->fmt.audio.i_rate );
982 FrameSpanAddSpan( &p_sys->position, &advance );
985 es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts );
987 es_out_Send( p_demux->out, p_sys->es, p_block );
992 /*****************************************************************************
994 *****************************************************************************/
995 static int Control( demux_t *p_demux, int i_query, va_list args )
997 int64_t i64, *pi64, i_sample;
999 frame_span_t position;
1001 demux_sys_t *p_sys = p_demux->p_sys;
1002 uint64_t i_num_samples = TotalNumSamples( p_demux );
1006 case DEMUX_GET_LENGTH:
1007 pi64 = ( int64_t* )va_arg( args, int64_t * );
1008 *pi64 = CLOCK_FREQ * ( i_num_samples / p_sys->fmt.audio.i_rate );
1011 case DEMUX_GET_TIME:
1012 pi64 = ( int64_t* )va_arg( args, int64_t * );
1013 *pi64 = CLOCK_FREQ * ( p_sys->position.i_samples / p_sys->fmt.audio.i_rate );
1016 case DEMUX_GET_POSITION:
1017 pf = (double*)va_arg( args, double * );
1018 *pf = i_num_samples ? (double)p_sys->position.i_samples / (double)i_num_samples : 0.0;
1021 case DEMUX_SET_POSITION:
1022 f = (double)va_arg( args, double );
1023 i_sample = f * i_num_samples;
1024 if( SetSpanWithSample( p_demux, &position, i_sample ))
1025 return VLC_EGENERIC;
1026 p_sys->position = position;
1029 case DEMUX_SET_TIME:
1030 i64 = (int64_t)va_arg( args, int64_t );
1031 i_sample = i64 * p_sys->fmt.audio.i_rate / INT64_C( 1000000 );
1032 if( SetSpanWithSample( p_demux, &position, i_sample ))
1033 return VLC_EGENERIC;
1034 p_sys->position = position;
1037 case DEMUX_GET_META:
1038 return stream_Control( p_demux->s, STREAM_GET_META, args );
1041 return VLC_EGENERIC;
1044 return VLC_EGENERIC;
1047 /*****************************************************************************
1049 *****************************************************************************/
1050 static void Close( vlc_object_t *p_this )
1052 demux_t *p_demux = (demux_t*)p_this;
1053 demux_sys_t *p_sys = p_demux->p_sys;
1055 es_out_Del( p_demux->out, p_sys->es );
1057 free( p_sys->fmt.p_extra );