+/*
+ * Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
+ * FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
+ *
+ * See file COPYING.
+ */
+
+/** \file mp4.c Paraslash's internal mp4 parser. */
+
+/*
+ * This is a stripped down version of the former mp4ff library which used to be
+ * part of the faad decoder project but was removed from the faad code base in
+ * 2017. The original code has been cleaned up substantially and the public API
+ * has been documented. See the git commit log for details.
+ */
+
+#include <regex.h>
+
+#include "para.h"
+#include "error.h"
+#include "portable_io.h"
+#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;
+
+ /* stsz */
+ uint32_t stsz_sample_size;
+ uint32_t stsz_sample_count;
+ uint32_t *stsz_table;
+
+ /* stts */
+ uint32_t stts_entry_count;
+ uint32_t *stts_sample_count;
+
+ /* stsc */
+ uint32_t stsc_entry_count;
+ uint32_t *stsc_first_chunk;
+ uint32_t *stsc_samples_per_chunk;
+
+ /* stsc */
+ uint32_t stco_entry_count;
+ uint32_t *stco_chunk_offset;
+
+ /* mdhd */
+ uint32_t time_scale;
+ uint64_t duration;
+};
+
+struct mp4 {
+ const struct mp4_callback *cb;
+
+ uint64_t moov_offset;
+ uint64_t moov_size;
+ uint64_t meta_offset;
+ uint32_t meta_size;
+ uint64_t ilst_offset;
+ uint32_t ilst_size;
+ uint64_t udta_offset;
+ uint32_t udta_size;
+
+ uint8_t last_atom;
+ struct mp4_track track;
+ struct mp4_metadata meta;
+};
+
+/*
+ * 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)
+{
+ while (size > 0) {
+ ssize_t ret = f->cb->read(f->cb->user_data, data, size);
+ if (ret < 0 && errno == EINTR)
+ continue;
+ /* regard EAGAIN as an error as reads should be blocking. */
+ if (ret <= 0)
+ return ret < 0? -E_MP4_READ : 0;
+ size -= ret;
+ }
+ return 1;
+}
+
+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 = read_u64_be(data);
+ return ret;
+}
+
+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 = read_u32_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 = read_u16_be(data);
+ return ret;
+}
+
+/** A macro defining the atoms we care about. It gets expanded twice. */
+#define ATOM_ITEMS \
+ ATOM_ITEM(MOOV, 'm', 'o', 'o', 'v') /* movie (top-level container) */ \
+ ATOM_ITEM(TRAK, 't', 'r', 'a', 'k') /* container for a single track */ \
+ ATOM_ITEM(MDIA, 'm', 'd', 'i', 'a') /* media information */ \
+ ATOM_ITEM(MINF, 'm', 'i', 'n', 'f') /* extends mdia */ \
+ ATOM_ITEM(STBL, 's', 't', 'b', 'l') /* sample table container */ \
+ ATOM_ITEM(UDTA, 'u', 'd', 't', 'a') /* user data */ \
+ ATOM_ITEM(ILST, 'i', 'l', 's', 't') /* iTunes Metadata list */ \
+ ATOM_ITEM(ARTIST, 0xa9, 'A', 'R', 'T') /* artist */ \
+ ATOM_ITEM(TITLE, 0xa9, 'n', 'a', 'm') /* title */ \
+ ATOM_ITEM(ALBUM, 0xa9, 'a', 'l', 'b') /* album */ \
+ ATOM_ITEM(DATE, 0xa9, 'd', 'a', 'y') /* date */ \
+ ATOM_ITEM(COMMENT, 0xa9, 'c', 'm', 't') /* comment */ \
+ 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') /* mp4 audio */ \
+ ATOM_ITEM(META, 'm', 'e', 't', 'a') /* iTunes Metadata box */ \
+ ATOM_ITEM(DATA, 'd', 'a', 't', 'a') /* iTunes Metadata data box */ \
+
+/** For the C enumeration we concatenate ATOM_ with the first argument. */
+#define ATOM_ITEM(_name, a, b, c, d) ATOM_ ## _name,
+/** The enumeration of interesting atoms. */
+enum atom {ATOM_ITEMS};
+#undef ATOM_ITEM
+
+/** A cpp version of read_u32_be(). */
+#define ATOM_VALUE(a, b, c, d) ((a << 24) + (b << 16) + (c << 8) + d)
+
+static uint8_t atom_name_to_type(uint8_t *p)
+{
+ /** Expands to an instance of the following unnamed structure. */
+ #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. */
+static int atom_read_header(struct mp4 *f, uint8_t *atom_type,
+ uint8_t *header_size, uint64_t *atom_size)
+{
+ uint32_t size;
+ int ret;
+ uint8_t atom_header[8];
+
+ ret = read_data(f, atom_header, 8);
+ if (ret <= 0)
+ return ret;
+ size = read_u32_be(atom_header);
+ if (size == 1) { /* 64 bit atom size */
+ if (header_size)
+ *header_size = 16;
+ ret = read_int64(f, atom_size);
+ if (ret <= 0)
+ return ret;
+ } else {
+ if (header_size)
+ *header_size = 8;
+ *atom_size = size;
+ }
+ *atom_type = atom_name_to_type(atom_header + 4);
+ return 1;
+}
+
+static off_t get_position(const struct mp4 *f)
+{
+ return f->cb->seek(f->cb->user_data, 0, SEEK_CUR);
+}
+
+static void set_position(struct mp4 *f, off_t position)
+{
+ f->cb->seek(f->cb->user_data, position, SEEK_SET);
+}
+
+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)
+{
+ int ret;
+ struct mp4_track *t = &f->track;
+
+ 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)
+ return ret;
+ ret = read_int32(f, &t->stsz_sample_count);
+ if (ret <= 0)
+ return ret;
+ if (t->stsz_sample_size != 0)
+ return 1;
+ t->stsz_table = arr_alloc(t->stsz_sample_count, sizeof(int32_t));
+ for (uint32_t n = 0; n < t->stsz_sample_count; n++) {
+ ret = read_int32(f, &t->stsz_table[n]);
+ if (ret <= 0)
+ return ret;
+ }
+ return 1;
+}
+
+static int read_stts(struct mp4 *f)
+{
+ int ret;
+ struct mp4_track *t = &f->track;
+
+ 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 = arr_alloc(t->stts_entry_count, sizeof(int32_t));
+ 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 */
+ }
+ return 1;
+}
+
+static int read_stsc(struct mp4 *f)
+{
+ int ret;
+ 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)
+ return ret;
+ t->stsc_first_chunk = arr_alloc(t->stsc_entry_count, sizeof(int32_t));
+ t->stsc_samples_per_chunk = arr_alloc(t->stsc_entry_count,
+ sizeof (int32_t));
+ 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[n]);
+ if (ret <= 0)
+ return ret;
+ skip_bytes(f, 4); /* sample desc index */
+ }
+ return 1;
+}
+
+static int read_stco(struct mp4 *f)
+{
+ int ret;
+ 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 = arr_alloc(t->stco_entry_count, sizeof(int32_t));
+ 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;
+ }
+ return 1;
+}
+
+static int read_stsd(struct mp4 *f)
+{
+ int ret;
+ uint32_t entry_count;
+
+ 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 (uint32_t n = 0; n < entry_count; n++) {
+ uint64_t skip = get_position(f);
+ uint64_t size;
+ uint8_t atom_type = 0;
+ ret = atom_read_header(f, &atom_type, NULL, &size);
+ if (ret <= 0)
+ return ret;
+ skip += size;
+ 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, &f->track.channel_count);
+ if (ret <= 0)
+ return ret;
+ skip_bytes(f, 6);
+ ret = read_int16(f, &f->track.sample_rate);
+ if (ret <= 0)
+ return ret;
+ }
+ set_position(f, skip);
+ }
+ return 1;
+}
+
+static const char *get_metadata_name(uint8_t atom_type)
+{
+ switch (atom_type) {
+ case ATOM_TITLE: return "title";
+ case ATOM_ARTIST: return "artist";
+ case ATOM_ALBUM: return "album";
+ case ATOM_DATE: return "date";
+ case ATOM_COMMENT: return "comment";
+ default: return "unknown";
+ }
+}
+
+static int parse_tag(struct mp4 *f, uint8_t parent, int32_t size)
+{
+ int ret;
+ uint64_t subsize, sumsize;
+ char *value = NULL;
+ uint32_t len = 0;
+ uint64_t destpos;
+ struct mp4_tag *tag;
+
+ for (
+ sumsize = 0;
+ sumsize < size;
+ set_position(f, destpos), sumsize += subsize
+ ) {
+ uint8_t atom_type;
+ uint8_t header_size = 0;
+ ret = atom_read_header(f, &atom_type, &header_size, &subsize);
+ if (ret <= 0)
+ goto fail;
+ destpos = get_position(f) + subsize - header_size;
+ if (atom_type != ATOM_DATA)
+ continue;
+ skip_bytes(f, 8); /* version (1), flags (3), reserved (4) */
+ ret = -E_MP4_CORRUPT;
+ if (subsize < header_size + 8 || subsize > UINT_MAX)
+ goto fail;
+ len = subsize - (header_size + 8);
+ free(value);
+ value = alloc(len + 1);
+ ret = read_data(f, value, len);
+ if (ret <= 0)
+ goto fail;
+ value[len] = '\0';
+ }
+ if (!value)
+ 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;
+ tag->item = para_strdup(get_metadata_name(parent));
+ tag->value = value;
+ f->meta.count++;
+ return 1;
+fail:
+ free(value);
+ return ret;
+}
+
+static int read_mdhd(struct mp4 *f)
+{
+ int ret;
+ uint32_t version;
+ struct mp4_track *t = &f->track;
+
+ if (t->state != ATS_INITIAL)
+ return 1;
+ ret = read_int32(f, &version);
+ if (ret <= 0)
+ return ret;
+ if (version == 1) {
+ 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);
+ if (ret <= 0)
+ return ret;
+ } else { /* version == 0 */
+ uint32_t temp;
+
+ 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);
+ if (ret <= 0)
+ return ret;
+ t->duration = (temp == (uint32_t) (-1))?
+ (uint64_t) (-1) : (uint64_t) (temp);
+ }
+ skip_bytes(f, 4);
+ return 1;
+}
+
+static int read_ilst(struct mp4 *f, int32_t size)
+{
+ int ret;
+ uint64_t sumsize = 0;
+
+ while (sumsize < size) {
+ uint8_t atom_type;
+ uint64_t subsize, destpos;
+ uint8_t header_size = 0;
+ ret = atom_read_header(f, &atom_type, &header_size, &subsize);
+ if (ret <= 0)
+ return ret;
+ destpos = get_position(f) + subsize - header_size;
+ switch (atom_type) {
+ case ATOM_ARTIST:
+ case ATOM_TITLE:
+ case ATOM_ALBUM:
+ case ATOM_COMMENT:
+ case ATOM_DATE:
+ ret = parse_tag(f, atom_type, subsize - header_size);
+ if (ret <= 0)
+ return ret;
+ }
+ set_position(f, destpos);
+ sumsize += subsize;
+ }
+ return 1;
+}
+
+static int read_meta(struct mp4 *f, uint64_t size)
+{
+ int ret;
+ uint64_t subsize, sumsize = 0;
+ uint8_t atom_type;
+ uint8_t header_size = 0;
+
+ 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)
+ return ret;
+ if (subsize <= header_size + 4)
+ return 1;
+ if (atom_type == ATOM_ILST) {
+ f->ilst_offset = get_position(f) - header_size;
+ f->ilst_size = subsize;
+ ret = read_ilst(f, subsize - (header_size + 4));
+ if (ret <= 0)
+ return ret;
+ } else
+ set_position(f, get_position(f) + subsize - header_size);
+ sumsize += subsize;
+ }
+ return 1;
+}
+
+static bool need_atom(uint8_t atom_type, bool meta_only)
+{
+ /* these are needed in any case */
+ switch (atom_type) {
+ case ATOM_STSD:
+ case ATOM_META:
+ case ATOM_TRAK:
+ case ATOM_MDIA:
+ case ATOM_MINF:
+ case ATOM_STBL:
+ case ATOM_UDTA:
+ return true;
+ }
+ /* meta-only opens don't need anything else */
+ if (meta_only)
+ return false;
+ /* these are only required for regular opens */
+ switch (atom_type) {
+ case ATOM_STTS:
+ case ATOM_STSZ:
+ case ATOM_STCO:
+ case ATOM_STSC:
+ case ATOM_MDHD:
+ return true;
+ }
+ return false;
+}
+
+/* parse atoms that are sub atoms of other atoms */
+static int parse_sub_atoms(struct mp4 *f, uint64_t total_size, bool meta_only)
+{
+ int ret;
+ uint64_t dest, size, end = get_position(f) + 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 -E_MP4_CORRUPT;
+ dest = get_position(f) + size - header_size;
+ 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;
+ }
+ if (!need_atom(atom_type, meta_only))
+ continue;
+ 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);
+ }
+ if (ret <= 0)
+ return ret;
+ }
+ return 1;
+}
+
+/**
+ * Deallocate all resources associated with an mp4 file handle.
+ *
+ * \param f File handle returned by \ref mp4_open() or \ref mp4_open_meta().
+ *
+ * This frees the metadata items and various tables which were allocated when
+ * the file was opened. The given file handle must not be NULL.
+ */
+void mp4_close(struct mp4 *f)
+{
+ 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);
+}
+
+static int open_file(const struct mp4_callback *cb, bool meta_only, struct mp4 **result)
+{
+ int ret;
+ uint64_t size;
+ uint8_t atom_type, header_size;
+ struct mp4 *f = zalloc(sizeof(*f));
+
+ f->cb = cb;
+ while ((ret = atom_read_header(f, &atom_type, &header_size, &size)) > 0) {
+ f->last_atom = atom_type;
+ if (atom_type != ATOM_MOOV || size <= header_size) { /* skip */
+ set_position(f, get_position(f) + size - header_size);
+ continue;
+ }
+ f->moov_offset = get_position(f) - header_size;
+ f->moov_size = size;
+ ret = parse_sub_atoms(f, size - header_size, meta_only);
+ if (ret <= 0)
+ break;
+ }
+ if (ret < 0)
+ goto fail;
+ ret = -E_MP4_TRACK;
+ if (f->track.channel_count == 0)
+ goto fail;
+ ret = -E_MP4_BAD_SAMPLERATE;
+ if (f->track.sample_rate == 0)
+ goto fail;
+ ret = -E_MP4_MISSING_ATOM;
+ if (f->udta_size == 0 || f->meta_size == 0 || f->ilst_size == 0)
+ goto fail;
+ *result = f;
+ return 1;
+fail:
+ *result = NULL;
+ mp4_close(f);
+ return ret;
+}
+
+/**
+ * Read the audio track and the metadata of an mp4 file.
+ *
+ * \param cb Only the ->read() and ->seek() methods need to be supplied.
+ * \param result Initialized to a non-NULL pointer iff the function succeeds.
+ *
+ * This detects and parses the first audio track and the metadata information
+ * of the mp4 file. Various error checks are performed after the mp4 atoms have
+ * been parsed successfully.
+ *
+ * This function does not modify the file. However, if the caller intents to
+ * update the metadata later, the ->write() and ->truncate() methods must be
+ * supplied in the callback structure.
+ *
+ * \return Standard. Several errors are possible.
+ *
+ * \sa \ref mp4_open_meta().
+ */
+int mp4_open(const struct mp4_callback *cb, struct mp4 **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;
+ ret = -E_MP4_CORRUPT;
+ if (f->track.time_scale == 0)
+ goto fail;
+ *result = f;
+ return 1;
+fail:
+ mp4_close(f);
+ return ret;
+}
+
+static int32_t chunk_of_sample(const struct mp4 *f, int32_t sample,
+ int32_t *chunk)
+{
+ const struct mp4_track *t = &f->track;
+ uint32_t *fc = t->stsc_first_chunk, *spc = t->stsc_samples_per_chunk;
+ uint32_t chunk1, chunk1samples, n, total, k;
+
+ 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[k - 1];
+ chunk1samples = spc[k - 1];
+ if (chunk1samples != 0)
+ *chunk = (sample - total) / chunk1samples + chunk1;
+ else
+ *chunk = 1;
+ return total + (*chunk - chunk1) * chunk1samples;
+}
+
+/**
+ * Compute the duration of an mp4 file.
+ *
+ * \param f See \ref mp4_close().
+ *
+ * \return The number of milliseconds of the audio track. This function never
+ * fails.
+ */
+uint64_t mp4_get_duration(const struct mp4 *f)
+{
+ const struct mp4_track *t = &f->track;
+
+ return t->duration * 1000 / t->time_scale;
+}
+
+/**
+ * Reposition the read/write file offset.
+ *
+ * \param f See \ref mp4_close().
+ * \param sample The number of the sample to reposition to.
+ *
+ * The given sample number must be within range, i.e., strictly less than the
+ * value returned by \ref mp4_num_samples().
+ *
+ * \return Standard. The only possible error is an invalid sample number.
+ */
+int mp4_set_sample_position(struct mp4 *f, uint32_t sample)
+{
+ const struct mp4_track *t = &f->track;
+ int32_t offset, chunk, chunk_sample;
+ uint32_t n, srs; /* sample range size */
+
+ if (sample >= t->stsz_sample_count)
+ return -ERRNO_TO_PARA_ERROR(EINVAL);
+ chunk_sample = chunk_of_sample(f, sample, &chunk);
+ if (t->stsz_sample_size > 0)
+ srs = (sample - chunk_sample) * t->stsz_sample_size;
+ else {
+ for (srs = 0, n = chunk_sample; n < sample; n++)
+ srs += t->stsz_table[n];
+ }
+ if (t->stco_entry_count > 0 && chunk > t->stco_entry_count)
+ offset = t->stco_chunk_offset[t->stco_entry_count - 1];
+ else if (t->stco_entry_count > 0)
+ offset = t->stco_chunk_offset[chunk - 1];
+ else
+ offset = 8;
+ set_position(f, offset + srs);
+ return 1;
+}
+
+/**
+ * Look up and return the size of the given sample in the stsz table.
+ *
+ * \param f See \ref mp4_close().
+ * \param sample The sample number of interest.
+ * \param result Sample size is returned here.
+ *
+ * For the sample argument the restriction mentioned in the documentation of
+ * \ref mp4_set_sample_position() applies as well.
+ *
+ * \return Standard. Like for \ref mp4_set_sample_position(), EINVAL is the
+ * only possible error.
+ */
+int mp4_get_sample_size(const struct mp4 *f, uint32_t sample, uint32_t *result)
+{
+ 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)
+ *result = t->stsz_sample_size;
+ else
+ *result = t->stsz_table[sample];
+ return 1;
+}
+
+/**
+ * Return the sample rate stored in the stsd atom.
+ *
+ * \param f See \ref mp4_close().
+ *
+ * The sample rate is a property of the audio track of the mp4 file and is thus
+ * independent of the sample number.
+ *
+ * \return The function always returns a positive value because the open
+ * operation fails if the sample rate happens to be zero. A typical value is
+ * 44100.
+ */
+uint16_t mp4_get_sample_rate(const struct mp4 *f)
+{
+ return f->track.sample_rate;
+}
+
+/**
+ * Return the number of channels of the audio track.
+ *
+ * \param f See \ref mp4_close().
+ *
+ * \return The returned channel count is guaranteed to be positive because the
+ * open operation fails if the mp4a atom is missing or contains a zero channel
+ * count.
+ */
+uint16_t mp4_get_channel_count(const struct mp4 *f)
+{
+ return f->track.channel_count;
+}
+
+/**
+ * Return the number of samples of the audio track.
+ *
+ * \param f See \ref mp4_close().
+ *
+ * \return The sample count is read from the stsz atom during open.
+ */
+uint32_t mp4_num_samples(const struct mp4 *f)
+{
+ return f->track.stsz_sample_count;
+}
+
+/**
+ * Open an mp4 file in metadata-only mode.
+ *
+ * \param cb See \ref mp4_open().
+ * \param result See \ref mp4_open().
+ *
+ * This is similar to \ref mp4_open() but is cheaper because it only parses the
+ * metadata of the mp4 file. The only functions that can subsequently be called
+ * with the file handle returned here are \ref mp4_get_meta() and \ref
+ * mp4_update_meta().
+ *
+ * \return Standard.
+ *
+ * \sa \ref mp4_open(). The comment about ->write() and ->truncate() applies to
+ * this function as well.
+ */
+int mp4_open_meta(const struct mp4_callback *cb, struct mp4 **result)
+{
+ struct mp4 *f;
+ int ret = open_file(cb, true, &f);
+
+ if (ret < 0)
+ return ret;
+ *result = f;
+ return 1;
+}
+
+/**
+ * Return the metadata of an mp4 file.
+ *
+ * \param f See \ref mp4_close().
+ *
+ * The caller is allowed to add, delete or modify the entries of the returned
+ * structure with the intention to pass the modified version to \ref
+ * mp4_update_meta().
+ *
+ * \return This never returns NULL, even if the file contains no metadata tag
+ * items. However, the meta count will be zero and the ->tags pointer NULL in
+ * this case.
+ */
+struct mp4_metadata *mp4_get_meta(struct mp4 *f)
+{
+ return &f->meta;
+}
+
+/** 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)
+{
+ for (unsigned n = 0; n < meta->count; n++) {
+ struct mp4_tag *tag = meta->tags + n;
+ unsigned len = strlen(tag->value);
+ const char *atom_name;
+
+ if (!strcasecmp(tag->item, "title"))
+ atom_name = "\xA9" "nam";
+ else if (!strcasecmp(tag->item, "artist"))
+ atom_name = "\xA9" "ART";
+ else if (!strcasecmp(tag->item, "album"))
+ atom_name = "\xA9" "alb";
+ else if (!strcasecmp(tag->item, "date"))
+ atom_name = "\xA9" "day";
+ else if (!strcasecmp(tag->item, "comment"))
+ atom_name = "\xA9" "cmt";
+ else
+ assert(false);
+ 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);
+ 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);
+ }
+}
+
+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 = f->moov_size - 8;
+ uint32_t new_ilst_size = 0;
+ void *out_buffer;
+ uint8_t *p_out;
+ int32_t size_delta;
+ uint32_t tmp;
+
+ 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 = alloc(*out_size);
+ p_out = out_buffer;
+ set_position(f, total_base);
+ ret = read_data(f, p_out, f->udta_offset - total_base);
+ if (ret <= 0)
+ return NULL;
+ p_out += f->udta_offset - total_base;
+ ret = read_int32(f, &tmp);
+ if (ret <= 0)
+ return NULL;
+ 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;
+ ret = read_data(f, p_out, f->meta_offset - f->udta_offset - 8);
+ if (ret <= 0)
+ return NULL;
+ p_out += f->meta_offset - f->udta_offset - 8;
+ ret = read_int32(f, &tmp);
+ if (ret <= 0)
+ return NULL;
+ 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;
+ ret = read_data(f, p_out, f->ilst_offset - f->meta_offset - 8);
+ if (ret <= 0)
+ return NULL;
+ p_out += f->ilst_offset - f->meta_offset - 8;
+ ret = read_int32(f, &tmp);
+ if (ret <= 0)
+ return NULL;
+ 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;
+ 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;
+ return out_buffer;
+}
+
+static int write_data(struct mp4 *f, void *data, size_t size)
+{
+ 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;
+}
+
+/**
+ * Write back the modified metadata items to the mp4 file.
+ *
+ * This is the only public function which modifies the contents of an mp4 file.
+ * This is achieved by calling the ->write() and ->truncate() methods of the
+ * callback structure passed to \ref mp4_open() or \ref mp4_open_meta().
+ *
+ * \param f See \ref mp4_close().
+ *
+ * The modified metadata structure does not need to be supplied to this
+ * function because it is part of the mp4 structure.
+ *
+ * \return Standard.
+ */
+int mp4_update_meta(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);
+ if (!new_moov_data ) {
+ mp4_close(f);
+ return 0;
+ }
+ if (f->last_atom != ATOM_MOOV) {
+ set_position(f, f->moov_offset + 4);
+ 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_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;
+ 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;
+}
+
+/**
+ * Return the value of the given tag item.
+ *
+ * \param f See \ref mp4_close().
+ * \param item "artist", "title", "album", "comment", or "date".
+ *
+ * \return The function 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.
+ */
+__malloc char *mp4_get_tag_value(const struct mp4 *f, const char *item)
+{
+ 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;
+}
projects / paraslash.git / commitdiff