]> git.tuebingen.mpg.de Git - paraslash.git/blobdiff - mp4.c
mp4: Rename overlong variable in mp4ff_parse_tag().
[paraslash.git] / mp4.c
diff --git a/mp4.c b/mp4.c
index 9b09a8f407822f6baee40a0440b729fb7a35787d..47d98bcf0403e46b1ca955efc2db45e0a4e0cf63 100644 (file)
--- a/mp4.c
+++ b/mp4.c
@@ -773,25 +773,15 @@ static int32_t mp4ff_tag_add_field(mp4ff_metadata_t * tags, const char *item,
                free(backup);
                return 0;
        } else {
-               tags->tags[tags->count].item = strdup(item);
+               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].value = strdup(value);
+                       tags->tags[tags->count].value = para_strdup(value);
                }
-
-               if (!tags->tags[tags->count].item || !tags->tags[tags->count].value) {
-                       free(tags->tags[tags->count].item);
-                       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;
        }
@@ -958,98 +948,95 @@ 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,
+static int32_t mp4ff_parse_tag(mp4ff_t * f, const uint8_t parent,
                const 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;
+       uint64_t destpos;
 
-       while (sumsize < size && !f->stream->read_error) {      /* CVE-2017-9222 */
-               uint64_t destpos;
+       for (
+               sumsize = 0;
+               sumsize < size && !f->stream->read_error; /* CVE-2017-9222 */
+               mp4ff_set_position(f, destpos), sumsize += subsize
+       ) {
                subsize = mp4ff_atom_read_header(f, &atom_type, &header_size);
                destpos = mp4ff_position(f) + subsize - header_size;
                if (done)
                        continue;
-               if (atom_type == ATOM_DATA) {
+               if (atom_type == ATOM_NAME) {
                        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;
+                       free(name);
+                       name = mp4ff_read_string(f, (uint32_t) (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 */
+
+               /* some need special attention */
+               if (parent == ATOM_GENRE2 || parent == ATOM_TEMPO) {
+                       if (subsize - header_size >= 8 + 2) {
+                               uint16_t val = mp4ff_read_int16(f);
+
+                               if (parent == 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);
                                }
-                       } 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];
+                               done = 1;
+                       }
+               } else if (parent == ATOM_TRACK || parent == ATOM_DISC) {
+                       if (subsize - header_size >= (sizeof (char) + sizeof (uint8_t) * 3 + sizeof (uint32_t) +        /* version + flags + reserved */
+                                                                +(parent == 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_TRACK)
                                        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;
+
+                               sprintf(temp, "%d", index);
+                               mp4ff_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),
+                                               parent == ATOM_TRACK?
+                                               "totaltracks" : "totaldiscs", temp, -1);
                                }
-                       } else {
-                               free(data);
-                               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 */
-                               free(name);
-                               name = mp4ff_read_string(f, (uint32_t) (subsize - (header_size + 4)));
+                               done = 1;
                        }
+               } else {
+                       free(data);
+                       data = mp4ff_read_string(f, (uint32_t) (subsize - (header_size + 8)));
+                       len = (uint32_t) (subsize - (header_size + 8));
                }
-               mp4ff_set_position(f, destpos);
-               sumsize += subsize;
        }
-
        if (data) {
                if (!done) {
                        if (name == NULL)
-                               mp4ff_set_metadata_name(parent_atom_type, &name);
+                               mp4ff_set_metadata_name(parent , &name);
                        if (name)
                                mp4ff_tag_add_field(&(f->tags), name, data, len);
                }
@@ -1475,8 +1462,8 @@ 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;
        }
 }
@@ -2165,7 +2152,7 @@ static int32_t mp4ff_meta_find_by_name(const mp4ff_t * f, const char *item,
 
        for (i = 0; i < f->tags.count; i++) {
                if (!stricmp(f->tags.tags[i].item, item)) {
-                       *value = strdup(f->tags.tags[i].value);
+                       *value = para_strdup(f->tags.tags[i].value);
                        return 1;
                }
        }