X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=mp4.c;h=365dce6550a5a150d1736cd194de8318667f4492;hb=2ca18e6d22391a7eded4a21925a44860a9840ecf;hp=1d8af6cb20853c33a4aff5d151eb143951bd5a90;hpb=30fcea984715a12b63aab776fb3080ac1851e43a;p=paraslash.git diff --git a/mp4.c b/mp4.c index 1d8af6cb..365dce65 100644 --- a/mp4.c +++ b/mp4.c @@ -14,8 +14,9 @@ #include "mp4.h" struct mp4_track { - uint16_t channelCount; - uint16_t sampleRate; + /* mp4a */ + uint16_t channel_count; + uint16_t sample_rate; /* stsz */ uint32_t stsz_sample_size; @@ -35,7 +36,8 @@ struct mp4_track { uint32_t stco_entry_count; uint32_t *stco_chunk_offset; - uint32_t timeScale; + /* mdhd */ + uint32_t time_scale; uint64_t duration; }; @@ -43,7 +45,6 @@ struct mp4_track { struct mp4 { const struct mp4_callback *cb; - int64_t current_position; uint64_t moov_offset; uint64_t moov_size; @@ -55,8 +56,6 @@ struct mp4 { uint32_t udta_size; uint8_t last_atom; - uint64_t file_size; - /* incremental track index while reading the file */ int32_t total_tracks; /* track data */ @@ -81,7 +80,6 @@ static int read_data(struct mp4 *f, void *data, size_t size) /* regard EAGAIN as an error as reads should be blocking. */ if (ret <= 0) return ret < 0? -1 : 0; - f->current_position += ret; size -= ret; } return 1; @@ -92,7 +90,7 @@ static int read_int64(struct mp4 *f, uint64_t *result) uint8_t data[8]; int ret = read_data(f, data, 8); - if (ret > 0 && result) + if (ret > 0) *result = read_u64_be(data); return ret; } @@ -102,283 +100,64 @@ static int read_int32(struct mp4 *f, uint32_t *result) uint8_t data[4]; int ret = read_data(f, data, 4); - if (ret > 0 && result) + if (ret > 0) *result = read_u32_be(data); return ret; } -static int read_int24(struct mp4 *f, uint32_t *result) -{ - uint8_t data[3]; - int ret = read_data(f, data, 3); - - if (ret > 0 && result) - *result = read_u24_be(data); - return ret; -} - static int read_int16(struct mp4 *f, uint16_t *result) { uint8_t data[2]; int ret = read_data(f, data, 2); - if (ret > 0 && result) + if (ret > 0) *result = read_u16_be(data); return ret; } -static uint8_t read_int8(struct mp4 *f, uint8_t *result) -{ - uint8_t data[1]; - int ret = read_data(f, data, 1); - - if (ret > 0 && result) - *result = data[0]; - return ret; -} - -static bool atom_compare(int8_t a1, int8_t b1, int8_t c1, int8_t d1, - int8_t a2, int8_t b2, int8_t c2, int8_t d2) -{ - return a1 == a2 && b1 == b2 && c1 == c2 && d1 == d2; -} - -enum atoms { - /* atoms with subatoms */ - ATOM_MOOV = 1, - ATOM_TRAK = 2, - ATOM_EDTS = 3, - ATOM_MDIA = 4, - ATOM_MINF = 5, - ATOM_STBL = 6, - ATOM_UDTA = 7, - ATOM_ILST = 8, /* iTunes Metadata list */ - ATOM_TITLE = 9, - ATOM_ARTIST = 10, - ATOM_WRITER = 11, - ATOM_ALBUM = 12, - ATOM_DATE = 13, - ATOM_TOOL = 14, - ATOM_COMMENT = 15, - ATOM_GENRE1 = 16, - ATOM_TRACK = 17, - ATOM_DISC = 18, - ATOM_COMPILATION = 19, - ATOM_GENRE2 = 20, - ATOM_TEMPO = 21, - ATOM_COVER = 22, - ATOM_DRMS = 23, - ATOM_SINF = 24, - ATOM_SCHI = 25, - - SUBATOMIC = 128, - - /* atoms without subatoms */ - ATOM_FTYP = 129, - ATOM_MDAT = 130, - ATOM_MVHD = 131, - ATOM_TKHD = 132, - ATOM_TREF = 133, - ATOM_MDHD = 134, /* track header */ - ATOM_VMHD = 135, - ATOM_SMHD = 136, - ATOM_HMHD = 137, - ATOM_STSD = 138, /* sample description box */ - ATOM_STTS = 139, /* time to sample box */ - ATOM_STSZ = 140, /* sample size box */ - ATOM_STZ2 = 141, - ATOM_STCO = 142, /* chunk offset box */ - ATOM_STSC = 143, /* sample to chunk box */ - ATOM_MP4A = 144, - ATOM_MP4V = 145, - ATOM_MP4S = 146, - ATOM_ESDS = 147, - ATOM_META = 148, /* iTunes Metadata box */ - ATOM_NAME = 149, /* iTunes Metadata name box */ - ATOM_DATA = 150, /* iTunes Metadata data box */ - ATOM_CTTS = 151, - ATOM_FRMA = 152, - ATOM_IVIV = 153, - ATOM_PRIV = 154, - ATOM_USER = 155, - ATOM_KEY = 156, - ATOM_ALBUM_ARTIST = 157, - ATOM_CONTENTGROUP = 158, - ATOM_LYRICS = 159, - ATOM_DESCRIPTION = 160, - ATOM_NETWORK = 161, - ATOM_SHOW = 162, - ATOM_EPISODENAME = 163, - ATOM_SORTTITLE = 164, - ATOM_SORTALBUM = 165, - ATOM_SORTARTIST = 166, - ATOM_SORTALBUMARTIST = 167, - ATOM_SORTWRITER = 168, - ATOM_SORTSHOW = 169, - ATOM_SEASON = 170, - ATOM_EPISODE = 171, - ATOM_PODCAST = 172, - - ATOM_UNKNOWN = 255 -}; - -#define ATOM_FREE ATOM_UNKNOWN -#define ATOM_SKIP ATOM_UNKNOWN - -#define COPYRIGHT_SYMBOL ((int8_t)0xA9) - -static uint8_t atom_name_to_type(int8_t a, int8_t b, int8_t c, int8_t d) -{ - if (a == 'm') { - if (atom_compare(a, b, c, d, 'm', 'o', 'o', 'v')) - return ATOM_MOOV; - else if (atom_compare(a, b, c, d, 'm', 'i', 'n', 'f')) - return ATOM_MINF; - else if (atom_compare(a, b, c, d, 'm', 'd', 'i', 'a')) - return ATOM_MDIA; - else if (atom_compare(a, b, c, d, 'm', 'd', 'a', 't')) - return ATOM_MDAT; - else if (atom_compare(a, b, c, d, 'm', 'd', 'h', 'd')) - return ATOM_MDHD; - else if (atom_compare(a, b, c, d, 'm', 'v', 'h', 'd')) - return ATOM_MVHD; - else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'a')) - return ATOM_MP4A; - else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'v')) - return ATOM_MP4V; - else if (atom_compare(a, b, c, d, 'm', 'p', '4', 's')) - return ATOM_MP4S; - else if (atom_compare(a, b, c, d, 'm', 'e', 't', 'a')) - return ATOM_META; - } else if (a == 't') { - if (atom_compare(a, b, c, d, 't', 'r', 'a', 'k')) - return ATOM_TRAK; - else if (atom_compare(a, b, c, d, 't', 'k', 'h', 'd')) - return ATOM_TKHD; - else if (atom_compare(a, b, c, d, 't', 'r', 'e', 'f')) - return ATOM_TREF; - else if (atom_compare(a, b, c, d, 't', 'r', 'k', 'n')) - return ATOM_TRACK; - else if (atom_compare(a, b, c, d, 't', 'm', 'p', 'o')) - return ATOM_TEMPO; - else if (atom_compare(a, b, c, d, 't', 'v', 'n', 'n')) - return ATOM_NETWORK; - else if (atom_compare(a, b, c, d, 't', 'v', 's', 'h')) - return ATOM_SHOW; - else if (atom_compare(a, b, c, d, 't', 'v', 'e', 'n')) - return ATOM_EPISODENAME; - else if (atom_compare(a, b, c, d, 't', 'v', 's', 'n')) - return ATOM_SEASON; - else if (atom_compare(a, b, c, d, 't', 'v', 'e', 's')) - return ATOM_EPISODE; - } else if (a == 's') { - if (atom_compare(a, b, c, d, 's', 't', 'b', 'l')) - return ATOM_STBL; - else if (atom_compare(a, b, c, d, 's', 'm', 'h', 'd')) - return ATOM_SMHD; - else if (atom_compare(a, b, c, d, 's', 't', 's', 'd')) - return ATOM_STSD; - else if (atom_compare(a, b, c, d, 's', 't', 't', 's')) - return ATOM_STTS; - else if (atom_compare(a, b, c, d, 's', 't', 'c', 'o')) - return ATOM_STCO; - else if (atom_compare(a, b, c, d, 's', 't', 's', 'c')) - return ATOM_STSC; - else if (atom_compare(a, b, c, d, 's', 't', 's', 'z')) - return ATOM_STSZ; - else if (atom_compare(a, b, c, d, 's', 't', 'z', '2')) - return ATOM_STZ2; - else if (atom_compare(a, b, c, d, 's', 'k', 'i', 'p')) - return ATOM_SKIP; - else if (atom_compare(a, b, c, d, 's', 'i', 'n', 'f')) - return ATOM_SINF; - else if (atom_compare(a, b, c, d, 's', 'c', 'h', 'i')) - return ATOM_SCHI; - else if (atom_compare(a, b, c, d, 's', 'o', 'n', 'm')) - return ATOM_SORTTITLE; - else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'l')) - return ATOM_SORTALBUM; - else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'r')) - return ATOM_SORTARTIST; - else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'a')) - return ATOM_SORTALBUMARTIST; - else if (atom_compare(a, b, c, d, 's', 'o', 'c', 'o')) - return ATOM_SORTWRITER; - else if (atom_compare(a, b, c, d, 's', 'o', 's', 'n')) - return ATOM_SORTSHOW; - } else if (a == COPYRIGHT_SYMBOL) { - if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'n', 'a', 'm')) - return ATOM_TITLE; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'A', 'R', 'T')) - return ATOM_ARTIST; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'w', 'r', 't')) - return ATOM_WRITER; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'a', 'l', 'b')) - return ATOM_ALBUM; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'd', 'a', 'y')) - return ATOM_DATE; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 't', 'o', 'o')) - return ATOM_TOOL; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'c', 'm', 't')) - return ATOM_COMMENT; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'e', 'n')) - return ATOM_GENRE1; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'r', 'p')) - return ATOM_CONTENTGROUP; - else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'l', 'y', 'r')) - return ATOM_LYRICS; - } - - if (atom_compare(a, b, c, d, 'e', 'd', 't', 's')) - return ATOM_EDTS; - else if (atom_compare(a, b, c, d, 'e', 's', 'd', 's')) - return ATOM_ESDS; - else if (atom_compare(a, b, c, d, 'f', 't', 'y', 'p')) - return ATOM_FTYP; - else if (atom_compare(a, b, c, d, 'f', 'r', 'e', 'e')) - return ATOM_FREE; - else if (atom_compare(a, b, c, d, 'h', 'm', 'h', 'd')) - return ATOM_HMHD; - else if (atom_compare(a, b, c, d, 'v', 'm', 'h', 'd')) - return ATOM_VMHD; - else if (atom_compare(a, b, c, d, 'u', 'd', 't', 'a')) - return ATOM_UDTA; - else if (atom_compare(a, b, c, d, 'i', 'l', 's', 't')) - return ATOM_ILST; - else if (atom_compare(a, b, c, d, 'n', 'a', 'm', 'e')) - return ATOM_NAME; - else if (atom_compare(a, b, c, d, 'd', 'a', 't', 'a')) - return ATOM_DATA; - else if (atom_compare(a, b, c, d, 'd', 'i', 's', 'k')) - return ATOM_DISC; - else if (atom_compare(a, b, c, d, 'g', 'n', 'r', 'e')) - return ATOM_GENRE2; - else if (atom_compare(a, b, c, d, 'c', 'o', 'v', 'r')) - return ATOM_COVER; - else if (atom_compare(a, b, c, d, 'c', 'p', 'i', 'l')) - return ATOM_COMPILATION; - else if (atom_compare(a, b, c, d, 'c', 't', 't', 's')) - return ATOM_CTTS; - else if (atom_compare(a, b, c, d, 'd', 'r', 'm', 's')) - return ATOM_DRMS; - else if (atom_compare(a, b, c, d, 'f', 'r', 'm', 'a')) - return ATOM_FRMA; - else if (atom_compare(a, b, c, d, 'p', 'r', 'i', 'v')) - return ATOM_PRIV; - else if (atom_compare(a, b, c, d, 'i', 'v', 'i', 'v')) - return ATOM_IVIV; - else if (atom_compare(a, b, c, d, 'u', 's', 'e', 'r')) - return ATOM_USER; - else if (atom_compare(a, b, c, d, 'k', 'e', 'y', ' ')) - return ATOM_KEY; - else if (atom_compare(a, b, c, d, 'a', 'A', 'R', 'T')) - return ATOM_ALBUM_ARTIST; - else if (atom_compare(a, b, c, d, 'd', 'e', 's', 'c')) - return ATOM_DESCRIPTION; - else if (atom_compare(a, b, c, d, 'p', 'c', 's', 't')) - return ATOM_PODCAST; - else - return ATOM_UNKNOWN; +#define ATOM_ITEMS \ + ATOM_ITEM(MOOV, 'm', 'o', 'o', 'v') \ + ATOM_ITEM(TRAK, 't', 'r', 'a', 'k') \ + ATOM_ITEM(MDIA, 'm', 'd', 'i', 'a') \ + ATOM_ITEM(MINF, 'm', 'i', 'n', 'f') \ + ATOM_ITEM(STBL, 's', 't', 'b', 'l') \ + ATOM_ITEM(UDTA, 'u', 'd', 't', 'a') \ + ATOM_ITEM(ILST, 'i', 'l', 's', 't') /* iTunes Metadata list */ \ + ATOM_ITEM(ARTIST, 0xa9, 'A', 'R', 'T') \ + ATOM_ITEM(TITLE, 0xa9, 'n', 'a', 'm') \ + ATOM_ITEM(ALBUM, 0xa9, 'a', 'l', 'b') \ + ATOM_ITEM(DATE, 0xa9, 'd', 'a', 'y') \ + ATOM_ITEM(COMMENT, 0xa9, 'c', 'm', 't') \ + ATOM_ITEM(MDHD, 'm', 'd', 'h', 'd') /* track header */ \ + ATOM_ITEM(STSD, 's', 't', 's', 'd') /* sample description box */ \ + ATOM_ITEM(STTS, 's', 't', 't', 's') /* time to sample box */ \ + ATOM_ITEM(STSZ, 's', 't', 's', 'z') /* sample size box */ \ + ATOM_ITEM(STCO, 's', 't', 'c', 'o') /* chunk offset box */ \ + ATOM_ITEM(STSC, 's', 't', 's', 'c') /* sample to chunk box */ \ + ATOM_ITEM(MP4A, 'm', 'p', '4', 'a') \ + ATOM_ITEM(META, 'm', 'e', 't', 'a') /* iTunes Metadata box */ \ + ATOM_ITEM(DATA, 'd', 'a', 't', 'a') /* iTunes Metadata data box */ \ + +#define ATOM_ITEM(_name, a, b, c, d) ATOM_ ## _name, +enum atom {ATOM_ITEMS}; +#undef ATOM_ITEM + +static uint8_t atom_name_to_type(uint8_t *p) +{ + #define ATOM_VALUE(a, b, c, d) ((a << 24) + (b << 16) + (c << 8) + d) + #define ATOM_ITEM(_name, a, b, c, d) \ + {.name = # _name, .val = ATOM_VALUE(a, b, c, d)}, + static const struct { + const char *name; + uint32_t val; + } atom_table[] = {ATOM_ITEMS}; + #undef ATOM_ITEM + uint32_t val = read_u32_be(p); + + for (uint8_t n = 0; n < ARRAY_SIZE(atom_table); n++) + if (val == atom_table[n].val) + return n; + return 255; } /* read atom header, atom size is returned with header included. */ @@ -387,7 +166,7 @@ static int atom_read_header(struct mp4 *f, uint8_t *atom_type, { uint32_t size; int ret; - int8_t atom_header[8]; + uint8_t atom_header[8]; ret = read_data(f, atom_header, 8); if (ret <= 0) @@ -405,22 +184,23 @@ static int atom_read_header(struct mp4 *f, uint8_t *atom_type, if (atom_size) *atom_size = size; } - *atom_type = atom_name_to_type(atom_header[4], atom_header[5], - atom_header[6], atom_header[7]); + *atom_type = atom_name_to_type(atom_header + 4); return 1; } -static int64_t get_position(const struct mp4 *f) +static off_t get_position(const struct mp4 *f) { - return f->current_position; + return f->cb->seek(f->cb->user_data, 0, SEEK_CUR); } -static int32_t set_position(struct mp4 *f, int64_t position) +static void set_position(struct mp4 *f, off_t position) { - f->cb->seek(f->cb->user_data, position); - f->current_position = position; + f->cb->seek(f->cb->user_data, position, SEEK_SET); +} - return 0; +static void skip_bytes(struct mp4 *f, off_t num_skip) +{ + f->cb->seek(f->cb->user_data, num_skip, SEEK_CUR); } static int read_stsz(struct mp4 *f) @@ -432,12 +212,7 @@ static int read_stsz(struct mp4 *f) if (f->total_tracks == 0) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stsz_sample_size); if (ret <= 0) return ret; @@ -466,12 +241,7 @@ static int read_stts(struct mp4 *f) t = f->track[f->total_tracks - 1]; if (t->stts_entry_count) return 0; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stts_entry_count); if (ret <= 0) return ret; @@ -481,9 +251,7 @@ static int read_stts(struct mp4 *f) ret = read_int32(f, &t->stts_sample_count[i]); if (ret <= 0) return ret; - ret = read_int32(f, NULL); /* sample delta */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* sample delta */ } return 1; } @@ -498,12 +266,7 @@ static int read_stsc(struct mp4 *f) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stsc_entry_count); if (ret <= 0) return ret; @@ -517,9 +280,7 @@ static int read_stsc(struct mp4 *f) ret = read_int32(f, &t->stsc_samples_per_chunk[i]); if (ret <= 0) return ret; - ret = read_int32(f, NULL); /* sample desc index */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* sample desc index */ } return 1; } @@ -534,12 +295,7 @@ static int read_stco(struct mp4 *f) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stco_entry_count); if (ret <= 0) return ret; @@ -553,45 +309,6 @@ static int read_stco(struct mp4 *f) return 1; } -static int read_mp4a(struct mp4 *f) -{ - int ret; - int32_t i; - struct mp4_track *t; - - if (f->total_tracks == 0) - return -1; - t = f->track[f->total_tracks - 1]; - - for (i = 0; i < 6; i++) { - ret = read_int8(f, NULL); /* reserved */ - if (ret <= 0) - return ret; - } - ret = read_int16(f, NULL); /* data_reference_index */ - if (ret <= 0) - return ret; - ret = read_int32(f, NULL); /* reserved */ - if (ret <= 0) - return ret; - ret = read_int32(f, NULL); /* reserved */ - if (ret <= 0) - return ret; - ret = read_int16(f, &t->channelCount); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - return read_int16(f, &t->sampleRate); -} - static int read_stsd(struct mp4 *f) { int ret; @@ -601,12 +318,7 @@ static int read_stsd(struct mp4 *f) if (f->total_tracks == 0) return -1; t = f->track[f->total_tracks - 1]; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &entry_count); if (ret <= 0) return ret; @@ -620,7 +332,15 @@ static int read_stsd(struct mp4 *f) skip += size; if (!f->audio_track && atom_type == ATOM_MP4A) { f->audio_track = t; - read_mp4a(f); + /* reserved (6), data reference index (2), reserved (8) */ + skip_bytes(f, 16); + ret = read_int16(f, &t->channel_count); + if (ret <= 0) + return ret; + skip_bytes(f, 6); + ret = read_int16(f, &t->sample_rate); + if (ret <= 0) + return ret; } set_position(f, skip); } @@ -661,15 +381,7 @@ static int parse_tag(struct mp4 *f, uint8_t parent, int32_t size) destpos = get_position(f) + subsize - header_size; if (atom_type != ATOM_DATA) continue; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - goto fail; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - goto fail; - ret = read_int32(f, NULL); /* reserved */ - if (ret <= 0) - goto fail; + skip_bytes(f, 8); /* version (1), flags (3), reserved (4) */ ret = -ERRNO_TO_PARA_ERROR(EINVAL); if (subsize < header_size + 8 || subsize > UINT_MAX) goto fail; @@ -710,13 +422,8 @@ static int read_mdhd(struct mp4 *f) if (ret <= 0) return ret; if (version == 1) { - ret = read_int64(f, NULL); /* creation-time */ - if (ret <= 0) - return ret; - ret = read_int64(f, NULL); /* modification-time */ - if (ret <= 0) - return ret; - ret = read_int32(f, &t->timeScale); + skip_bytes(f, 16); /* creation time (8), modification time (8) */ + ret = read_int32(f, &t->time_scale); if (ret <= 0) return ret; ret = read_int64(f, &t->duration); @@ -725,13 +432,8 @@ static int read_mdhd(struct mp4 *f) } else { //version == 0 uint32_t temp; - ret = read_int32(f, NULL); /* creation-time */ - if (ret <= 0) - return ret; - ret = read_int32(f, NULL); /* modification-time */ - if (ret <= 0) - return ret; - ret = read_int32(f, &t->timeScale); + skip_bytes(f, 8); /* creation time (4), modification time (4) */ + ret = read_int32(f, &t->time_scale); if (ret <= 0) return ret; ret = read_int32(f, &temp); @@ -740,12 +442,7 @@ static int read_mdhd(struct mp4 *f) t->duration = (temp == (uint32_t) (-1))? (uint64_t) (-1) : (uint64_t) (temp); } - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; - ret = read_int16(f, NULL); - if (ret <= 0) - return ret; + skip_bytes(f, 4); return 1; } @@ -785,12 +482,7 @@ static int32_t read_meta(struct mp4 *f, uint64_t size) uint8_t atom_type; uint8_t header_size = 0; - ret = read_int8(f, NULL); /* version */ - if (ret <= 0) - return ret; - ret = read_int24(f, NULL); /* flags */ - if (ret <= 0) - return ret; + skip_bytes(f, 4); /* version (1), flags (3) */ while (sumsize < (size - (header_size + 4))) { ret = atom_read_header(f, &atom_type, &header_size, &subsize); if (ret <= 0) @@ -810,29 +502,6 @@ static int32_t read_meta(struct mp4 *f, uint64_t size) return 1; } -static int parse_leaf_atom(struct mp4 *f, uint64_t size, uint8_t header_size, - uint8_t atom_type) -{ - uint64_t dest_position = get_position(f) + size - 8; - int ret = 1; /* return success for atoms we don't care about */ - - switch (atom_type) { - case ATOM_STSZ: ret = read_stsz(f); break; - case ATOM_STTS: ret = read_stts(f); break; - case ATOM_STSC: ret = read_stsc(f); break; - case ATOM_STCO: ret = read_stco(f); break; - case ATOM_STSD: ret = read_stsd(f); break; - case ATOM_MDHD: ret = read_mdhd(f); break; - case ATOM_META: - f->meta_offset = get_position(f) - header_size; - f->meta_size = size; - ret = read_meta(f, size); - break; - } - set_position(f, dest_position); - return ret; -} - static bool need_atom(uint8_t atom_type, bool meta_only) { /* these are needed in any case */ @@ -865,18 +534,16 @@ static bool need_atom(uint8_t atom_type, bool meta_only) static int parse_sub_atoms(struct mp4 *f, uint64_t total_size, bool meta_only) { int ret; - uint64_t size; - uint8_t atom_type = 0; - uint64_t counted_size = 0; - uint8_t header_size = 0; + uint64_t dest, size, end = get_position(f) + total_size; - while (counted_size < total_size) { + for (dest = get_position(f); dest < end; set_position(f, dest)) { + uint8_t header_size, atom_type; ret = atom_read_header(f, &atom_type, &header_size, &size); if (ret <= 0) return ret; if (size == 0) return -1; - counted_size += size; + dest = get_position(f) + size - header_size; if (atom_type == ATOM_TRAK) { if (f->total_tracks >= MAX_TRACKS) return -1; @@ -887,14 +554,23 @@ static int parse_sub_atoms(struct mp4 *f, uint64_t total_size, bool meta_only) f->udta_offset = get_position(f) - header_size; f->udta_size = size; } - if (!need_atom(atom_type, meta_only)) { - set_position(f, get_position(f) + size - header_size); + if (!need_atom(atom_type, meta_only)) continue; - } - if (atom_type < SUBATOMIC) /* atom contains subatoms */ + switch (atom_type) { + case ATOM_STSZ: ret = read_stsz(f); break; + case ATOM_STTS: ret = read_stts(f); break; + case ATOM_STSC: ret = read_stsc(f); break; + case ATOM_STCO: ret = read_stco(f); break; + case ATOM_STSD: ret = read_stsd(f); break; + case ATOM_MDHD: ret = read_mdhd(f); break; + case ATOM_META: + f->meta_offset = get_position(f) - header_size; + f->meta_size = size; + ret = read_meta(f, size); + break; + default: ret = parse_sub_atoms(f, size - header_size, meta_only); - else - ret = parse_leaf_atom(f, size, header_size, atom_type); + } if (ret <= 0) return ret; } @@ -910,7 +586,6 @@ static int open_file(const struct mp4_callback *cb, bool meta_only, struct mp4 * f->cb = cb; while ((ret = atom_read_header(f, &atom_type, &header_size, &size)) > 0) { - f->file_size += size; f->last_atom = atom_type; if (atom_type != ATOM_MOOV || size <= header_size) { /* skip */ set_position(f, get_position(f) + size - header_size); @@ -994,9 +669,9 @@ uint64_t mp4_get_duration(const struct mp4 *f) { const struct mp4_track *t = f->audio_track; - if (t->timeScale == 0) + if (t->time_scale == 0) return 0; - return t->duration * 1000 / t->timeScale; + return t->duration * 1000 / t->time_scale; } int mp4_set_sample_position(struct mp4 *f, int32_t sample) @@ -1035,12 +710,12 @@ int32_t mp4_get_sample_size(const struct mp4 *f, int sample) uint32_t mp4_get_sample_rate(const struct mp4 *f) { - return f->audio_track->sampleRate; + return f->audio_track->sample_rate; } uint32_t mp4_get_channel_count(const struct mp4 *f) { - return f->audio_track->channelCount ; + return f->audio_track->channel_count; } int32_t mp4_num_samples(const struct mp4 *f) @@ -1083,68 +758,11 @@ struct mp4_metadata *mp4_get_meta(struct mp4 *f) return &f->meta; } -struct membuffer { - void *data; - unsigned written; - unsigned allocated; -}; - -static struct membuffer *membuffer_create(void) -{ - struct membuffer *buf = para_calloc(sizeof(*buf)); - - buf->allocated = 256; - buf->data = para_malloc(buf->allocated); - return buf; -} - -static void membuffer_write(struct membuffer *buf, const void *ptr, - unsigned bytes) +/** Total length of an on-disk metadata tag. */ +#define TAG_LEN(_len) (24 + (_len)) +static void create_ilst(const struct mp4_metadata *meta, uint8_t *out) { - unsigned dest_size = buf->written + bytes; - - if (dest_size > buf->allocated) { - do { - buf->allocated <<= 1; - } while (dest_size > buf->allocated); - buf->data = para_realloc(buf->data, buf->allocated); - } - - if (ptr) - memcpy((char *) buf->data + buf->written, ptr, bytes); - buf->written += bytes; -} - -static void membuffer_write_atom_name(struct membuffer *buf, const char *data) -{ - membuffer_write(buf, data, 4); -} - -static void membuffer_write_int32(struct membuffer *buf, uint32_t data) -{ - uint8_t temp[4]; - write_u32_be(temp, data); - membuffer_write(buf, temp, 4); -} - -static unsigned membuffer_get_size(const struct membuffer *buf) -{ - return buf->written; -} - -static void *membuffer_detach(struct membuffer *buf) -{ - void *ret = para_realloc(buf->data, buf->written); - free(buf); - return ret; -} - -static void *create_ilst(const struct mp4_metadata *meta, uint32_t *out_size) -{ - struct membuffer *buf = membuffer_create(); - unsigned n; - - for (n = 0; n < meta->count; n++) { + for (unsigned n = 0; n < meta->count; n++) { struct mp4_tag *tag = meta->tags + n; unsigned len = strlen(tag->value); const char *atom_name; @@ -1161,26 +779,17 @@ static void *create_ilst(const struct mp4_metadata *meta, uint32_t *out_size) atom_name = "\xA9" "cmt"; else assert(false); - membuffer_write_int32(buf, 8 /* atom header */ - + 8 /* data atom header */ - + 8 /* flags + reserved */ - + len); - membuffer_write_atom_name(buf, atom_name); - membuffer_write_int32(buf, 8 /* data atom header */ + write_u32_be(out, TAG_LEN(len)); + memcpy(out + 4, atom_name, 4); + write_u32_be(out + 8, 8 /* data atom header */ + 8 /* flags + reserved */ + len); - membuffer_write_atom_name(buf, "data"); - membuffer_write_int32(buf, 1); /* flags */ - membuffer_write_int32(buf, 0); /* reserved */ - membuffer_write(buf, tag->value, len); + memcpy(out + 12, "data", 4); + write_u32_be(out + 16, 1); /* flags */ + write_u32_be(out + 20, 0); /* reserved */ + memcpy(out + 24, tag->value, len); + out += TAG_LEN(len); } - *out_size = membuffer_get_size(buf); - return membuffer_detach(buf); -} - -static uint32_t fix_byte_order_32(uint32_t src) -{ - return read_u32_be(&src); } static void *modify_moov(struct mp4 *f, uint32_t *out_size) @@ -1188,13 +797,14 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) int ret; uint64_t total_base = f->moov_offset + 8; uint32_t total_size = (uint32_t) (f->moov_size - 8); - uint32_t new_ilst_size; - void *new_ilst_buffer, *out_buffer; + uint32_t new_ilst_size = 0; + void *out_buffer; uint8_t *p_out; int32_t size_delta; uint32_t tmp; - new_ilst_buffer = create_ilst(&f->meta, &new_ilst_size); + for (unsigned n = 0; n < f->meta.count; n++) + new_ilst_size += TAG_LEN(strlen(f->meta.tags[n].value)); size_delta = new_ilst_size - (f->ilst_size - 8); *out_size = total_size + size_delta; out_buffer = para_malloc(*out_size); @@ -1207,7 +817,7 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) ret = read_int32(f, &tmp); if (ret <= 0) return NULL; - *(uint32_t *)p_out = fix_byte_order_32(tmp + size_delta); + write_u32_be(p_out, tmp + size_delta); p_out += 4; ret = read_data(f, p_out, 4); if (ret <= 0) @@ -1220,7 +830,7 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) ret = read_int32(f, &tmp); if (ret <= 0) return NULL; - *(uint32_t *)p_out = fix_byte_order_32(tmp + size_delta); + write_u32_be(p_out, tmp + size_delta); p_out += 4; ret = read_data(f, p_out, 4); if (ret <= 0) @@ -1233,45 +843,42 @@ static void *modify_moov(struct mp4 *f, uint32_t *out_size) ret = read_int32(f, &tmp); if (ret <= 0) return NULL; - *(uint32_t *)p_out = fix_byte_order_32(tmp + size_delta); + write_u32_be(p_out, tmp + size_delta); p_out += 4; ret = read_data(f, p_out, 4); if (ret <= 0) return NULL; p_out += 4; - memcpy(p_out, new_ilst_buffer, new_ilst_size); + create_ilst(&f->meta, p_out); p_out += new_ilst_size; set_position(f, f->ilst_offset + f->ilst_size); ret = read_data(f, p_out, total_size - (f->ilst_offset - total_base) - f->ilst_size); if (ret <= 0) return NULL; - free(new_ilst_buffer); return out_buffer; } -static int32_t write_data(struct mp4 *f, void *data, uint32_t size) -{ - int32_t result = 1; - - result = f->cb->write(f->cb->user_data, data, size); - - f->current_position += size; - - return result; -} - -static int32_t write_int32(struct mp4 *f, uint32_t data) +static int write_data(struct mp4 *f, void *data, size_t size) { - int8_t temp[4]; - write_u32_be(temp, data); - return write_data(f, temp, sizeof(temp)); + while (size > 0) { + ssize_t ret = f->cb->write(f->cb->user_data, data, size); + if (ret < 0) { + if (errno == EINTR) + continue; + return -ERRNO_TO_PARA_ERROR(errno); + } + size -= ret; + } + return 1; } -int32_t mp4_meta_update(struct mp4 *f) +int mp4_meta_update(struct mp4 *f) { void *new_moov_data; uint32_t new_moov_size; + uint8_t buf[8] = "----moov"; + int ret; set_position(f, 0); new_moov_data = modify_moov(f, &new_moov_size); @@ -1279,27 +886,27 @@ int32_t mp4_meta_update(struct mp4 *f) mp4_close(f); return 0; } - /* copy moov atom to end of the file */ if (f->last_atom != ATOM_MOOV) { - char *free_data = "free"; - - /* rename old moov to free */ set_position(f, f->moov_offset + 4); - write_data(f, free_data, 4); - - set_position(f, f->file_size); - write_int32(f, new_moov_size + 8); - write_data(f, "moov", 4); - write_data(f, new_moov_data, new_moov_size); - } else { + ret = write_data(f, "free", 4); /* rename old moov to free */ + if (ret < 0) + goto free_moov; + /* write new moov atom at EOF */ + f->cb->seek(f->cb->user_data, 0, SEEK_END); + } else /* overwrite old moov atom */ set_position(f, f->moov_offset); - write_int32(f, new_moov_size + 8); - write_data(f, "moov", 4); - write_data(f, new_moov_data, new_moov_size); - } - free(new_moov_data); + write_u32_be(buf, new_moov_size + 8); + ret = write_data(f, buf, sizeof(buf)); + if (ret < 0) + goto free_moov; + ret = write_data(f, new_moov_data, new_moov_size); + if (ret < 0) + goto free_moov; f->cb->truncate(f->cb->user_data); - return 1; + ret = 1; +free_moov: + free(new_moov_data); + return ret; } static char *meta_find_by_name(const struct mp4 *f, const char *item)