{
return a1 == a2 && b1 == b2 && c1 == c2 && d1 == d2;
}
-
enum atoms {
/* atoms with subatoms */
ATOM_MOOV = 1,
static int32_t tag_add_field(struct mp4_metadata *tags, const char *item,
const char *value, int32_t len)
{
- if (!item || (item && !*item) || !value)
- return 0;
tags->tags = para_realloc(tags->tags,
(tags->count + 1) * sizeof(struct mp4_tag));
tags->tags[tags->count].item = para_strdup(item);
"Anime", "JPop", "SynthPop",
};
-static const char *meta_index_to_genre(uint32_t idx)
-{
- if (idx > 0 && idx <= sizeof (ID3v1GenreList) / sizeof (ID3v1GenreList[0])) {
- return ID3v1GenreList[idx - 1];
- } else {
- return 0;
- }
-}
-
static char *read_string(struct mp4 *f, uint32_t length)
{
char *str = para_malloc(length + 1);
switch (atom_type) {
case ATOM_TITLE: return "title";
case ATOM_ARTIST: return "artist";
- case ATOM_WRITER: return "writer";
case ATOM_ALBUM: return "album";
case ATOM_DATE: return "date";
- case ATOM_TOOL: return "tool";
case ATOM_COMMENT: return "comment";
- case ATOM_GENRE1: return "genre";
- case ATOM_TRACK: return "track";
- case ATOM_DISC: return "disc";
- case ATOM_COMPILATION: return "compilation";
- case ATOM_GENRE2: return "genre";
- case ATOM_TEMPO: return "tempo";
- case ATOM_COVER: return "cover";
- case ATOM_ALBUM_ARTIST: return "album_artist";
- case ATOM_CONTENTGROUP: return "contentgroup";
- case ATOM_LYRICS: return "lyrics";
- case ATOM_DESCRIPTION: return "description";
- case ATOM_NETWORK: return "network";
- case ATOM_SHOW: return "show";
- case ATOM_EPISODENAME: return "episodename";
- case ATOM_SORTTITLE: return "sorttitle";
- case ATOM_SORTALBUM: return "sortalbum";
- case ATOM_SORTARTIST: return "sortartist";
- case ATOM_SORTALBUMARTIST: return "sortalbumartist";
- case ATOM_SORTWRITER: return "sortwriter";
- case ATOM_SORTSHOW: return "sortshow";
- case ATOM_SEASON: return "season";
- case ATOM_EPISODE: return "episode";
- case ATOM_PODCAST: return "podcast";
default: return "unknown";
}
}
-static uint32_t min_body_size(uint8_t atom_type)
-{
- switch(atom_type) {
- case ATOM_GENRE2:
- case ATOM_TEMPO:
- return 10;
- case ATOM_TRACK:
- return sizeof (char) /* version */
- + sizeof(uint8_t) * 3 /* flags */
- + sizeof(uint32_t) /* reserved */
- + sizeof(uint16_t) /* leading uint16_t */
- + sizeof(uint16_t) /* track */
- + sizeof(uint16_t); /* totaltracks */
- case ATOM_DISC:
- return sizeof (char) /* version */
- + sizeof(uint8_t) * 3 /* flags */
- + sizeof(uint32_t) /* reserved */
- + sizeof(uint16_t) /* disc */
- + sizeof(uint16_t); /* totaldiscs */
- default: assert(false);
- }
-}
-
-static int32_t parse_tag(struct mp4 *f, uint8_t parent, int32_t size)
+static void parse_tag(struct mp4 *f, uint8_t parent, int32_t size)
{
- uint8_t atom_type;
- uint8_t header_size = 0;
uint64_t subsize, sumsize;
- char *name = NULL;
char *data = NULL;
- uint32_t done = 0;
uint32_t len = 0;
uint64_t destpos;
sumsize < size && !f->read_error; /* CVE-2017-9222 */
set_position(f, destpos), sumsize += subsize
) {
+ uint8_t atom_type;
+ uint8_t header_size = 0;
subsize = atom_read_header(f, &atom_type, &header_size);
destpos = get_position(f) + subsize - header_size;
- if (done)
- continue;
- if (atom_type == ATOM_NAME) {
- read_char(f); /* version */
- read_int24(f); /* flags */
- free(name);
- name = read_string(f, subsize - (header_size + 4));
- continue;
- }
if (atom_type != ATOM_DATA)
continue;
read_char(f); /* version */
read_int24(f); /* flags */
read_int32(f); /* reserved */
-
- /* some need special attention */
- if (parent == ATOM_GENRE2 || parent == ATOM_TEMPO) {
- uint16_t val;
- if (subsize - header_size < min_body_size(parent))
- continue;
- val = read_int16(f);
- if (parent == ATOM_TEMPO) {
- char temp[16];
- sprintf(temp, "%.5u BPM", val);
- tag_add_field(&(f-> tags), "tempo",
- temp, -1);
- } else {
- const char *tmp = meta_index_to_genre(val);
- if (tmp)
- tag_add_field (&(f->tags),
- "genre", tmp, -1);
- }
- done = 1;
- } else if (parent == ATOM_TRACK || parent == ATOM_DISC) {
- uint16_t index, total;
- char temp[32];
- if (subsize - header_size < min_body_size(parent))
- continue;
- read_int16(f);
- index = read_int16(f);
- total = read_int16(f);
- if (parent == ATOM_TRACK)
- read_int16(f);
- sprintf(temp, "%d", index);
- tag_add_field(&(f->tags), parent == ATOM_TRACK?
- "track" : "disc", temp, -1);
- if (total > 0) {
- sprintf(temp, "%d", total);
- tag_add_field(& (f-> tags),
- parent == ATOM_TRACK?
- "totaltracks" : "totaldiscs", temp, -1);
- }
- done = 1;
- } else {
- free(data);
- data = read_string(f, subsize - (header_size + 8));
- len = subsize - (header_size + 8);
- }
- }
- if (data) {
- if (!done) {
- if (!name)
- name = para_strdup(get_metadata_name(parent));
- tag_add_field(&(f->tags), name, data, len);
- }
free(data);
+ data = read_string(f, subsize - (header_size + 8));
+ len = subsize - (header_size + 8);
}
- free(name);
- return 1;
+ if (!data)
+ return;
+ tag_add_field(&f->tags, get_metadata_name(parent), data, len);
+ free(data);
}
static int32_t read_mdhd(struct mp4 *f)
static int32_t parse_metadata(struct mp4 *f, int32_t size)
{
- uint64_t subsize, sumsize = 0;
- uint8_t atom_type;
- uint8_t header_size = 0;
+ uint64_t sumsize = 0;
while (sumsize < size) {
+ uint8_t atom_type;
+ uint64_t subsize, destpos;
+ uint8_t header_size = 0;
subsize = atom_read_header(f, &atom_type, &header_size);
if (subsize == 0)
break;
- parse_tag(f, atom_type, (uint32_t)(subsize - header_size));
+ destpos = get_position(f) + subsize - header_size;
+ switch (atom_type) {
+ case ATOM_ARTIST:
+ case ATOM_TITLE:
+ case ATOM_ALBUM:
+ case ATOM_COMMENT:
+ case ATOM_DATE:
+ parse_tag(f, atom_type, subsize - header_size);
+ }
+ set_position(f, destpos);
sumsize += subsize;
}
return f;
}
-int32_t mp4_meta_get_num_items(const struct mp4 *f)
-{
- return f->tags.count;
-}
-
-int32_t mp4_meta_get_by_index(const struct mp4 *f, uint32_t index,
- char **item, char **value)
+/**
+ * Return the metadata of an mp4 file.
+ *
+ * \param f As returned by either \ref mp4_open_read() or \ref mp4_open_meta().
+ *
+ * The caller is allowed to add, delete or modify the entries of the returned
+ * structure in order to pass the modified version to \ref mp4_meta_update().
+ */
+struct mp4_metadata *mp4_get_meta(struct mp4 *f)
{
- if (index >= f->tags.count) {
- *item = NULL;
- *value = NULL;
- return 0;
- } else {
- *item = para_strdup(f->tags.tags[index].item);
- *value = para_strdup(f->tags.tags[index].value);
- return 1;
- }
+ return &f->tags;
}
static uint32_t find_atom(struct mp4 *f, uint64_t base, uint32_t size,
return read_u32_be(&src);
}
-static uint32_t modify_moov(struct mp4 *f, const struct mp4_metadata *data,
- void **out_buffer, uint32_t * out_size)
+static uint32_t modify_moov(struct mp4 *f, void **out_buffer,
+ uint32_t *out_size)
{
uint64_t total_base = f->moov_offset + 8;
uint32_t total_size = (uint32_t) (f->moov_size - 8);
struct membuffer *buf;
void *new_udta_buffer;
uint32_t new_udta_size;
- if (!create_udta(data, &new_udta_buffer, &new_udta_size))
+ if (!create_udta(&f->tags, &new_udta_buffer, &new_udta_size))
return 0;
buf = membuffer_create();
struct membuffer *buf;
void *new_meta_buffer;
uint32_t new_meta_size;
- if (!create_meta(data, &new_meta_buffer, &new_meta_size))
+
+ if (!create_meta(&f->tags, &new_meta_buffer, &new_meta_size))
return 0;
buf = membuffer_create();
ilst_offset = get_position(f);
ilst_size = read_int32(f);
- if (!create_ilst(data, &new_ilst_buffer, &new_ilst_size))
+ if (!create_ilst(&f->tags, &new_ilst_buffer, &new_ilst_size))
return 0;
size_delta = new_ilst_size - (ilst_size - 8);
return write_data(f, temp, sizeof(temp));
}
-int32_t mp4_meta_update(const struct mp4_callback *cb,
- const struct mp4_metadata *data)
+int32_t mp4_meta_update(struct mp4 *f)
{
void *new_moov_data;
uint32_t new_moov_size;
- 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)) {
+ if (!modify_moov(f, &new_moov_data, &new_moov_size)) {
mp4_close(f);
return 0;
}
-
/* copy moov atom to end of the file */
if (f->last_atom != ATOM_MOOV) {
char *free_data = "free";
write_data(f, "moov", 4);
write_data(f, new_moov_data, new_moov_size);
}
- cb->truncate(cb->user_data);
- mp4_close(f);
+ free(new_moov_data);
+ f->cb->truncate(f->cb->user_data);
return 1;
}
-/* find a metadata item by name */
-/* returns 0 if item found, 1 if no such item */
-static int32_t meta_find_by_name(const struct mp4 *f, const char *item,
- char **value)
+static char *meta_find_by_name(const struct mp4 *f, const char *item)
{
uint32_t i;
- for (i = 0; i < f->tags.count; i++) {
- if (!strcasecmp(f->tags.tags[i].item, item)) {
- *value = para_strdup(f->tags.tags[i].value);
- return 1;
- }
- }
-
- *value = NULL;
-
- /* not found */
- return 0;
+ for (i = 0; i < f->tags.count; i++)
+ if (!strcasecmp(f->tags.tags[i].item, item))
+ return para_strdup(f->tags.tags[i].value);
+ return NULL;
}
-int32_t mp4_meta_get_artist(const struct mp4 *f, char **value)
+/**
+ * Return the value of the artist meta tag of an mp4 file.
+ *
+ * \param f Must not be NULL.
+ *
+ * \return If the file does not contain this metadata tag, the function returns
+ * NULL. Otherwise, a copy of the tag value is returned. The caller should free
+ * this memory when it is no longer needed.
+ */
+char *mp4_meta_get_artist(const struct mp4 *f)
{
- return meta_find_by_name(f, "artist", value);
+ return meta_find_by_name(f, "artist");
}
-int32_t mp4_meta_get_title(const struct mp4 *f, char **value)
+/**
+ * Return the value of the title meta tag of an mp4 file.
+ *
+ * \param f See \ref mp4_meta_get_artist().
+ * \return See \ref mp4_meta_get_artist().
+ */
+char *mp4_meta_get_title(const struct mp4 *f)
{
- return meta_find_by_name(f, "title", value);
+ return meta_find_by_name(f, "title");
}
-int32_t mp4_meta_get_date(const struct mp4 *f, char **value)
+/**
+ * Return the value of the date meta tag of an mp4 file.
+ *
+ * \param f See \ref mp4_meta_get_artist().
+ * \return See \ref mp4_meta_get_artist().
+ */
+char *mp4_meta_get_date(const struct mp4 *f)
{
- return meta_find_by_name(f, "date", value);
+ return meta_find_by_name(f, "date");
}
-int32_t mp4_meta_get_album(const struct mp4 *f, char **value)
+/**
+ * Return the value of the album meta tag of an mp4 file.
+ *
+ * \param f See \ref mp4_meta_get_artist().
+ * \return See \ref mp4_meta_get_artist().
+ */
+char *mp4_meta_get_album(const struct mp4 *f)
{
- return meta_find_by_name(f, "album", value);
+ return meta_find_by_name(f, "album");
}
-int32_t mp4_meta_get_comment(const struct mp4 *f, char **value)
+/**
+ * Return the value of the comment meta tag of an mp4 file.
+ *
+ * \param f See \ref mp4_meta_get_artist().
+ * \return See \ref mp4_meta_get_artist().
+ */
+char *mp4_meta_get_comment(const struct mp4 *f)
{
- return meta_find_by_name(f, "comment", value);
+ return meta_find_by_name(f, "comment");
}
projects / paraslash.git / blobdiff