mp4: Use uniform names for callback and mp4 structures.

Currently it's a confusing mess, with callbacks called f, ff, or
stream, where the former two are also used for pointers to struct
mp4. Let's call a spade a spade and use cb everywhere for the callbacks
while f is reserved to denote an mp4 pointer.

diff --git a/mp4.c b/mp4.c
index 991ba08db18ab9d4aa38f06afef8603cc2be4fef..23bd7934ac87db131331df06e78703d6ec5d0438 100644 (file)
--- a/mp4.c
+++ b/mp4.c
@@ -44,8 +44,7 @@ struct mp4_track {
 #define MAX_TRACKS 1024
 
 struct mp4 {
-       /* stream to read from */
-       struct mp4_callback *stream;
+       struct mp4_callback *cb;
        int64_t current_position;
 
        uint64_t moov_offset;
@@ -75,7 +74,7 @@ static int32_t read_data(struct mp4 *f, void *data, uint32_t size)
 {
        int32_t result = 1;
 
-       result = f->stream->read(f->stream->user_data, data, size);
+       result = f->cb->read(f->cb->user_data, data, size);
 
        if (result < size)
                f->read_error++;
@@ -390,7 +389,7 @@ static int need_parse_when_meta_only(uint8_t atom_type)
 
 static int32_t set_position(struct mp4 *f, int64_t position)
 {
-       f->stream->seek(f->stream->user_data, position);
+       f->cb->seek(f->cb->user_data, position);
        f->current_position = position;
 
        return 0;
@@ -1067,20 +1066,17 @@ static int32_t parse_atoms(struct mp4 *f, int meta_only)
        return 0;
 }
 
-struct mp4 *mp4_open_read(struct mp4_callback *f)
+struct mp4 *mp4_open_read(struct mp4_callback *cb)
 {
-       struct mp4 *ff = para_calloc(sizeof(struct mp4));
+       struct mp4 *f = para_calloc(sizeof(struct mp4));
 
-       ff->stream = f;
-
-       parse_atoms(ff, 0);
-
-       if (ff->error) {
-               free(ff);
-               ff = NULL;
+       f->cb = cb;
+       parse_atoms(f, 0);
+       if (f->error) {
+               free(f);
+               f = NULL;
        }
-
-       return ff;
+       return f;
 }
 
 static int32_t tag_delete(struct mp4_metadata *tags)
@@ -1098,25 +1094,25 @@ static int32_t tag_delete(struct mp4_metadata *tags)
        return 0;
 }
 
-void mp4_close(struct mp4 *ff)
+void mp4_close(struct mp4 *f)
 {
        int32_t i;
 
-       for (i = 0; i < ff->total_tracks; i++) {
-               if (ff->track[i]) {
-                       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]);
+       for (i = 0; i < f->total_tracks; i++) {
+               if (f->track[i]) {
+                       free(f->track[i]->stsz_table);
+                       free(f->track[i]->stts_sample_count);
+                       free(f->track[i]->stts_sample_delta);
+                       free(f->track[i]->stsc_first_chunk);
+                       free(f->track[i]->stsc_samples_per_chunk);
+                       free(f->track[i]->stsc_sample_desc_index);
+                       free(f->track[i]->stco_chunk_offset);
+                       free(f->track[i]);
                }
        }
 
-       tag_delete(&(ff->tags));
-       free(ff);
+       tag_delete(&(f->tags));
+       free(f);
 }
 
 static int32_t chunk_of_sample(const struct mp4 *f, int32_t track,
@@ -1283,20 +1279,17 @@ int32_t mp4_num_samples(const struct mp4 *f, int32_t track)
        return total;
 }
 
-struct mp4 *mp4_open_meta(struct mp4_callback *f)
+struct mp4 *mp4_open_meta(struct mp4_callback *cb)
 {
-       struct mp4 *ff = para_calloc(sizeof(struct mp4));
-
-       ff->stream = f;
+       struct mp4 *f = para_calloc(sizeof(struct mp4));
 
-       parse_atoms(ff, 1);
-
-       if (ff->error) {
-               free(ff);
-               ff = NULL;
+       f->cb = cb;
+       parse_atoms(f, 1);
+       if (f->error) {
+               free(f);
+               f = NULL;
        }
-
-       return ff;
+       return f;
 }
 
 int32_t mp4_meta_get_num_items(const struct mp4 *f)
@@ -1889,7 +1882,7 @@ static int32_t write_data(struct mp4 *f, void *data, uint32_t size)
 {
        int32_t result = 1;
 
-       result = f->stream->write(f->stream->user_data, data, size);
+       result = f->cb->write(f->cb->user_data, data, size);
 
        f->current_position += size;
 
@@ -1903,42 +1896,40 @@ static int32_t write_int32(struct mp4 *f, uint32_t data)
        return write_data(f, temp, sizeof(temp));
 }
 
-int32_t mp4_meta_update(struct mp4_callback *f, const struct mp4_metadata *data)
+int32_t mp4_meta_update(struct mp4_callback *cb, const struct mp4_metadata *data)
 {
        void *new_moov_data;
        uint32_t new_moov_size;
 
-       struct mp4 *ff = para_calloc(sizeof(struct mp4));
-       ff->stream = f;
-       set_position(ff, 0);
-
-       parse_atoms(ff, 1);
-
-       if (!modify_moov(ff, data, &new_moov_data, &new_moov_size)) {
-               mp4_close(ff);
+       struct mp4 *f = para_calloc(sizeof(struct mp4));
+       f->cb = cb;
+       set_position(f, 0);
+       parse_atoms(f, 1);
+       if (!modify_moov(f, data, &new_moov_data, &new_moov_size)) {
+               mp4_close(f);
                return 0;
        }
 
        /* copy moov atom to end of the file */
-       if (ff->last_atom != ATOM_MOOV) {
+       if (f->last_atom != ATOM_MOOV) {
                char *free_data = "free";
 
                /* rename old moov to free */
-               set_position(ff, ff->moov_offset + 4);
-               write_data(ff, free_data, 4);
+               set_position(f, f->moov_offset + 4);
+               write_data(f, free_data, 4);
 
-               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);
+               set_position(f, f->file_size);
+               write_int32(f, new_moov_size + 8);
+               write_data(f, "moov", 4);
+               write_data(f, new_moov_data, new_moov_size);
        } else {
-               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);
+               set_position(f, f->moov_offset);
+               write_int32(f, new_moov_size + 8);
+               write_data(f, "moov", 4);
+               write_data(f, new_moov_data, new_moov_size);
        }
-       f->truncate(f->user_data);
-       mp4_close(ff);
+       cb->truncate(cb->user_data);
+       mp4_close(f);
        return 1;
 }
 

diff --git a/mp4.h b/mp4.h
index 9946b0fd626bba7df4968743085477e868f46e9a..1690b0dac5961ce93407d44b5a0638d6094ebfd2 100644 (file)
--- a/mp4.h
+++ b/mp4.h
@@ -22,18 +22,18 @@ struct mp4; /* opaque */
 void mp4_set_sample_position(struct mp4 *f, int32_t track, int32_t sample);
 int32_t mp4_total_tracks(const struct mp4 *f);
 bool mp4_is_audio_track(const struct mp4 *f, int32_t track);
-struct mp4 *mp4_open_read(struct mp4_callback *f);
+struct mp4 *mp4_open_read(struct mp4_callback *cb);
 void mp4_close(struct mp4 *f);
 int32_t mp4_get_sample_size(const struct mp4 *f, int track, int sample);
 uint32_t mp4_get_sample_rate(const struct mp4 *f, int32_t track);
 uint32_t mp4_get_channel_count(const struct mp4 * f, int32_t track);
 int32_t mp4_num_samples(const struct mp4 *f, int track);
 uint64_t mp4_get_duration(const struct mp4 *f, int32_t track);
-struct mp4 *mp4_open_meta(struct mp4_callback *f);
+struct mp4 *mp4_open_meta(struct mp4_callback *cb);
 
 int mp4_meta_get_by_index(const struct mp4 *f, unsigned int index,
                             char **item, char **value);
-int32_t mp4_meta_update(struct mp4_callback *f,const struct mp4_metadata * data);
+int32_t mp4_meta_update(struct mp4_callback *cb, const struct mp4_metadata *data);
 
 int mp4_meta_get_num_items(const struct mp4 *f);
 int mp4_meta_get_artist(const struct mp4 *f, char **value);