Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
What's new
7
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in / Register
Toggle navigation
Open sidebar
GSoC
GSoC2018
macOS
vlc
Commits
d475c5fd
Commit
d475c5fd
authored
Sep 30, 2013
by
Matthias Keiser
Committed by
Jean-Baptiste Kempf
Oct 02, 2013
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Add a new caf file demuxer module
parent
93fba1b5
Changes
5
Hide whitespace changes
Inline
Side-by-side
Showing
5 changed files
with
1069 additions
and
1 deletion
+1069
-1
NEWS
NEWS
+3
-0
modules/MODULES_LIST
modules/MODULES_LIST
+2
-1
modules/demux/Makefile.am
modules/demux/Makefile.am
+4
-0
modules/demux/caf.c
modules/demux/caf.c
+1059
-0
po/POTFILES.in
po/POTFILES.in
+1
-0
No files found.
NEWS
View file @
d475c5fd
...
...
@@ -13,6 +13,9 @@ Encoder:
* Support for HEVC/H.265 encoding using x265
* Support for Opus encoding using libopus
Demuxer:
* New CAF format module
Streaming:
* WebM streaming, including live sources, compatible with all major browsers
vlc <your-source> vlc://quit --sout '#transcode{vcodec=VP80,vb=1000,acodec=vorb,ab=128}
...
...
modules/MODULES_LIST
View file @
d475c5fd
List of vlc plugins (41
3
)
List of vlc plugins (41
4
)
$Id$
* a52: A/52 basic parser/packetizer
* a52tofloat32: A/52 audio converter & decoder plugin, using liba52
...
...
@@ -55,6 +55,7 @@ $Id$
* bluescreen: Bluescreen (weather channel like) video filter
* bonjour: Zeroconf services discovery
* caca: color ASCII art video output using libcaca
* caf: CAF demuxer
* canvas: Automatically resize and padd a video
* cc: CC 608/708 subtitles decoder
* cdda: input module to read audio CDs
...
...
modules/demux/Makefile.am
View file @
d475c5fd
...
...
@@ -126,6 +126,10 @@ demux_LTLIBRARIES += libasf_plugin.la
libavi_plugin_la_SOURCES
=
demux/avi/avi.c demux/avi/libavi.c demux/avi/libavi.h
demux_LTLIBRARIES
+=
libavi_plugin.la
libcaf_plugin_la_SOURCES
=
demux/caf.c
libcaf_plugin_la_LIBADD
=
$(LIBM)
demux_LTLIBRARIES
+=
libcaf_plugin.la
libavformat_plugin_la_SOURCES
=
demux/avformat/demux.c
\
codec/avcodec/fourcc.c
\
codec/avcodec/chroma.c
\
...
...
modules/demux/caf.c
0 → 100644
View file @
d475c5fd
/*****************************************************************************
* caf.c: Core Audio File Format demuxer
*****************************************************************************
* Copyright (C) 2013 VLC authors and VideoLAN
* $Id$
*
* Authors: Matthias Keiser <matthias@tristan-inc.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <math.h>
#include <limits.h>
#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_demux.h>
#include <vlc_codecs.h>
/* TODO:
*
* - handle channel layout
* - 64 bit float LPCM is broken (sound has artifacts with little endian, only silence plays for big endian).
*/
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static
int
Open
(
vlc_object_t
*
);
static
void
Close
(
vlc_object_t
*
);
vlc_module_begin
()
set_category
(
CAT_INPUT
)
set_subcategory
(
SUBCAT_INPUT_DEMUX
)
set_description
(
N_
(
"CAF demuxer"
))
set_capability
(
"demux"
,
140
)
set_callbacks
(
Open
,
Close
)
add_shortcut
(
"caf"
)
vlc_module_end
()
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static
int
Demux
(
demux_t
*
);
static
int
Control
(
demux_t
*
,
int
i_query
,
va_list
args
);
typedef
struct
frame_span_t
{
uint64_t
i_frames
;
uint64_t
i_samples
;
uint64_t
i_bytes
;
uint64_t
i_desc_bytes
;
}
frame_span_t
;
typedef
struct
packet_table_t
{
uint64_t
i_num_packets
;
uint64_t
i_num_valid_frames
;
uint32_t
i_num_priming_frames
;
uint32_t
i_num_remainder_frames
;
uint64_t
i_descriptions_start
;
}
packet_table_t
;
struct
demux_sys_t
{
es_format_t
fmt
;
es_out_id_t
*
es
;
uint64_t
i_data_offset
;
uint64_t
i_data_size
;
frame_span_t
position
;
packet_table_t
packet_table
;
};
/*
We use this value to indicate that the data section extends until the end of the file.
*/
static
const
uint64_t
kCHUNK_SIZE_EOF
=
UINT64_C
(
0xffffffffffffffff
);
/*****************************************************************************
* Various Utility Functions
*****************************************************************************/
/* ParseVarLenInteger parses a var length integer as found in the packet descriptions
(and in the aac magic cookie). In theorie a var length integer could be bigger than
an uint64_t, but I think it's unlikely to ever be a problem... */
static
int
ParseVarLenInteger
(
const
uint8_t
*
p_buff
,
size_t
i_buff_len
,
uint64_t
*
pi_value_out
,
uint32_t
*
i_len_out
)
{
*
i_len_out
=
0
;
uint64_t
i_value
=
0
;
bool
finished
=
false
;
for
(
uint32_t
i
=
0
;
i
<
i_buff_len
;
i
++
)
{
if
(
((
i_value
>>
32
)
<<
7
)
>
UINT32_MAX
)
{
return
VLC_EGENERIC
;
/* overflow */
}
uint8_t
i_byte
=
p_buff
[
i
];
i_value
=
(
i_value
<<
7
)
|
(
i_byte
&
0x7f
);
(
*
i_len_out
)
++
;
if
(
!
(
i_byte
&
0x80
))
{
finished
=
true
;
break
;
}
}
if
(
!
finished
)
{
return
VLC_EGENERIC
;
}
*
pi_value_out
=
i_value
;
return
VLC_SUCCESS
;
}
/* Utility function that reads a big endian double from the input buffer. */
static
inline
double
GetDBLBE
(
const
uint8_t
*
p
)
{
union
{
uint64_t
uint64
;
double
dbl
;
}
u_64
;
u_64
.
uint64
=
GetQWBE
(
p
);
return
u_64
.
dbl
;
}
/* Utility function that reads a big endian signed 32 bit integer into an unsigned 32 bit variable.
If the read value is negative, this function returns an error.
*/
static
inline
int
ReadBEInt32ToUInt32
(
const
uint8_t
*
p
,
uint32_t
*
i_out
)
{
uint32_t
i_value
=
GetDWBE
(
p
);
if
(
i_value
>
INT32_MAX
)
return
VLC_EGENERIC
;
*
i_out
=
i_value
;
return
VLC_SUCCESS
;
}
/* Utility function that reads a big endian signed 64 bit integer into an unsigned 64 bit variable.
If the read value is negative, this function returns an error.
*/
static
inline
int
ReadBEInt64ToUInt64
(
const
uint8_t
*
p
,
uint64_t
*
i_out
)
{
uint64_t
i_value
=
GetQWBE
(
p
);
if
(
i_value
>
INT64_MAX
)
return
VLC_EGENERIC
;
*
i_out
=
i_value
;
return
VLC_SUCCESS
;
}
static
inline
bool
NeedsPacketTable
(
demux_sys_t
*
p_sys
)
{
return
(
!
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
||
!
p_sys
->
fmt
.
audio
.
i_frame_length
);
}
static
uint64_t
TotalNumFrames
(
demux_t
*
p_demux
)
{
demux_sys_t
*
p_sys
=
p_demux
->
p_sys
;
if
(
!
NeedsPacketTable
(
p_sys
))
{
uint64_t
i_data_size
;
if
(
p_sys
->
i_data_size
!=
kCHUNK_SIZE_EOF
)
{
i_data_size
=
p_sys
->
i_data_size
;
}
else
{
int64_t
i_stream_size
=
stream_Size
(
p_demux
->
s
);
if
(
i_stream_size
>=
0
&&
(
uint64_t
)
i_stream_size
>=
p_sys
->
i_data_offset
)
i_data_size
=
i_stream_size
-
p_sys
->
i_data_offset
;
else
i_data_size
=
0
;
}
return
i_data_size
/
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
;
}
else
{
return
p_sys
->
packet_table
.
i_num_packets
;
}
}
static
uint64_t
TotalNumSamples
(
demux_t
*
p_demux
)
{
demux_sys_t
*
p_sys
=
p_demux
->
p_sys
;
if
(
!
NeedsPacketTable
(
p_sys
))
{
return
TotalNumFrames
(
p_demux
)
*
p_sys
->
fmt
.
audio
.
i_frame_length
;
}
else
{
return
p_sys
->
packet_table
.
i_num_valid_frames
+
p_sys
->
packet_table
.
i_num_priming_frames
+
p_sys
->
packet_table
.
i_num_remainder_frames
;
}
}
static
inline
vlc_fourcc_t
ReadFOURCC
(
const
uint8_t
*
p
)
{
return
VLC_FOURCC
(
p
[
0
],
p
[
1
],
p
[
2
],
p
[
3
]
);
}
/*****************************************************************************
* FrameSpan Functions
*****************************************************************************
* A FrameSpan structure contains the relationship between a number of
frames, the number of samples they contain, the amount of data they
use, and the length of their packet descriptions (if any).
*****************************************************************************/
/* FrameSpanAddSpan adds span2 to span1 */
static
inline
void
FrameSpanAddSpan
(
frame_span_t
*
span1
,
frame_span_t
*
span2
)
{
span1
->
i_frames
+=
span2
->
i_frames
;
span1
->
i_samples
+=
span2
->
i_samples
;
span1
->
i_bytes
+=
span2
->
i_bytes
;
span1
->
i_desc_bytes
+=
span2
->
i_desc_bytes
;
}
/* Adds the frame that is described at i_desc_offset to span */
static
int
FrameSpanAddDescription
(
demux_t
*
p_demux
,
uint64_t
i_desc_offset
,
frame_span_t
*
span
)
{
demux_sys_t
*
p_sys
=
p_demux
->
p_sys
;
/* Avoid seeking + peeking for simple case (PCM) */
if
(
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
&&
p_sys
->
fmt
.
audio
.
i_frame_length
)
{
span
->
i_bytes
+=
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
;
span
->
i_samples
+=
p_sys
->
fmt
.
audio
.
i_frame_length
;
span
->
i_frames
++
;
return
VLC_SUCCESS
;
}
uint32_t
i_desc_size
=
0
;
if
(
stream_Seek
(
p_demux
->
s
,
p_sys
->
packet_table
.
i_descriptions_start
+
i_desc_offset
))
{
msg_Err
(
p_demux
,
"Couldn't seek packet description."
);
return
VLC_EGENERIC
;
}
const
uint8_t
*
p_peek
;
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 ). */
if
(
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
)
{
span
->
i_bytes
+=
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
;
}
else
{
uint64_t
i_size
;
uint32_t
i_this_int
;
if
(
ParseVarLenInteger
(
p_peek
,
i_peek_len
,
&
i_size
,
&
i_this_int
))
{
return
VLC_EGENERIC
;
}
i_desc_size
+=
i_this_int
;
span
->
i_bytes
+=
i_size
;
}
if
(
p_sys
->
fmt
.
audio
.
i_frame_length
)
{
span
->
i_samples
+=
p_sys
->
fmt
.
audio
.
i_frame_length
;
}
else
{
if
(
i_desc_size
>=
i_peek_len
)
{
return
VLC_EGENERIC
;
}
uint64_t
i_num_samples
;
uint32_t
i_this_int
;
if
(
ParseVarLenInteger
(
p_peek
+
i_desc_size
,
i_peek_len
-
i_desc_size
,
&
i_num_samples
,
&
i_this_int
))
{
return
VLC_EGENERIC
;
}
i_desc_size
+=
i_this_int
;
span
->
i_samples
+=
i_num_samples
;
}
span
->
i_desc_bytes
+=
i_desc_size
;
span
->
i_frames
++
;
return
VLC_SUCCESS
;
}
/* FrameSpanGetTime returns the time span represented by the frame span. */
static
inline
mtime_t
FrameSpanGetTime
(
frame_span_t
*
span
,
uint32_t
i_sample_rate
)
{
if
(
!
i_sample_rate
)
return
0
;
return
(
span
->
i_samples
*
CLOCK_FREQ
)
/
i_sample_rate
+
1
;
}
/* SetSpanWithSample returns the span from the beginning of the file up to and
including the specified sample. This works at frame granularity, so the
returned span may not represent the exact target sample.
Since we might have to lineraly search the packet descriptions, this is a
potentially slow operation! */
static
int
SetSpanWithSample
(
demux_t
*
p_demux
,
frame_span_t
*
p_span
,
uint64_t
i_target_sample
)
{
demux_sys_t
*
p_sys
=
p_demux
->
p_sys
;
uint64_t
i_num_frames
=
TotalNumFrames
(
p_demux
);
if
(
!
NeedsPacketTable
(
p_sys
))
{
uint64_t
i_frame
=
i_target_sample
/
p_sys
->
fmt
.
audio
.
i_frame_length
;
uint64_t
i_remaining
=
i_target_sample
-
i_frame
*
p_sys
->
fmt
.
audio
.
i_frame_length
;
if
(
i_remaining
>
(
p_sys
->
fmt
.
audio
.
i_frame_length
/
2
))
i_frame
++
;
if
(
i_frame
>
i_num_frames
)
i_frame
=
i_num_frames
;
p_span
->
i_frames
=
i_frame
;
p_span
->
i_samples
=
i_frame
*
p_sys
->
fmt
.
audio
.
i_frame_length
;
p_span
->
i_bytes
=
i_frame
*
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
;
p_span
->
i_desc_bytes
=
0
;
}
else
{
*
p_span
=
(
frame_span_t
){
0
};
frame_span_t
prev_span
;
while
(
p_span
->
i_samples
<
i_target_sample
&&
p_span
->
i_frames
<
i_num_frames
)
{
prev_span
=
*
p_span
;
if
(
FrameSpanAddDescription
(
p_demux
,
p_span
->
i_desc_bytes
,
p_span
))
return
VLC_EGENERIC
;
if
(
p_span
->
i_samples
>=
i_target_sample
)
{
uint64_t
i_this_samples
=
p_span
->
i_samples
-
prev_span
.
i_samples
;
if
(
i_target_sample
-
prev_span
.
i_samples
<
i_this_samples
/
2
)
*
p_span
=
prev_span
;
break
;
}
}
}
return
VLC_SUCCESS
;
}
/*****************************************************************************
* CAF Parsing Functions
*****************************************************************************/
/* The NextChunk function returns the four char code and the (sanitized) size at the current file position.
Upon return the file position points to the start of the chunk payload.
Note that the ReadXXXChunk functions expect the chunk to size to be sanitized
(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).
*/
static
int
NextChunk
(
demux_t
*
p_demux
,
vlc_fourcc_t
*
p_fcc
,
uint64_t
*
pi_size
)
{
uint8_t
p_read
[
12
];
if
(
stream_Read
(
p_demux
->
s
,
p_read
,
12
)
<
12
)
return
VLC_EGENERIC
;
*
p_fcc
=
ReadFOURCC
(
p_read
);
uint64_t
i_size
=
GetQWBE
(
p_read
+
4
);
/* We accept no negativ sizes for chunks, except -1 for the data chunk. */
if
(
i_size
>
INT64_MAX
)
{
if
(
*
p_fcc
==
VLC_FOURCC
(
'd'
,
'a'
,
't'
,
'a'
)
&&
i_size
==
UINT64_C
(
-
1
))
i_size
=
kCHUNK_SIZE_EOF
;
else
return
VLC_EGENERIC
;
}
*
pi_size
=
i_size
;
return
VLC_SUCCESS
;
}
static
int
ReadDescChunk
(
demux_t
*
p_demux
)
{
demux_sys_t
*
p_sys
=
p_demux
->
p_sys
;
const
uint8_t
*
p_peek
;
if
(
stream_Peek
(
p_demux
->
s
,
&
p_peek
,
8
+
6
*
4
)
<
(
8
+
6
*
4
))
{
return
VLC_EGENERIC
;
}
vlc_fourcc_t
i_fmt
=
ReadFOURCC
(
p_peek
+
8
);
uint32_t
i_fmt_flags
=
GetDWBE
(
p_peek
+
12
);
uint32_t
i_bits_per_channel
=
GetDWBE
(
p_peek
+
28
);
uint32_t
i_bytes_per_packet
=
GetDWBE
(
p_peek
+
16
);
uint32_t
i_frames_per_packet
=
GetDWBE
(
p_peek
+
20
);
uint32_t
i_channels_per_frame
=
GetDWBE
(
p_peek
+
24
);
if
(
i_fmt
==
VLC_CODEC_DVD_LPCM
)
{
if
(
!
i_frames_per_packet
||
!
i_channels_per_frame
)
{
msg_Err
(
p_demux
,
"Absurd LPCM parameters (frames_per_packet: %u, channels_per_frame: %u)."
,
i_frames_per_packet
,
i_channels_per_frame
);
return
VLC_EGENERIC
;
}
uint32_t
i_unpacked_bits_per_sample
=
(
i_bytes_per_packet
/
i_frames_per_packet
/
i_channels_per_frame
)
*
8
;
bool
b_is_float
=
!!
(
i_fmt_flags
&
(
1
<<
0
)
);
bool
b_is_be
=
!
(
i_fmt_flags
&
(
1
<<
1
)
);
vlc_fourcc_t
i_basic_codec
=
0
;
if
(
!
b_is_float
)
{
i_basic_codec
=
b_is_be
?
VLC_FOURCC
(
't'
,
'w'
,
'o'
,
's'
)
:
VLC_FOURCC
(
's'
,
'o'
,
'w'
,
't'
);
es_format_Init
(
&
p_sys
->
fmt
,
AUDIO_ES
,
vlc_fourcc_GetCodecAudio
(
i_basic_codec
,
i_unpacked_bits_per_sample
));
}
else
{
if
(
i_bits_per_channel
==
32
)
i_basic_codec
=
b_is_be
?
VLC_CODEC_F32B
:
VLC_CODEC_F32L
;
else
if
(
i_bits_per_channel
==
64
)
i_basic_codec
=
b_is_be
?
VLC_CODEC_F64B
:
VLC_CODEC_F64L
;
if
(
i_basic_codec
)
es_format_Init
(
&
p_sys
->
fmt
,
AUDIO_ES
,
vlc_fourcc_GetCodecAudio
(
i_basic_codec
,
i_bits_per_channel
));
}
}
else
if
(
i_fmt
==
VLC_FOURCC
(
'a'
,
'a'
,
'c'
,
' '
))
{
const
uint32_t
kMP4Audio_AAC_LC_ObjectType
=
2
;
if
(
i_fmt_flags
!=
kMP4Audio_AAC_LC_ObjectType
)
{
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
);
}
es_format_Init
(
&
p_sys
->
fmt
,
AUDIO_ES
,
vlc_fourcc_GetCodecAudio
(
VLC_CODEC_MP4A
,
0
));
}
else
{
es_format_Init
(
&
p_sys
->
fmt
,
AUDIO_ES
,
vlc_fourcc_GetCodecAudio
(
i_fmt
,
0
));
}
if
(
!
p_sys
->
fmt
.
i_codec
)
{
msg_Err
(
p_demux
,
"could not determine codec"
);
return
VLC_EGENERIC
;
}
double
d_rate
=
round
(
GetDBLBE
(
p_peek
));
if
(
d_rate
<=
0
||
d_rate
>
UINT_MAX
)
return
VLC_EGENERIC
;
p_sys
->
fmt
.
audio
.
i_rate
=
(
unsigned
int
)
lround
(
d_rate
);
p_sys
->
fmt
.
audio
.
i_channels
=
i_channels_per_frame
;
p_sys
->
fmt
.
audio
.
i_bytes_per_frame
=
i_bytes_per_packet
;
/* "mBytesPerPacket" in Apple parlance */
p_sys
->
fmt
.
audio
.
i_frame_length
=
i_frames_per_packet
;
/* "mFramesPerPacket" in Apple parlance */
p_sys
->
fmt
.
audio
.
i_bitspersample
=
i_bits_per_channel
;
/* mBitsPerChannel */
p_sys
->
fmt
.
audio
.
i_blockalign
=
i_bytes_per_packet
;
p_sys
->
fmt
.
i_bitrate
=
i_bits_per_channel
*
p_sys
->
fmt
.
audio
.
i_rate
*
i_channels_per_frame
;
return
VLC_SUCCESS
;
}
/* This is lifted from cafdec.c in libavformat (function read_kuki_chunk). Appearantly the
alac library expects the cookie to be of length 36, but current alac files
have a cookie length of 24.
*/
static
int
ProcessALACCookie
(
demux_t
*
p_demux
,
const
uint8_t
*
p
,
uint64_t
i_size
)
{
demux_sys_t
*
p_sys
=
p_demux
->
p_sys
;
const
unsigned
int
kALAC_NEW_KUKI_SIZE
=
24
;
const
unsigned
int
kALAC_LIB_REQ_KUKI_SIZE
=
36
;
int
i_extra
;
if
(
i_size
==
kALAC_NEW_KUKI_SIZE
||
i_size
==
kALAC_LIB_REQ_KUKI_SIZE
)
{
i_extra
=
kALAC_LIB_REQ_KUKI_SIZE
;
}
else
{
msg_Warn
(
p_demux
,
"Unknown alac magic cookie. Passing it on to the decoder as is and hoping for the best."
);
i_extra
=
(
int
)
i_size
;
}
p_sys
->
fmt
.
i_extra
=
i_extra
;
p_sys
->
fmt
.
p_extra
=
malloc
(
i_extra
);
if
(
!
p_sys
->
fmt
.
p_extra
)
return
VLC_ENOMEM
;
uint8_t
*
p_extra
=
(
uint8_t
*
)
p_sys
->
fmt
.
p_extra
;
if
(
i_size
==
kALAC_NEW_KUKI_SIZE
)
{
SetDWBE
(
p_extra
,
36
);
memcpy
(
p_extra
+
4
,
"alac"
,
4
);
SetDWBE
(
p_extra
+
8
,
0
);
memcpy
(
p_extra
+
12
,
p
,
24
);
}
else
{
memcpy
(
p_sys
->
fmt
.
p_extra
,
p
,
i_size
);
}
return
VLC_SUCCESS
;
}
/* Helper functions for AAC cookie processing. */
static
inline
bool
AACCookieGetTag
(
uint8_t
*
p_tag
,
const
uint8_t
*
p
,
uint64_t
*
p_offset
,
uint64_t
i_size
)
{
if
(
*
p_offset
+
1
>
i_size
)
return
false
;
*
p_tag
=
*
(
p
+
*
p_offset
);
*
p_offset
+=
1
;
return
true
;
}
static
inline
bool
AACCookieTagLen
(
uint64_t
*
p_tag_len
,
const
uint8_t
*
p
,
uint64_t
*
p_offset
,
uint64_t
i_size
)
{
uint32_t
i_int_size
;
if
(
ParseVarLenInteger
(
p
+
*
p_offset
,
i_size
-
*
p_offset
,
p_tag_len
,
&
i_int_size
))
return
false
;
*
p_offset
+=
i_int_size
;
return
true
;
}
static
inline
bool
AACCookieChkLen
(
int64_t
i_length
,
uint64_t
i_size
,
uint64_t
i_offset
)
{
return
(
i_offset
+
i_length
<=
i_size
);
}
/* This is lifted from libmp4.c in the mp4 demuxer module (function MP4_ReadBox_esds). The aac
library only want a subset of the magic cookie ("decoder specific info"), so we have to parse it.
*/
static
int
ProcessAACCookie
(
demux_t
*
p_demux
,
const
uint8_t
*
p
,
uint64_t
i_size
)
{