[fdkaac.git] / src / metadata.c

#if HAVE_CONFIG_H
#  include "config.h"
#endif
#if HAVE_STDINT_H
#  include <stdint.h>
#endif
#if HAVE_INTTYPES_H
#  include <inttypes.h>
#elif defined(_MSC_VER)
#  define SCNd64 "I64d"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include "m4af.h"
#include "metadata.h"
#include "compat.h"
#include "parson.h"

typedef struct tag_key_mapping_t {
    const char *name;
    uint32_t fcc;
} tag_key_mapping_t;

enum {
    TAG_TOTAL_DISCS  = 1,
    TAG_TOTAL_TRACKS = 2
};

static tag_key_mapping_t tag_mapping_table[] = {
    { "album",                      M4AF_TAG_ALBUM               },
    { "albumartist",                M4AF_TAG_ALBUM_ARTIST        },
    { "albumartistsort",            M4AF_FOURCC('s','o','a','a') },
    { "albumartistsortorder",       M4AF_FOURCC('s','o','a','a') },
    { "albumsort",                  M4AF_FOURCC('s','o','a','l') },
    { "albumsortorder",             M4AF_FOURCC('s','o','a','l') },
    { "artist",                     M4AF_TAG_ARTIST              },
    { "artistsort",                 M4AF_FOURCC('s','o','a','r') },
    { "artistsortorder",            M4AF_FOURCC('s','o','a','r') },
    { "band",                       M4AF_TAG_ALBUM_ARTIST        },
    { "bpm",                        M4AF_TAG_TEMPO               },
    { "comment",                    M4AF_TAG_COMMENT             },
    { "compilation",                M4AF_TAG_COMPILATION         },
    { "composer",                   M4AF_TAG_COMPOSER            },
    { "composersort",               M4AF_FOURCC('s','o','c','o') },
    { "composersortorder",          M4AF_FOURCC('s','o','c','o') },
    { "contentgroup",               M4AF_TAG_GROUPING            },
    { "copyright",                  M4AF_TAG_COPYRIGHT           },
    { "date",                       M4AF_TAG_DATE                },
    { "disc",                       M4AF_TAG_DISK                },
    { "disctotal",                  TAG_TOTAL_DISCS              },
    { "discnumber",                 M4AF_TAG_DISK                },
    { "genre",                      M4AF_TAG_GENRE               },
    { "grouping",                   M4AF_TAG_GROUPING            },
    { "itunescompilation",          M4AF_TAG_COMPILATION         },
    { "lyrics",                     M4AF_TAG_LYRICS              },
    { "title",                      M4AF_TAG_TITLE               },
    { "titlesort",                  M4AF_FOURCC('s','o','n','m') },
    { "titlesortorder",             M4AF_FOURCC('s','o','n','m') },
    { "totaldiscs",                 TAG_TOTAL_DISCS              },
    { "totaltracks",                TAG_TOTAL_TRACKS             },
    { "track",                      M4AF_TAG_TRACK               },
    { "tracknumber",                M4AF_TAG_TRACK               },
    { "tracktotal",                 TAG_TOTAL_TRACKS             },
    { "unsyncedlyrics",             M4AF_TAG_LYRICS              },
    { "year",                       M4AF_TAG_DATE                },
};

static
int tag_key_comparator(const void *k, const void *v)
{
    return strcmp((const char *)k, ((tag_key_mapping_t*)v)->name);
}

static
uint32_t get_tag_fcc_from_name(const char *name)
{
    char *name_p = 0, *p;
    const tag_key_mapping_t *ent;

    name_p = malloc(strlen(name) + 1);
    for (p = name_p; *name; ++name) {
        unsigned char c = *name;
        if (c != ' ' && c != '-' && c != '_')
            *p++ = tolower(c);
    }
    *p = 0;
    ent = bsearch(name_p, tag_mapping_table,
                  sizeof(tag_mapping_table) / sizeof(tag_mapping_table[0]),
                  sizeof(tag_mapping_table[0]),
                  tag_key_comparator);
    free(name_p);
    return ent ? ent->fcc : 0;
}

char *aacenc_load_tag_from_file(const char *path, uint32_t *data_size)
{
    FILE *fp = 0;
    char *data = 0;
    int64_t size;

    if ((fp = aacenc_fopen(path, "rb")) == NULL) {
        aacenc_fprintf(stderr, "WARNING: %s: %s\n", path, strerror(errno));
        goto END;
    }
    fseeko(fp, 0, SEEK_END);
    size = ftello(fp);
    if (size > 5*1024*1024) {
        aacenc_fprintf(stderr, "WARNING: %s: size too large\n", path);
        goto END;
    }
    fseeko(fp, 0, SEEK_SET);
    data = malloc(size + 1);
    if (data) fread(data, 1, size, fp);
    data[size] = 0;
    *data_size = (uint32_t)size;
END:
    if (fp) fclose(fp);
    return data;
}

void aacenc_param_add_itmf_entry(aacenc_tag_param_t *params, uint32_t tag,
                                 const char *key, const char *value,
                                 uint32_t size, int is_file_name)
{
    aacenc_tag_entry_t *entry;

    if (!is_file_name && !size)
        return;
    if (params->tag_count == params->tag_table_capacity) {
        unsigned newsize = params->tag_table_capacity;
        newsize = newsize ? newsize * 2 : 1;
        params->tag_table =
            realloc(params->tag_table, newsize * sizeof(aacenc_tag_entry_t));
        params->tag_table_capacity = newsize;
    }
    entry = params->tag_table + params->tag_count;
    entry->tag = tag;
    if (tag == M4AF_FOURCC('-','-','-','-'))
        entry->name = key;
    entry->data = value;
    entry->data_size = size;
    entry->is_file_name = is_file_name;
    params->tag_count++;
}

static
void tag_put_number_pair(m4af_ctx_t *m4af, uint32_t fcc,
                         const char *snumber, const char *stotal)
{
    unsigned number = 0, total = 0;
    char buf[128];
    aacenc_tag_entry_t entry = { 0 };

    if (snumber) sscanf(snumber, "%u", &number);
    if (stotal)  sscanf(stotal,  "%u", &total);
    if (number) {
        if (total) sprintf(buf, "%u/%u", number, total);
        else       sprintf(buf, "%u",    number);
        entry.tag = fcc;
        entry.data = buf;
        entry.data_size = strlen(buf);
        aacenc_put_tag_entry(m4af, &entry);
    }
}

static
const char *aacenc_json_object_get_string(JSON_Object *obj, const char *key,
                                          char *buf)
{
    JSON_Value_Type type;
    const char *val = 0;

    type = json_value_get_type(json_object_get_value(obj, key));
    if (type == JSONString)
        val = json_object_get_string(obj, key);
    else if (type == JSONNumber) {
        double num = json_object_get_number(obj, key);
        sprintf(buf, "%.15g", num);
        val = buf;
    } else if (type == JSONBoolean) {
        int n = json_object_get_boolean(obj, key);
        sprintf(buf, "%d", n);
        val = buf;
    }
    return val;
}

void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
{
    char *data = 0;
    JSON_Value *json = 0;
    JSON_Object *root;
    size_t i, nelts;
    uint32_t data_size;
    char *json_dot_path;
    char *filename = 0;
    char *disc = 0;
    char *track = 0;
    char *total_discs = 0;
    char *total_tracks = 0;
    aacenc_tag_entry_t entry = { 0 };
    
    filename = strdup(json_filename);
    if ((json_dot_path = strchr(filename, '?')) != 0)
        *json_dot_path++ = '\0';

    if (!(data = aacenc_load_tag_from_file(filename, &data_size)))
        goto DONE;
    if (!(json = json_parse_string(data))) {
        aacenc_fprintf(stderr, "WARNING: failed to parse JSON\n");
        goto DONE;
    }
    root = json_value_get_object(json);
    if (json_dot_path) {
        if (!(root = json_object_dotget_object(root, json_dot_path))) {
            aacenc_fprintf(stderr, "WARNING: %s not found in JSON\n",
                           json_dot_path);
            goto DONE;
        }
    }
    nelts = json_object_get_count(root);
    for (i = 0; i < nelts; ++i) {
        char buf[256];
        const char *key = json_object_get_name(root, i);
        const char *val = aacenc_json_object_get_string(root, key, buf);
        uint32_t fcc = get_tag_fcc_from_name(key);
        if (!val || !fcc)
            continue;

        switch (fcc) {
        case TAG_TOTAL_DISCS:
            total_discs = realloc(total_discs, strlen(val) + 1);
            strcpy(total_discs, val);
            break;
        case TAG_TOTAL_TRACKS:
            total_tracks = realloc(total_tracks, strlen(val) + 1);
            strcpy(total_tracks, val);
            break;
        case M4AF_TAG_DISK:
            disc = realloc(disc, strlen(val) + 1);
            strcpy(disc, val);
            break;
        case M4AF_TAG_TRACK:
            track = realloc(track, strlen(val) + 1);
            strcpy(track, val);
            break;
        default:
            {
                entry.tag = fcc;
                entry.data = val;
                entry.data_size = strlen(val);
                aacenc_put_tag_entry(m4af, &entry);
            }
        }
    }
    tag_put_number_pair(m4af, M4AF_TAG_TRACK, track, total_tracks);
    tag_put_number_pair(m4af, M4AF_TAG_DISK,  disc,  total_discs);
DONE:
    if (track) free(track);
    if (disc) free(disc);
    if (total_tracks) free(total_tracks);
    if (total_discs) free(total_discs);
    if (data) free(data);
    if (filename) free(filename);
    if (json) json_value_free(json);
}

void aacenc_put_tag_entry(m4af_ctx_t *m4af, const aacenc_tag_entry_t *tag)
{
    unsigned m, n = 0;
    const char *data = tag->data;
    uint32_t data_size = tag->data_size;
    char *file_contents = 0;

    if (tag->is_file_name) {
        data = file_contents = aacenc_load_tag_from_file(tag->data, &data_size);
        if (!data) return;
    }
    switch (tag->tag) {
    case M4AF_TAG_TRACK:
        if (sscanf(data, "%u/%u", &m, &n) >= 1)
            m4af_add_itmf_track_tag(m4af, m, n);
        break;
    case M4AF_TAG_DISK:
        if (sscanf(data, "%u/%u", &m, &n) >= 1)
            m4af_add_itmf_disk_tag(m4af, m, n);
        break;
    case M4AF_TAG_GENRE_ID3:
        if (sscanf(data, "%u", &n) == 1)
            m4af_add_itmf_genre_tag(m4af, n);
        break;
    case M4AF_TAG_TEMPO:
        if (sscanf(data, "%u", &n) == 1)
            m4af_add_itmf_int16_tag(m4af, tag->tag, n);
        break;
    case M4AF_TAG_COMPILATION:
    case M4AF_FOURCC('a','k','I','D'):
    case M4AF_FOURCC('h','d','v','d'):
    case M4AF_FOURCC('p','c','s','t'):
    case M4AF_FOURCC('p','g','a','p'):
    case M4AF_FOURCC('r','t','n','g'):
    case M4AF_FOURCC('s','t','i','k'):
        if (sscanf(data, "%u", &n) == 1)
            m4af_add_itmf_int8_tag(m4af, tag->tag, n);
        break;
    case M4AF_FOURCC('a','t','I','D'):
    case M4AF_FOURCC('c','m','I','D'):
    case M4AF_FOURCC('c','n','I','D'):
    case M4AF_FOURCC('g','e','I','D'):
    case M4AF_FOURCC('s','f','I','D'):
    case M4AF_FOURCC('t','v','s','n'):
    case M4AF_FOURCC('t','v','s','s'):
        if (sscanf(data, "%u", &n) == 1)
            m4af_add_itmf_int32_tag(m4af, tag->tag, n);
        break;
    case M4AF_FOURCC('p','l','I','D'):
        {
            int64_t qn;
            if (sscanf(data, "%" SCNd64, &qn) == 1)
                m4af_add_itmf_int64_tag(m4af, tag->tag, qn);
            break;
        }
    case M4AF_TAG_ARTWORK:
        {
            int data_type = 0;
            if (!memcmp(data, "GIF", 3))
                data_type = M4AF_GIF;
            else if (!memcmp(data, "\xff\xd8\xff", 3))
                data_type = M4AF_JPEG;
            else if (!memcmp(data, "\x89PNG", 4))
                data_type = M4AF_PNG;
            if (data_type)
                m4af_add_itmf_short_tag(m4af, tag->tag, data_type,
                                        data, data_size);
            break;
        }
    case M4AF_FOURCC('-','-','-','-'):
        {
            char *u8 = aacenc_to_utf8(data);
            m4af_add_itmf_long_tag(m4af, tag->name, u8);
            free(u8);
            break;
        }
    case M4AF_TAG_TITLE:
    case M4AF_TAG_ARTIST:
    case M4AF_TAG_ALBUM:
    case M4AF_TAG_GENRE:
    case M4AF_TAG_DATE:
    case M4AF_TAG_COMPOSER:
    case M4AF_TAG_GROUPING:
    case M4AF_TAG_COMMENT:
    case M4AF_TAG_LYRICS:
    case M4AF_TAG_TOOL:
    case M4AF_TAG_ALBUM_ARTIST:
    case M4AF_TAG_DESCRIPTION:
    case M4AF_TAG_LONG_DESCRIPTION:
    case M4AF_TAG_COPYRIGHT:
    case M4AF_FOURCC('a','p','I','D'):
    case M4AF_FOURCC('c','a','t','g'):
    case M4AF_FOURCC('k','e','y','w'):
    case M4AF_FOURCC('p','u','r','d'):
    case M4AF_FOURCC('p','u','r','l'):
    case M4AF_FOURCC('s','o','a','a'):
    case M4AF_FOURCC('s','o','a','l'):
    case M4AF_FOURCC('s','o','a','r'):
    case M4AF_FOURCC('s','o','c','o'):
    case M4AF_FOURCC('s','o','n','m'):
    case M4AF_FOURCC('s','o','s','n'):
    case M4AF_FOURCC('t','v','e','n'):
    case M4AF_FOURCC('t','v','n','n'):
    case M4AF_FOURCC('t','v','s','h'):
    case M4AF_FOURCC('x','i','d',' '):
    case M4AF_FOURCC('\xa9','e','n','c'):
    case M4AF_FOURCC('\xa9','s','t','3'):
        {
            char *u8 = aacenc_to_utf8(data);
            m4af_add_itmf_string_tag(m4af, tag->tag, u8);
            free(u8);
            break;
        }
    default:
        fprintf(stderr, "WARNING: unknown/unsupported tag: %c%c%c%c\n",
                tag->tag >> 24, (tag->tag >> 16) & 0xff,
                (tag->tag >> 8) & 0xff, tag->tag & 0xff);
    }
    if (file_contents) free(file_contents);
}
Commit	Line	Data
cbb23cdb	1	#if HAVE_CONFIG_H
	2	# include "config.h"
	3	#endif
	4	#if HAVE_STDINT_H
	5	# include <stdint.h>
	6	#endif
	7	#if HAVE_INTTYPES_H
	8	# include <inttypes.h>
	9	#elif defined(_MSC_VER)
	10	# define SCNd64 "I64d"
	11	#endif
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <string.h>
	15	#include <ctype.h>
	16	#include <errno.h>
	17	#include "m4af.h"
	18	#include "metadata.h"
	19	#include "compat.h"
	20	#include "parson.h"
	21
	22	typedef struct tag_key_mapping_t {
	23	const char *name;
	24	uint32_t fcc;
	25	} tag_key_mapping_t;
	26
	27	enum {
	28	TAG_TOTAL_DISCS = 1,
	29	TAG_TOTAL_TRACKS = 2
	30	};
	31
	32	static tag_key_mapping_t tag_mapping_table[] = {
	33	{ "album", M4AF_TAG_ALBUM },
	34	{ "albumartist", M4AF_TAG_ALBUM_ARTIST },
	35	{ "albumartistsort", M4AF_FOURCC('s','o','a','a') },
	36	{ "albumartistsortorder", M4AF_FOURCC('s','o','a','a') },
	37	{ "albumsort", M4AF_FOURCC('s','o','a','l') },
	38	{ "albumsortorder", M4AF_FOURCC('s','o','a','l') },
	39	{ "artist", M4AF_TAG_ARTIST },
	40	{ "artistsort", M4AF_FOURCC('s','o','a','r') },
	41	{ "artistsortorder", M4AF_FOURCC('s','o','a','r') },
	42	{ "band", M4AF_TAG_ALBUM_ARTIST },
	43	{ "bpm", M4AF_TAG_TEMPO },
	44	{ "comment", M4AF_TAG_COMMENT },
	45	{ "compilation", M4AF_TAG_COMPILATION },
	46	{ "composer", M4AF_TAG_COMPOSER },
	47	{ "composersort", M4AF_FOURCC('s','o','c','o') },
	48	{ "composersortorder", M4AF_FOURCC('s','o','c','o') },
	49	{ "contentgroup", M4AF_TAG_GROUPING },
	50	{ "copyright", M4AF_TAG_COPYRIGHT },
	51	{ "date", M4AF_TAG_DATE },
	52	{ "disc", M4AF_TAG_DISK },
	53	{ "disctotal", TAG_TOTAL_DISCS },
	54	{ "discnumber", M4AF_TAG_DISK },
	55	{ "genre", M4AF_TAG_GENRE },
	56	{ "grouping", M4AF_TAG_GROUPING },
	57	{ "itunescompilation", M4AF_TAG_COMPILATION },
	58	{ "lyrics", M4AF_TAG_LYRICS },
	59	{ "title", M4AF_TAG_TITLE },
	60	{ "titlesort", M4AF_FOURCC('s','o','n','m') },
	61	{ "titlesortorder", M4AF_FOURCC('s','o','n','m') },
	62	{ "totaldiscs", TAG_TOTAL_DISCS },
	63	{ "totaltracks", TAG_TOTAL_TRACKS },
	64	{ "track", M4AF_TAG_TRACK },
65	{ "tracknumber", M4AF_TAG_TRACK },
66	{ "tracktotal", TAG_TOTAL_TRACKS },
67	{ "unsyncedlyrics", M4AF_TAG_LYRICS },
68	{ "year", M4AF_TAG_DATE },
69	};
70
71	static
72	int tag_key_comparator(const void k, const void v)
73	{
74	return strcmp((const char )k, ((tag_key_mapping_t)v)->name);
75	}
76
77	static
78	uint32_t get_tag_fcc_from_name(const char *name)
79	{
80	char name_p = 0, p;
81	const tag_key_mapping_t *ent;
82
83	name_p = malloc(strlen(name) + 1);
84	for (p = name_p; *name; ++name) {
85	unsigned char c = *name;
86	if (c != ' ' && c != '-' && c != '_')
87	*p++ = tolower(c);
88	}
89	*p = 0;
90	ent = bsearch(name_p, tag_mapping_table,
91	sizeof(tag_mapping_table) / sizeof(tag_mapping_table[0]),
92	sizeof(tag_mapping_table[0]),
93	tag_key_comparator);
94	free(name_p);
95	return ent ? ent->fcc : 0;
96	}
97
98	char aacenc_load_tag_from_file(const char path, uint32_t *data_size)
99	{
100	FILE *fp = 0;
101	char *data = 0;
102	int64_t size;
103
104	if ((fp = aacenc_fopen(path, "rb")) == NULL) {
105	aacenc_fprintf(stderr, "WARNING: %s: %s\n", path, strerror(errno));
106	goto END;
107	}
108	fseeko(fp, 0, SEEK_END);
109	size = ftello(fp);
110	if (size > 510241024) {
111	aacenc_fprintf(stderr, "WARNING: %s: size too large\n", path);
112	goto END;
113	}
114	fseeko(fp, 0, SEEK_SET);
115	data = malloc(size + 1);
116	if (data) fread(data, 1, size, fp);
117	data[size] = 0;
118	*data_size = (uint32_t)size;
119	END:
120	if (fp) fclose(fp);
121	return data;
122	}
123
124	void aacenc_param_add_itmf_entry(aacenc_tag_param_t *params, uint32_t tag,
125	const char key, const char value,
126	uint32_t size, int is_file_name)
127	{
128	aacenc_tag_entry_t *entry;
129
130	if (!is_file_name && !size)
131	return;
132	if (params->tag_count == params->tag_table_capacity) {
133	unsigned newsize = params->tag_table_capacity;
134	newsize = newsize ? newsize * 2 : 1;
135	params->tag_table =
136	realloc(params->tag_table, newsize * sizeof(aacenc_tag_entry_t));
137	params->tag_table_capacity = newsize;
138	}
139	entry = params->tag_table + params->tag_count;
140	entry->tag = tag;
141	if (tag == M4AF_FOURCC('-','-','-','-'))
142	entry->name = key;
143	entry->data = value;
144	entry->data_size = size;
145	entry->is_file_name = is_file_name;
146	params->tag_count++;
147	}
148
149	static
150	void tag_put_number_pair(m4af_ctx_t *m4af, uint32_t fcc,
151	const char snumber, const char stotal)
152	{
153	unsigned number = 0, total = 0;
154	char buf[128];
155	aacenc_tag_entry_t entry = { 0 };
156
157	if (snumber) sscanf(snumber, "%u", &number);
158	if (stotal) sscanf(stotal, "%u", &total);
159	if (number) {
160	if (total) sprintf(buf, "%u/%u", number, total);
161	else sprintf(buf, "%u", number);
162	entry.tag = fcc;
163	entry.data = buf;
164	entry.data_size = strlen(buf);
165	aacenc_put_tag_entry(m4af, &entry);
166	}
167	}
168
1184a1f5	169	static
	170	const char aacenc_json_object_get_string(JSON_Object obj, const char *key,
	171	char *buf)
	172	{
	173	JSON_Value_Type type;
	174	const char *val = 0;
	175
	176	type = json_value_get_type(json_object_get_value(obj, key));
	177	if (type == JSONString)
	178	val = json_object_get_string(obj, key);
	179	else if (type == JSONNumber) {
	180	double num = json_object_get_number(obj, key);
	181	sprintf(buf, "%.15g", num);
	182	val = buf;
	183	} else if (type == JSONBoolean) {
	184	int n = json_object_get_boolean(obj, key);
	185	sprintf(buf, "%d", n);
	186	val = buf;
	187	}
	188	return val;
	189	}
	190
cbb23cdb	191	void aacenc_put_tags_from_json(m4af_ctx_t m4af, const char json_filename)
	192	{
	193	char *data = 0;
	194	JSON_Value *json = 0;
	195	JSON_Object *root;
	196	size_t i, nelts;
	197	uint32_t data_size;
	198	char *json_dot_path;
	199	char *filename = 0;
	200	char *disc = 0;
	201	char *track = 0;
	202	char *total_discs = 0;
	203	char *total_tracks = 0;
	204	aacenc_tag_entry_t entry = { 0 };
	205
	206	filename = strdup(json_filename);
	207	if ((json_dot_path = strchr(filename, '?')) != 0)
	208	*json_dot_path++ = '\0';
	209
	210	if (!(data = aacenc_load_tag_from_file(filename, &data_size)))
	211	goto DONE;
	212	if (!(json = json_parse_string(data))) {
	213	aacenc_fprintf(stderr, "WARNING: failed to parse JSON\n");
	214	goto DONE;
	215	}
	216	root = json_value_get_object(json);
	217	if (json_dot_path) {
	218	if (!(root = json_object_dotget_object(root, json_dot_path))) {
	219	aacenc_fprintf(stderr, "WARNING: %s not found in JSON\n",
	220	json_dot_path);
	221	goto DONE;
	222	}
	223	}
	224	nelts = json_object_get_count(root);
	225	for (i = 0; i < nelts; ++i) {
	226	char buf[256];
1184a1f5	227	const char *key = json_object_get_name(root, i);
	228	const char *val = aacenc_json_object_get_string(root, key, buf);
	229	uint32_t fcc = get_tag_fcc_from_name(key);
cbb23cdb	230	if (!val \|\| !fcc)
	231	continue;
	232
	233	switch (fcc) {
	234	case TAG_TOTAL_DISCS:
1184a1f5	235	total_discs = realloc(total_discs, strlen(val) + 1);
	236	strcpy(total_discs, val);
	237	break;
cbb23cdb	238	case TAG_TOTAL_TRACKS:
1184a1f5	239	total_tracks = realloc(total_tracks, strlen(val) + 1);
	240	strcpy(total_tracks, val);
	241	break;
cbb23cdb	242	case M4AF_TAG_DISK:
1184a1f5	243	disc = realloc(disc, strlen(val) + 1);
	244	strcpy(disc, val);
	245	break;
cbb23cdb	246	case M4AF_TAG_TRACK:
1184a1f5	247	track = realloc(track, strlen(val) + 1);
	248	strcpy(track, val);
	249	break;
cbb23cdb	250	default:
	251	{
	252	entry.tag = fcc;
	253	entry.data = val;
	254	entry.data_size = strlen(val);
	255	aacenc_put_tag_entry(m4af, &entry);
	256	}
	257	}
	258	}
	259	tag_put_number_pair(m4af, M4AF_TAG_TRACK, track, total_tracks);
	260	tag_put_number_pair(m4af, M4AF_TAG_DISK, disc, total_discs);
	261	DONE:
	262	if (track) free(track);
	263	if (disc) free(disc);
	264	if (total_tracks) free(total_tracks);
	265	if (total_discs) free(total_discs);
	266	if (data) free(data);
	267	if (filename) free(filename);
	268	if (json) json_value_free(json);
	269	}
	270
	271	void aacenc_put_tag_entry(m4af_ctx_t m4af, const aacenc_tag_entry_t tag)
	272	{
	273	unsigned m, n = 0;
	274	const char *data = tag->data;
	275	uint32_t data_size = tag->data_size;
	276	char *file_contents = 0;
	277
	278	if (tag->is_file_name) {
	279	data = file_contents = aacenc_load_tag_from_file(tag->data, &data_size);
	280	if (!data) return;
	281	}
	282	switch (tag->tag) {
	283	case M4AF_TAG_TRACK:
	284	if (sscanf(data, "%u/%u", &m, &n) >= 1)
	285	m4af_add_itmf_track_tag(m4af, m, n);
	286	break;
	287	case M4AF_TAG_DISK:
	288	if (sscanf(data, "%u/%u", &m, &n) >= 1)
	289	m4af_add_itmf_disk_tag(m4af, m, n);
	290	break;
	291	case M4AF_TAG_GENRE_ID3:
	292	if (sscanf(data, "%u", &n) == 1)
	293	m4af_add_itmf_genre_tag(m4af, n);
	294	break;
	295	case M4AF_TAG_TEMPO:
	296	if (sscanf(data, "%u", &n) == 1)
	297	m4af_add_itmf_int16_tag(m4af, tag->tag, n);
	298	break;
	299	case M4AF_TAG_COMPILATION:
	300	case M4AF_FOURCC('a','k','I','D'):
	301	case M4AF_FOURCC('h','d','v','d'):
	302	case M4AF_FOURCC('p','c','s','t'):
	303	case M4AF_FOURCC('p','g','a','p'):
	304	case M4AF_FOURCC('r','t','n','g'):
	305	case M4AF_FOURCC('s','t','i','k'):
	306	if (sscanf(data, "%u", &n) == 1)
	307	m4af_add_itmf_int8_tag(m4af, tag->tag, n);
	308	break;
	309	case M4AF_FOURCC('a','t','I','D'):
	310	case M4AF_FOURCC('c','m','I','D'):
	311	case M4AF_FOURCC('c','n','I','D'):
	312	case M4AF_FOURCC('g','e','I','D'):
	313	case M4AF_FOURCC('s','f','I','D'):
314	case M4AF_FOURCC('t','v','s','n'):
315	case M4AF_FOURCC('t','v','s','s'):
316	if (sscanf(data, "%u", &n) == 1)
317	m4af_add_itmf_int32_tag(m4af, tag->tag, n);
318	break;
319	case M4AF_FOURCC('p','l','I','D'):
320	{
321	int64_t qn;
322	if (sscanf(data, "%" SCNd64, &qn) == 1)
323	m4af_add_itmf_int64_tag(m4af, tag->tag, qn);
324	break;
325	}
326	case M4AF_TAG_ARTWORK:
327	{
328	int data_type = 0;
329	if (!memcmp(data, "GIF", 3))
330	data_type = M4AF_GIF;
331	else if (!memcmp(data, "\xff\xd8\xff", 3))
332	data_type = M4AF_JPEG;
333	else if (!memcmp(data, "\x89PNG", 4))
334	data_type = M4AF_PNG;
335	if (data_type)
336	m4af_add_itmf_short_tag(m4af, tag->tag, data_type,
337	data, data_size);
338	break;
339	}
340	case M4AF_FOURCC('-','-','-','-'):
341	{
342	char *u8 = aacenc_to_utf8(data);
343	m4af_add_itmf_long_tag(m4af, tag->name, u8);
344	free(u8);
345	break;
346	}
347	case M4AF_TAG_TITLE:
348	case M4AF_TAG_ARTIST:
349	case M4AF_TAG_ALBUM:
350	case M4AF_TAG_GENRE:
351	case M4AF_TAG_DATE:
352	case M4AF_TAG_COMPOSER:
353	case M4AF_TAG_GROUPING:
354	case M4AF_TAG_COMMENT:
355	case M4AF_TAG_LYRICS:
356	case M4AF_TAG_TOOL:
357	case M4AF_TAG_ALBUM_ARTIST:
358	case M4AF_TAG_DESCRIPTION:
359	case M4AF_TAG_LONG_DESCRIPTION:
360	case M4AF_TAG_COPYRIGHT:
361	case M4AF_FOURCC('a','p','I','D'):
362	case M4AF_FOURCC('c','a','t','g'):
363	case M4AF_FOURCC('k','e','y','w'):
364	case M4AF_FOURCC('p','u','r','d'):
365	case M4AF_FOURCC('p','u','r','l'):
366	case M4AF_FOURCC('s','o','a','a'):
367	case M4AF_FOURCC('s','o','a','l'):
368	case M4AF_FOURCC('s','o','a','r'):
369	case M4AF_FOURCC('s','o','c','o'):
370	case M4AF_FOURCC('s','o','n','m'):
371	case M4AF_FOURCC('s','o','s','n'):
372	case M4AF_FOURCC('t','v','e','n'):
373	case M4AF_FOURCC('t','v','n','n'):
374	case M4AF_FOURCC('t','v','s','h'):
375	case M4AF_FOURCC('x','i','d',' '):
376	case M4AF_FOURCC('\xa9','e','n','c'):
377	case M4AF_FOURCC('\xa9','s','t','3'):
378	{
379	char *u8 = aacenc_to_utf8(data);
380	m4af_add_itmf_string_tag(m4af, tag->tag, u8);
381	free(u8);
382	break;
383	}
384	default:
385	fprintf(stderr, "WARNING: unknown/unsupported tag: %c%c%c%c\n",
386	tag->tag >> 24, (tag->tag >> 16) & 0xff,
387	(tag->tag >> 8) & 0xff, tag->tag & 0xff);
388	}
389	if (file_contents) free(file_contents);
390	}
391
392