X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=mp4.c;h=b12cbbf48c121c83c8b1bf40c92196fa5d051841;hb=a318723afb0893cbbacfd5ad5bce356ac1ddfd7a;hp=365dce6550a5a150d1736cd194de8318667f4492;hpb=2ca18e6d22391a7eded4a21925a44860a9840ecf;p=paraslash.git diff --git a/mp4.c b/mp4.c index 365dce65..b12cbbf4 100644 --- a/mp4.c +++ b/mp4.c @@ -13,7 +13,23 @@ #include "string.h" #include "mp4.h" +/** + * The three states of the mp4 parser. The parser only loads the audio specific + * values and tables when it is in the second state. + */ +enum audio_track_state { + /** We haven't encountered an mp4a atom so far. */ + ATS_INITIAL, + /** We have seen an mp4a atom but no subsequent trak atom yet. */ + ATS_SEEN_MP4A, + /** A trak atom was seen *after* the mp4a atom. */ + ATS_TRACK_CHANGE, +}; + struct mp4_track { + /* determines which atoms we still need to parse. */ + enum audio_track_state state; + /* mp4a */ uint16_t channel_count; uint16_t sample_rate; @@ -41,8 +57,6 @@ struct mp4_track { uint64_t duration; }; -#define MAX_TRACKS 1024 - struct mp4 { const struct mp4_callback *cb; @@ -56,20 +70,13 @@ struct mp4 { uint32_t udta_size; uint8_t last_atom; - /* incremental track index while reading the file */ - int32_t total_tracks; - /* track data */ - struct mp4_track *track[MAX_TRACKS]; - /* the first audio track found */ - struct mp4_track *audio_track; - - /* metadata */ + struct mp4_track track; struct mp4_metadata meta; }; /* - * Returns -1, 0, or 1 on errors/EOF/success. Partial reads followed by EOF or - * read errors are treated as errors. + * Returns -E_MP4_READ, 0, or 1 on errors/EOF/success. Partial reads followed + * by EOF or read errors are treated as errors. */ static int read_data(struct mp4 *f, void *data, size_t size) { @@ -79,7 +86,7 @@ static int read_data(struct mp4 *f, void *data, size_t size) continue; /* regard EAGAIN as an error as reads should be blocking. */ if (ret <= 0) - return ret < 0? -1 : 0; + return ret < 0? -E_MP4_READ : 0; size -= ret; } return 1; @@ -181,8 +188,7 @@ static int atom_read_header(struct mp4 *f, uint8_t *atom_type, } else { if (header_size) *header_size = 8; - if (atom_size) - *atom_size = size; + *atom_size = size; } *atom_type = atom_name_to_type(atom_header + 4); return 1; @@ -206,12 +212,10 @@ static void skip_bytes(struct mp4 *f, off_t num_skip) static int read_stsz(struct mp4 *f) { int ret; - int32_t i; - struct mp4_track *t; + struct mp4_track *t = &f->track; - if (f->total_tracks == 0) - return -1; - t = f->track[f->total_tracks - 1]; + if (t->state != ATS_SEEN_MP4A || t->stsz_table) + return 1; skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stsz_sample_size); if (ret <= 0) @@ -222,8 +226,8 @@ static int read_stsz(struct mp4 *f) if (t->stsz_sample_size != 0) return 1; t->stsz_table = para_malloc(t->stsz_sample_count * sizeof(int32_t)); - for (i = 0; i < t->stsz_sample_count; i++) { - ret = read_int32(f, &t->stsz_table[i]); + for (uint32_t n = 0; n < t->stsz_sample_count; n++) { + ret = read_int32(f, &t->stsz_table[n]); if (ret <= 0) return ret; } @@ -233,22 +237,18 @@ static int read_stsz(struct mp4 *f) static int read_stts(struct mp4 *f) { int ret; - int32_t i; - struct mp4_track *t; + struct mp4_track *t = &f->track; - if (f->total_tracks == 0) - return -1; - t = f->track[f->total_tracks - 1]; - if (t->stts_entry_count) - return 0; + if (t->state != ATS_SEEN_MP4A || t->stts_sample_count) + return 1; skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stts_entry_count); if (ret <= 0) return ret; t->stts_sample_count = para_malloc(t->stts_entry_count * sizeof(int32_t)); - for (i = 0; i < t->stts_entry_count; i++) { - ret = read_int32(f, &t->stts_sample_count[i]); + for (uint32_t n = 0; n < t->stts_entry_count; n++) { + ret = read_int32(f, &t->stts_sample_count[n]); if (ret <= 0) return ret; skip_bytes(f, 4); /* sample delta */ @@ -259,13 +259,12 @@ static int read_stts(struct mp4 *f) static int read_stsc(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]; + struct mp4_track *t = &f->track; + if (t->state != ATS_SEEN_MP4A) + return 1; + if (t->stsc_first_chunk || t->stsc_samples_per_chunk) + return 1; skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stsc_entry_count); if (ret <= 0) @@ -273,11 +272,11 @@ static int read_stsc(struct mp4 *f) t->stsc_first_chunk = para_malloc(t->stsc_entry_count * sizeof(int32_t)); t->stsc_samples_per_chunk = para_malloc(t->stsc_entry_count * sizeof (int32_t)); - for (i = 0; i < t->stsc_entry_count; i++) { - ret = read_int32(f, &t->stsc_first_chunk[i]); + for (uint32_t n = 0; n < t->stsc_entry_count; n++) { + ret = read_int32(f, &t->stsc_first_chunk[n]); if (ret <= 0) return ret; - ret = read_int32(f, &t->stsc_samples_per_chunk[i]); + ret = read_int32(f, &t->stsc_samples_per_chunk[n]); if (ret <= 0) return ret; skip_bytes(f, 4); /* sample desc index */ @@ -288,21 +287,18 @@ static int read_stsc(struct mp4 *f) static int read_stco(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]; + struct mp4_track *t = &f->track; + if (t->state != ATS_SEEN_MP4A || t->stco_chunk_offset) + return 1; skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &t->stco_entry_count); if (ret <= 0) return ret; t->stco_chunk_offset = para_malloc(t->stco_entry_count * sizeof(int32_t)); - for (i = 0; i < t->stco_entry_count; i++) { - ret = read_int32(f, &t->stco_chunk_offset[i]); + for (uint32_t n = 0; n < t->stco_entry_count; n++) { + ret = read_int32(f, &t->stco_chunk_offset[n]); if (ret <= 0) return ret; } @@ -312,17 +308,15 @@ static int read_stco(struct mp4 *f) static int read_stsd(struct mp4 *f) { int ret; - uint32_t i, entry_count; - struct mp4_track *t; + uint32_t entry_count; - if (f->total_tracks == 0) - return -1; - t = f->track[f->total_tracks - 1]; + if (f->track.state != ATS_INITIAL) + return 1; skip_bytes(f, 4); /* version (1), flags (3) */ ret = read_int32(f, &entry_count); if (ret <= 0) return ret; - for (i = 0; i < entry_count; i++) { + for (uint32_t n = 0; n < entry_count; n++) { uint64_t skip = get_position(f); uint64_t size; uint8_t atom_type = 0; @@ -330,15 +324,15 @@ static int read_stsd(struct mp4 *f) if (ret <= 0) return ret; skip += size; - if (!f->audio_track && atom_type == ATOM_MP4A) { - f->audio_track = t; + if (atom_type == ATOM_MP4A) { + f->track.state = ATS_SEEN_MP4A; /* reserved (6), data reference index (2), reserved (8) */ skip_bytes(f, 16); - ret = read_int16(f, &t->channel_count); + ret = read_int16(f, &f->track.channel_count); if (ret <= 0) return ret; skip_bytes(f, 6); - ret = read_int16(f, &t->sample_rate); + ret = read_int16(f, &f->track.sample_rate); if (ret <= 0) return ret; } @@ -382,7 +376,7 @@ static int parse_tag(struct mp4 *f, uint8_t parent, int32_t size) if (atom_type != ATOM_DATA) continue; skip_bytes(f, 8); /* version (1), flags (3), reserved (4) */ - ret = -ERRNO_TO_PARA_ERROR(EINVAL); + ret = -E_MP4_CORRUPT; if (subsize < header_size + 8 || subsize > UINT_MAX) goto fail; len = subsize - (header_size + 8); @@ -394,7 +388,7 @@ static int parse_tag(struct mp4 *f, uint8_t parent, int32_t size) value[len] = '\0'; } if (!value) - return -ERRNO_TO_PARA_ERROR(EINVAL); + return -E_MP4_CORRUPT; f->meta.tags = para_realloc(f->meta.tags, (f->meta.count + 1) * sizeof(struct mp4_tag)); tag = f->meta.tags + f->meta.count; @@ -412,12 +406,10 @@ static int read_mdhd(struct mp4 *f) { int ret; uint32_t version; - struct mp4_track *t; - - if (f->total_tracks == 0) - return -1; - t = f->track[f->total_tracks - 1]; + struct mp4_track *t = &f->track; + if (t->state != ATS_INITIAL) + return 1; ret = read_int32(f, &version); if (ret <= 0) return ret; @@ -542,15 +534,13 @@ static int parse_sub_atoms(struct mp4 *f, uint64_t total_size, bool meta_only) if (ret <= 0) return ret; if (size == 0) - return -1; + return -E_MP4_CORRUPT; dest = get_position(f) + size - header_size; - if (atom_type == ATOM_TRAK) { - if (f->total_tracks >= MAX_TRACKS) - return -1; - f->total_tracks++; - f->track[f->total_tracks - 1] = para_calloc( - sizeof(struct mp4_track)); - } else if (atom_type == ATOM_UDTA) { + if (atom_type == ATOM_TRAK && f->track.state == ATS_SEEN_MP4A) { + f->track.state = ATS_TRACK_CHANGE; + continue; + } + if (atom_type == ATOM_UDTA) { f->udta_offset = get_position(f) - header_size; f->udta_size = size; } @@ -597,12 +587,13 @@ static int open_file(const struct mp4_callback *cb, bool meta_only, struct mp4 * if (ret <= 0) break; } - if (ret < 0) { - ret = -E_MP4_OPEN; + if (ret < 0) goto fail; - } ret = -E_MP4_TRACK; - if (!f->audio_track) + if (f->track.channel_count == 0) + goto fail; + ret = -E_MP4_BAD_SAMPLERATE; + if (f->track.sample_rate == 0) goto fail; *result = f; return 1; @@ -614,26 +605,33 @@ fail: int mp4_open_read(const struct mp4_callback *cb, struct mp4 **result) { - return open_file(cb, false, result); + struct mp4 *f; + int ret; + + *result = NULL; + ret = open_file(cb, false, &f); + if (ret < 0) + return ret; + ret = -E_MP4_BAD_SAMPLE_COUNT; + if (f->track.stsz_sample_count == 0) + goto fail; + *result = f; + return 1; +fail: + mp4_close(f); + return ret; } void mp4_close(struct mp4 *f) { - int32_t i; - - for (i = 0; i < f->total_tracks; i++) { - if (f->track[i]) { - free(f->track[i]->stsz_table); - free(f->track[i]->stts_sample_count); - free(f->track[i]->stsc_first_chunk); - free(f->track[i]->stsc_samples_per_chunk); - free(f->track[i]->stco_chunk_offset); - free(f->track[i]); - } - } - for (i = 0; i < f->meta.count; i++) { - free(f->meta.tags[i].item); - free(f->meta.tags[i].value); + free(f->track.stsz_table); + free(f->track.stts_sample_count); + free(f->track.stsc_first_chunk); + free(f->track.stsc_samples_per_chunk); + free(f->track.stco_chunk_offset); + for (uint32_t n = 0; n < f->meta.count; n++) { + free(f->meta.tags[n].item); + free(f->meta.tags[n].value); } free(f->meta.tags); free(f); @@ -642,17 +640,17 @@ void mp4_close(struct mp4 *f) static int32_t chunk_of_sample(const struct mp4 *f, int32_t sample, int32_t *chunk) { - const struct mp4_track *t = f->audio_track; + const struct mp4_track *t = &f->track; uint32_t *fc = t->stsc_first_chunk, *spc = t->stsc_samples_per_chunk; - int32_t chunk1, chunk1samples, n, total, i; + uint32_t chunk1, chunk1samples, n, total, k; - for (i = 1, total = 0; i < t->stsc_entry_count; i++, total += n) { - n = (fc[i] - fc[i - 1]) * spc[i - 1]; /* number of samples */ + for (k = 1, total = 0; k < t->stsc_entry_count; k++, total += n) { + n = (fc[k] - fc[k - 1]) * spc[k - 1]; /* number of samples */ if (sample < total + n) break; } - chunk1 = fc[i - 1]; - chunk1samples = spc[i - 1]; + chunk1 = fc[k - 1]; + chunk1samples = spc[k - 1]; if (chunk1samples != 0) *chunk = (sample - total) / chunk1samples + chunk1; else @@ -667,16 +665,16 @@ static int32_t chunk_of_sample(const struct mp4 *f, int32_t sample, */ uint64_t mp4_get_duration(const struct mp4 *f) { - const struct mp4_track *t = f->audio_track; + const struct mp4_track *t = &f->track; if (t->time_scale == 0) return 0; return t->duration * 1000 / t->time_scale; } -int mp4_set_sample_position(struct mp4 *f, int32_t sample) +int mp4_set_sample_position(struct mp4 *f, uint32_t sample) { - const struct mp4_track *t = f->audio_track; + const struct mp4_track *t = &f->track; int32_t offset, chunk, chunk_sample; uint32_t n, srs; /* sample range size */ @@ -699,33 +697,36 @@ int mp4_set_sample_position(struct mp4 *f, int32_t sample) return 1; } -int32_t mp4_get_sample_size(const struct mp4 *f, int sample) +int mp4_get_sample_size(const struct mp4 *f, uint32_t sample, uint32_t *result) { - const struct mp4_track *t = f->audio_track; + const struct mp4_track *t = &f->track; + if (sample >= t->stsz_sample_count) + return -ERRNO_TO_PARA_ERROR(EINVAL); if (t->stsz_sample_size != 0) - return t->stsz_sample_size; - return t->stsz_table[sample]; + *result = t->stsz_sample_size; + else + *result = t->stsz_table[sample]; + return 1; } uint32_t mp4_get_sample_rate(const struct mp4 *f) { - return f->audio_track->sample_rate; + return f->track.sample_rate; } -uint32_t mp4_get_channel_count(const struct mp4 *f) +uint16_t mp4_get_channel_count(const struct mp4 *f) { - return f->audio_track->channel_count; + return f->track.channel_count; } int32_t mp4_num_samples(const struct mp4 *f) { - const struct mp4_track *t = f->audio_track; - int32_t i; + const struct mp4_track *t = &f->track; int32_t total = 0; - for (i = 0; i < t->stts_entry_count; i++) - total += t->stts_sample_count[i]; + for (uint32_t n = 0; n < t->stts_entry_count; n++) + total += t->stts_sample_count[n]; return total; } @@ -902,77 +903,29 @@ int mp4_meta_update(struct mp4 *f) ret = write_data(f, new_moov_data, new_moov_size); if (ret < 0) goto free_moov; - f->cb->truncate(f->cb->user_data); - ret = 1; + ret = f->cb->truncate(f->cb->user_data); + if (ret < 0) + ret = -ERRNO_TO_PARA_ERROR(errno); free_moov: free(new_moov_data); return ret; } -static char *meta_find_by_name(const struct mp4 *f, const char *item) -{ - uint32_t i; - - for (i = 0; i < f->meta.count; i++) - if (!strcasecmp(f->meta.tags[i].item, item)) - return para_strdup(f->meta.tags[i].value); - return NULL; -} - /** - * Return the value of the artist meta tag of an mp4 file. + * Return the value of the given tag item. * * \param f Must not be NULL. + * \param item "artist", "title", "album", "comment", or "date". * - * \return If the file does not contain this metadata tag, the function returns - * NULL. Otherwise, a copy of the tag value is returned. The caller should free - * this memory when it is no longer needed. - */ -char *mp4_meta_get_artist(const struct mp4 *f) -{ - return meta_find_by_name(f, "artist"); -} - -/** - * Return the value of the title meta tag of an mp4 file. - * - * \param f See \ref mp4_meta_get_artist(). - * \return See \ref mp4_meta_get_artist(). - */ -char *mp4_meta_get_title(const struct mp4 *f) -{ - return meta_find_by_name(f, "title"); -} - -/** - * Return the value of the date meta tag of an mp4 file. - * - * \param f See \ref mp4_meta_get_artist(). - * \return See \ref mp4_meta_get_artist(). - */ -char *mp4_meta_get_date(const struct mp4 *f) -{ - return meta_find_by_name(f, "date"); -} - -/** - * Return the value of the album meta tag of an mp4 file. - * - * \param f See \ref mp4_meta_get_artist(). - * \return See \ref mp4_meta_get_artist(). + * \return The function always returns NULL if the given item is not in the + * above list. Otherwise, if the file does not contain a tag for the given + * item, the function also returns NULL. Otherwise a copy of the tag value is + * returned and the caller should free this memory when it is no longer needed. */ -char *mp4_meta_get_album(const struct mp4 *f) +char *mp4_get_tag_value(const struct mp4 *f, const char *item) { - return meta_find_by_name(f, "album"); -} - -/** - * Return the value of the comment meta tag of an mp4 file. - * - * \param f See \ref mp4_meta_get_artist(). - * \return See \ref mp4_meta_get_artist(). - */ -char *mp4_meta_get_comment(const struct mp4 *f) -{ - return meta_find_by_name(f, "comment"); + for (unsigned n = 0; n < f->meta.count; n++) + if (!strcasecmp(f->meta.tags[n].item, item)) + return para_strdup(f->meta.tags[n].value); + return NULL; }