From 5c31a83497cdcec70be18555af6430fc99b09531 Mon Sep 17 00:00:00 2001 From: Andre Noll Date: Mon, 9 Aug 2021 22:11:48 +0200 Subject: [PATCH] mp4: Strip mp4ff_ prefix from static functions. This way it is clear from the name which functions are internal. --- mp4.c | 649 ++++++++++++++++++++++++++++------------------------------ 1 file changed, 318 insertions(+), 331 deletions(-) diff --git a/mp4.c b/mp4.c index fa6f8704..aab39a1e 100644 --- a/mp4.c +++ b/mp4.c @@ -16,7 +16,7 @@ int32_t mp4ff_total_tracks(const mp4ff_t * f) return f->total_tracks; } -static int32_t mp4ff_read_data(mp4ff_t * f, void *data, uint32_t size) +static int32_t read_data(mp4ff_t * f, void *data, uint32_t size) { int32_t result = 1; @@ -31,7 +31,7 @@ static int32_t mp4ff_read_data(mp4ff_t * f, void *data, uint32_t size) } /* parse atom header size */ -static int32_t mp4ff_atom_get_size(const int8_t * data) +static int32_t atom_get_size(const int8_t * data) { uint32_t result; uint32_t a, b, c, d; @@ -45,13 +45,13 @@ static int32_t mp4ff_atom_get_size(const int8_t * data) return (int32_t) result; } -static uint64_t mp4ff_read_int64(mp4ff_t * f) +static uint64_t read_int64(mp4ff_t * f) { uint8_t data[8]; uint64_t result = 0; int8_t i; - mp4ff_read_data(f, data, 8); + read_data(f, data, 8); for (i = 0; i < 8; i++) { result |= ((uint64_t) data[i]) << ((7 - i) * 8); @@ -61,7 +61,7 @@ static uint64_t mp4ff_read_int64(mp4ff_t * f) } /* 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, +static int32_t 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) @@ -158,197 +158,187 @@ static int32_t mp4ff_atom_compare(const int8_t a1, const int8_t b1, #define COPYRIGHT_SYMBOL ((int8_t)0xA9) -static uint8_t mp4ff_atom_name_to_type(const int8_t a, const int8_t b, +static uint8_t atom_name_to_type(const int8_t a, const int8_t b, const int8_t c, const 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(mp4ff_t * 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 = atom_get_size(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 mp4ff_t * f) { return f->current_position; } @@ -374,7 +364,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(mp4ff_t * f, const int64_t position) { f->stream->seek(f->stream->user_data, position); f->current_position = position; @@ -382,7 +372,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(mp4ff_t * f) { f->total_tracks++; @@ -394,20 +384,20 @@ static void mp4ff_track_add(mp4ff_t * f) f->track[f->total_tracks - 1] = para_calloc(sizeof (mp4ff_track_t)); } -static uint8_t mp4ff_read_char(mp4ff_t * f) +static uint8_t read_char(mp4ff_t * 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(mp4ff_t * f) { uint32_t result; uint32_t a, b, c; int8_t data[4]; - mp4ff_read_data(f, data, 3); + read_data(f, data, 3); a = (uint8_t) data[0]; b = (uint8_t) data[1]; c = (uint8_t) data[2]; @@ -416,13 +406,13 @@ static uint32_t mp4ff_read_int24(mp4ff_t * f) return (uint32_t) result; } -static uint32_t mp4ff_read_int32(mp4ff_t * f) +static uint32_t read_int32(mp4ff_t * f) { uint32_t result; uint32_t a, b, c, d; int8_t data[4]; - mp4ff_read_data(f, data, 4); + read_data(f, data, 4); a = (uint8_t) data[0]; b = (uint8_t) data[1]; c = (uint8_t) data[2]; @@ -432,7 +422,7 @@ static uint32_t mp4ff_read_int32(mp4ff_t * f) return (uint32_t) result; } -static int32_t mp4ff_read_stsz(mp4ff_t * f) +static int32_t read_stsz(mp4ff_t * f) { int32_t i; mp4ff_track_t *t; @@ -440,19 +430,19 @@ static int32_t mp4ff_read_stsz(mp4ff_t * f) 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 */ - t->stsz_sample_size = mp4ff_read_int32(f); - t->stsz_sample_count = mp4ff_read_int32(f); + 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] = mp4ff_read_int32(f); + t->stsz_table[i] = read_int32(f); return 0; } -static int32_t mp4ff_read_stts(mp4ff_t * f) +static int32_t read_stts(mp4ff_t * f) { int32_t i; mp4ff_track_t *t; @@ -463,9 +453,9 @@ static int32_t mp4ff_read_stts(mp4ff_t * f) t = f->track[f->total_tracks - 1]; if (t->stts_entry_count) return 0; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - t->stts_entry_count = mp4ff_read_int32(f); + read_char(f); /* version */ + read_int24(f); /* flags */ + t->stts_entry_count = read_int32(f); t->stts_sample_count = para_malloc(t->stts_entry_count * sizeof(int32_t)); @@ -473,13 +463,13 @@ static int32_t mp4ff_read_stts(mp4ff_t * f) * sizeof (int32_t)); /* CVE-2017-9254 */ for (i = 0; i < t->stts_entry_count && !f->stream->read_error; i++) { - t->stts_sample_count[i] = mp4ff_read_int32(f); - t->stts_sample_delta[i] = mp4ff_read_int32(f); + 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(mp4ff_t * f) { int32_t i; mp4ff_track_t *t; @@ -490,9 +480,9 @@ static int32_t mp4ff_read_ctts(mp4ff_t * f) if (t->ctts_entry_count) return 0; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - t->ctts_entry_count = mp4ff_read_int32(f); + read_char(f); /* version */ + read_int24(f); /* flags */ + t->ctts_entry_count = read_int32(f); t->ctts_sample_count = para_malloc(t->ctts_entry_count * sizeof (int32_t)); @@ -501,13 +491,13 @@ static int32_t mp4ff_read_ctts(mp4ff_t * f) /* CVE-2017-9257 */ for (i = 0; i < t->ctts_entry_count && !f->stream->read_error; i++) { - t->ctts_sample_count[i] = mp4ff_read_int32(f); - t->ctts_sample_offset[i] = mp4ff_read_int32(f); + 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(mp4ff_t * f) { int32_t i; mp4ff_track_t *t; @@ -516,9 +506,9 @@ static int32_t mp4ff_read_stsc(mp4ff_t * f) return f->error++; t = f->track[f->total_tracks - 1]; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - t->stsc_entry_count = mp4ff_read_int32(f); + 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)); @@ -527,14 +517,14 @@ static int32_t mp4ff_read_stsc(mp4ff_t * f) /* CVE-2017-9255 */ for (i = 0; i < t->stsc_entry_count && !f->stream->read_error; i++) { - t->stsc_first_chunk[i] = mp4ff_read_int32(f); - t->stsc_samples_per_chunk[i] = mp4ff_read_int32(f); - t->stsc_sample_desc_index[i] = mp4ff_read_int32(f); + 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(mp4ff_t * f) { int32_t i; mp4ff_track_t *t; @@ -543,24 +533,24 @@ static int32_t mp4ff_read_stco(mp4ff_t * f) return f->error++; t = f->track[f->total_tracks - 1]; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - t->stco_entry_count = mp4ff_read_int32(f); + 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] = mp4ff_read_int32(f); + t->stco_chunk_offset[i] = read_int32(f); return 0; } -static uint16_t mp4ff_read_int16(mp4ff_t * f) +static uint16_t read_int16(mp4ff_t * f) { uint32_t result; uint32_t a, b; int8_t data[2]; - mp4ff_read_data(f, data, 2); + read_data(f, data, 2); a = (uint8_t) data[0]; b = (uint8_t) data[1]; @@ -568,21 +558,21 @@ static uint16_t mp4ff_read_int16(mp4ff_t * f) return (uint16_t) result; } -static uint32_t mp4ff_read_mp4_descr_length(mp4ff_t * f) +static uint32_t read_mp4_descr_length(mp4ff_t * f) { uint8_t b; uint8_t numBytes = 0; uint32_t length = 0; do { - b = mp4ff_read_char(f); + b = 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) +static int32_t read_esds(mp4ff_t * f) { uint8_t tag; uint32_t temp; @@ -591,52 +581,52 @@ static int32_t mp4ff_read_esds(mp4ff_t * f) 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 */ /* get and verify ES_DescrTag */ - tag = mp4ff_read_char(f); + tag = read_char(f); if (tag == 0x03) { /* read length */ - if (mp4ff_read_mp4_descr_length(f) < 5 + 15) { + if (read_mp4_descr_length(f) < 5 + 15) { return 1; } /* skip 3 bytes */ - mp4ff_read_int24(f); + read_int24(f); } else { /* skip 2 bytes */ - mp4ff_read_int16(f); + read_int16(f); } /* get and verify DecoderConfigDescrTab */ - if (mp4ff_read_char(f) != 0x04) { + if (read_char(f) != 0x04) { return 1; } /* read length */ - temp = mp4ff_read_mp4_descr_length(f); + temp = read_mp4_descr_length(f); if (temp < 13) return 1; - t->audioType = mp4ff_read_char(f); - mp4ff_read_int32(f); //0x15000414 ???? - t->maxBitrate = mp4ff_read_int32(f); - t->avgBitrate = mp4ff_read_int32(f); + t->audioType = read_char(f); + read_int32(f); //0x15000414 ???? + t->maxBitrate = read_int32(f); + t->avgBitrate = read_int32(f); /* get and verify DecSpecificInfoTag */ - if (mp4ff_read_char(f) != 0x05) { + if (read_char(f) != 0x05) { return 1; } /* read length */ - t->decoderConfigLen = mp4ff_read_mp4_descr_length(f); + t->decoderConfigLen = read_mp4_descr_length(f); free(t->decoderConfig); t->decoderConfig = para_malloc(t->decoderConfigLen); - mp4ff_read_data(f, t->decoderConfig, t->decoderConfigLen); + read_data(f, t->decoderConfig, t->decoderConfigLen); /* will skip the remainder of the atom */ return 0; } -static int32_t mp4ff_read_mp4a(mp4ff_t * f) +static int32_t read_mp4a(mp4ff_t * f) { int32_t i; uint8_t atom_type = 0; @@ -648,32 +638,30 @@ static int32_t mp4ff_read_mp4a(mp4ff_t * f) 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); + /* data_reference_index */ read_int16(f); - mp4ff_read_int32(f); /* reserved */ - mp4ff_read_int32(f); /* reserved */ + read_int32(f); /* reserved */ + read_int32(f); /* reserved */ - t->channelCount = mp4ff_read_int16(f); - t->sampleSize = mp4ff_read_int16(f); + t->channelCount = read_int16(f); + t->sampleSize = read_int16(f); - mp4ff_read_int16(f); - mp4ff_read_int16(f); + read_int16(f); + read_int16(f); - t->sampleRate = mp4ff_read_int16(f); + t->sampleRate = read_int16(f); - mp4ff_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); + if (atom_type == ATOM_ESDS) + read_esds(f); return 0; } -static int32_t mp4ff_read_stsd(mp4ff_t * f) +static int32_t read_stsd(mp4ff_t * f) { int32_t i; uint8_t header_size = 0; @@ -684,22 +672,22 @@ static int32_t mp4ff_read_stsd(mp4ff_t * f) 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 */ - t->stsd_entry_count = mp4ff_read_int32(f); + t->stsd_entry_count = read_int32(f); /* CVE-2017-9253 */ for (i = 0; i < t->stsd_entry_count && !f->stream->read_error; i++) { - uint64_t skip = mp4ff_position(f); + 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) { t->type = TRACK_AUDIO; - mp4ff_read_mp4a(f); + read_mp4a(f); } else if (atom_type == ATOM_MP4V) { t->type = TRACK_VIDEO; } else if (atom_type == ATOM_MP4S) { @@ -707,44 +695,44 @@ static int32_t mp4ff_read_stsd(mp4ff_t * f) } else { t->type = TRACK_UNKNOWN; } - mp4ff_set_position(f, skip); + set_position(f, skip); } return 0; } -static int32_t mp4ff_read_mvhd(mp4ff_t * f) +static int32_t read_mvhd(mp4ff_t * 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); + read_char(f); /* version */ + read_int24(f); /* flags */ + /* creation_time */ read_int32(f); + /* modification_time */ read_int32(f); + f->time_scale = read_int32(f); + f->duration = read_int32(f); + /* preferred_rate */ read_int32(f); /*mp4ff_read_fixed32(f); */ - /* preferred_volume */ mp4ff_read_int16(f); + /* preferred_volume */ read_int16(f); /*mp4ff_read_fixed16(f); */ for (i = 0; i < 10; i++) { - /* reserved */ mp4ff_read_char(f); + /* reserved */ read_char(f); } for (i = 0; i < 9; i++) { - mp4ff_read_int32(f); /* matrix */ + 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); + /* 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 */ read_int32(f); return 0; } -static int32_t mp4ff_tag_add_field(mp4ff_metadata_t * tags, const char *item, +static int32_t tag_add_field(mp4ff_metadata_t * tags, const char *item, const char *value, int32_t len) { void *backup = (void *) tags->tags; @@ -803,7 +791,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]; @@ -812,10 +800,10 @@ 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(mp4ff_t *f, uint32_t length) { char *str = para_malloc(length + 1); - if ((uint32_t)mp4ff_read_data(f, str, length) != length) { + if ((uint32_t)read_data(f, str, length) != length) { free(str); str = NULL; } else @@ -823,7 +811,7 @@ static char *mp4ff_read_string(mp4ff_t * f, uint32_t length) return str; } -static int32_t mp4ff_set_metadata_name(const uint8_t atom_type, char **name) +static int32_t set_metadata_name(const uint8_t atom_type, char **name) { static char *tag_names[] = { "unknown", "title", "artist", "writer", "album", @@ -960,7 +948,7 @@ static uint32_t min_body_size(const uint8_t atom_type) } } -static int32_t mp4ff_parse_tag(mp4ff_t * f, const uint8_t parent, +static int32_t parse_tag(mp4ff_t * f, const uint8_t parent, const int32_t size) { uint8_t atom_type; @@ -975,40 +963,40 @@ static int32_t mp4ff_parse_tag(mp4ff_t * f, const uint8_t parent, for ( sumsize = 0; sumsize < size && !f->stream->read_error; /* CVE-2017-9222 */ - mp4ff_set_position(f, destpos), sumsize += subsize + set_position(f, destpos), sumsize += subsize ) { - subsize = mp4ff_atom_read_header(f, &atom_type, &header_size); - destpos = mp4ff_position(f) + subsize - header_size; + subsize = atom_read_header(f, &atom_type, &header_size); + destpos = get_position(f) + subsize - header_size; if (done) continue; if (atom_type == ATOM_NAME) { - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ + read_char(f); /* version */ + read_int24(f); /* flags */ free(name); - name = mp4ff_read_string(f, subsize - (header_size + 4)); + name = read_string(f, subsize - (header_size + 4)); continue; } if (atom_type != ATOM_DATA) continue; - mp4ff_read_char(f); /* version */ - mp4ff_read_int24(f); /* flags */ - mp4ff_read_int32(f); /* reserved */ + 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 = mp4ff_read_int16(f); + val = read_int16(f); if (parent == ATOM_TEMPO) { char temp[16]; sprintf(temp, "%.5u BPM", val); - mp4ff_tag_add_field(&(f-> tags), "tempo", + tag_add_field(&(f-> tags), "tempo", temp, -1); } else { - const char *tmp = mp4ff_meta_index_to_genre(val); + const char *tmp = meta_index_to_genre(val); if (tmp) - mp4ff_tag_add_field (&(f->tags), + tag_add_field (&(f->tags), "genre", tmp, -1); } done = 1; @@ -1017,33 +1005,33 @@ static int32_t mp4ff_parse_tag(mp4ff_t * f, const uint8_t parent, char temp[32]; if (subsize - header_size < min_body_size(parent)) continue; - mp4ff_read_int16(f); - index = mp4ff_read_int16(f); - total = mp4ff_read_int16(f); + read_int16(f); + index = read_int16(f); + total = read_int16(f); if (parent == ATOM_TRACK) - mp4ff_read_int16(f); + read_int16(f); sprintf(temp, "%d", index); - mp4ff_tag_add_field(&(f->tags), parent == ATOM_TRACK? + tag_add_field(&(f->tags), parent == ATOM_TRACK? "track" : "disc", temp, -1); if (total > 0) { sprintf(temp, "%d", total); - mp4ff_tag_add_field(& (f-> tags), + tag_add_field(& (f-> tags), parent == ATOM_TRACK? "totaltracks" : "totaldiscs", temp, -1); } done = 1; } else { free(data); - data = mp4ff_read_string(f, subsize - (header_size + 8)); + 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 , &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); @@ -1052,7 +1040,7 @@ static int32_t mp4ff_parse_tag(mp4ff_t * f, const uint8_t parent, return 1; } -static int32_t mp4ff_read_mdhd(mp4ff_t * f) +static int32_t read_mdhd(mp4ff_t * f) { uint32_t version; mp4ff_track_t *t; @@ -1062,62 +1050,61 @@ static int32_t mp4ff_read_mdhd(mp4ff_t * f) 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 - t->timeScale = mp4ff_read_int32(f); //timescale - t->duration = mp4ff_read_int64(f); //duration + 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 - t->timeScale = mp4ff_read_int32(f); //timescale - temp = mp4ff_read_int32(f); + 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(mp4ff_t * f, const 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(mp4ff_t * f, const 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; } @@ -1125,40 +1112,40 @@ 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(mp4ff_t *f, const int32_t size, + const 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; } @@ -1171,7 +1158,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 */ @@ -1181,17 +1168,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); } } @@ -1209,23 +1194,23 @@ 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_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); } } @@ -1269,7 +1254,7 @@ 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(mp4ff_metadata_t * tags) { uint32_t i; @@ -1304,11 +1289,11 @@ void mp4ff_close(mp4ff_t * ff) } } - mp4ff_tag_delete(&(ff->tags)); + tag_delete(&(ff->tags)); free(ff); } -static int32_t mp4ff_chunk_of_sample(const mp4ff_t * f, const int32_t track, +static int32_t chunk_of_sample(const mp4ff_t * f, const int32_t track, const int32_t sample, int32_t * chunk_sample, int32_t * chunk) { int32_t total_entries = 0; @@ -1354,7 +1339,7 @@ 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, +static int32_t chunk_to_offset(const mp4ff_t * f, const int32_t track, const int32_t chunk) { const mp4ff_track_t *p_track = f->track[track]; @@ -1371,7 +1356,7 @@ 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, +static int32_t sample_range_size(const mp4ff_t * f, const int32_t track, const int32_t chunk_sample, const int32_t sample) { int32_t i, total; @@ -1390,15 +1375,16 @@ 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, + +static int32_t sample_to_offset(const mp4ff_t * f, const int32_t track, const 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; } @@ -1406,8 +1392,8 @@ static int32_t mp4ff_sample_to_offset(const mp4ff_t * f, const int32_t track, void mp4ff_set_sample_position(mp4ff_t *f, const int32_t track, const int32_t sample) { - int32_t offset = mp4ff_sample_to_offset(f, track, sample); - mp4ff_set_position(f, offset); + int32_t offset = sample_to_offset(f, track, sample); + set_position(f, offset); } int32_t mp4ff_get_sample_size(const mp4ff_t *f, int track, int sample) @@ -1484,17 +1470,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; } @@ -1503,14 +1489,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, 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; @@ -1520,7 +1507,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; @@ -1533,7 +1520,7 @@ 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; @@ -1648,7 +1635,7 @@ 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++) { @@ -1823,7 +1810,7 @@ static uint32_t create_ilst(const mp4ff_metadata_t * data, void **out_buffer, (uint16_t) myatoi(tempo_ptr)); if (genre_ptr) { - uint32_t index = mp4ff_meta_genre_to_index(genre_ptr); + uint32_t index = meta_genre_to_index(genre_ptr); if (index == 0) membuffer_write_std_tag(buf, "©gen", genre_ptr); @@ -1893,7 +1880,7 @@ static unsigned membuffer_transfer_from_file(membuffer * buf, mp4ff_t * src, 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; @@ -1985,7 +1972,7 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, 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, @@ -1998,8 +1985,8 @@ 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; void *new_meta_buffer; @@ -2008,7 +1995,7 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, 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)); @@ -2025,12 +2012,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; @@ -2041,34 +2028,34 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data, *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); @@ -2076,7 +2063,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(mp4ff_t * f, void *data, uint32_t size) { int32_t result = 1; @@ -2087,7 +2074,7 @@ 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(mp4ff_t * f, const uint32_t data) { uint32_t result; uint32_t a, b, c, d; @@ -2101,10 +2088,10 @@ static int32_t mp4ff_write_int32(mp4ff_t * f, const uint32_t data) result = (a << 24) | (b << 16) | (c << 8) | d; - return mp4ff_write_data(f, (uint8_t *) & result, sizeof (result)); + return write_data(f, (uint8_t *) & result, sizeof (result)); } -static int32_t mp4ff_truncate(mp4ff_t * f) +static int32_t truncate_stream(mp4ff_t * f) { return f->stream->truncate(f->stream->user_data); } @@ -2116,7 +2103,7 @@ int32_t mp4ff_meta_update(mp4ff_callback_t * f, const mp4ff_metadata_t * data) mp4ff_t *ff = para_calloc(sizeof(mp4ff_t)); ff->stream = f; - mp4ff_set_position(ff, 0); + set_position(ff, 0); parse_atoms(ff, 1); @@ -2130,21 +2117,21 @@ 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); return 1; @@ -2152,7 +2139,7 @@ int32_t mp4ff_meta_update(mp4ff_callback_t * f, const mp4ff_metadata_t * data) /* 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 mp4ff_t * f, const char *item, char **value) { uint32_t i; @@ -2172,25 +2159,25 @@ static int32_t mp4ff_meta_find_by_name(const mp4ff_t * f, const char *item, int32_t mp4ff_meta_get_artist(const mp4ff_t * 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) { - 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) { - 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) { - 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) { - return mp4ff_meta_find_by_name(f, "comment", value); + return meta_find_by_name(f, "comment", value); } -- 2.39.5