X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=mp4.c;h=959dbde8c677676eff5464476b66a35e87f22ff3;hb=87e0ea6a858f3727d0f6c8a0ace440146bb68afe;hp=bb5409e6140dd3976c26debfe8a34586ce4c891c;hpb=4348eab9a04464214d5bc83f4656b7076d447f32;p=paraslash.git diff --git a/mp4.c b/mp4.c index bb5409e6..959dbde8 100644 --- a/mp4.c +++ b/mp4.c @@ -5,15 +5,87 @@ * See file COPYING. */ +#include + #include "para.h" +#include "portable_io.h" +#include "string.h" #include "mp4.h" -int32_t mp4ff_total_tracks(const mp4ff_t * f) +struct mp4_track { + bool is_audio; + int32_t channelCount; + int32_t sampleSize; + uint16_t sampleRate; + + /* stsd */ + int32_t stsd_entry_count; + + /* stsz */ + int32_t stsz_sample_size; + int32_t stsz_sample_count; + int32_t *stsz_table; + + /* stts */ + int32_t stts_entry_count; + int32_t *stts_sample_count; + int32_t *stts_sample_delta; + + /* stsc */ + int32_t stsc_entry_count; + int32_t *stsc_first_chunk; + int32_t *stsc_samples_per_chunk; + int32_t *stsc_sample_desc_index; + + /* stsc */ + int32_t stco_entry_count; + int32_t *stco_chunk_offset; + + /* ctts */ + int32_t ctts_entry_count; + int32_t *ctts_sample_count; + int32_t *ctts_sample_offset; + + uint32_t maxBitrate; + uint32_t avgBitrate; + + uint32_t timeScale; + uint64_t duration; +}; + +#define MAX_TRACKS 1024 + +struct mp4 { + /* stream to read from */ + struct mp4_callback *stream; + int64_t current_position; + + uint64_t moov_offset; + uint64_t moov_size; + uint8_t last_atom; + uint64_t file_size; + uint32_t error; + + /* mvhd */ + int32_t time_scale; + int32_t duration; + + /* incremental track index while reading the file */ + int32_t total_tracks; + + /* track data */ + struct mp4_track *track[MAX_TRACKS]; + + /* metadata */ + struct mp4_metadata tags; +}; + +int32_t mp4_total_tracks(const struct mp4 *f) { return f->total_tracks; } -static int32_t mp4ff_read_data(mp4ff_t * f, void *data, uint32_t size) +static int32_t read_data(struct mp4 *f, void *data, uint32_t size) { int32_t result = 1; @@ -27,41 +99,17 @@ static int32_t mp4ff_read_data(mp4ff_t * f, void *data, uint32_t size) return result; } -/* parse atom header size */ -static int32_t mp4ff_atom_get_size(const int8_t * data) -{ - uint32_t result; - uint32_t a, b, c, d; - - a = (uint8_t) data[0]; - b = (uint8_t) data[1]; - c = (uint8_t) data[2]; - d = (uint8_t) data[3]; - - result = (a << 24) | (b << 16) | (c << 8) | d; - return (int32_t) result; -} - -static uint64_t mp4ff_read_int64(mp4ff_t * f) +static uint64_t read_int64(struct mp4 *f) { uint8_t data[8]; - uint64_t result = 0; - int8_t i; - mp4ff_read_data(f, data, 8); - - for (i = 0; i < 8; i++) { - result |= ((uint64_t) data[i]) << ((7 - i) * 8); - } - - return result; + read_data(f, data, 8); + return read_u64_be(data); } /* comnapre 2 atom names, returns 1 for equal, 0 for unequal */ -static int32_t mp4ff_atom_compare(const int8_t a1, const int8_t b1, - const int8_t c1, const int8_t d1, - const int8_t a2, const int8_t b2, - const int8_t c2, const int8_t d2) +static int32_t 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) { if (a1 == a2 && b1 == b2 && c1 == c2 && d1 == d2) return 1; @@ -69,283 +117,270 @@ static int32_t mp4ff_atom_compare(const int8_t a1, const int8_t b1, return 0; } -#define TRACK_AUDIO 1 -#define TRACK_VIDEO 2 -#define TRACK_SYSTEM 3 -#define TRACK_UNKNOWN 0 - -/* atoms with subatoms */ -#define ATOM_MOOV 1 -#define ATOM_TRAK 2 -#define ATOM_EDTS 3 -#define ATOM_MDIA 4 -#define ATOM_MINF 5 -#define ATOM_STBL 6 -#define ATOM_UDTA 7 -#define ATOM_ILST 8 /* iTunes Metadata list */ -#define ATOM_TITLE 9 -#define ATOM_ARTIST 10 -#define ATOM_WRITER 11 -#define ATOM_ALBUM 12 -#define ATOM_DATE 13 -#define ATOM_TOOL 14 -#define ATOM_COMMENT 15 -#define ATOM_GENRE1 16 -#define ATOM_TRACK 17 -#define ATOM_DISC 18 -#define ATOM_COMPILATION 19 -#define ATOM_GENRE2 20 -#define ATOM_TEMPO 21 -#define ATOM_COVER 22 -#define ATOM_DRMS 23 -#define ATOM_SINF 24 -#define ATOM_SCHI 25 - -#define SUBATOMIC 128 - -/* atoms without subatoms */ -#define ATOM_FTYP 129 -#define ATOM_MDAT 130 -#define ATOM_MVHD 131 -#define ATOM_TKHD 132 -#define ATOM_TREF 133 -#define ATOM_MDHD 134 -#define ATOM_VMHD 135 -#define ATOM_SMHD 136 -#define ATOM_HMHD 137 -#define ATOM_STSD 138 -#define ATOM_STTS 139 -#define ATOM_STSZ 140 -#define ATOM_STZ2 141 -#define ATOM_STCO 142 -#define ATOM_STSC 143 -#define ATOM_MP4A 144 -#define ATOM_MP4V 145 -#define ATOM_MP4S 146 -#define ATOM_ESDS 147 -#define ATOM_META 148 /* iTunes Metadata box */ -#define ATOM_NAME 149 /* iTunes Metadata name box */ -#define ATOM_DATA 150 /* iTunes Metadata data box */ -#define ATOM_CTTS 151 -#define ATOM_FRMA 152 -#define ATOM_IVIV 153 -#define ATOM_PRIV 154 -#define ATOM_USER 155 -#define ATOM_KEY 156 -#define ATOM_ALBUM_ARTIST 157 -#define ATOM_CONTENTGROUP 158 -#define ATOM_LYRICS 159 -#define ATOM_DESCRIPTION 160 -#define ATOM_NETWORK 161 -#define ATOM_SHOW 162 -#define ATOM_EPISODENAME 163 -#define ATOM_SORTTITLE 164 -#define ATOM_SORTALBUM 165 -#define ATOM_SORTARTIST 166 -#define ATOM_SORTALBUMARTIST 167 -#define ATOM_SORTWRITER 168 -#define ATOM_SORTSHOW 169 -#define ATOM_SEASON 170 -#define ATOM_EPISODE 171 -#define ATOM_PODCAST 172 - -#define ATOM_UNKNOWN 255 +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, + ATOM_VMHD = 135, + ATOM_SMHD = 136, + ATOM_HMHD = 137, + ATOM_STSD = 138, + ATOM_STTS = 139, + ATOM_STSZ = 140, + ATOM_STZ2 = 141, + ATOM_STCO = 142, + ATOM_STSC = 143, + 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 mp4ff_atom_name_to_type(const int8_t a, const int8_t b, - const int8_t c, const int8_t d) +static uint8_t atom_name_to_type(int8_t a, int8_t b, int8_t c, int8_t d) { if (a == 'm') { - if (mp4ff_atom_compare(a, b, c, d, 'm', 'o', 'o', 'v')) + if (atom_compare(a, b, c, d, 'm', 'o', 'o', 'v')) return ATOM_MOOV; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'i', 'n', 'f')) + else if (atom_compare(a, b, c, d, 'm', 'i', 'n', 'f')) return ATOM_MINF; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'd', 'i', 'a')) + else if (atom_compare(a, b, c, d, 'm', 'd', 'i', 'a')) return ATOM_MDIA; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'd', 'a', 't')) + else if (atom_compare(a, b, c, d, 'm', 'd', 'a', 't')) return ATOM_MDAT; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'd', 'h', 'd')) + else if (atom_compare(a, b, c, d, 'm', 'd', 'h', 'd')) return ATOM_MDHD; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'v', 'h', 'd')) + else if (atom_compare(a, b, c, d, 'm', 'v', 'h', 'd')) return ATOM_MVHD; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'p', '4', 'a')) + else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'a')) return ATOM_MP4A; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'p', '4', 'v')) + else if (atom_compare(a, b, c, d, 'm', 'p', '4', 'v')) return ATOM_MP4V; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'p', '4', 's')) + else if (atom_compare(a, b, c, d, 'm', 'p', '4', 's')) return ATOM_MP4S; - else if (mp4ff_atom_compare(a, b, c, d, 'm', 'e', 't', 'a')) + else if (atom_compare(a, b, c, d, 'm', 'e', 't', 'a')) return ATOM_META; } else if (a == 't') { - if (mp4ff_atom_compare(a, b, c, d, 't', 'r', 'a', 'k')) + if (atom_compare(a, b, c, d, 't', 'r', 'a', 'k')) return ATOM_TRAK; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'k', 'h', 'd')) + else if (atom_compare(a, b, c, d, 't', 'k', 'h', 'd')) return ATOM_TKHD; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'r', 'e', 'f')) + else if (atom_compare(a, b, c, d, 't', 'r', 'e', 'f')) return ATOM_TREF; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'r', 'k', 'n')) + else if (atom_compare(a, b, c, d, 't', 'r', 'k', 'n')) return ATOM_TRACK; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'm', 'p', 'o')) + else if (atom_compare(a, b, c, d, 't', 'm', 'p', 'o')) return ATOM_TEMPO; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'v', 'n', 'n')) + else if (atom_compare(a, b, c, d, 't', 'v', 'n', 'n')) return ATOM_NETWORK; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'v', 's', 'h')) + else if (atom_compare(a, b, c, d, 't', 'v', 's', 'h')) return ATOM_SHOW; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'v', 'e', 'n')) + else if (atom_compare(a, b, c, d, 't', 'v', 'e', 'n')) return ATOM_EPISODENAME; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'v', 's', 'n')) + else if (atom_compare(a, b, c, d, 't', 'v', 's', 'n')) return ATOM_SEASON; - else if (mp4ff_atom_compare(a, b, c, d, 't', 'v', 'e', 's')) + else if (atom_compare(a, b, c, d, 't', 'v', 'e', 's')) return ATOM_EPISODE; } else if (a == 's') { - if (mp4ff_atom_compare(a, b, c, d, 's', 't', 'b', 'l')) + if (atom_compare(a, b, c, d, 's', 't', 'b', 'l')) return ATOM_STBL; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'm', 'h', 'd')) + else if (atom_compare(a, b, c, d, 's', 'm', 'h', 'd')) return ATOM_SMHD; - else if (mp4ff_atom_compare(a, b, c, d, 's', 't', 's', 'd')) + else if (atom_compare(a, b, c, d, 's', 't', 's', 'd')) return ATOM_STSD; - else if (mp4ff_atom_compare(a, b, c, d, 's', 't', 't', 's')) + else if (atom_compare(a, b, c, d, 's', 't', 't', 's')) return ATOM_STTS; - else if (mp4ff_atom_compare(a, b, c, d, 's', 't', 'c', 'o')) + else if (atom_compare(a, b, c, d, 's', 't', 'c', 'o')) return ATOM_STCO; - else if (mp4ff_atom_compare(a, b, c, d, 's', 't', 's', 'c')) + else if (atom_compare(a, b, c, d, 's', 't', 's', 'c')) return ATOM_STSC; - else if (mp4ff_atom_compare(a, b, c, d, 's', 't', 's', 'z')) + else if (atom_compare(a, b, c, d, 's', 't', 's', 'z')) return ATOM_STSZ; - else if (mp4ff_atom_compare(a, b, c, d, 's', 't', 'z', '2')) + else if (atom_compare(a, b, c, d, 's', 't', 'z', '2')) return ATOM_STZ2; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'k', 'i', 'p')) + else if (atom_compare(a, b, c, d, 's', 'k', 'i', 'p')) return ATOM_SKIP; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'i', 'n', 'f')) + else if (atom_compare(a, b, c, d, 's', 'i', 'n', 'f')) return ATOM_SINF; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'c', 'h', 'i')) + else if (atom_compare(a, b, c, d, 's', 'c', 'h', 'i')) return ATOM_SCHI; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'o', 'n', 'm')) + else if (atom_compare(a, b, c, d, 's', 'o', 'n', 'm')) return ATOM_SORTTITLE; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'o', 'a', 'l')) + else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'l')) return ATOM_SORTALBUM; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'o', 'a', 'r')) + else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'r')) return ATOM_SORTARTIST; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'o', 'a', 'a')) + else if (atom_compare(a, b, c, d, 's', 'o', 'a', 'a')) return ATOM_SORTALBUMARTIST; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'o', 'c', 'o')) + else if (atom_compare(a, b, c, d, 's', 'o', 'c', 'o')) return ATOM_SORTWRITER; - else if (mp4ff_atom_compare(a, b, c, d, 's', 'o', 's', 'n')) + else if (atom_compare(a, b, c, d, 's', 'o', 's', 'n')) return ATOM_SORTSHOW; } else if (a == COPYRIGHT_SYMBOL) { - if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'n', 'a', 'm')) + if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'n', 'a', 'm')) return ATOM_TITLE; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'A', 'R', 'T')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'A', 'R', 'T')) return ATOM_ARTIST; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'w', 'r', 't')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'w', 'r', 't')) return ATOM_WRITER; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'a', 'l', 'b')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'a', 'l', 'b')) return ATOM_ALBUM; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'd', 'a', 'y')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'd', 'a', 'y')) return ATOM_DATE; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 't', 'o', 'o')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 't', 'o', 'o')) return ATOM_TOOL; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'c', 'm', 't')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'c', 'm', 't')) return ATOM_COMMENT; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'e', 'n')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'e', 'n')) return ATOM_GENRE1; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'r', 'p')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'g', 'r', 'p')) return ATOM_CONTENTGROUP; - else if (mp4ff_atom_compare - (a, b, c, d, COPYRIGHT_SYMBOL, 'l', 'y', 'r')) + else if (atom_compare(a, b, c, d, COPYRIGHT_SYMBOL, 'l', 'y', 'r')) return ATOM_LYRICS; } - if (mp4ff_atom_compare(a, b, c, d, 'e', 'd', 't', 's')) + if (atom_compare(a, b, c, d, 'e', 'd', 't', 's')) return ATOM_EDTS; - else if (mp4ff_atom_compare(a, b, c, d, 'e', 's', 'd', 's')) + else if (atom_compare(a, b, c, d, 'e', 's', 'd', 's')) return ATOM_ESDS; - else if (mp4ff_atom_compare(a, b, c, d, 'f', 't', 'y', 'p')) + else if (atom_compare(a, b, c, d, 'f', 't', 'y', 'p')) return ATOM_FTYP; - else if (mp4ff_atom_compare(a, b, c, d, 'f', 'r', 'e', 'e')) + else if (atom_compare(a, b, c, d, 'f', 'r', 'e', 'e')) return ATOM_FREE; - else if (mp4ff_atom_compare(a, b, c, d, 'h', 'm', 'h', 'd')) + else if (atom_compare(a, b, c, d, 'h', 'm', 'h', 'd')) return ATOM_HMHD; - else if (mp4ff_atom_compare(a, b, c, d, 'v', 'm', 'h', 'd')) + else if (atom_compare(a, b, c, d, 'v', 'm', 'h', 'd')) return ATOM_VMHD; - else if (mp4ff_atom_compare(a, b, c, d, 'u', 'd', 't', 'a')) + else if (atom_compare(a, b, c, d, 'u', 'd', 't', 'a')) return ATOM_UDTA; - else if (mp4ff_atom_compare(a, b, c, d, 'i', 'l', 's', 't')) + else if (atom_compare(a, b, c, d, 'i', 'l', 's', 't')) return ATOM_ILST; - else if (mp4ff_atom_compare(a, b, c, d, 'n', 'a', 'm', 'e')) + else if (atom_compare(a, b, c, d, 'n', 'a', 'm', 'e')) return ATOM_NAME; - else if (mp4ff_atom_compare(a, b, c, d, 'd', 'a', 't', 'a')) + else if (atom_compare(a, b, c, d, 'd', 'a', 't', 'a')) return ATOM_DATA; - else if (mp4ff_atom_compare(a, b, c, d, 'd', 'i', 's', 'k')) + else if (atom_compare(a, b, c, d, 'd', 'i', 's', 'k')) return ATOM_DISC; - else if (mp4ff_atom_compare(a, b, c, d, 'g', 'n', 'r', 'e')) + else if (atom_compare(a, b, c, d, 'g', 'n', 'r', 'e')) return ATOM_GENRE2; - else if (mp4ff_atom_compare(a, b, c, d, 'c', 'o', 'v', 'r')) + else if (atom_compare(a, b, c, d, 'c', 'o', 'v', 'r')) return ATOM_COVER; - else if (mp4ff_atom_compare(a, b, c, d, 'c', 'p', 'i', 'l')) + else if (atom_compare(a, b, c, d, 'c', 'p', 'i', 'l')) return ATOM_COMPILATION; - else if (mp4ff_atom_compare(a, b, c, d, 'c', 't', 't', 's')) + else if (atom_compare(a, b, c, d, 'c', 't', 't', 's')) return ATOM_CTTS; - else if (mp4ff_atom_compare(a, b, c, d, 'd', 'r', 'm', 's')) + else if (atom_compare(a, b, c, d, 'd', 'r', 'm', 's')) return ATOM_DRMS; - else if (mp4ff_atom_compare(a, b, c, d, 'f', 'r', 'm', 'a')) + else if (atom_compare(a, b, c, d, 'f', 'r', 'm', 'a')) return ATOM_FRMA; - else if (mp4ff_atom_compare(a, b, c, d, 'p', 'r', 'i', 'v')) + else if (atom_compare(a, b, c, d, 'p', 'r', 'i', 'v')) return ATOM_PRIV; - else if (mp4ff_atom_compare(a, b, c, d, 'i', 'v', 'i', 'v')) + else if (atom_compare(a, b, c, d, 'i', 'v', 'i', 'v')) return ATOM_IVIV; - else if (mp4ff_atom_compare(a, b, c, d, 'u', 's', 'e', 'r')) + else if (atom_compare(a, b, c, d, 'u', 's', 'e', 'r')) return ATOM_USER; - else if (mp4ff_atom_compare(a, b, c, d, 'k', 'e', 'y', ' ')) + else if (atom_compare(a, b, c, d, 'k', 'e', 'y', ' ')) return ATOM_KEY; - else if (mp4ff_atom_compare(a, b, c, d, 'a', 'A', 'R', 'T')) + else if (atom_compare(a, b, c, d, 'a', 'A', 'R', 'T')) return ATOM_ALBUM_ARTIST; - else if (mp4ff_atom_compare(a, b, c, d, 'd', 'e', 's', 'c')) + else if (atom_compare(a, b, c, d, 'd', 'e', 's', 'c')) return ATOM_DESCRIPTION; - else if (mp4ff_atom_compare(a, b, c, d, 'p', 'c', 's', 't')) + else if (atom_compare(a, b, c, d, 'p', 'c', 's', 't')) return ATOM_PODCAST; else return ATOM_UNKNOWN; } /* read atom header, return atom size, atom size is with header included */ -static uint64_t mp4ff_atom_read_header(mp4ff_t * f, uint8_t * atom_type, +static uint64_t atom_read_header(struct mp4 *f, uint8_t * atom_type, uint8_t * header_size) { uint64_t size; int32_t ret; int8_t atom_header[8]; - ret = mp4ff_read_data(f, atom_header, 8); + ret = read_data(f, atom_header, 8); if (ret != 8) return 0; - size = mp4ff_atom_get_size(atom_header); + size = read_u32_be(atom_header); *header_size = 8; /* check for 64 bit atom size */ if (size == 1) { *header_size = 16; - size = mp4ff_read_int64(f); + size = read_int64(f); } - *atom_type = mp4ff_atom_name_to_type(atom_header[4], atom_header[5], + *atom_type = atom_name_to_type(atom_header[4], atom_header[5], atom_header[6], atom_header[7]); return size; } -static int64_t mp4ff_position(const mp4ff_t * f) +static int64_t get_position(const struct mp4 *f) { return f->current_position; } @@ -371,7 +406,7 @@ static int need_parse_when_meta_only(uint8_t atom_type) } } -static int32_t mp4ff_set_position(mp4ff_t * f, const int64_t position) +static int32_t set_position(struct mp4 *f, int64_t position) { f->stream->seek(f->stream->user_data, position); f->current_position = position; @@ -379,7 +414,7 @@ static int32_t mp4ff_set_position(mp4ff_t * f, const int64_t position) return 0; } -static void mp4ff_track_add(mp4ff_t * f) +static void track_add(struct mp4 *f) { f->total_tracks++; @@ -388,475 +423,271 @@ static void mp4ff_track_add(mp4ff_t * f) f->error++; return; } - - f->track[f->total_tracks - 1] = malloc(sizeof (mp4ff_track_t)); - - memset(f->track[f->total_tracks - 1], 0, sizeof (mp4ff_track_t)); + f->track[f->total_tracks - 1] = para_calloc(sizeof(struct mp4_track)); } -static uint8_t mp4ff_read_char(mp4ff_t * f) +static uint8_t read_char(struct mp4 *f) { uint8_t output; - mp4ff_read_data(f, &output, 1); + read_data(f, &output, 1); return output; } -static uint32_t mp4ff_read_int24(mp4ff_t * f) +static uint32_t read_int24(struct mp4 *f) { - uint32_t result; - uint32_t a, b, c; int8_t data[4]; - mp4ff_read_data(f, data, 3); - a = (uint8_t) data[0]; - b = (uint8_t) data[1]; - c = (uint8_t) data[2]; - - result = (a << 16) | (b << 8) | c; - return (uint32_t) result; + read_data(f, data, 3); + return read_u24_be(data); } -static uint32_t mp4ff_read_int32(mp4ff_t * f) +static uint32_t read_int32(struct mp4 *f) { - uint32_t result; - uint32_t a, b, c, d; int8_t data[4]; - mp4ff_read_data(f, data, 4); - a = (uint8_t) data[0]; - b = (uint8_t) data[1]; - c = (uint8_t) data[2]; - d = (uint8_t) data[3]; - - result = (a << 24) | (b << 16) | (c << 8) | d; - return (uint32_t) result; + read_data(f, data, 4); + return read_u32_be(data); } -static int32_t mp4ff_read_stsz(mp4ff_t * f) +static int32_t read_stsz(struct mp4 *f) { + int32_t i; + struct mp4_track *t; + if (f->total_tracks == 0) return f->error++; - - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - f->track[f->total_tracks - 1]->stsz_sample_size = mp4ff_read_int32(f); - f->track[f->total_tracks - 1]->stsz_sample_count = mp4ff_read_int32(f); - - if (f->track[f->total_tracks - 1]->stsz_sample_size == 0) { - int32_t i; - f->track[f->total_tracks - 1]->stsz_table = - (int32_t *)malloc(f->track[f->total_tracks - 1]->stsz_sample_count - * sizeof (int32_t)); - - if (!f->track[f->total_tracks - 1]->stsz_table) - return f->error++; - - for (i = 0; i < f->track[f->total_tracks - 1]->stsz_sample_count - && !f->stream->read_error; i++) { - f->track[f->total_tracks - 1]->stsz_table[i] = mp4ff_read_int32(f); - } - } + t = f->track[f->total_tracks - 1]; + read_char(f); /* version */ + read_int24(f); /* flags */ + t->stsz_sample_size = read_int32(f); + t->stsz_sample_count = read_int32(f); + if (t->stsz_sample_size != 0) + return 0; + t->stsz_table = para_malloc(t->stsz_sample_count * sizeof(int32_t)); + for (i = 0; i < t->stsz_sample_count && !f->stream->read_error; i++) + t->stsz_table[i] = read_int32(f); return 0; } -static int32_t mp4ff_read_stts(mp4ff_t * f) +static int32_t read_stts(struct mp4 *f) { int32_t i; - mp4ff_track_t *p_track; + struct mp4_track *t; /* CVE-2017-9223 */ if (f->total_tracks == 0) return f->error++; - - p_track = f->track[f->total_tracks - 1]; - - if (p_track->stts_entry_count) + t = f->track[f->total_tracks - 1]; + if (t->stts_entry_count) return 0; + read_char(f); /* version */ + read_int24(f); /* flags */ + t->stts_entry_count = read_int32(f); - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - p_track->stts_entry_count = mp4ff_read_int32(f); - - p_track->stts_sample_count = (int32_t *)malloc(p_track->stts_entry_count - * sizeof (int32_t)); - p_track->stts_sample_delta = (int32_t *)malloc(p_track->stts_entry_count + t->stts_sample_count = para_malloc(t->stts_entry_count + * sizeof(int32_t)); + t->stts_sample_delta = para_malloc(t->stts_entry_count * sizeof (int32_t)); - - if (p_track->stts_sample_count == 0 || p_track->stts_sample_delta == 0) { - if (p_track->stts_sample_count) { - free(p_track->stts_sample_count); - p_track->stts_sample_count = 0; - } - if (p_track->stts_sample_delta) { - free(p_track->stts_sample_delta); - p_track->stts_sample_delta = 0; - } - p_track->stts_entry_count = 0; - return 0; - } else { - for (i = 0; i < f->track[f->total_tracks - 1]->stts_entry_count && !f->stream->read_error; i++) { /* CVE-2017-9254 */ - p_track->stts_sample_count[i] = mp4ff_read_int32(f); - p_track->stts_sample_delta[i] = mp4ff_read_int32(f); - } - return 1; + /* CVE-2017-9254 */ + for (i = 0; i < t->stts_entry_count && !f->stream->read_error; i++) { + t->stts_sample_count[i] = read_int32(f); + t->stts_sample_delta[i] = read_int32(f); } + return 1; } -static int32_t mp4ff_read_ctts(mp4ff_t * f) +static int32_t read_ctts(struct mp4 *f) { int32_t i; - mp4ff_track_t *p_track; + struct mp4_track *t; if (f->total_tracks == 0) return f->error++; - - p_track = f->track[f->total_tracks - 1]; - if (p_track->ctts_entry_count) + t = f->track[f->total_tracks - 1]; + if (t->ctts_entry_count) return 0; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - p_track->ctts_entry_count = mp4ff_read_int32(f); + read_char(f); /* version */ + read_int24(f); /* flags */ + t->ctts_entry_count = read_int32(f); - p_track->ctts_sample_count = (int32_t *)malloc(p_track->ctts_entry_count + t->ctts_sample_count = para_malloc(t->ctts_entry_count * sizeof (int32_t)); - p_track->ctts_sample_offset = (int32_t *)malloc(p_track->ctts_entry_count + t->ctts_sample_offset = para_malloc(t->ctts_entry_count * sizeof (int32_t)); - if (p_track->ctts_sample_count == 0 || p_track->ctts_sample_offset == 0) { - if (p_track->ctts_sample_count) { - free(p_track->ctts_sample_count); - p_track->ctts_sample_count = 0; - } - if (p_track->ctts_sample_offset) { - free(p_track->ctts_sample_offset); - p_track->ctts_sample_offset = 0; - } - p_track->ctts_entry_count = 0; - return 0; - } else { - for (i = 0; i < f->track[f->total_tracks - 1]->ctts_entry_count && !f->stream->read_error; i++) { /* CVE-2017-9257 */ - p_track->ctts_sample_count[i] = mp4ff_read_int32(f); - p_track->ctts_sample_offset[i] = mp4ff_read_int32(f); - } - return 1; + /* CVE-2017-9257 */ + for (i = 0; i < t->ctts_entry_count && !f->stream->read_error; i++) { + t->ctts_sample_count[i] = read_int32(f); + t->ctts_sample_offset[i] = read_int32(f); } + return 1; } -static int32_t mp4ff_read_stsc(mp4ff_t * f) +static int32_t read_stsc(struct mp4 *f) { int32_t i; + struct mp4_track *t; if (f->total_tracks == 0) return f->error++; + t = f->track[f->total_tracks - 1]; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - f->track[f->total_tracks - 1]->stsc_entry_count = mp4ff_read_int32(f); - - f->track[f->total_tracks - 1]->stsc_first_chunk = - (int32_t *) malloc(f->track[f->total_tracks - 1]->stsc_entry_count * - sizeof (int32_t)); - f->track[f->total_tracks - 1]->stsc_samples_per_chunk = - (int32_t *) malloc(f->track[f->total_tracks - 1]->stsc_entry_count * - sizeof (int32_t)); - f->track[f->total_tracks - 1]->stsc_sample_desc_index = - (int32_t *) malloc(f->track[f->total_tracks - 1]->stsc_entry_count * + read_char(f); /* version */ + read_int24(f); /* flags */ + t->stsc_entry_count = read_int32(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)); + t->stsc_sample_desc_index = para_malloc(t->stsc_entry_count * sizeof (int32_t)); - /* CVE-2017-9219 */ - if (!f->track[f->total_tracks - 1]->stsc_first_chunk) { - return f->error++; - } - if (!f->track[f->total_tracks - 1]->stsc_samples_per_chunk) { - free(f->track[f->total_tracks - 1]->stsc_first_chunk); - f->track[f->total_tracks - 1]->stsc_first_chunk = NULL; - return f->error++; - } - if (!f->track[f->total_tracks - 1]->stsc_sample_desc_index) { - free(f->track[f->total_tracks - 1]->stsc_first_chunk); - f->track[f->total_tracks - 1]->stsc_first_chunk = NULL; - free(f->track[f->total_tracks - 1]->stsc_samples_per_chunk); - f->track[f->total_tracks - 1]->stsc_samples_per_chunk = NULL; - return f->error++; - } - - for (i = 0; i < f->track[f->total_tracks - 1]->stsc_entry_count && !f->stream->read_error; i++) { /* CVE-2017-9255 */ - f->track[f->total_tracks - 1]->stsc_first_chunk[i] = - mp4ff_read_int32(f); - f->track[f->total_tracks - 1]->stsc_samples_per_chunk[i] = - mp4ff_read_int32(f); - f->track[f->total_tracks - 1]->stsc_sample_desc_index[i] = - mp4ff_read_int32(f); + /* CVE-2017-9255 */ + for (i = 0; i < t->stsc_entry_count && !f->stream->read_error; i++) { + t->stsc_first_chunk[i] = read_int32(f); + t->stsc_samples_per_chunk[i] = read_int32(f); + t->stsc_sample_desc_index[i] = read_int32(f); } - return 0; } -static int32_t mp4ff_read_stco(mp4ff_t * f) +static int32_t read_stco(struct mp4 *f) { int32_t i; + struct mp4_track *t; if (f->total_tracks == 0) return f->error++; - - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - f->track[f->total_tracks - 1]->stco_entry_count = mp4ff_read_int32(f); - - f->track[f->total_tracks - 1]->stco_chunk_offset = - (int32_t *) malloc(f->track[f->total_tracks - 1]->stco_entry_count * - sizeof (int32_t)); - - /* CVE-2017-9220 */ - if (!f->track[f->total_tracks - 1]->stco_chunk_offset) - return f->error++; - - for (i = 0; i < f->track[f->total_tracks - 1]->stco_entry_count && !f->stream->read_error; i++) { /* CVE-2017-9256 */ - f->track[f->total_tracks - 1]->stco_chunk_offset[i] = - mp4ff_read_int32(f); - } - + t = f->track[f->total_tracks - 1]; + + read_char(f); /* version */ + read_int24(f); /* flags */ + t->stco_entry_count = read_int32(f); + t->stco_chunk_offset = para_malloc(t->stco_entry_count + * sizeof(int32_t)); + /* CVE-2017-9256 */ + for (i = 0; i < t->stco_entry_count && !f->stream->read_error; i++) + t->stco_chunk_offset[i] = read_int32(f); return 0; } -static uint16_t mp4ff_read_int16(mp4ff_t * f) +static uint16_t read_int16(struct mp4 *f) { - uint32_t result; - uint32_t a, b; int8_t data[2]; - mp4ff_read_data(f, data, 2); - a = (uint8_t) data[0]; - b = (uint8_t) data[1]; - - result = (a << 8) | b; - return (uint16_t) result; + read_data(f, data, 2); + return read_u16_be(data); } -static uint32_t mp4ff_read_mp4_descr_length(mp4ff_t * f) -{ - uint8_t b; - uint8_t numBytes = 0; - uint32_t length = 0; - - do { - b = mp4ff_read_char(f); - numBytes++; - length = (length << 7) | (b & 0x7F); - } while ((b & 0x80) && numBytes < 4); - - return length; -} -static int32_t mp4ff_read_esds(mp4ff_t * f) -{ - uint8_t tag; - uint32_t temp; - - if (f->total_tracks == 0) - return f->error++; - - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - - /* get and verify ES_DescrTag */ - tag = mp4ff_read_char(f); - if (tag == 0x03) { - /* read length */ - if (mp4ff_read_mp4_descr_length(f) < 5 + 15) { - return 1; - } - /* skip 3 bytes */ - mp4ff_read_int24(f); - } else { - /* skip 2 bytes */ - mp4ff_read_int16(f); - } - - /* get and verify DecoderConfigDescrTab */ - if (mp4ff_read_char(f) != 0x04) { - return 1; - } - - /* read length */ - temp = mp4ff_read_mp4_descr_length(f); - if (temp < 13) - return 1; - - f->track[f->total_tracks - 1]->audioType = mp4ff_read_char(f); - mp4ff_read_int32(f); //0x15000414 ???? - f->track[f->total_tracks - 1]->maxBitrate = mp4ff_read_int32(f); - f->track[f->total_tracks - 1]->avgBitrate = mp4ff_read_int32(f); - - /* get and verify DecSpecificInfoTag */ - if (mp4ff_read_char(f) != 0x05) { - return 1; - } - - /* read length */ - f->track[f->total_tracks - 1]->decoderConfigLen = - mp4ff_read_mp4_descr_length(f); - - if (f->track[f->total_tracks - 1]->decoderConfig) - free(f->track[f->total_tracks - 1]->decoderConfig); - f->track[f->total_tracks - 1]->decoderConfig = - malloc(f->track[f->total_tracks - 1]->decoderConfigLen); - if (f->track[f->total_tracks - 1]->decoderConfig) { - mp4ff_read_data(f, f->track[f->total_tracks - 1]->decoderConfig, - f->track[f->total_tracks - - 1]->decoderConfigLen); - } else { - f->track[f->total_tracks - 1]->decoderConfigLen = 0; - } - - /* will skip the remainder of the atom */ - return 0; -} -static int32_t mp4ff_read_mp4a(mp4ff_t * f) +static int32_t read_mp4a(struct mp4 *f) { int32_t i; uint8_t atom_type = 0; uint8_t header_size = 0; + struct mp4_track *t; if (f->total_tracks == 0) return f->error++; + t = f->track[f->total_tracks - 1]; for (i = 0; i < 6; i++) { - mp4ff_read_char(f); /* reserved */ + read_char(f); /* reserved */ } - /* data_reference_index */ mp4ff_read_int16(f); - - mp4ff_read_int32(f); /* reserved */ - mp4ff_read_int32(f); /* reserved */ + /* data_reference_index */ read_int16(f); - f->track[f->total_tracks - 1]->channelCount = mp4ff_read_int16(f); - f->track[f->total_tracks - 1]->sampleSize = mp4ff_read_int16(f); + read_int32(f); /* reserved */ + read_int32(f); /* reserved */ - mp4ff_read_int16(f); - mp4ff_read_int16(f); + t->channelCount = read_int16(f); + t->sampleSize = read_int16(f); - f->track[f->total_tracks - 1]->sampleRate = mp4ff_read_int16(f); + read_int16(f); + read_int16(f); - mp4ff_read_int16(f); + t->sampleRate = read_int16(f); - mp4ff_atom_read_header(f, &atom_type, &header_size); - if (atom_type == ATOM_ESDS) { - mp4ff_read_esds(f); - } + read_int16(f); + atom_read_header(f, &atom_type, &header_size); return 0; } -static int32_t mp4ff_read_stsd(mp4ff_t * f) +static int32_t read_stsd(struct mp4 *f) { int32_t i; uint8_t header_size = 0; + struct mp4_track *t; /* CVE-2017-9218 */ if (f->total_tracks == 0) return f->error++; + t = f->track[f->total_tracks - 1]; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ + read_char(f); /* version */ + read_int24(f); /* flags */ - f->track[f->total_tracks - 1]->stsd_entry_count = mp4ff_read_int32(f); + t->stsd_entry_count = read_int32(f); - for (i = 0; i < f->track[f->total_tracks - 1]->stsd_entry_count && !f->stream->read_error; i++) { /* CVE-2017-9253 */ - uint64_t skip = mp4ff_position(f); + /* CVE-2017-9253 */ + for (i = 0; i < t->stsd_entry_count && !f->stream->read_error; i++) { + uint64_t skip = get_position(f); uint64_t size; uint8_t atom_type = 0; - size = mp4ff_atom_read_header(f, &atom_type, &header_size); + size = atom_read_header(f, &atom_type, &header_size); skip += size; - - if (atom_type == ATOM_MP4A) { - f->track[f->total_tracks - 1]->type = TRACK_AUDIO; - mp4ff_read_mp4a(f); - } else if (atom_type == ATOM_MP4V) { - f->track[f->total_tracks - 1]->type = TRACK_VIDEO; - } else if (atom_type == ATOM_MP4S) { - f->track[f->total_tracks - 1]->type = TRACK_SYSTEM; - } else { - f->track[f->total_tracks - 1]->type = TRACK_UNKNOWN; - } - - mp4ff_set_position(f, skip); + t->is_audio = atom_type == ATOM_MP4A; + if (t->is_audio) + read_mp4a(f); + set_position(f, skip); } return 0; } -static int32_t mp4ff_read_mvhd(mp4ff_t * f) +static int32_t read_mvhd(struct mp4 *f) { int32_t i; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - /* creation_time */ mp4ff_read_int32(f); - /* modification_time */ mp4ff_read_int32(f); - f->time_scale = mp4ff_read_int32(f); - f->duration = mp4ff_read_int32(f); - /* preferred_rate */ mp4ff_read_int32(f); - /*mp4ff_read_fixed32(f); */ - /* preferred_volume */ mp4ff_read_int16(f); - /*mp4ff_read_fixed16(f); */ - for (i = 0; i < 10; i++) { - /* reserved */ mp4ff_read_char(f); - } - for (i = 0; i < 9; i++) { - mp4ff_read_int32(f); /* matrix */ - } - /* preview_time */ mp4ff_read_int32(f); - /* preview_duration */ mp4ff_read_int32(f); - /* poster_time */ mp4ff_read_int32(f); - /* selection_time */ mp4ff_read_int32(f); - /* selection_duration */ mp4ff_read_int32(f); - /* current_time */ mp4ff_read_int32(f); - /* next_track_id */ mp4ff_read_int32(f); - + read_char(f); /* version */ + read_int24(f); /* flags */ + read_int32(f); /* creation_time */ + read_int32(f); /* modification_time */ + f->time_scale = read_int32(f); + f->duration = read_int32(f); + read_int32(f); /* preferred_rate */ + read_int16(f); /* preferred_volume */ + for (i = 0; i < 10; i++) + read_char(f); /* reserved */ + for (i = 0; i < 9; i++) + read_int32(f); /* matrix */ + read_int32(f); /* preview_time */ + read_int32(f); /* preview_duration */ + read_int32(f); /* poster_time */ + read_int32(f); /* selection_time */ + read_int32(f); /* selection_duration */ + read_int32(f); /* current_time */ + read_int32(f); /* next_track_id */ return 0; } -static int32_t mp4ff_tag_add_field(mp4ff_metadata_t * tags, const char *item, +static int32_t tag_add_field(struct mp4_metadata *tags, const char *item, const char *value, int32_t len) { - void *backup = (void *) tags->tags; - if (!item || (item && !*item) || !value) return 0; - - tags->tags = (mp4ff_tag_t *) realloc(tags->tags, - (tags->count + 1) * sizeof (mp4ff_tag_t)); - if (!tags->tags) { - if (backup) - free(backup); - return 0; + tags->tags = para_realloc(tags->tags, + (tags->count + 1) * sizeof(struct mp4_tag)); + tags->tags[tags->count].item = para_strdup(item); + tags->tags[tags->count].len = len; + if (len >= 0) { + tags->tags[tags->count].value = para_malloc(len + 1); + memcpy(tags->tags[tags->count].value, value, len); + tags->tags[tags->count].value[len] = 0; } else { - tags->tags[tags->count].item = strdup(item); - tags->tags[tags->count].len = len; - if (len >= 0) { - tags->tags[tags->count].value = malloc(len + 1); - if (tags->tags[tags->count].value != NULL) { - memcpy(tags->tags[tags->count].value, value, len); - tags->tags[tags->count].value[len] = 0; - } - } else { - tags->tags[tags->count].value = strdup(value); - } - - if (!tags->tags[tags->count].item || !tags->tags[tags->count].value) { - if (!tags->tags[tags->count].item) - free(tags->tags[tags->count].item); - if (!tags->tags[tags->count].value) - free(tags->tags[tags->count].value); - tags->tags[tags->count].item = NULL; - tags->tags[tags->count].value = NULL; - tags->tags[tags->count].len = 0; - return 0; - } - - tags->count++; - return 1; + tags->tags[tags->count].value = para_strdup(value); } + tags->count++; + return 1; } static const char *ID3v1GenreList[] = { @@ -890,7 +721,7 @@ static const char *ID3v1GenreList[] = { "Anime", "JPop", "SynthPop", }; -static const char *mp4ff_meta_index_to_genre(uint32_t idx) +static const char *meta_index_to_genre(uint32_t idx) { if (idx > 0 && idx <= sizeof (ID3v1GenreList) / sizeof (ID3v1GenreList[0])) { return ID3v1GenreList[idx - 1]; @@ -899,21 +730,18 @@ static const char *mp4ff_meta_index_to_genre(uint32_t idx) } } -static char *mp4ff_read_string(mp4ff_t * f, uint32_t length) +static char *read_string(struct mp4 *f, uint32_t length) { - char *str = (char *) malloc(length + 1); - if (str != 0) { - if ((uint32_t) mp4ff_read_data(f, str, length) != length) { - free(str); - str = 0; - } else { - str[length] = 0; - } - } + char *str = para_malloc(length + 1); + if ((uint32_t)read_data(f, str, length) != length) { + free(str); + str = NULL; + } else + str[length] = 0; return str; } -static int32_t mp4ff_set_metadata_name(const uint8_t atom_type, char **name) +static int32_t set_metadata_name(uint8_t atom_type, char **name) { static char *tag_names[] = { "unknown", "title", "artist", "writer", "album", @@ -1023,176 +851,189 @@ static int32_t mp4ff_set_metadata_name(const uint8_t atom_type, char **name) break; } - *name = strdup(tag_names[tag_idx]); - + *name = para_strdup(tag_names[tag_idx]); return 0; } -static int32_t mp4ff_parse_tag(mp4ff_t * f, const uint8_t parent_atom_type, - const int32_t size) +static uint32_t min_body_size(uint8_t atom_type) +{ + switch(atom_type) { + case ATOM_GENRE2: + case ATOM_TEMPO: + return 10; + case ATOM_TRACK: + return sizeof (char) /* version */ + + sizeof(uint8_t) * 3 /* flags */ + + sizeof(uint32_t) /* reserved */ + + sizeof(uint16_t) /* leading uint16_t */ + + sizeof(uint16_t) /* track */ + + sizeof(uint16_t); /* totaltracks */ + case ATOM_DISC: + return sizeof (char) /* version */ + + sizeof(uint8_t) * 3 /* flags */ + + sizeof(uint32_t) /* reserved */ + + sizeof(uint16_t) /* disc */ + + sizeof(uint16_t); /* totaldiscs */ + default: assert(false); + } +} + +static int32_t parse_tag(struct mp4 *f, uint8_t parent, int32_t size) { uint8_t atom_type; uint8_t header_size = 0; - uint64_t subsize, sumsize = 0; + uint64_t subsize, sumsize; char *name = NULL; char *data = NULL; uint32_t done = 0; uint32_t len = 0; - - while (sumsize < size && !f->stream->read_error) { /* CVE-2017-9222 */ - uint64_t destpos; - subsize = mp4ff_atom_read_header(f, &atom_type, &header_size); - destpos = mp4ff_position(f) + subsize - header_size; - if (!done) { - if (atom_type == ATOM_DATA) { - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - mp4ff_read_int32(f); /* reserved */ - - /* some need special attention */ - if (parent_atom_type == ATOM_GENRE2 || parent_atom_type == ATOM_TEMPO) { - if (subsize - header_size >= 8 + 2) { - uint16_t val = mp4ff_read_int16(f); - - if (parent_atom_type == ATOM_TEMPO) { - char temp[16]; - sprintf(temp, - "%.5u BPM", - val); - mp4ff_tag_add_field(&(f-> tags), "tempo", temp, -1); - } else { - const char *temp = mp4ff_meta_index_to_genre(val); - if (temp) { - mp4ff_tag_add_field (&(f->tags), "genre", temp, -1); - } - } - done = 1; - } - } else if (parent_atom_type == ATOM_TRACK || parent_atom_type == ATOM_DISC) { - if (!done && (subsize - header_size) >= (sizeof (char) + sizeof (uint8_t) * 3 + sizeof (uint32_t) + /* version + flags + reserved */ - +(parent_atom_type == ATOM_TRACK ? sizeof (uint16_t) : 0) /* leading uint16_t if ATOM_TRACK */ - +sizeof (uint16_t) /* track / disc */ - +sizeof (uint16_t)) /* totaltracks / totaldiscs */) { - uint16_t index, total; - char temp[32]; - mp4ff_read_int16(f); - index = mp4ff_read_int16(f); - total = mp4ff_read_int16(f); - if (parent_atom_type == ATOM_TRACK) - mp4ff_read_int16(f); - - sprintf(temp, "%d", index); - mp4ff_tag_add_field(&(f->tags), parent_atom_type == ATOM_TRACK ? - "track" : "disc", temp, -1); - if (total > 0) { - sprintf(temp, "%d", - total); - mp4ff_tag_add_field(& (f-> tags), - parent_atom_type == ATOM_TRACK? - "totaltracks" : "totaldiscs", temp, -1); - } - done = 1; - } - } else { - if (data) { - free(data); - data = NULL; - } - data = mp4ff_read_string(f, (uint32_t) (subsize - (header_size + 8))); - len = (uint32_t) (subsize - (header_size + 8)); - } - } else if (atom_type == ATOM_NAME) { - if (!done) { - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - if (name) - free(name); - name = mp4ff_read_string(f, (uint32_t) (subsize - (header_size + 4))); - } + uint64_t destpos; + + for ( + sumsize = 0; + sumsize < size && !f->stream->read_error; /* CVE-2017-9222 */ + set_position(f, destpos), sumsize += subsize + ) { + subsize = atom_read_header(f, &atom_type, &header_size); + destpos = get_position(f) + subsize - header_size; + if (done) + continue; + if (atom_type == ATOM_NAME) { + read_char(f); /* version */ + read_int24(f); /* flags */ + free(name); + name = read_string(f, subsize - (header_size + 4)); + continue; + } + if (atom_type != ATOM_DATA) + continue; + read_char(f); /* version */ + read_int24(f); /* flags */ + read_int32(f); /* reserved */ + + /* some need special attention */ + if (parent == ATOM_GENRE2 || parent == ATOM_TEMPO) { + uint16_t val; + if (subsize - header_size < min_body_size(parent)) + continue; + val = read_int16(f); + if (parent == ATOM_TEMPO) { + char temp[16]; + sprintf(temp, "%.5u BPM", val); + tag_add_field(&(f-> tags), "tempo", + temp, -1); + } else { + const char *tmp = meta_index_to_genre(val); + if (tmp) + tag_add_field (&(f->tags), + "genre", tmp, -1); + } + done = 1; + } else if (parent == ATOM_TRACK || parent == ATOM_DISC) { + uint16_t index, total; + char temp[32]; + if (subsize - header_size < min_body_size(parent)) + continue; + read_int16(f); + index = read_int16(f); + total = read_int16(f); + if (parent == ATOM_TRACK) + read_int16(f); + sprintf(temp, "%d", index); + tag_add_field(&(f->tags), parent == ATOM_TRACK? + "track" : "disc", temp, -1); + if (total > 0) { + sprintf(temp, "%d", total); + tag_add_field(& (f-> tags), + parent == ATOM_TRACK? + "totaltracks" : "totaldiscs", temp, -1); } - mp4ff_set_position(f, destpos); - sumsize += subsize; + done = 1; + } else { + free(data); + data = read_string(f, subsize - (header_size + 8)); + len = subsize - (header_size + 8); } } - if (data) { if (!done) { if (name == NULL) - mp4ff_set_metadata_name(parent_atom_type, &name); + set_metadata_name(parent , &name); if (name) - mp4ff_tag_add_field(&(f->tags), name, data, len); + tag_add_field(&(f->tags), name, data, len); } free(data); } - if (name) - free(name); + free(name); return 1; } -static int32_t mp4ff_read_mdhd(mp4ff_t * f) + +static int32_t read_mdhd(struct mp4 *f) { uint32_t version; + struct mp4_track *t; /* CVE-2017-9221 */ if (f->total_tracks == 0) return f->error++; + t = f->track[f->total_tracks - 1]; - version = mp4ff_read_int32(f); + version = read_int32(f); if (version == 1) { - mp4ff_read_int64(f); //creation-time - mp4ff_read_int64(f); //modification-time - f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f); //timescale - f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f); //duration - } else //version == 0 - { + read_int64(f); //creation-time + read_int64(f); //modification-time + t->timeScale = read_int32(f); //timescale + t->duration = read_int64(f); //duration + } else { //version == 0 uint32_t temp; - mp4ff_read_int32(f); //creation-time - mp4ff_read_int32(f); //modification-time - f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f); //timescale - temp = mp4ff_read_int32(f); - f->track[f->total_tracks - 1]->duration = (temp == (uint32_t) (-1)) ? (uint64_t) (-1) : (uint64_t) (temp); + read_int32(f); //creation-time + read_int32(f); //modification-time + t->timeScale = read_int32(f); //timescale + temp = read_int32(f); + t->duration = (temp == (uint32_t) (-1))? + (uint64_t) (-1) : (uint64_t) (temp); } - mp4ff_read_int16(f); - mp4ff_read_int16(f); + read_int16(f); + read_int16(f); return 1; } -static int32_t mp4ff_parse_metadata(mp4ff_t * f, const int32_t size) +static int32_t parse_metadata(struct mp4 *f, int32_t size) { uint64_t subsize, sumsize = 0; uint8_t atom_type; uint8_t header_size = 0; while (sumsize < size) { - subsize = mp4ff_atom_read_header(f, &atom_type, &header_size); + subsize = atom_read_header(f, &atom_type, &header_size); if (subsize == 0) break; - mp4ff_parse_tag(f, atom_type, - (uint32_t) (subsize - header_size)); + parse_tag(f, atom_type, (uint32_t)(subsize - header_size)); sumsize += subsize; } return 0; } -static int32_t mp4ff_read_meta(mp4ff_t * f, const uint64_t size) +static int32_t read_meta(struct mp4 *f, uint64_t size) { uint64_t subsize, sumsize = 0; uint8_t atom_type; uint8_t header_size = 0; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ + read_char(f); /* version */ + read_int24(f); /* flags */ while (sumsize < (size - (header_size + 4))) { - subsize = mp4ff_atom_read_header(f, &atom_type, &header_size); + subsize = atom_read_header(f, &atom_type, &header_size); if (subsize <= header_size + 4) return 1; if (atom_type == ATOM_ILST) { - mp4ff_parse_metadata(f, (uint32_t) (subsize - (header_size + 4))); + parse_metadata(f, (uint32_t) (subsize - (header_size + 4))); } else { - mp4ff_set_position(f, mp4ff_position(f) + subsize - header_size); + set_position(f, get_position(f) + subsize - header_size); } sumsize += subsize; } @@ -1200,45 +1041,44 @@ static int32_t mp4ff_read_meta(mp4ff_t * f, const uint64_t size) return 0; } -static int32_t mp4ff_atom_read(mp4ff_t * f, const int32_t size, - const uint8_t atom_type) +static int32_t atom_read(struct mp4 *f, int32_t size, uint8_t atom_type) { - uint64_t dest_position = mp4ff_position(f) + size - 8; + uint64_t dest_position = get_position(f) + size - 8; if (atom_type == ATOM_STSZ) { /* sample size box */ - mp4ff_read_stsz(f); + read_stsz(f); } else if (atom_type == ATOM_STTS) { /* time to sample box */ - mp4ff_read_stts(f); + read_stts(f); } else if (atom_type == ATOM_CTTS) { /* composition offset box */ - mp4ff_read_ctts(f); + read_ctts(f); } else if (atom_type == ATOM_STSC) { /* sample to chunk box */ - mp4ff_read_stsc(f); + read_stsc(f); } else if (atom_type == ATOM_STCO) { /* chunk offset box */ - mp4ff_read_stco(f); + read_stco(f); } else if (atom_type == ATOM_STSD) { /* sample description box */ - mp4ff_read_stsd(f); + read_stsd(f); } else if (atom_type == ATOM_MVHD) { /* movie header box */ - mp4ff_read_mvhd(f); + read_mvhd(f); } else if (atom_type == ATOM_MDHD) { /* track header */ - mp4ff_read_mdhd(f); + read_mdhd(f); } else if (atom_type == ATOM_META) { /* iTunes Metadata box */ - mp4ff_read_meta(f, size); + read_meta(f, size); } - mp4ff_set_position(f, dest_position); + set_position(f, dest_position); return 0; } /* parse atoms that are sub atoms of other atoms */ -static int32_t parse_sub_atoms(mp4ff_t * f, const uint64_t total_size, int meta_only) +static int32_t parse_sub_atoms(struct mp4 *f, uint64_t total_size, int meta_only) { uint64_t size; uint8_t atom_type = 0; @@ -1246,7 +1086,7 @@ static int32_t parse_sub_atoms(mp4ff_t * f, const uint64_t total_size, int meta_ uint8_t header_size = 0; while (counted_size < total_size) { - size = mp4ff_atom_read_header(f, &atom_type, &header_size); + size = atom_read_header(f, &atom_type, &header_size); counted_size += size; /* check for end of file */ @@ -1256,17 +1096,15 @@ static int32_t parse_sub_atoms(mp4ff_t * f, const uint64_t total_size, int meta_ /* we're starting to read a new track, update index, * so that all data and tables get written in the right place */ - if (atom_type == ATOM_TRAK) { - mp4ff_track_add(f); - } - + if (atom_type == ATOM_TRAK) + track_add(f); /* parse subatoms */ if (meta_only && !need_parse_when_meta_only(atom_type)) { - mp4ff_set_position(f, mp4ff_position(f) + size - header_size); + set_position(f, get_position(f) + size - header_size); } else if (atom_type < SUBATOMIC) { parse_sub_atoms(f, size - header_size, meta_only); } else { - mp4ff_atom_read(f, (uint32_t) size, atom_type); + atom_read(f, (uint32_t) size, atom_type); } } @@ -1274,7 +1112,7 @@ static int32_t parse_sub_atoms(mp4ff_t * f, const uint64_t total_size, int meta_ } /* parse root atoms */ -static int32_t parse_atoms(mp4ff_t * f, int meta_only) +static int32_t parse_atoms(struct mp4 *f, int meta_only) { uint64_t size; uint8_t atom_type = 0; @@ -1284,60 +1122,32 @@ static int32_t parse_atoms(mp4ff_t * f, int meta_only) f->stream->read_error = 0; while ((size = - mp4ff_atom_read_header(f, &atom_type, &header_size)) != 0) { + atom_read_header(f, &atom_type, &header_size)) != 0) { f->file_size += size; f->last_atom = atom_type; if (atom_type == ATOM_MOOV && size > header_size) { - f->moov_read = 1; - f->moov_offset = mp4ff_position(f) - header_size; + f->moov_offset = get_position(f) - header_size; f->moov_size = size; } /* parse subatoms */ if (meta_only && !need_parse_when_meta_only(atom_type)) { - mp4ff_set_position(f, mp4ff_position(f) + size - header_size); + set_position(f, get_position(f) + size - header_size); } else if (atom_type < SUBATOMIC) { parse_sub_atoms(f, size - header_size, meta_only); } else { /* skip this atom */ - mp4ff_set_position(f, mp4ff_position(f) + size - header_size); + set_position(f, get_position(f) + size - header_size); } } return 0; } -void mp4ff_get_decoder_config(const mp4ff_t * f, const int track, - unsigned char **ppBuf, unsigned int *pBufSize) +struct mp4 *mp4_open_read(struct mp4_callback *f) { - if (track >= f->total_tracks) { - *ppBuf = NULL; - *pBufSize = 0; - return; - } - - if (f->track[track]->decoderConfig == NULL - || f->track[track]->decoderConfigLen == 0) { - *ppBuf = NULL; - *pBufSize = 0; - } else { - *ppBuf = malloc(f->track[track]->decoderConfigLen); - if (*ppBuf == NULL) { - *pBufSize = 0; - return; - } - memcpy(*ppBuf, f->track[track]->decoderConfig, - f->track[track]->decoderConfigLen); - *pBufSize = f->track[track]->decoderConfigLen; - } -} - -mp4ff_t *mp4ff_open_read(mp4ff_callback_t * f) -{ - mp4ff_t *ff = malloc(sizeof (mp4ff_t)); - - memset(ff, 0, sizeof (mp4ff_t)); + struct mp4 *ff = para_calloc(sizeof(struct mp4)); ff->stream = f; @@ -1351,64 +1161,46 @@ mp4ff_t *mp4ff_open_read(mp4ff_callback_t * f) return ff; } -static int32_t mp4ff_tag_delete(mp4ff_metadata_t * tags) +static int32_t tag_delete(struct mp4_metadata *tags) { uint32_t i; for (i = 0; i < tags->count; i++) { - if (tags->tags[i].item) - free(tags->tags[i].item); - if (tags->tags[i].value) - free(tags->tags[i].value); + free(tags->tags[i].item); + free(tags->tags[i].value); } - - if (tags->tags) - free(tags->tags); - + free(tags->tags); tags->tags = NULL; tags->count = 0; return 0; } -void mp4ff_close(mp4ff_t * ff) +void mp4_close(struct mp4 *ff) { int32_t i; for (i = 0; i < ff->total_tracks; i++) { if (ff->track[i]) { - if (ff->track[i]->stsz_table) - free(ff->track[i]->stsz_table); - if (ff->track[i]->stts_sample_count) - free(ff->track[i]->stts_sample_count); - if (ff->track[i]->stts_sample_delta) - free(ff->track[i]->stts_sample_delta); - if (ff->track[i]->stsc_first_chunk) - free(ff->track[i]->stsc_first_chunk); - if (ff->track[i]->stsc_samples_per_chunk) - free(ff->track[i]->stsc_samples_per_chunk); - if (ff->track[i]->stsc_sample_desc_index) - free(ff->track[i]->stsc_sample_desc_index); - if (ff->track[i]->stco_chunk_offset) - free(ff->track[i]->stco_chunk_offset); - if (ff->track[i]->decoderConfig) - free(ff->track[i]->decoderConfig); - if (ff->track[i]->ctts_sample_count) - free(ff->track[i]->ctts_sample_count); - if (ff->track[i]->ctts_sample_offset) - free(ff->track[i]->ctts_sample_offset); + free(ff->track[i]->stsz_table); + free(ff->track[i]->stts_sample_count); + free(ff->track[i]->stts_sample_delta); + free(ff->track[i]->stsc_first_chunk); + free(ff->track[i]->stsc_samples_per_chunk); + free(ff->track[i]->stsc_sample_desc_index); + free(ff->track[i]->stco_chunk_offset); + free(ff->track[i]->ctts_sample_count); + free(ff->track[i]->ctts_sample_offset); free(ff->track[i]); } } - mp4ff_tag_delete(&(ff->tags)); - - if (ff) - free(ff); + tag_delete(&(ff->tags)); + free(ff); } -static int32_t mp4ff_chunk_of_sample(const mp4ff_t * f, const int32_t track, - const int32_t sample, int32_t * chunk_sample, int32_t * chunk) +static int32_t chunk_of_sample(const struct mp4 *f, int32_t track, + int32_t sample, int32_t *chunk_sample, int32_t *chunk) { int32_t total_entries = 0; int32_t chunk2entry; @@ -1453,10 +1245,10 @@ static int32_t mp4ff_chunk_of_sample(const mp4ff_t * f, const int32_t track, return 0; } -static int32_t mp4ff_chunk_to_offset(const mp4ff_t * f, const int32_t track, - const int32_t chunk) +static int32_t chunk_to_offset(const struct mp4 *f, int32_t track, + int32_t chunk) { - const mp4ff_track_t *p_track = f->track[track]; + const struct mp4_track *p_track = f->track[track]; if (p_track->stco_entry_count && (chunk > p_track->stco_entry_count)) { return p_track->stco_chunk_offset[p_track->stco_entry_count - @@ -1470,11 +1262,11 @@ static int32_t mp4ff_chunk_to_offset(const mp4ff_t * f, const int32_t track, return 0; } -static int32_t mp4ff_sample_range_size(const mp4ff_t * f, const int32_t track, - const int32_t chunk_sample, const int32_t sample) +static int32_t sample_range_size(const struct mp4 *f, int32_t track, + int32_t chunk_sample, int32_t sample) { int32_t i, total; - const mp4ff_track_t *p_track = f->track[track]; + const struct mp4_track *p_track = f->track[track]; if (p_track->stsz_sample_size) { return (sample - chunk_sample) * p_track->stsz_sample_size; @@ -1489,65 +1281,78 @@ static int32_t mp4ff_sample_range_size(const mp4ff_t * f, const int32_t track, return total; } -static int32_t mp4ff_sample_to_offset(const mp4ff_t * f, const int32_t track, - const int32_t sample) + +static int32_t sample_to_offset(const struct mp4 *f, int32_t track, + int32_t sample) { int32_t chunk, chunk_sample, chunk_offset1, chunk_offset2; - mp4ff_chunk_of_sample(f, track, sample, &chunk_sample, &chunk); + chunk_of_sample(f, track, sample, &chunk_sample, &chunk); - chunk_offset1 = mp4ff_chunk_to_offset(f, track, chunk); - chunk_offset2 = chunk_offset1 + mp4ff_sample_range_size(f, + chunk_offset1 = chunk_to_offset(f, track, chunk); + chunk_offset2 = chunk_offset1 + sample_range_size(f, track, chunk_sample, sample); return chunk_offset2; } -int32_t mp4ff_set_sample_position(mp4ff_t * f, const int32_t track, - const int32_t sample) +/** + * Return the number of milliseconds of the given track. + * + * \param f As returned by \ref mp4_open_read(), must not be NULL. + * \param track Between zero and the value returned by \ref mp4_total_tracks(). + * + * The function returns zero if the audio file is of zero length or contains a + * corrupt track header. + */ +uint64_t mp4_get_duration(const struct mp4 *f, int32_t track) { - int32_t offset; + const struct mp4_track *t = f->track[track]; - offset = mp4ff_sample_to_offset(f, track, sample); - mp4ff_set_position(f, offset); - - return 0; + if (t->timeScale == 0) + return 0; + return t->duration * 1000 / t->timeScale; } -static int32_t mp4ff_audio_frame_size(const mp4ff_t * f, const int32_t track, - const int32_t sample) +/** + * Check whether the given track number corresponds to an audio track. + * + * \param f See \ref mp4_get_duration(). + * \param track See \ref mp4_get_duration(). + * + * Besides audio tracks, an mp4 file may contain video and system tracks. For + * those the function returns false. + */ +bool mp4_is_audio_track(const struct mp4 *f, int32_t track) { - int32_t bytes; - const mp4ff_track_t *p_track = f->track[track]; - - if (p_track->stsz_sample_size) { - bytes = p_track->stsz_sample_size; - } else { - bytes = p_track->stsz_table[sample]; - } + return f->track[track]->is_audio; +} - return bytes; +void mp4_set_sample_position(struct mp4 *f, int32_t track, int32_t sample) +{ + int32_t offset = sample_to_offset(f, track, sample); + set_position(f, offset); } -int32_t mp4ff_read_sample_getsize(mp4ff_t * f, const int track, - const int sample) +int32_t mp4_get_sample_size(const struct mp4 *f, int track, int sample) { - int32_t temp = mp4ff_audio_frame_size(f, track, sample); - if (temp < 0) - temp = 0; - return temp; + const struct mp4_track *t = f->track[track]; + + if (t->stsz_sample_size != 0) + return t->stsz_sample_size; + return t->stsz_table[sample]; } -uint32_t mp4ff_get_sample_rate(const mp4ff_t * f, const int32_t track) +uint32_t mp4_get_sample_rate(const struct mp4 *f, int32_t track) { return f->track[track]->sampleRate; } -uint32_t mp4ff_get_channel_count(const mp4ff_t * f, const int32_t track) +uint32_t mp4_get_channel_count(const struct mp4 *f, int32_t track) { return f->track[track]->channelCount; } -int32_t mp4ff_num_samples(const mp4ff_t * f, const int32_t track) +int32_t mp4_num_samples(const struct mp4 *f, int32_t track) { int32_t i; int32_t total = 0; @@ -1558,11 +1363,9 @@ int32_t mp4ff_num_samples(const mp4ff_t * f, const int32_t track) return total; } -mp4ff_t *mp4ff_open_read_metaonly(mp4ff_callback_t * f) +struct mp4 *mp4_open_meta(struct mp4_callback *f) { - mp4ff_t *ff = malloc(sizeof (mp4ff_t)); - - memset(ff, 0, sizeof (mp4ff_t)); + struct mp4 *ff = para_calloc(sizeof(struct mp4)); ff->stream = f; @@ -1576,12 +1379,12 @@ mp4ff_t *mp4ff_open_read_metaonly(mp4ff_callback_t * f) return ff; } -int32_t mp4ff_meta_get_num_items(const mp4ff_t * f) +int32_t mp4_meta_get_num_items(const struct mp4 *f) { return f->tags.count; } -int32_t mp4ff_meta_get_by_index(const mp4ff_t * f, uint32_t index, +int32_t mp4_meta_get_by_index(const struct mp4 *f, uint32_t index, char **item, char **value) { if (index >= f->tags.count) { @@ -1589,13 +1392,13 @@ int32_t mp4ff_meta_get_by_index(const mp4ff_t * f, uint32_t index, *value = NULL; return 0; } else { - *item = strdup(f->tags.tags[index].item); - *value = strdup(f->tags.tags[index].value); + *item = para_strdup(f->tags.tags[index].item); + *value = para_strdup(f->tags.tags[index].value); return 1; } } -static uint32_t find_atom(mp4ff_t * f, uint64_t base, uint32_t size, +static uint32_t find_atom(struct mp4 *f, uint64_t base, uint32_t size, const char *name) { uint32_t remaining = size; @@ -1604,17 +1407,17 @@ static uint32_t find_atom(mp4ff_t * f, uint64_t base, uint32_t size, char atom_name[4]; uint32_t atom_size; - mp4ff_set_position(f, atom_offset); + set_position(f, atom_offset); if (remaining < 8) break; - atom_size = mp4ff_read_int32(f); + atom_size = read_int32(f); if (atom_size > remaining || atom_size < 8) break; - mp4ff_read_data(f, atom_name, 4); + read_data(f, atom_name, 4); if (!memcmp(atom_name, name, 4)) { - mp4ff_set_position(f, atom_offset); + set_position(f, atom_offset); return 1; } @@ -1623,14 +1426,15 @@ static uint32_t find_atom(mp4ff_t * f, uint64_t base, uint32_t size, } return 0; } -static uint32_t find_atom_v2(mp4ff_t * f, uint64_t base, uint32_t size, + +static uint32_t find_atom_v2(struct mp4 *f, uint64_t base, uint32_t size, const char *name, uint32_t extraheaders, const char *name_inside) { uint64_t first_base = (uint64_t) (-1); while (find_atom(f, base, size, name)) //try to find atom with atom in it { - uint64_t mybase = mp4ff_position(f); - uint32_t mysize = mp4ff_read_int32(f); + uint64_t mybase = get_position(f); + uint32_t mysize = read_int32(f); if (first_base == (uint64_t) (-1)) first_base = mybase; @@ -1640,7 +1444,7 @@ static uint32_t find_atom_v2(mp4ff_t * f, uint64_t base, uint32_t size, if (find_atom (f, mybase + (8 + extraheaders), mysize - (8 + extraheaders), name_inside)) { - mp4ff_set_position(f, mybase); + set_position(f, mybase); return 2; } base += mysize; @@ -1653,27 +1457,25 @@ static uint32_t find_atom_v2(mp4ff_t * f, uint64_t base, uint32_t size, if (first_base != (uint64_t) (-1)) //wanted atom inside not found { - mp4ff_set_position(f, first_base); + set_position(f, first_base); return 1; } else return 0; } -typedef struct { +struct membuffer { void *data; unsigned written; unsigned allocated; unsigned error; -} membuffer; - -#define stricmp strcasecmp +}; -static membuffer *membuffer_create(void) +static struct membuffer *membuffer_create(void) { const unsigned initial_size = 256; - membuffer *buf = (membuffer *) malloc(sizeof (membuffer)); - buf->data = malloc(initial_size); + struct membuffer *buf = para_malloc(sizeof(*buf)); + buf->data = para_malloc(initial_size); buf->written = 0; buf->allocated = initial_size; buf->error = buf->data == 0 ? 1 : 0; @@ -1681,7 +1483,7 @@ static membuffer *membuffer_create(void) return buf; } -static unsigned membuffer_write(membuffer * buf, const void *ptr, unsigned bytes) +static unsigned membuffer_write(struct membuffer *buf, const void *ptr, unsigned bytes) { unsigned dest_size = buf->written + bytes; @@ -1691,17 +1493,7 @@ static unsigned membuffer_write(membuffer * buf, const void *ptr, unsigned bytes do { buf->allocated <<= 1; } while (dest_size > buf->allocated); - - { - void *newptr = realloc(buf->data, buf->allocated); - if (newptr == 0) { - free(buf->data); - buf->data = 0; - buf->error = 1; - return 0; - } - buf->data = newptr; - } + buf->data = para_realloc(buf->data, buf->allocated); } if (ptr) @@ -1710,27 +1502,27 @@ static unsigned membuffer_write(membuffer * buf, const void *ptr, unsigned bytes return bytes; } -#define membuffer_write_data membuffer_write - -static unsigned membuffer_write_atom_name(membuffer * buf, const char *data) +static unsigned membuffer_write_atom_name(struct membuffer *buf, const char *data) { - return membuffer_write_data(buf, data, 4) == 4 ? 1 : 0; + return membuffer_write(buf, data, 4) == 4 ? 1 : 0; } -static unsigned membuffer_write_int16(membuffer * buf, uint16_t data) +static unsigned membuffer_write_int16(struct membuffer *buf, uint16_t data) { - uint8_t temp[2] = { (uint8_t) (data >> 8), (uint8_t) data }; - return membuffer_write_data(buf, temp, 2); + uint8_t temp[2]; + + write_u16_be(temp, data); + return membuffer_write(buf, temp, 2); } -static unsigned membuffer_write_int32(membuffer * buf, uint32_t data) +static unsigned membuffer_write_int32(struct membuffer *buf, uint32_t data) { - uint8_t temp[4] = { (uint8_t) (data >> 24), (uint8_t) (data >> 16), - (uint8_t) (data >> 8), (uint8_t) data }; - return membuffer_write_data(buf, temp, 4); + uint8_t temp[4]; + write_u32_be(temp, data); + return membuffer_write(buf, temp, 4); } -static void membuffer_write_track_tag(membuffer * buf, const char *name, +static void membuffer_write_track_tag(struct membuffer *buf, const char *name, uint32_t index, uint32_t total) { membuffer_write_int32(buf, @@ -1749,7 +1541,7 @@ static void membuffer_write_track_tag(membuffer * buf, const char *name, membuffer_write_int16(buf, 0); } -static void membuffer_write_int16_tag(membuffer * buf, const char *name, +static void membuffer_write_int16_tag(struct membuffer *buf, const char *name, uint16_t value) { membuffer_write_int32(buf, @@ -1770,22 +1562,22 @@ static uint32_t myatoi(const char *param) return param ? atoi(param) : 0; } -static uint32_t mp4ff_meta_genre_to_index(const char *genrestr) +static uint32_t meta_genre_to_index(const char *genrestr) { unsigned n; for (n = 0; n < sizeof (ID3v1GenreList) / sizeof (ID3v1GenreList[0]); n++) { - if (!stricmp(genrestr, ID3v1GenreList[n])) + if (!strcasecmp(genrestr, ID3v1GenreList[n])) return n + 1; } return 0; } -typedef struct { +struct stdmeta_entry { const char *atom; const char *name; -} stdmeta_entry; +}; -static stdmeta_entry stdmetas[] = { +struct stdmeta_entry stdmetas[] = { {"\xA9" "nam", "title"}, {"\xA9" "ART", "artist"}, {"\xA9" "wrt", "writer"}, @@ -1802,13 +1594,13 @@ static const char *find_standard_meta(const char *name) //returns atom name if f { unsigned n; for (n = 0; n < sizeof (stdmetas) / sizeof (stdmetas[0]); n++) { - if (!stricmp(name, stdmetas[n].name)) + if (!strcasecmp(name, stdmetas[n].name)) return stdmetas[n].atom; } return 0; } -static void membuffer_write_std_tag(membuffer * buf, const char *name, +static void membuffer_write_std_tag(struct membuffer *buf, const char *name, const char *value) { uint32_t flags = 1; @@ -1828,10 +1620,10 @@ static void membuffer_write_std_tag(membuffer * buf, const char *name, membuffer_write_atom_name(buf, "data"); membuffer_write_int32(buf, flags); //flags membuffer_write_int32(buf, 0); //reserved - membuffer_write_data(buf, value, strlen(value)); + membuffer_write(buf, value, strlen(value)); } -static void membuffer_write_custom_tag(membuffer * buf, const char *name, +static void membuffer_write_custom_tag(struct membuffer *buf, const char *name, const char *value) { membuffer_write_int32(buf, @@ -1843,135 +1635,118 @@ static void membuffer_write_custom_tag(membuffer * buf, const char *name, membuffer_write_int32(buf, 0x1C); //weirdo itunes atom membuffer_write_atom_name(buf, "mean"); membuffer_write_int32(buf, 0); - membuffer_write_data(buf, "com.apple.iTunes", 16); + membuffer_write(buf, "com.apple.iTunes", 16); membuffer_write_int32(buf, 12 + strlen(name)); membuffer_write_atom_name(buf, "name"); membuffer_write_int32(buf, 0); - membuffer_write_data(buf, name, strlen(name)); + membuffer_write(buf, name, strlen(name)); membuffer_write_int32(buf, 8 /*data atom header */ + 8 /*flags + reserved */ + strlen(value)); membuffer_write_atom_name(buf, "data"); membuffer_write_int32(buf, 1); //flags membuffer_write_int32(buf, 0); //reserved - membuffer_write_data(buf, value, strlen(value)); + membuffer_write(buf, value, strlen(value)); } -static unsigned membuffer_error(const membuffer * buf) +static unsigned membuffer_error(const struct membuffer *buf) { return buf->error; } -static void membuffer_free(membuffer * buf) +static void membuffer_free(struct membuffer *buf) { - if (buf->data) - free(buf->data); + free(buf->data); free(buf); } -static unsigned membuffer_get_size(const membuffer * buf) +static unsigned membuffer_get_size(const struct membuffer *buf) { return buf->written; } -static void *membuffer_detach(membuffer * buf) +static void *membuffer_detach(struct membuffer *buf) { void *ret; if (buf->error) return 0; - - ret = realloc(buf->data, buf->written); - - if (ret == 0) - free(buf->data); - + ret = para_realloc(buf->data, buf->written); buf->data = 0; buf->error = 1; - return ret; } -static uint32_t create_ilst(const mp4ff_metadata_t * data, void **out_buffer, +static uint32_t create_ilst(const struct mp4_metadata *data, void **out_buffer, uint32_t * out_size) { - membuffer *buf = membuffer_create(); + struct membuffer *buf = membuffer_create(); unsigned metaptr; - char *mask = (char *) malloc(data->count); - memset(mask, 0, data->count); - - { - const char *tracknumber_ptr = 0, *totaltracks_ptr = 0; - const char *discnumber_ptr = 0, *totaldiscs_ptr = 0; - const char *genre_ptr = 0, *tempo_ptr = 0; - for (metaptr = 0; metaptr < data->count; metaptr++) { - mp4ff_tag_t *tag = &data->tags[metaptr]; - if (!stricmp(tag->item, "tracknumber") || !stricmp(tag->item, "track")) { - if (tracknumber_ptr == 0) - tracknumber_ptr = tag->value; - mask[metaptr] = 1; - } else if (!stricmp(tag->item, "totaltracks")) { - if (totaltracks_ptr == 0) - totaltracks_ptr = tag->value; - mask[metaptr] = 1; - } else if (!stricmp(tag->item, "discnumber") - || !stricmp(tag->item, "disc")) { - if (discnumber_ptr == 0) - discnumber_ptr = tag->value; - mask[metaptr] = 1; - } else if (!stricmp(tag->item, "totaldiscs")) { - if (totaldiscs_ptr == 0) - totaldiscs_ptr = tag->value; - mask[metaptr] = 1; - } else if (!stricmp(tag->item, "genre")) { - if (genre_ptr == 0) - genre_ptr = tag->value; - mask[metaptr] = 1; - } else if (!stricmp(tag->item, "tempo")) { - if (tempo_ptr == 0) - tempo_ptr = tag->value; - mask[metaptr] = 1; - } - - } + char *mask = para_calloc(data->count); + const char *tracknumber_ptr = 0, *totaltracks_ptr = 0; + const char *discnumber_ptr = 0, *totaldiscs_ptr = 0; + const char *genre_ptr = 0, *tempo_ptr = 0; - if (tracknumber_ptr) - membuffer_write_track_tag(buf, "trkn", - myatoi(tracknumber_ptr), - myatoi(totaltracks_ptr)); - if (discnumber_ptr) - membuffer_write_track_tag(buf, "disk", - myatoi(discnumber_ptr), - myatoi(totaldiscs_ptr)); - if (tempo_ptr) - membuffer_write_int16_tag(buf, "tmpo", - (uint16_t) myatoi(tempo_ptr)); - - if (genre_ptr) { - uint32_t index = mp4ff_meta_genre_to_index(genre_ptr); - if (index == 0) - membuffer_write_std_tag(buf, "©gen", - genre_ptr); - else - membuffer_write_int16_tag(buf, "gnre", - (uint16_t) index); + for (metaptr = 0; metaptr < data->count; metaptr++) { + struct mp4_tag *tag = &data->tags[metaptr]; + if (!strcasecmp(tag->item, "tracknumber") + || !strcasecmp(tag->item, "track")) { + if (tracknumber_ptr == 0) + tracknumber_ptr = tag->value; + mask[metaptr] = 1; + } else if (!strcasecmp(tag->item, "totaltracks")) { + if (totaltracks_ptr == 0) + totaltracks_ptr = tag->value; + mask[metaptr] = 1; + } else if (!strcasecmp(tag->item, "discnumber") + || !strcasecmp(tag->item, "disc")) { + if (discnumber_ptr == 0) + discnumber_ptr = tag->value; + mask[metaptr] = 1; + } else if (!strcasecmp(tag->item, "totaldiscs")) { + if (totaldiscs_ptr == 0) + totaldiscs_ptr = tag->value; + mask[metaptr] = 1; + } else if (!strcasecmp(tag->item, "genre")) { + if (genre_ptr == 0) + genre_ptr = tag->value; + mask[metaptr] = 1; + } else if (!strcasecmp(tag->item, "tempo")) { + if (tempo_ptr == 0) + tempo_ptr = tag->value; + mask[metaptr] = 1; } } + if (tracknumber_ptr) + membuffer_write_track_tag(buf, "trkn", myatoi(tracknumber_ptr), + myatoi(totaltracks_ptr)); + if (discnumber_ptr) + membuffer_write_track_tag(buf, "disk", myatoi(discnumber_ptr), + myatoi(totaldiscs_ptr)); + if (tempo_ptr) + membuffer_write_int16_tag(buf, "tmpo", myatoi(tempo_ptr)); + + if (genre_ptr) { + uint32_t index = meta_genre_to_index(genre_ptr); + if (index == 0) + membuffer_write_std_tag(buf, "©gen", genre_ptr); + else + membuffer_write_int16_tag(buf, "gnre", index); + } for (metaptr = 0; metaptr < data->count; metaptr++) { - if (!mask[metaptr]) { - mp4ff_tag_t *tag = &data->tags[metaptr]; - const char *std_meta_atom = find_standard_meta(tag->item); - if (std_meta_atom) { - membuffer_write_std_tag(buf, std_meta_atom, - tag->value); - } else { - membuffer_write_custom_tag(buf, tag->item, - tag->value); - } - } + struct mp4_tag *tag; + const char *std_meta_atom; + + if (mask[metaptr]) + continue; + tag = &data->tags[metaptr]; + std_meta_atom = find_standard_meta(tag->item); + if (std_meta_atom) + membuffer_write_std_tag(buf, std_meta_atom, tag->value); + else + membuffer_write_custom_tag(buf, tag->item, tag->value); } - free(mask); if (membuffer_error(buf)) { @@ -1986,39 +1761,39 @@ static uint32_t create_ilst(const mp4ff_metadata_t * data, void **out_buffer, return 1; } -static void membuffer_write_atom(membuffer * buf, const char *name, unsigned size, +static void membuffer_write_atom(struct membuffer *buf, const char *name, unsigned size, const void *data) { membuffer_write_int32(buf, size + 8); membuffer_write_atom_name(buf, name); - membuffer_write_data(buf, data, size); + membuffer_write(buf, data, size); } -static void *membuffer_get_ptr(const membuffer * buf) +static void *membuffer_get_ptr(const struct membuffer *buf) { return buf->data; } -static void membuffer_set_error(membuffer * buf) +static void membuffer_set_error(struct membuffer *buf) { buf->error = 1; } -static unsigned membuffer_transfer_from_file(membuffer * buf, mp4ff_t * src, +static unsigned membuffer_transfer_from_file(struct membuffer *buf, struct mp4 *src, unsigned bytes) { unsigned oldsize; void *bufptr; oldsize = membuffer_get_size(buf); - if (membuffer_write_data(buf, 0, bytes) != bytes) + if (membuffer_write(buf, 0, bytes) != bytes) return 0; bufptr = membuffer_get_ptr(buf); if (bufptr == 0) return 0; - if ((unsigned) mp4ff_read_data(src, (char *) bufptr + oldsize, bytes) != + if ((unsigned)read_data(src, (char *) bufptr + oldsize, bytes) != bytes) { membuffer_set_error(buf); return 0; @@ -2027,10 +1802,10 @@ static unsigned membuffer_transfer_from_file(membuffer * buf, mp4ff_t * src, return bytes; } -static uint32_t create_meta(const mp4ff_metadata_t * data, void **out_buffer, +static uint32_t create_meta(const struct mp4_metadata *data, void **out_buffer, uint32_t * out_size) { - membuffer *buf; + struct membuffer *buf; uint32_t ilst_size; void *ilst_buffer; @@ -2049,10 +1824,10 @@ static uint32_t create_meta(const mp4ff_metadata_t * data, void **out_buffer, return 1; } -static uint32_t create_udta(const mp4ff_metadata_t * data, void **out_buffer, +static uint32_t create_udta(const struct mp4_metadata *data, void **out_buffer, uint32_t * out_size) { - membuffer *buf; + struct membuffer *buf; uint32_t meta_size; void *meta_buffer; @@ -2073,21 +1848,10 @@ uint32_t * out_size) static uint32_t fix_byte_order_32(uint32_t src) { - uint32_t result; - uint32_t a, b, c, d; - int8_t data[4]; - - memcpy(data, &src, sizeof (src)); - a = (uint8_t) data[0]; - b = (uint8_t) data[1]; - c = (uint8_t) data[2]; - d = (uint8_t) data[3]; - - result = (a << 24) | (b << 16) | (c << 8) | d; - return (uint32_t) result; + return read_u32_be(&src); } -static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, +static uint32_t modify_moov(struct mp4 *f, const struct mp4_metadata *data, void **out_buffer, uint32_t * out_size) { uint64_t total_base = f->moov_offset + 8; @@ -2103,14 +1867,14 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, int32_t size_delta; if (!find_atom_v2(f, total_base, total_size, "udta", 0, "meta")) { - membuffer *buf; + struct membuffer *buf; void *new_udta_buffer; uint32_t new_udta_size; if (!create_udta(data, &new_udta_buffer, &new_udta_size)) return 0; buf = membuffer_create(); - mp4ff_set_position(f, total_base); + set_position(f, total_base); membuffer_transfer_from_file(buf, f, total_size); membuffer_write_atom(buf, "udta", new_udta_size, @@ -2123,17 +1887,17 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, membuffer_free(buf); return 1; } else { - udta_offset = mp4ff_position(f); - udta_size = mp4ff_read_int32(f); + udta_offset = get_position(f); + udta_size = read_int32(f); if (!find_atom_v2 (f, udta_offset + 8, udta_size - 8, "meta", 4, "ilst")) { - membuffer *buf; + struct membuffer *buf; void *new_meta_buffer; uint32_t new_meta_size; if (!create_meta(data, &new_meta_buffer, &new_meta_size)) return 0; buf = membuffer_create(); - mp4ff_set_position(f, total_base); + set_position(f, total_base); membuffer_transfer_from_file(buf, f, (uint32_t)(udta_offset - total_base)); @@ -2150,12 +1914,12 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, membuffer_free(buf); return 1; } - meta_offset = mp4ff_position(f); - meta_size = mp4ff_read_int32(f); + meta_offset = get_position(f); + meta_size = read_int32(f); if (!find_atom(f, meta_offset + 12, meta_size - 12, "ilst")) return 0; //shouldn't happen, find_atom_v2 above takes care of it - ilst_offset = mp4ff_position(f); - ilst_size = mp4ff_read_int32(f); + ilst_offset = get_position(f); + ilst_size = read_int32(f); if (!create_ilst(data, &new_ilst_buffer, &new_ilst_size)) return 0; @@ -2163,42 +1927,37 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, size_delta = new_ilst_size - (ilst_size - 8); *out_size = total_size + size_delta; - *out_buffer = malloc(*out_size); - if (*out_buffer == 0) { - free(new_ilst_buffer); - return 0; - } - + *out_buffer = para_malloc(*out_size); p_out = (uint8_t *) * out_buffer; - mp4ff_set_position(f, total_base); - mp4ff_read_data(f, p_out, + set_position(f, total_base); + read_data(f, p_out, (uint32_t) (udta_offset - total_base)); p_out += (uint32_t) (udta_offset - total_base); - *(uint32_t *) p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); + *(uint32_t *) p_out = fix_byte_order_32(read_int32(f) + size_delta); p_out += 4; - mp4ff_read_data(f, p_out, 4); + read_data(f, p_out, 4); p_out += 4; - mp4ff_read_data(f, p_out, + read_data(f, p_out, (uint32_t) (meta_offset - udta_offset - 8)); p_out += (uint32_t) (meta_offset - udta_offset - 8); - *(uint32_t *) p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); + *(uint32_t *) p_out = fix_byte_order_32(read_int32(f) + size_delta); p_out += 4; - mp4ff_read_data(f, p_out, 4); + read_data(f, p_out, 4); p_out += 4; - mp4ff_read_data(f, p_out, + read_data(f, p_out, (uint32_t) (ilst_offset - meta_offset - 8)); p_out += (uint32_t) (ilst_offset - meta_offset - 8); - *(uint32_t *) p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); + *(uint32_t *) p_out = fix_byte_order_32(read_int32(f) + size_delta); p_out += 4; - mp4ff_read_data(f, p_out, 4); + read_data(f, p_out, 4); p_out += 4; memcpy(p_out, new_ilst_buffer, new_ilst_size); p_out += new_ilst_size; - mp4ff_set_position(f, ilst_offset + ilst_size); - mp4ff_read_data(f, p_out, (uint32_t) (total_size + set_position(f, ilst_offset + ilst_size); + read_data(f, p_out, (uint32_t) (total_size - (ilst_offset - total_base) - ilst_size)); free(new_ilst_buffer); @@ -2206,7 +1965,7 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, return 1; } -static int32_t mp4ff_write_data(mp4ff_t * f, void *data, uint32_t size) +static int32_t write_data(struct mp4 *f, void *data, uint32_t size) { int32_t result = 1; @@ -2217,43 +1976,31 @@ static int32_t mp4ff_write_data(mp4ff_t * f, void *data, uint32_t size) return result; } -static int32_t mp4ff_write_int32(mp4ff_t * f, const uint32_t data) +static int32_t write_int32(struct mp4 *f, uint32_t data) { - uint32_t result; - uint32_t a, b, c, d; int8_t temp[4]; - - *(uint32_t *) temp = data; - a = (uint8_t) temp[0]; - b = (uint8_t) temp[1]; - c = (uint8_t) temp[2]; - d = (uint8_t) temp[3]; - - result = (a << 24) | (b << 16) | (c << 8) | d; - - return mp4ff_write_data(f, (uint8_t *) & result, sizeof (result)); + write_u32_be(temp, data); + return write_data(f, temp, sizeof(temp)); } -static int32_t mp4ff_truncate(mp4ff_t * f) +static int32_t truncate_stream(struct mp4 *f) { return f->stream->truncate(f->stream->user_data); } -int32_t mp4ff_meta_update(mp4ff_callback_t * f, const mp4ff_metadata_t * data) +int32_t mp4_meta_update(struct mp4_callback *f, const struct mp4_metadata *data) { void *new_moov_data; uint32_t new_moov_size; - mp4ff_t *ff = malloc(sizeof (mp4ff_t)); - - memset(ff, 0, sizeof (mp4ff_t)); + struct mp4 *ff = para_calloc(sizeof(struct mp4)); ff->stream = f; - mp4ff_set_position(ff, 0); + set_position(ff, 0); parse_atoms(ff, 1); if (!modify_moov(ff, data, &new_moov_data, &new_moov_size)) { - mp4ff_close(ff); + mp4_close(ff); return 0; } @@ -2262,36 +2009,36 @@ int32_t mp4ff_meta_update(mp4ff_callback_t * f, const mp4ff_metadata_t * data) char *free_data = "free"; /* rename old moov to free */ - mp4ff_set_position(ff, ff->moov_offset + 4); - mp4ff_write_data(ff, free_data, 4); + set_position(ff, ff->moov_offset + 4); + write_data(ff, free_data, 4); - mp4ff_set_position(ff, ff->file_size); - mp4ff_write_int32(ff, new_moov_size + 8); - mp4ff_write_data(ff, "moov", 4); - mp4ff_write_data(ff, new_moov_data, new_moov_size); + set_position(ff, ff->file_size); + write_int32(ff, new_moov_size + 8); + write_data(ff, "moov", 4); + write_data(ff, new_moov_data, new_moov_size); } else { - mp4ff_set_position(ff, ff->moov_offset); - mp4ff_write_int32(ff, new_moov_size + 8); - mp4ff_write_data(ff, "moov", 4); - mp4ff_write_data(ff, new_moov_data, new_moov_size); + set_position(ff, ff->moov_offset); + write_int32(ff, new_moov_size + 8); + write_data(ff, "moov", 4); + write_data(ff, new_moov_data, new_moov_size); } - mp4ff_truncate(ff); + truncate_stream(ff); - mp4ff_close(ff); + mp4_close(ff); return 1; } /* find a metadata item by name */ /* returns 0 if item found, 1 if no such item */ -static int32_t mp4ff_meta_find_by_name(const mp4ff_t * f, const char *item, +static int32_t meta_find_by_name(const struct mp4 *f, const char *item, char **value) { uint32_t i; for (i = 0; i < f->tags.count; i++) { - if (!stricmp(f->tags.tags[i].item, item)) { - *value = strdup(f->tags.tags[i].value); + if (!strcasecmp(f->tags.tags[i].item, item)) { + *value = para_strdup(f->tags.tags[i].value); return 1; } } @@ -2302,27 +2049,27 @@ static int32_t mp4ff_meta_find_by_name(const mp4ff_t * f, const char *item, return 0; } -int32_t mp4ff_meta_get_artist(const mp4ff_t * f, char **value) +int32_t mp4_meta_get_artist(const struct mp4 *f, char **value) { - return mp4ff_meta_find_by_name(f, "artist", value); + return meta_find_by_name(f, "artist", value); } -int32_t mp4ff_meta_get_title(const mp4ff_t * f, char **value) +int32_t mp4_meta_get_title(const struct mp4 *f, char **value) { - return mp4ff_meta_find_by_name(f, "title", value); + return meta_find_by_name(f, "title", value); } -int32_t mp4ff_meta_get_date(const mp4ff_t * f, char **value) +int32_t mp4_meta_get_date(const struct mp4 *f, char **value) { - return mp4ff_meta_find_by_name(f, "date", value); + return meta_find_by_name(f, "date", value); } -int32_t mp4ff_meta_get_album(const mp4ff_t * f, char **value) +int32_t mp4_meta_get_album(const struct mp4 *f, char **value) { - return mp4ff_meta_find_by_name(f, "album", value); + return meta_find_by_name(f, "album", value); } -int32_t mp4ff_meta_get_comment(const mp4ff_t * f, char **value) +int32_t mp4_meta_get_comment(const struct mp4 *f, char **value) { - return mp4ff_meta_find_by_name(f, "comment", value); + return meta_find_by_name(f, "comment", value); }