forked from len0rd/rockbox
Add codecs to librbcodec.
Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97 Reviewed-on: http://gerrit.rockbox.org/137 Reviewed-by: Nils Wallménius <nils@rockbox.org> Tested-by: Nils Wallménius <nils@rockbox.org>
This commit is contained in:
Sean Bartell
Nils Wallménius
parent
a0009907de
commit
f40bfc9267
757 changed files with 122 additions and 122 deletions
826
lib/rbcodec/codecs/libm4a/demux.c
Normal file
826
lib/rbcodec/codecs/libm4a/demux.c
Normal file
|
|
@ -0,0 +1,826 @@
|
|||
/*
|
||||
* ALAC (Apple Lossless Audio Codec) decoder
|
||||
* Copyright (c) 2005 David Hammerton
|
||||
* All rights reserved.
|
||||
*
|
||||
* This is the quicktime container demuxer.
|
||||
*
|
||||
* http://crazney.net/programs/itunes/alac.html
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person
|
||||
* obtaining a copy of this software and associated documentation
|
||||
* files (the "Software"), to deal in the Software without
|
||||
* restriction, including without limitation the rights to use,
|
||||
* copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "codeclib.h"
|
||||
|
||||
#include "m4a.h"
|
||||
|
||||
#undef DEBUGF
|
||||
#if defined(DEBUG)
|
||||
#define DEBUGF qtmovie->stream->ci->debugf
|
||||
#else
|
||||
#define DEBUGF(...)
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
stream_t *stream;
|
||||
demux_res_t *res;
|
||||
} qtmovie_t;
|
||||
|
||||
|
||||
/* chunk handlers */
|
||||
static void read_chunk_ftyp(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
fourcc_t type;
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
type = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining-=4;
|
||||
if ((type != MAKEFOURCC('M','4','A',' ')) &&
|
||||
(type != MAKEFOURCC('m','4','a',' ')) &&
|
||||
(type != MAKEFOURCC('M','4','B',' ')) &&
|
||||
(type != MAKEFOURCC('m','p','4','2')) &&
|
||||
(type != MAKEFOURCC('3','g','p','6')) &&
|
||||
(type != MAKEFOURCC('q','t',' ',' ')) &&
|
||||
(type != MAKEFOURCC('i','s','o','m')))
|
||||
{
|
||||
DEBUGF("not M4A file\n");
|
||||
return;
|
||||
}
|
||||
/* minor_ver = */ stream_read_uint32(qtmovie->stream);
|
||||
size_remaining-=4;
|
||||
|
||||
/* compatible brands */
|
||||
while (size_remaining)
|
||||
{
|
||||
/* unused */
|
||||
/*fourcc_t cbrand =*/ stream_read_uint32(qtmovie->stream);
|
||||
size_remaining-=4;
|
||||
}
|
||||
}
|
||||
|
||||
static uint32_t mp4ff_read_mp4_descr_length(stream_t* stream)
|
||||
{
|
||||
uint8_t b;
|
||||
uint8_t numBytes = 0;
|
||||
uint32_t length = 0;
|
||||
|
||||
do
|
||||
{
|
||||
b = stream_read_uint8(stream);
|
||||
numBytes++;
|
||||
length = (length << 7) | (b & 0x7F);
|
||||
} while ((b & 0x80) && numBytes < 4);
|
||||
|
||||
return length;
|
||||
}
|
||||
|
||||
/* The following function is based on mp4ff */
|
||||
static bool read_chunk_esds(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
uint8_t tag;
|
||||
uint32_t temp;
|
||||
|
||||
(void)chunk_len;
|
||||
/* version and flags */
|
||||
temp=stream_read_uint32(qtmovie->stream);
|
||||
|
||||
/* get and verify ES_DescrTag */
|
||||
tag = stream_read_uint8(qtmovie->stream);
|
||||
if (tag == 0x03)
|
||||
{
|
||||
/* read length */
|
||||
if (mp4ff_read_mp4_descr_length(qtmovie->stream) < 5 + 15)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* skip 3 bytes */
|
||||
stream_skip(qtmovie->stream,3);
|
||||
} else {
|
||||
/* skip 2 bytes */
|
||||
stream_skip(qtmovie->stream,2);
|
||||
}
|
||||
|
||||
/* get and verify DecoderConfigDescrTab */
|
||||
if (stream_read_uint8(qtmovie->stream) != 0x04)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/* read length */
|
||||
temp = mp4ff_read_mp4_descr_length(qtmovie->stream);
|
||||
if (temp < 13) return false;
|
||||
|
||||
/* audioType = */ stream_read_uint8(qtmovie->stream);
|
||||
/* temp = */ stream_read_int32(qtmovie->stream);//0x15000414 ????
|
||||
/* maxBitrate = */ stream_read_int32(qtmovie->stream);
|
||||
/* avgBitrate = */ stream_read_int32(qtmovie->stream);
|
||||
|
||||
/* get and verify DecSpecificInfoTag */
|
||||
if (stream_read_uint8(qtmovie->stream) != 0x05)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/* read length */
|
||||
qtmovie->res->codecdata_len = mp4ff_read_mp4_descr_length(qtmovie->stream);
|
||||
if (qtmovie->res->codecdata_len > MAX_CODECDATA_SIZE)
|
||||
{
|
||||
DEBUGF("codecdata too large (%d) in esds\n",
|
||||
(int)qtmovie->res->codecdata_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
stream_read(qtmovie->stream, qtmovie->res->codecdata_len, qtmovie->res->codecdata);
|
||||
|
||||
/* will skip the remainder of the atom */
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_stsd(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
unsigned int i;
|
||||
int j;
|
||||
uint32_t numentries;
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
bool got_codec_data = false;
|
||||
|
||||
/* version */
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
size_remaining -= 1;
|
||||
/* flags */
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
size_remaining -= 3;
|
||||
|
||||
numentries = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
/* if (numentries != 1)
|
||||
{
|
||||
DEBUGF("only expecting one entry in sample description atom!\n");
|
||||
return false;
|
||||
} */
|
||||
|
||||
for (i = 0; i < numentries; i++)
|
||||
{
|
||||
uint32_t entry_size;
|
||||
|
||||
uint32_t entry_remaining;
|
||||
|
||||
entry_size = stream_read_uint32(qtmovie->stream);
|
||||
qtmovie->res->format = stream_read_uint32(qtmovie->stream);
|
||||
DEBUGF("format: %c%c%c%c\n",SPLITFOURCC(qtmovie->res->format));
|
||||
entry_remaining = entry_size;
|
||||
entry_remaining -= 8;
|
||||
|
||||
/* sound info: */
|
||||
|
||||
/* reserved + data reference index + sound version + reserved */
|
||||
stream_skip(qtmovie->stream, 6 + 2 + 2 + 6);
|
||||
entry_remaining -= 6 + 2 + 2 + 6;
|
||||
|
||||
qtmovie->res->num_channels = stream_read_uint16(qtmovie->stream);
|
||||
qtmovie->res->sound_sample_size = stream_read_uint16(qtmovie->stream);
|
||||
entry_remaining -= 4;
|
||||
|
||||
/* packet size */
|
||||
stream_skip(qtmovie->stream, 2);
|
||||
qtmovie->res->sound_sample_rate = stream_read_uint32(qtmovie->stream);
|
||||
/* reserved size */
|
||||
stream_skip(qtmovie->stream, 2);
|
||||
entry_remaining -= 8;
|
||||
|
||||
/* remaining is codec data */
|
||||
|
||||
if ((qtmovie->res->format==MAKEFOURCC('a','l','a','c'))) {
|
||||
if (qtmovie->stream->ci->id3->codectype!=AFMT_MP4_ALAC) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/* 12 = audio format atom, 8 = padding */
|
||||
qtmovie->res->codecdata_len = entry_remaining + 12 + 8;
|
||||
if (qtmovie->res->codecdata_len > MAX_CODECDATA_SIZE)
|
||||
{
|
||||
DEBUGF("codecdata too large (%d) in stsd\n",
|
||||
(int)qtmovie->res->codecdata_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
memset(qtmovie->res->codecdata, 0, qtmovie->res->codecdata_len);
|
||||
/* audio format atom */
|
||||
#if 0
|
||||
/* The ALAC decoder skips these bytes, so there is no need to store them,
|
||||
and this code isn't endian/alignment safe */
|
||||
((unsigned int*)qtmovie->res->codecdata)[0] = 0x0c000000;
|
||||
((unsigned int*)qtmovie->res->codecdata)[1] = MAKEFOURCC('a','m','r','f');
|
||||
((unsigned int*)qtmovie->res->codecdata)[2] = MAKEFOURCC('c','a','l','a');
|
||||
#endif
|
||||
|
||||
stream_read(qtmovie->stream,
|
||||
entry_remaining,
|
||||
((char*)qtmovie->res->codecdata) + 12);
|
||||
entry_remaining -= entry_remaining;
|
||||
got_codec_data = true;
|
||||
|
||||
if (entry_remaining)
|
||||
stream_skip(qtmovie->stream, entry_remaining);
|
||||
|
||||
} else if (qtmovie->res->format==MAKEFOURCC('m','p','4','a')) {
|
||||
if (qtmovie->stream->ci->id3->codectype!=AFMT_MP4_AAC &&
|
||||
qtmovie->stream->ci->id3->codectype!=AFMT_MP4_AAC_HE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t sub_chunk_len;
|
||||
fourcc_t sub_chunk_id;
|
||||
|
||||
sub_chunk_len = stream_read_uint32(qtmovie->stream);
|
||||
if (sub_chunk_len <= 1 || sub_chunk_len > entry_remaining)
|
||||
{
|
||||
DEBUGF("strange size (%lu) for chunk inside mp4a\n",
|
||||
(unsigned long)sub_chunk_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
sub_chunk_id = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
if (sub_chunk_id != MAKEFOURCC('e','s','d','s'))
|
||||
{
|
||||
DEBUGF("Expected esds chunk inside mp4a, found %c%c%c%c\n",SPLITFOURCC(sub_chunk_id));
|
||||
return false;
|
||||
}
|
||||
|
||||
j=qtmovie->stream->ci->curpos+sub_chunk_len-8;
|
||||
if (read_chunk_esds(qtmovie,sub_chunk_len)) {
|
||||
if (j!=qtmovie->stream->ci->curpos) {
|
||||
DEBUGF("curpos=%ld, j=%d - Skipping %ld bytes\n",qtmovie->stream->ci->curpos,j,j-qtmovie->stream->ci->curpos);
|
||||
stream_skip(qtmovie->stream,j-qtmovie->stream->ci->curpos);
|
||||
}
|
||||
got_codec_data = true;
|
||||
entry_remaining-=sub_chunk_len;
|
||||
} else {
|
||||
DEBUGF("Error reading esds\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
DEBUGF("entry_remaining=%ld\n",(long)entry_remaining);
|
||||
stream_skip(qtmovie->stream,entry_remaining);
|
||||
|
||||
} else if (qtmovie->res->format==MAKEFOURCC('f','r','e','e')) {
|
||||
/* Skip "filler" atom */
|
||||
stream_skip(qtmovie->stream,entry_remaining);
|
||||
} else {
|
||||
DEBUGF("expecting 'alac', 'mp4a' or 'free' data format, got %c%c%c%c\n",
|
||||
SPLITFOURCC(qtmovie->res->format));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return got_codec_data;
|
||||
}
|
||||
|
||||
static bool read_chunk_stts(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
unsigned int i;
|
||||
uint32_t numentries;
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
/* version */
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
size_remaining -= 1;
|
||||
/* flags */
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
size_remaining -= 3;
|
||||
|
||||
numentries = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
qtmovie->res->num_time_to_samples = numentries;
|
||||
qtmovie->res->time_to_sample = malloc(numentries * sizeof(*qtmovie->res->time_to_sample));
|
||||
|
||||
if (!qtmovie->res->time_to_sample)
|
||||
{
|
||||
DEBUGF("stts too large\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
for (i = 0; i < numentries; i++)
|
||||
{
|
||||
qtmovie->res->time_to_sample[i].sample_count = stream_read_uint32(qtmovie->stream);
|
||||
qtmovie->res->time_to_sample[i].sample_duration = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 8;
|
||||
}
|
||||
|
||||
if (size_remaining)
|
||||
{
|
||||
DEBUGF("ehm, size remianing?\n");
|
||||
stream_skip(qtmovie->stream, size_remaining);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_stsz(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
/* version */
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
size_remaining -= 1;
|
||||
/* flags */
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
stream_read_uint8(qtmovie->stream);
|
||||
size_remaining -= 3;
|
||||
|
||||
/* default sample size */
|
||||
if (stream_read_uint32(qtmovie->stream) != 0)
|
||||
{
|
||||
DEBUGF("i was expecting variable samples sizes\n");
|
||||
stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
return true;
|
||||
}
|
||||
size_remaining -= 4;
|
||||
|
||||
qtmovie->res->num_sample_byte_sizes = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
if (size_remaining)
|
||||
{
|
||||
stream_skip(qtmovie->stream, size_remaining);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_stsc(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
unsigned int i;
|
||||
uint32_t numentries;
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
/* version + flags */
|
||||
stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
numentries = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
qtmovie->res->num_sample_to_chunks = numentries;
|
||||
qtmovie->res->sample_to_chunk = malloc(numentries * sizeof(sample_to_chunk_t));
|
||||
|
||||
if (!qtmovie->res->sample_to_chunk)
|
||||
{
|
||||
DEBUGF("stsc too large\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
for (i = 0; i < numentries; i++)
|
||||
{
|
||||
qtmovie->res->sample_to_chunk[i].first_chunk =
|
||||
stream_read_uint32(qtmovie->stream);
|
||||
qtmovie->res->sample_to_chunk[i].num_samples =
|
||||
stream_read_uint32(qtmovie->stream);
|
||||
stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 12;
|
||||
}
|
||||
|
||||
if (size_remaining)
|
||||
{
|
||||
DEBUGF("ehm, size remianing?\n");
|
||||
stream_skip(qtmovie->stream, size_remaining);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_stco(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
uint32_t i, k, old_i;
|
||||
uint32_t numentries;
|
||||
uint32_t idx = 0;
|
||||
uint32_t frame;
|
||||
uint32_t offset;
|
||||
uint32_t old_first;
|
||||
uint32_t new_first;
|
||||
uint32_t old_frame;
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
/* version + flags */
|
||||
stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
numentries = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
qtmovie->res->num_lookup_table = numentries;
|
||||
qtmovie->res->lookup_table = malloc(numentries * sizeof(*qtmovie->res->lookup_table));
|
||||
|
||||
if (!qtmovie->res->lookup_table)
|
||||
{
|
||||
DEBUGF("stco too large to allocate lookup_table[]\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
/* read first offset */
|
||||
offset = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
|
||||
/* Build up lookup table. The lookup table contains the sample index and
|
||||
* byte position in the file for each chunk. This table is used to seek
|
||||
* and resume (see m4a_seek() and m4a_seek_raw() in libm4a/m4a.c) and
|
||||
* to skip empty chunks (see m4a_check_sample_offset() in codecs/aac.c and
|
||||
* libm4a/m4a.c).
|
||||
* The seek/resume precision is lower than using sample_byte_size[] and
|
||||
* depends on numentries. Typically the resolution is ~1/10 of all frames
|
||||
* which equals about 1/4-1/2 seconds. The loss of seek precision is
|
||||
* accepted to be able to avoid allocation of the large sample_byte_size[]
|
||||
* table. This reduces the memory consumption by a factor of 2 or even
|
||||
* more. */
|
||||
i = 1;
|
||||
old_i = 1;
|
||||
frame = 0;
|
||||
old_first = qtmovie->res->sample_to_chunk[0].first_chunk;
|
||||
old_frame = qtmovie->res->sample_to_chunk[0].num_samples;
|
||||
new_first = qtmovie->res->sample_to_chunk[1].first_chunk;
|
||||
for (k = 1; k < numentries; ++k)
|
||||
{
|
||||
for (; i < qtmovie->res->num_sample_to_chunks; ++i)
|
||||
{
|
||||
if (i > old_i)
|
||||
{
|
||||
/* Only access sample_to_chunk[] if new data is required. */
|
||||
old_first = qtmovie->res->sample_to_chunk[i-1].first_chunk;
|
||||
old_frame = qtmovie->res->sample_to_chunk[i-1].num_samples;
|
||||
new_first = qtmovie->res->sample_to_chunk[i ].first_chunk;
|
||||
old_i = i;
|
||||
}
|
||||
|
||||
if (new_first > k)
|
||||
break;
|
||||
|
||||
frame += (new_first - old_first) * old_frame;
|
||||
}
|
||||
frame += (k - old_first) * old_frame;
|
||||
|
||||
qtmovie->res->lookup_table[idx].sample = frame;
|
||||
qtmovie->res->lookup_table[idx].offset = offset;
|
||||
idx++;
|
||||
|
||||
frame -= (k - old_first) * old_frame;
|
||||
|
||||
offset = stream_read_uint32(qtmovie->stream);
|
||||
size_remaining -= 4;
|
||||
}
|
||||
/* zero-terminate the lookup table */
|
||||
qtmovie->res->lookup_table[idx].sample = 0;
|
||||
qtmovie->res->lookup_table[idx].offset = 0;
|
||||
|
||||
if (size_remaining)
|
||||
{
|
||||
DEBUGF("ehm, size remianing?\n");
|
||||
stream_skip(qtmovie->stream, size_remaining);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_stbl(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
while (size_remaining)
|
||||
{
|
||||
size_t sub_chunk_len;
|
||||
fourcc_t sub_chunk_id;
|
||||
|
||||
sub_chunk_len = stream_read_uint32(qtmovie->stream);
|
||||
if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
|
||||
{
|
||||
DEBUGF("strange size (%lu) for chunk inside stbl\n",
|
||||
(unsigned long)sub_chunk_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
sub_chunk_id = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
switch (sub_chunk_id)
|
||||
{
|
||||
case MAKEFOURCC('s','t','s','d'):
|
||||
if (!read_chunk_stsd(qtmovie, sub_chunk_len)) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case MAKEFOURCC('s','t','t','s'):
|
||||
if (!read_chunk_stts(qtmovie, sub_chunk_len))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case MAKEFOURCC('s','t','s','z'):
|
||||
if (!read_chunk_stsz(qtmovie, sub_chunk_len))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case MAKEFOURCC('s','t','s','c'):
|
||||
if (!read_chunk_stsc(qtmovie, sub_chunk_len))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case MAKEFOURCC('s','t','c','o'):
|
||||
if (!read_chunk_stco(qtmovie, sub_chunk_len))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/*DEBUGF("(stbl) unknown chunk id: %c%c%c%c\n",
|
||||
SPLITFOURCC(sub_chunk_id));*/
|
||||
stream_skip(qtmovie->stream, sub_chunk_len - 8);
|
||||
}
|
||||
|
||||
size_remaining -= sub_chunk_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_minf(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
uint32_t i;
|
||||
|
||||
/* Check for smhd, only kind of minf we care about */
|
||||
|
||||
if ((i = stream_read_uint32(qtmovie->stream)) != 16)
|
||||
{
|
||||
DEBUGF("unexpected size in media info: %ld\n", (long)i);
|
||||
stream_skip(qtmovie->stream, size_remaining-4);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (stream_read_uint32(qtmovie->stream) != MAKEFOURCC('s','m','h','d'))
|
||||
{
|
||||
DEBUGF("not a sound header! can't handle this.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
/* now skip the rest of the atom */
|
||||
stream_skip(qtmovie->stream, 16 - 8);
|
||||
size_remaining -= 16;
|
||||
|
||||
while (size_remaining)
|
||||
{
|
||||
size_t sub_chunk_len;
|
||||
fourcc_t sub_chunk_id;
|
||||
|
||||
sub_chunk_len = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
|
||||
{
|
||||
DEBUGF("strange size (%lu) for chunk inside minf\n",
|
||||
(unsigned long)sub_chunk_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
sub_chunk_id = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
switch (sub_chunk_id)
|
||||
{
|
||||
case MAKEFOURCC('s','t','b','l'):
|
||||
if (!read_chunk_stbl(qtmovie, sub_chunk_len)) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/*DEBUGF("(minf) unknown chunk id: %c%c%c%c\n",
|
||||
SPLITFOURCC(sub_chunk_id));*/
|
||||
stream_skip(qtmovie->stream, sub_chunk_len - 8);
|
||||
break;
|
||||
}
|
||||
|
||||
size_remaining -= sub_chunk_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_chunk_mdia(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
while (size_remaining)
|
||||
{
|
||||
size_t sub_chunk_len;
|
||||
fourcc_t sub_chunk_id;
|
||||
|
||||
sub_chunk_len = stream_read_uint32(qtmovie->stream);
|
||||
if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
|
||||
{
|
||||
DEBUGF("strange size (%lu) for chunk inside mdia\n",
|
||||
(unsigned long)sub_chunk_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
sub_chunk_id = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
switch (sub_chunk_id)
|
||||
{
|
||||
case MAKEFOURCC('m','i','n','f'):
|
||||
if (!read_chunk_minf(qtmovie, sub_chunk_len)) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/*DEBUGF("(mdia) unknown chunk id: %c%c%c%c\n",
|
||||
SPLITFOURCC(sub_chunk_id));*/
|
||||
stream_skip(qtmovie->stream, sub_chunk_len - 8);
|
||||
break;
|
||||
}
|
||||
|
||||
size_remaining -= sub_chunk_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/* 'trak' - a movie track - contains other atoms */
|
||||
static bool read_chunk_trak(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
while (size_remaining)
|
||||
{
|
||||
size_t sub_chunk_len;
|
||||
fourcc_t sub_chunk_id;
|
||||
|
||||
sub_chunk_len = stream_read_uint32(qtmovie->stream);
|
||||
if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
|
||||
{
|
||||
DEBUGF("strange size (%lu) for chunk inside trak\n",
|
||||
(unsigned long)sub_chunk_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
sub_chunk_id = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
switch (sub_chunk_id)
|
||||
{
|
||||
case MAKEFOURCC('m','d','i','a'):
|
||||
if (!read_chunk_mdia(qtmovie, sub_chunk_len)) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/*DEBUGF("(trak) unknown chunk id: %c%c%c%c\n",
|
||||
SPLITFOURCC(sub_chunk_id));*/
|
||||
stream_skip(qtmovie->stream, sub_chunk_len - 8);
|
||||
break;
|
||||
}
|
||||
|
||||
size_remaining -= sub_chunk_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/* 'moov' movie atom - contains other atoms */
|
||||
static bool read_chunk_moov(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
while (size_remaining)
|
||||
{
|
||||
size_t sub_chunk_len;
|
||||
fourcc_t sub_chunk_id;
|
||||
|
||||
sub_chunk_len = stream_read_uint32(qtmovie->stream);
|
||||
if (sub_chunk_len <= 1 || sub_chunk_len > size_remaining)
|
||||
{
|
||||
DEBUGF("strange size (%lu) for chunk inside moov\n",
|
||||
(unsigned long)sub_chunk_len);
|
||||
return false;
|
||||
}
|
||||
|
||||
sub_chunk_id = stream_read_uint32(qtmovie->stream);
|
||||
|
||||
switch (sub_chunk_id)
|
||||
{
|
||||
case MAKEFOURCC('t','r','a','k'):
|
||||
if (!read_chunk_trak(qtmovie, sub_chunk_len)) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
/*DEBUGF("(moov) unknown chunk id: %c%c%c%c\n",
|
||||
SPLITFOURCC(sub_chunk_id));*/
|
||||
stream_skip(qtmovie->stream, sub_chunk_len - 8);
|
||||
break;
|
||||
}
|
||||
|
||||
size_remaining -= sub_chunk_len;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static void read_chunk_mdat(qtmovie_t *qtmovie, size_t chunk_len)
|
||||
{
|
||||
size_t size_remaining = chunk_len - 8;
|
||||
|
||||
qtmovie->res->mdat_len = size_remaining;
|
||||
}
|
||||
|
||||
int qtmovie_read(stream_t *file, demux_res_t *demux_res)
|
||||
{
|
||||
qtmovie_t qtmovie;
|
||||
|
||||
/* construct the stream */
|
||||
qtmovie.stream = file;
|
||||
qtmovie.res = demux_res;
|
||||
|
||||
/* read the chunks */
|
||||
while (1)
|
||||
{
|
||||
size_t chunk_len;
|
||||
fourcc_t chunk_id;
|
||||
|
||||
chunk_len = stream_read_uint32(qtmovie.stream);
|
||||
if (stream_eof(qtmovie.stream))
|
||||
{
|
||||
if(qtmovie.res->mdat_offset == 0 || qtmovie.res->format == 0)
|
||||
return 0;
|
||||
stream_seek(qtmovie.stream, qtmovie.res->mdat_offset);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (chunk_len == 1)
|
||||
{
|
||||
//DEBUGF("need 64bit support\n");
|
||||
return 0;
|
||||
}
|
||||
chunk_id = stream_read_uint32(qtmovie.stream);
|
||||
|
||||
//DEBUGF("Found a chunk %c%c%c%c, length=%d\n",SPLITFOURCC(chunk_id),chunk_len);
|
||||
switch (chunk_id)
|
||||
{
|
||||
case MAKEFOURCC('f','t','y','p'):
|
||||
read_chunk_ftyp(&qtmovie, chunk_len);
|
||||
break;
|
||||
case MAKEFOURCC('m','o','o','v'):
|
||||
if (!read_chunk_moov(&qtmovie, chunk_len)) {
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
case MAKEFOURCC('m','d','a','t'):
|
||||
/* There can be empty mdats before the real one. If so, skip them */
|
||||
if (chunk_len == 8)
|
||||
break;
|
||||
read_chunk_mdat(&qtmovie, chunk_len);
|
||||
qtmovie.res->mdat_offset=stream_tell(qtmovie.stream);
|
||||
/* If we've already seen the format, assume there's nothing
|
||||
interesting after the mdat chunk (the file is "streamable").
|
||||
This avoids having to seek, which might cause rebuffering. */
|
||||
if(qtmovie.res->format > 0)
|
||||
return 1;
|
||||
stream_skip(qtmovie.stream, chunk_len - 8);
|
||||
break;
|
||||
|
||||
/* these following atoms can be skipped !!!! */
|
||||
case MAKEFOURCC('f','r','e','e'):
|
||||
stream_skip(qtmovie.stream, chunk_len - 8);
|
||||
break;
|
||||
default:
|
||||
//DEBUGF("(top) unknown chunk id: %c%c%c%c\n",SPLITFOURCC(chunk_id));
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue