mp4: Avoid typedefs for data structures.

They only obfuscate the type.

diff --git a/aac_afh.c b/aac_afh.c
index c2daf5b533ca881990963618fbd2c488468f58ce..dd9247d7ac6bba54a1c49512613ea8011a387a46 100644 (file)
--- a/aac_afh.c
+++ b/aac_afh.c
@@ -23,9 +23,9 @@ struct aac_afh_context {
        size_t mapsize;
        size_t fpos;
        int32_t track;
-       mp4ff_t *mp4ff;
+       struct mp4ff *mp4ff;
        mp4AudioSpecificConfig masc;
-       mp4ff_callback_t cb;
+       struct mp4ff_callback cb;
 };
 
 static uint32_t aac_afh_read_cb(void *user_data, void *dest, uint32_t want)
@@ -50,7 +50,7 @@ static uint32_t aac_afh_seek_cb(void *user_data, uint64_t pos)
        return 0;
 }
 
-static int32_t aac_afh_get_track(mp4ff_t *mp4ff, mp4AudioSpecificConfig *masc)
+static int32_t aac_afh_get_track(struct mp4ff *mp4ff, mp4AudioSpecificConfig *masc)
 {
        int32_t i, rc, num_tracks = mp4ff_total_tracks(mp4ff);
 
@@ -127,7 +127,7 @@ static int aac_afh_get_chunk(uint32_t chunk_num, void *afh_context,
        return 1;
 }
 
-static void _aac_afh_get_taginfo(const mp4ff_t *mp4ff, struct taginfo *tags)
+static void _aac_afh_get_taginfo(const struct mp4ff *mp4ff, struct taginfo *tags)
 {
        mp4ff_meta_get_artist(mp4ff, &tags->artist);
        mp4ff_meta_get_title(mp4ff, &tags->title);
@@ -216,14 +216,14 @@ static uint32_t aac_afh_meta_truncate_cb(void *user_data)
        return ftruncate(fd, offset);
 }
 
-static void replace_tag(mp4ff_tag_t *tag, const char *new_val, bool *found)
+static void replace_tag(struct mp4ff_tag *tag, const char *new_val, bool *found)
 {
        free(tag->value);
        tag->value = para_strdup(new_val);
        *found = true;
 }
 
-static void add_tag(mp4ff_metadata_t *md, const char *item, const char *value)
+static void add_tag(struct mp4ff_metadata *md, const char *item, const char *value)
 {
        md->tags[md->count].item = para_strdup(item);
        md->tags[md->count].value = para_strdup(value);
@@ -235,9 +235,9 @@ static int aac_afh_rewrite_tags(const char *map, size_t mapsize,
 {
        int ret, i;
        int32_t rv;
-       mp4ff_metadata_t metadata;
-       mp4ff_t *mp4ff;
-       mp4ff_callback_t cb = {
+       struct mp4ff_metadata metadata;
+       struct mp4ff *mp4ff;
+       struct mp4ff_callback cb = {
                .read = aac_afh_meta_read_cb,
                .seek = aac_afh_meta_seek_cb,
                .write = aac_afh_meta_write_cb,
@@ -263,9 +263,9 @@ static int aac_afh_rewrite_tags(const char *map, size_t mapsize,
        metadata.count = rv;
        PARA_NOTICE_LOG("%d metadata item(s) found\n", rv);
 
-       metadata.tags = para_malloc((metadata.count + 5) * sizeof(mp4ff_tag_t));
+       metadata.tags = para_malloc((metadata.count + 5) * sizeof(struct mp4ff_tag));
        for (i = 0; i < metadata.count; i++) {
-               mp4ff_tag_t *tag = metadata.tags + i;
+               struct mp4ff_tag *tag = metadata.tags + i;
 
                ret = -E_MP4FF_META_READ;
                if (!mp4ff_meta_get_by_index(mp4ff, i, &tag->item, &tag->value))

diff --git a/mp4.c b/mp4.c
index 345775b247d0cf417dff7bb5f513ab0e7a86773b..b6fbabcd39e45c5fb2a5df9d4dcb45e0db8fe205 100644 (file)
--- a/mp4.c
+++ b/mp4.c
@@ -12,12 +12,12 @@
 #include "string.h"
 #include "mp4.h"
 
-int32_t mp4ff_total_tracks(const mp4ff_t * f)
+int32_t mp4ff_total_tracks(const struct mp4ff *f)
 {
        return f->total_tracks;
 }
 
-static int32_t read_data(mp4ff_t * f, void *data, uint32_t size)
+static int32_t read_data(struct mp4ff *f, void *data, uint32_t size)
 {
        int32_t result = 1;
 
@@ -31,7 +31,7 @@ static int32_t read_data(mp4ff_t * f, void *data, uint32_t size)
        return result;
 }
 
-static uint64_t read_int64(mp4ff_t * f)
+static uint64_t read_int64(struct mp4ff *f)
 {
        uint8_t data[8];
 
@@ -298,7 +298,7 @@ static uint8_t atom_name_to_type(const int8_t a, const int8_t b,
 }
 
 /* read atom header, return atom size, atom size is with header included */
-static uint64_t atom_read_header(mp4ff_t * f, uint8_t * atom_type,
+static uint64_t atom_read_header(struct mp4ff *f, uint8_t * atom_type,
                                uint8_t * header_size)
 {
        uint64_t size;
@@ -322,7 +322,7 @@ static uint64_t atom_read_header(mp4ff_t * f, uint8_t * atom_type,
        return size;
 }
 
-static int64_t get_position(const mp4ff_t * f)
+static int64_t get_position(const struct mp4ff *f)
 {
        return f->current_position;
 }
@@ -348,7 +348,7 @@ static int need_parse_when_meta_only(uint8_t atom_type)
        }
 }
 
-static int32_t set_position(mp4ff_t * f, const int64_t position)
+static int32_t set_position(struct mp4ff *f, const int64_t position)
 {
        f->stream->seek(f->stream->user_data, position);
        f->current_position = position;
@@ -356,7 +356,7 @@ static int32_t set_position(mp4ff_t * f, const int64_t position)
        return 0;
 }
 
-static void track_add(mp4ff_t * f)
+static void track_add(struct mp4ff *f)
 {
        f->total_tracks++;
 
@@ -365,17 +365,17 @@ static void track_add(mp4ff_t * f)
                f->error++;
                return;
        }
-       f->track[f->total_tracks - 1] = para_calloc(sizeof (mp4ff_track_t));
+       f->track[f->total_tracks - 1] = para_calloc(sizeof(struct mp4ff_track));
 }
 
-static uint8_t read_char(mp4ff_t * f)
+static uint8_t read_char(struct mp4ff *f)
 {
        uint8_t output;
        read_data(f, &output, 1);
        return output;
 }
 
-static uint32_t read_int24(mp4ff_t * f)
+static uint32_t read_int24(struct mp4ff *f)
 {
        int8_t data[4];
 
@@ -383,7 +383,7 @@ static uint32_t read_int24(mp4ff_t * f)
        return read_u24_be(data);
 }
 
-static uint32_t read_int32(mp4ff_t * f)
+static uint32_t read_int32(struct mp4ff *f)
 {
        int8_t data[4];
 
@@ -391,10 +391,10 @@ static uint32_t read_int32(mp4ff_t * f)
        return read_u32_be(data);
 }
 
-static int32_t read_stsz(mp4ff_t * f)
+static int32_t read_stsz(struct mp4ff *f)
 {
        int32_t i;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        if (f->total_tracks == 0)
                return f->error++;
@@ -411,10 +411,10 @@ static int32_t read_stsz(mp4ff_t * f)
        return 0;
 }
 
-static int32_t read_stts(mp4ff_t * f)
+static int32_t read_stts(struct mp4ff *f)
 {
        int32_t i;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        /* CVE-2017-9223 */
        if (f->total_tracks == 0)
@@ -438,10 +438,10 @@ static int32_t read_stts(mp4ff_t * f)
        return 1;
 }
 
-static int32_t read_ctts(mp4ff_t * f)
+static int32_t read_ctts(struct mp4ff *f)
 {
        int32_t i;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        if (f->total_tracks == 0)
                return f->error++;
@@ -466,10 +466,10 @@ static int32_t read_ctts(mp4ff_t * f)
        return 1;
 }
 
-static int32_t read_stsc(mp4ff_t * f)
+static int32_t read_stsc(struct mp4ff *f)
 {
        int32_t i;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        if (f->total_tracks == 0)
                return f->error++;
@@ -493,10 +493,10 @@ static int32_t read_stsc(mp4ff_t * f)
        return 0;
 }
 
-static int32_t read_stco(mp4ff_t * f)
+static int32_t read_stco(struct mp4ff *f)
 {
        int32_t i;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        if (f->total_tracks == 0)
                return f->error++;
@@ -513,7 +513,7 @@ static int32_t read_stco(mp4ff_t * f)
        return 0;
 }
 
-static uint16_t read_int16(mp4ff_t * f)
+static uint16_t read_int16(struct mp4ff *f)
 {
        int8_t data[2];
 
@@ -521,7 +521,7 @@ static uint16_t read_int16(mp4ff_t * f)
        return read_u16_be(data);
 }
 
-static uint32_t read_mp4_descr_length(mp4ff_t * f)
+static uint32_t read_mp4_descr_length(struct mp4ff *f)
 {
        uint8_t b;
        uint8_t numBytes = 0;
@@ -535,11 +535,11 @@ static uint32_t read_mp4_descr_length(mp4ff_t * f)
 
        return length;
 }
-static int32_t read_esds(mp4ff_t * f)
+static int32_t read_esds(struct mp4ff *f)
 {
        uint8_t tag;
        uint32_t temp;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        if (f->total_tracks == 0)
                return f->error++;
@@ -589,12 +589,12 @@ static int32_t read_esds(mp4ff_t * f)
        return 0;
 }
 
-static int32_t read_mp4a(mp4ff_t * f)
+static int32_t read_mp4a(struct mp4ff *f)
 {
        int32_t i;
        uint8_t atom_type = 0;
        uint8_t header_size = 0;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        if (f->total_tracks == 0)
                return f->error++;
@@ -624,11 +624,11 @@ static int32_t read_mp4a(mp4ff_t * f)
        return 0;
 }
 
-static int32_t read_stsd(mp4ff_t * f)
+static int32_t read_stsd(struct mp4ff *f)
 {
        int32_t i;
        uint8_t header_size = 0;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        /* CVE-2017-9218 */
        if (f->total_tracks == 0)
@@ -664,7 +664,7 @@ static int32_t read_stsd(mp4ff_t * f)
        return 0;
 }
 
-static int32_t read_mvhd(mp4ff_t * f)
+static int32_t read_mvhd(struct mp4ff *f)
 {
        int32_t i;
 
@@ -690,7 +690,7 @@ static int32_t read_mvhd(mp4ff_t * f)
        return 0;
 }
 
-static int32_t tag_add_field(mp4ff_metadata_t * tags, const char *item,
+static int32_t tag_add_field(struct mp4ff_metadata *tags, const char *item,
                const char *value, int32_t len)
 {
        void *backup = (void *) tags->tags;
@@ -698,8 +698,8 @@ static int32_t tag_add_field(mp4ff_metadata_t * tags, const char *item,
        if (!item || (item && !*item) || !value)
                return 0;
 
-       tags->tags = (mp4ff_tag_t *) realloc(tags->tags,
-               (tags->count + 1) * sizeof (mp4ff_tag_t));
+       tags->tags = (struct mp4ff_tag *)realloc(tags->tags,
+               (tags->count + 1) * sizeof(struct mp4ff_tag));
        if (!tags->tags) {
                free(backup);
                return 0;
@@ -758,7 +758,7 @@ static const char *meta_index_to_genre(uint32_t idx)
        }
 }
 
-static char *read_string(mp4ff_t *f, uint32_t length)
+static char *read_string(struct mp4ff *f, uint32_t length)
 {
        char *str = para_malloc(length + 1);
        if ((uint32_t)read_data(f, str, length) != length) {
@@ -906,7 +906,7 @@ static uint32_t min_body_size(const uint8_t atom_type)
        }
 }
 
-static int32_t parse_tag(mp4ff_t * f, const uint8_t parent,
+static int32_t parse_tag(struct mp4ff *f, const uint8_t parent,
                const int32_t size)
 {
        uint8_t atom_type;
@@ -998,10 +998,10 @@ static int32_t parse_tag(mp4ff_t * f, const uint8_t parent,
        return 1;
 }
 
-static int32_t read_mdhd(mp4ff_t * f)
+static int32_t read_mdhd(struct mp4ff *f)
 {
        uint32_t version;
-       mp4ff_track_t *t;
+       struct mp4ff_track *t;
 
        /* CVE-2017-9221 */
        if (f->total_tracks == 0)
@@ -1029,7 +1029,7 @@ static int32_t read_mdhd(mp4ff_t * f)
        return 1;
 }
 
-static int32_t parse_metadata(mp4ff_t * f, const int32_t size)
+static int32_t parse_metadata(struct mp4ff *f, const int32_t size)
 {
        uint64_t subsize, sumsize = 0;
        uint8_t atom_type;
@@ -1046,7 +1046,7 @@ static int32_t parse_metadata(mp4ff_t * f, const int32_t size)
        return 0;
 }
 
-static int32_t read_meta(mp4ff_t * f, const uint64_t size)
+static int32_t read_meta(struct mp4ff *f, const uint64_t size)
 {
        uint64_t subsize, sumsize = 0;
        uint8_t atom_type;
@@ -1070,7 +1070,7 @@ static int32_t read_meta(mp4ff_t * f, const uint64_t size)
        return 0;
 }
 
-static int32_t atom_read(mp4ff_t *f, const int32_t size,
+static int32_t atom_read(struct mp4ff *f, const int32_t size,
                const uint8_t atom_type)
 {
        uint64_t dest_position = get_position(f) + size - 8;
@@ -1108,7 +1108,7 @@ static int32_t atom_read(mp4ff_t *f, const int32_t size,
 }
 
 /* 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 mp4ff *f, const uint64_t total_size, int meta_only)
 {
        uint64_t size;
        uint8_t atom_type = 0;
@@ -1142,7 +1142,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 mp4ff *f, int meta_only)
 {
        uint64_t size;
        uint8_t atom_type = 0;
@@ -1175,7 +1175,7 @@ static int32_t parse_atoms(mp4ff_t * f, int meta_only)
        return 0;
 }
 
-void mp4ff_get_decoder_config(const mp4ff_t * f, const int track,
+void mp4ff_get_decoder_config(const struct mp4ff *f, const int track,
                                 unsigned char **ppBuf, unsigned int *pBufSize)
 {
        if (track >= f->total_tracks) {
@@ -1196,9 +1196,9 @@ void mp4ff_get_decoder_config(const mp4ff_t * f, const int track,
        }
 }
 
-mp4ff_t *mp4ff_open_read(mp4ff_callback_t * f)
+struct mp4ff *mp4ff_open_read(struct mp4ff_callback *f)
 {
-       mp4ff_t *ff = para_calloc(sizeof(mp4ff_t));
+       struct mp4ff *ff = para_calloc(sizeof(struct mp4ff));
 
        ff->stream = f;
 
@@ -1212,7 +1212,7 @@ mp4ff_t *mp4ff_open_read(mp4ff_callback_t * f)
        return ff;
 }
 
-static int32_t tag_delete(mp4ff_metadata_t * tags)
+static int32_t tag_delete(struct mp4ff_metadata *tags)
 {
        uint32_t i;
 
@@ -1227,7 +1227,7 @@ static int32_t tag_delete(mp4ff_metadata_t * tags)
        return 0;
 }
 
-void mp4ff_close(mp4ff_t * ff)
+void mp4ff_close(struct mp4ff *ff)
 {
        int32_t i;
 
@@ -1251,7 +1251,7 @@ void mp4ff_close(mp4ff_t * ff)
        free(ff);
 }
 
-static int32_t chunk_of_sample(const mp4ff_t * f, const int32_t track,
+static int32_t chunk_of_sample(const struct mp4ff *f, const int32_t track,
                const int32_t sample, int32_t * chunk_sample, int32_t * chunk)
 {
        int32_t total_entries = 0;
@@ -1297,10 +1297,10 @@ static int32_t chunk_of_sample(const mp4ff_t * f, const int32_t track,
        return 0;
 }
 
-static int32_t chunk_to_offset(const mp4ff_t * f, const int32_t track,
+static int32_t chunk_to_offset(const struct mp4ff *f, const int32_t track,
                const int32_t chunk)
 {
-       const mp4ff_track_t *p_track = f->track[track];
+       const struct mp4ff_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 -
@@ -1314,11 +1314,11 @@ static int32_t chunk_to_offset(const mp4ff_t * f, const int32_t track,
        return 0;
 }
 
-static int32_t sample_range_size(const mp4ff_t * f, const int32_t track,
+static int32_t sample_range_size(const struct mp4ff *f, const int32_t track,
                const int32_t chunk_sample, const int32_t sample)
 {
        int32_t i, total;
-       const mp4ff_track_t *p_track = f->track[track];
+       const struct mp4ff_track *p_track = f->track[track];
 
        if (p_track->stsz_sample_size) {
                return (sample - chunk_sample) * p_track->stsz_sample_size;
@@ -1334,7 +1334,7 @@ static int32_t sample_range_size(const mp4ff_t * f, const int32_t track,
        return total;
 }
 
-static int32_t sample_to_offset(const mp4ff_t * f, const int32_t track,
+static int32_t sample_to_offset(const struct mp4ff *f, const int32_t track,
                const int32_t sample)
 {
        int32_t chunk, chunk_sample, chunk_offset1, chunk_offset2;
@@ -1347,33 +1347,33 @@ static int32_t sample_to_offset(const mp4ff_t * f, const int32_t track,
        return chunk_offset2;
 }
 
-void mp4ff_set_sample_position(mp4ff_t *f, const int32_t track,
+void mp4ff_set_sample_position(struct mp4ff *f, const int32_t track,
                const int32_t sample)
 {
        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)
+int32_t mp4ff_get_sample_size(const struct mp4ff *f, int track, int sample)
 {
-       const mp4ff_track_t *t = f->track[track];
+       const struct mp4ff_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 mp4ff_get_sample_rate(const struct mp4ff *f, const int32_t track)
 {
        return f->track[track]->sampleRate;
 }
 
-uint32_t mp4ff_get_channel_count(const mp4ff_t * f, const int32_t track)
+uint32_t mp4ff_get_channel_count(const struct mp4ff *f, const int32_t track)
 {
        return f->track[track]->channelCount;
 }
 
-int32_t mp4ff_num_samples(const mp4ff_t * f, const int32_t track)
+int32_t mp4ff_num_samples(const struct mp4ff *f, const int32_t track)
 {
        int32_t i;
        int32_t total = 0;
@@ -1384,9 +1384,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 mp4ff *mp4ff_open_read_metaonly(struct mp4ff_callback *f)
 {
-       mp4ff_t *ff = para_calloc(sizeof(mp4ff_t));
+       struct mp4ff *ff = para_calloc(sizeof(struct mp4ff));
 
        ff->stream = f;
 
@@ -1400,12 +1400,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 mp4ff_meta_get_num_items(const struct mp4ff *f)
 {
        return f->tags.count;
 }
 
-int32_t mp4ff_meta_get_by_index(const mp4ff_t * f, uint32_t index,
+int32_t mp4ff_meta_get_by_index(const struct mp4ff *f, uint32_t index,
                                char **item, char **value)
 {
        if (index >= f->tags.count) {
@@ -1419,7 +1419,7 @@ int32_t mp4ff_meta_get_by_index(const mp4ff_t * f, uint32_t index,
        }
 }
 
-static uint32_t find_atom(mp4ff_t * f, uint64_t base, uint32_t size,
+static uint32_t find_atom(struct mp4ff *f, uint64_t base, uint32_t size,
                          const char *name)
 {
        uint32_t remaining = size;
@@ -1448,7 +1448,7 @@ 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 mp4ff *f, uint64_t base, uint32_t size,
                const char *name, uint32_t extraheaders, const char *name_inside)
 {
        uint64_t first_base = (uint64_t) (-1);
@@ -1484,20 +1484,20 @@ static uint32_t find_atom_v2(mp4ff_t * f, uint64_t base, uint32_t size,
                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 = para_malloc(sizeof (membuffer));
+       struct membuffer *buf = para_malloc(sizeof(*buf));
        buf->data = para_malloc(initial_size);
        buf->written = 0;
        buf->allocated = initial_size;
@@ -1506,7 +1506,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;
 
@@ -1535,12 +1535,12 @@ static unsigned membuffer_write(membuffer * buf, const void *ptr, unsigned bytes
        return bytes;
 }
 
-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(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];
 
@@ -1548,14 +1548,14 @@ static unsigned membuffer_write_int16(membuffer * buf, uint16_t 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];
        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,
@@ -1574,7 +1574,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,
@@ -1605,12 +1605,12 @@ static uint32_t meta_genre_to_index(const char *genrestr)
        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"},
@@ -1633,7 +1633,7 @@ static const char *find_standard_meta(const char *name)   //returns atom name if f
        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;
@@ -1656,7 +1656,7 @@ static void membuffer_write_std_tag(membuffer * buf, const char *name,
        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,
@@ -1682,23 +1682,23 @@ static void membuffer_write_custom_tag(membuffer * buf, const char *name,
        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)
 {
        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;
 
@@ -1716,10 +1716,10 @@ static void *membuffer_detach(membuffer * buf)
        return ret;
 }
 
-static uint32_t create_ilst(const mp4ff_metadata_t * data, void **out_buffer,
+static uint32_t create_ilst(const struct mp4ff_metadata *data, void **out_buffer,
                uint32_t * out_size)
 {
-       membuffer *buf = membuffer_create();
+       struct membuffer *buf = membuffer_create();
        unsigned metaptr;
        char *mask = para_calloc(data->count);
        {
@@ -1727,7 +1727,7 @@ static uint32_t create_ilst(const mp4ff_metadata_t * data, void **out_buffer,
                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];
+                       struct mp4ff_tag *tag = &data->tags[metaptr];
                        if (!stricmp(tag->item, "tracknumber") || !stricmp(tag->item, "track")) {
                                if (tracknumber_ptr == 0)
                                        tracknumber_ptr = tag->value;
@@ -1782,7 +1782,7 @@ static uint32_t create_ilst(const mp4ff_metadata_t * data, void **out_buffer,
 
        for (metaptr = 0; metaptr < data->count; metaptr++) {
                if (!mask[metaptr]) {
-                       mp4ff_tag_t *tag = &data->tags[metaptr];
+                       struct mp4ff_tag *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,
@@ -1808,7 +1808,7 @@ 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);
@@ -1816,17 +1816,17 @@ static void membuffer_write_atom(membuffer * buf, const char *name, unsigned siz
        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 mp4ff *src,
                unsigned bytes)
 {
        unsigned oldsize;
@@ -1849,10 +1849,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 mp4ff_metadata *data, void **out_buffer,
                uint32_t * out_size)
 {
-       membuffer *buf;
+       struct membuffer *buf;
        uint32_t ilst_size;
        void *ilst_buffer;
 
@@ -1871,10 +1871,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 mp4ff_metadata *data, void **out_buffer,
 uint32_t * out_size)
 {
-       membuffer *buf;
+       struct membuffer *buf;
        uint32_t meta_size;
        void *meta_buffer;
 
@@ -1898,7 +1898,7 @@ static uint32_t fix_byte_order_32(uint32_t src)
        return read_u32_be(&src);
 }
 
-static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data,
+static uint32_t modify_moov(struct mp4ff *f, const struct mp4ff_metadata *data,
                void **out_buffer, uint32_t * out_size)
 {
        uint64_t total_base = f->moov_offset + 8;
@@ -1914,7 +1914,7 @@ 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))
@@ -1937,7 +1937,7 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data,
                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))
@@ -2012,7 +2012,7 @@ static uint32_t modify_moov(mp4ff_t * f, const mp4ff_metadata_t * data,
        return 1;
 }
 
-static int32_t write_data(mp4ff_t * f, void *data, uint32_t size)
+static int32_t write_data(struct mp4ff *f, void *data, uint32_t size)
 {
        int32_t result = 1;
 
@@ -2023,24 +2023,24 @@ static int32_t write_data(mp4ff_t * f, void *data, uint32_t size)
        return result;
 }
 
-static int32_t write_int32(mp4ff_t * f, const uint32_t data)
+static int32_t write_int32(struct mp4ff *f, const uint32_t data)
 {
        int8_t temp[4];
        write_u32_be(temp, data);
        return write_data(f, temp, sizeof(temp));
 }
 
-static int32_t truncate_stream(mp4ff_t * f)
+static int32_t truncate_stream(struct mp4ff *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 mp4ff_meta_update(struct mp4ff_callback *f, const struct mp4ff_metadata *data)
 {
        void *new_moov_data;
        uint32_t new_moov_size;
 
-       mp4ff_t *ff = para_calloc(sizeof(mp4ff_t));
+       struct mp4ff *ff = para_calloc(sizeof(struct mp4ff));
        ff->stream = f;
        set_position(ff, 0);
 
@@ -2078,7 +2078,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 meta_find_by_name(const mp4ff_t * f, const char *item,
+static int32_t meta_find_by_name(const struct mp4ff *f, const char *item,
                char **value)
 {
        uint32_t i;
@@ -2096,27 +2096,27 @@ static int32_t 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 mp4ff_meta_get_artist(const struct mp4ff *f, char **value)
 {
        return meta_find_by_name(f, "artist", value);
 }
 
-int32_t mp4ff_meta_get_title(const mp4ff_t * f, char **value)
+int32_t mp4ff_meta_get_title(const struct mp4ff *f, char **value)
 {
        return meta_find_by_name(f, "title", value);
 }
 
-int32_t mp4ff_meta_get_date(const mp4ff_t * f, char **value)
+int32_t mp4ff_meta_get_date(const struct mp4ff *f, char **value)
 {
        return meta_find_by_name(f, "date", value);
 }
 
-int32_t mp4ff_meta_get_album(const mp4ff_t * f, char **value)
+int32_t mp4ff_meta_get_album(const struct mp4ff *f, char **value)
 {
        return meta_find_by_name(f, "album", value);
 }
 
-int32_t mp4ff_meta_get_comment(const mp4ff_t * f, char **value)
+int32_t mp4ff_meta_get_comment(const struct mp4ff *f, char **value)
 {
        return meta_find_by_name(f, "comment", value);
 }

diff --git a/mp4.h b/mp4.h
index 28cfbce499143d37bb5287fba2ad72cd9b47614c..216a6c041f5139367701b177ec6578a8187f0a1d 100644 (file)
--- a/mp4.h
+++ b/mp4.h
@@ -1,15 +1,13 @@
-typedef struct
-{
+struct mp4ff_callback {
     uint32_t (*read)(void *user_data, void *buffer, uint32_t length);
     uint32_t (*write)(void *udata, void *buffer, uint32_t length);
     uint32_t (*seek)(void *user_data, uint64_t position);
     uint32_t (*truncate)(void *user_data);
     void *user_data;
     uint32_t read_error;
-} mp4ff_callback_t;
+};
 
-typedef struct
-{
+struct mp4ff_track {
     int32_t type;
     int32_t channelCount;
     int32_t sampleSize;
@@ -54,28 +52,25 @@ typedef struct
     uint32_t timeScale;
     uint64_t duration;
 
-} mp4ff_track_t;
+};
 
 #define MAX_TRACKS 1024
 
-typedef struct
-{
+struct mp4ff_tag {
     char *item;
     char *value;
     uint32_t len;
-} mp4ff_tag_t;
+};
 
-typedef struct
-{
-    mp4ff_tag_t *tags;
+struct mp4ff_metadata {
+    struct mp4ff_tag *tags;
     uint32_t count;
-} mp4ff_metadata_t;
+};
 
 /* mp4 main file structure */
-typedef struct
-{
+struct mp4ff {
     /* stream to read from */
-    mp4ff_callback_t *stream;
+    struct mp4ff_callback *stream;
     int64_t current_position;
 
     uint64_t moov_offset;
@@ -92,31 +87,31 @@ typedef struct
     int32_t total_tracks;
 
     /* track data */
-    mp4ff_track_t *track[MAX_TRACKS];
+    struct mp4ff_track *track[MAX_TRACKS];
 
     /* metadata */
-    mp4ff_metadata_t tags;
-} mp4ff_t;
+    struct mp4ff_metadata tags;
+};
 
-void mp4ff_set_sample_position(mp4ff_t *f, const int32_t track, const int32_t sample);
-int32_t mp4ff_total_tracks(const mp4ff_t *f);
-void mp4ff_get_decoder_config(const mp4ff_t *f, const int track,
+void mp4ff_set_sample_position(struct mp4ff *f, const int32_t track, const int32_t sample);
+int32_t mp4ff_total_tracks(const struct mp4ff *f);
+void mp4ff_get_decoder_config(const struct mp4ff *f, const int track,
                unsigned char** ppBuf, unsigned int* pBufSize);
-mp4ff_t *mp4ff_open_read(mp4ff_callback_t *f);
-void mp4ff_close(mp4ff_t *f);
-int32_t mp4ff_get_sample_size(const mp4ff_t *f, int track, int sample);
-uint32_t mp4ff_get_sample_rate(const mp4ff_t *f, const int32_t track);
-uint32_t mp4ff_get_channel_count(const mp4ff_t * f,const int32_t track);
-int32_t mp4ff_num_samples(const mp4ff_t *f, const int track);
-mp4ff_t *mp4ff_open_read_metaonly(mp4ff_callback_t *f);
-
-int mp4ff_meta_get_by_index(const mp4ff_t *f, unsigned int index,
+struct mp4ff *mp4ff_open_read(struct mp4ff_callback *f);
+void mp4ff_close(struct mp4ff *f);
+int32_t mp4ff_get_sample_size(const struct mp4ff *f, int track, int sample);
+uint32_t mp4ff_get_sample_rate(const struct mp4ff *f, const int32_t track);
+uint32_t mp4ff_get_channel_count(const struct mp4ff * f,const int32_t track);
+int32_t mp4ff_num_samples(const struct mp4ff *f, const int track);
+struct mp4ff *mp4ff_open_read_metaonly(struct mp4ff_callback *f);
+
+int mp4ff_meta_get_by_index(const struct mp4ff *f, unsigned int index,
                             char **item, char **value);
-int32_t mp4ff_meta_update(mp4ff_callback_t *f,const mp4ff_metadata_t * data);
-
-int mp4ff_meta_get_num_items(const mp4ff_t *f);
-int mp4ff_meta_get_artist(const mp4ff_t *f, char **value);
-int mp4ff_meta_get_title(const mp4ff_t *f, char **value);
-int mp4ff_meta_get_date(const mp4ff_t *f, char **value);
-int mp4ff_meta_get_album(const mp4ff_t *f, char **value);
-int mp4ff_meta_get_comment(const mp4ff_t *f, char **value);
+int32_t mp4ff_meta_update(struct mp4ff_callback *f,const struct mp4ff_metadata * data);
+
+int mp4ff_meta_get_num_items(const struct mp4ff *f);
+int mp4ff_meta_get_artist(const struct mp4ff *f, char **value);
+int mp4ff_meta_get_title(const struct mp4ff *f, char **value);
+int mp4ff_meta_get_date(const struct mp4ff *f, char **value);
+int mp4ff_meta_get_album(const struct mp4ff *f, char **value);
+int mp4ff_meta_get_comment(const struct mp4ff *f, char **value);