[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;
}

static
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;
}

static
int aacenc_is_string_tag(uint32_t tag)
{
    switch (tag) {
    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'):
    case M4AF_FOURCC('-','-','-','-'):
        return 1;
    }
    return 0;
}

void aacenc_add_tag_to_store(aacenc_tag_store_t *store, uint32_t tag,
                             const char *key, const char *value,
                             uint32_t size, int is_file_name)
{
    aacenc_tag_entry_t entry = { 0 };
    char *dp = 0;

    if (!is_file_name && !size)
        return;
    entry.tag = tag;
    if (tag == M4AF_FOURCC('-','-','-','-'))
        entry.name = (char *)key;

    if (is_file_name) {
        entry.data = dp = aacenc_load_tag_from_file(value, &size);
        entry.data_size = size;
    } else if (aacenc_is_string_tag(tag)) {
        entry.data = dp = aacenc_to_utf8(value);
        entry.data_size = strlen(entry.data);
    } else {
        entry.data = (char *)value;
        entry.data_size = size;
    }
    aacenc_add_tag_entry_to_store(store, &entry);
    free(dp);
}

void aacenc_add_tag_entry_to_store(void *ctx, const aacenc_tag_entry_t *tag)
{
    aacenc_tag_store_t *store = ctx;
    aacenc_tag_entry_t *entry;
    if (store->tag_count == store->tag_table_capacity) {
        unsigned newsize = store->tag_table_capacity;
        newsize = newsize ? newsize * 2 : 1;
        store->tag_table =
            realloc(store->tag_table, newsize * sizeof(aacenc_tag_entry_t));
        store->tag_table_capacity = newsize;
    }
    entry = store->tag_table + store->tag_count;
    entry->tag  = tag->tag;
    entry->data_size = tag->data_size;
    entry->name = tag->name ? strdup(tag->name) : 0;
    entry->data = malloc(tag->data_size + 1);
    memcpy(entry->data, tag->data, tag->data_size);
    entry->data[tag->data_size] = 0;
    store->tag_count++;
}

static
void tag_put_number_pair(aacenc_translate_generic_text_tag_ctx_t *ctx,
                         uint32_t fcc, unsigned number, unsigned total)
{
    char buf[128];
    aacenc_tag_entry_t entry = { 0 };

    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);
        ctx->add(ctx->add_ctx, &entry);
    }
}

void aacenc_translate_generic_text_tag(void *pctx, const char *key,
                                       const char *val, uint32_t size)
{
    aacenc_translate_generic_text_tag_ctx_t *ctx = pctx;
    aacenc_tag_entry_t entry = { 0 };
    uint32_t fcc;
    /*
     * Since track/disc number pair (number and total) can be stored within
     * either single tag or separately, we cannot instantly translate
     * them in one-to-one manner.
     * Instead, we keep and store them until all tags are processed,
     * then finally submit.
     */
    if (!key) {
        /* use null key as flushing signal */
        tag_put_number_pair(ctx, M4AF_TAG_TRACK, ctx->track, ctx->track_total);
        tag_put_number_pair(ctx, M4AF_TAG_DISK,  ctx->disc,  ctx->disc_total);
        return;
    }
    if (!val || !size)
        return;
    if ((fcc = get_tag_fcc_from_name(key)) == 0)
        return;

    switch (fcc) {
    case TAG_TOTAL_DISCS:
        sscanf(val, "%d", &ctx->disc_total); break;
    case TAG_TOTAL_TRACKS:
        sscanf(val, "%d", &ctx->track_total); break;
    case M4AF_TAG_DISK:
        sscanf(val, "%d/%d", &ctx->disc, &ctx->disc_total); break;
    case M4AF_TAG_TRACK:
        sscanf(val, "%d/%d", &ctx->track, &ctx->track_total); break;
    default:
        {
            entry.tag = fcc;
            entry.data = (char *)val;
            entry.data_size = (size == ~0U) ? strlen(val) : size;
            ctx->add(ctx->add_ctx, &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_write_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;
    aacenc_translate_generic_text_tag_ctx_t ctx = { 0 };

    ctx.add = aacenc_write_tag_entry;
    ctx.add_ctx = m4af;

    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);
        if (val) aacenc_translate_generic_text_tag(&ctx, key, val, ~0U);
    }
    aacenc_translate_generic_text_tag(&ctx, 0, 0, 0);
DONE:
    if (data) free(data);
    if (filename) free(filename);
    if (json) json_value_free(json);
}

void aacenc_free_tag_store(aacenc_tag_store_t *store)
{
    if (store->tag_table) {
        unsigned i;
        for (i = 0; i < store->tag_count; ++i) {
            aacenc_tag_entry_t *ent = &store->tag_table[i];
            free(ent->name);
            free(ent->data);
        }
        free(store->tag_table);
        store->tag_table = 0;
        store->tag_count = 0;
    }
}

void aacenc_write_tag_entry(void *ctx, const aacenc_tag_entry_t *tag)
{
    m4af_ctx_t *m4af = ctx;
    unsigned m, n = 0;
    const char *data = tag->data;

    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, tag->data_size);
            break;
        }
    case M4AF_FOURCC('-','-','-','-'):
        {
            m4af_add_itmf_long_tag(m4af, tag->name, data);
            break;
        }
    default:
        if (aacenc_is_string_tag(tag->tag))
            m4af_add_itmf_string_tag(m4af, tag->tag, data);
        else
            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);
    }
}
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
3b666b75	98	static
cbb23cdb	99	char aacenc_load_tag_from_file(const char path, uint32_t *data_size)
	100	{
	101	FILE *fp = 0;
	102	char *data = 0;
	103	int64_t size;
	104
	105	if ((fp = aacenc_fopen(path, "rb")) == NULL) {
	106	aacenc_fprintf(stderr, "WARNING: %s: %s\n", path, strerror(errno));
	107	goto END;
	108	}
	109	fseeko(fp, 0, SEEK_END);
	110	size = ftello(fp);
	111	if (size > 510241024) {
	112	aacenc_fprintf(stderr, "WARNING: %s: size too large\n", path);
	113	goto END;
	114	}
	115	fseeko(fp, 0, SEEK_SET);
	116	data = malloc(size + 1);
	117	if (data) fread(data, 1, size, fp);
	118	data[size] = 0;
	119	*data_size = (uint32_t)size;
	120	END:
	121	if (fp) fclose(fp);
	122	return data;
	123	}
	124
3b666b75	125	static
3b666b75	126	int aacenc_is_string_tag(uint32_t tag)
cbb23cdb	127	{
3b666b75	128	switch (tag) {
	129	case M4AF_TAG_TITLE:
	130	case M4AF_TAG_ARTIST:
	131	case M4AF_TAG_ALBUM:
	132	case M4AF_TAG_GENRE:
	133	case M4AF_TAG_DATE:
	134	case M4AF_TAG_COMPOSER:
	135	case M4AF_TAG_GROUPING:
	136	case M4AF_TAG_COMMENT:
	137	case M4AF_TAG_LYRICS:
	138	case M4AF_TAG_TOOL:
	139	case M4AF_TAG_ALBUM_ARTIST:
	140	case M4AF_TAG_DESCRIPTION:
	141	case M4AF_TAG_LONG_DESCRIPTION:
	142	case M4AF_TAG_COPYRIGHT:
	143	case M4AF_FOURCC('a','p','I','D'):
	144	case M4AF_FOURCC('c','a','t','g'):
	145	case M4AF_FOURCC('k','e','y','w'):
	146	case M4AF_FOURCC('p','u','r','d'):
	147	case M4AF_FOURCC('p','u','r','l'):
	148	case M4AF_FOURCC('s','o','a','a'):
	149	case M4AF_FOURCC('s','o','a','l'):
	150	case M4AF_FOURCC('s','o','a','r'):
	151	case M4AF_FOURCC('s','o','c','o'):
	152	case M4AF_FOURCC('s','o','n','m'):
	153	case M4AF_FOURCC('s','o','s','n'):
	154	case M4AF_FOURCC('t','v','e','n'):
	155	case M4AF_FOURCC('t','v','n','n'):
	156	case M4AF_FOURCC('t','v','s','h'):
	157	case M4AF_FOURCC('x','i','d',' '):
	158	case M4AF_FOURCC('\xa9','e','n','c'):
	159	case M4AF_FOURCC('\xa9','s','t','3'):
	160	case M4AF_FOURCC('-','-','-','-'):
	161	return 1;
	162	}
	163	return 0;
	164	}
	165
	166	void aacenc_add_tag_to_store(aacenc_tag_store_t *store, uint32_t tag,
	167	const char key, const char value,
	168	uint32_t size, int is_file_name)
	169	{
	170	aacenc_tag_entry_t entry = { 0 };
	171	char *dp = 0;
cbb23cdb	172
	173	if (!is_file_name && !size)
	174	return;
3b666b75	175	entry.tag = tag;
	176	if (tag == M4AF_FOURCC('-','-','-','-'))
	177	entry.name = (char *)key;
	178
	179	if (is_file_name) {
	180	entry.data = dp = aacenc_load_tag_from_file(value, &size);
	181	entry.data_size = size;
	182	} else if (aacenc_is_string_tag(tag)) {
	183	entry.data = dp = aacenc_to_utf8(value);
	184	entry.data_size = strlen(entry.data);
	185	} else {
	186	entry.data = (char *)value;
	187	entry.data_size = size;
	188	}
	189	aacenc_add_tag_entry_to_store(store, &entry);
	190	free(dp);
	191	}
	192
	193	void aacenc_add_tag_entry_to_store(void ctx, const aacenc_tag_entry_t tag)
	194	{
	195	aacenc_tag_store_t *store = ctx;
	196	aacenc_tag_entry_t *entry;
	197	if (store->tag_count == store->tag_table_capacity) {
	198	unsigned newsize = store->tag_table_capacity;
cbb23cdb	199	newsize = newsize ? newsize * 2 : 1;
3b666b75	200	store->tag_table =
	201	realloc(store->tag_table, newsize * sizeof(aacenc_tag_entry_t));
	202	store->tag_table_capacity = newsize;
cbb23cdb	203	}
3b666b75	204	entry = store->tag_table + store->tag_count;
	205	entry->tag = tag->tag;
	206	entry->data_size = tag->data_size;
	207	entry->name = tag->name ? strdup(tag->name) : 0;
	208	entry->data = malloc(tag->data_size + 1);
	209	memcpy(entry->data, tag->data, tag->data_size);
	210	entry->data[tag->data_size] = 0;
	211	store->tag_count++;
cbb23cdb	212	}
	213
	214	static
3b666b75	215	void tag_put_number_pair(aacenc_translate_generic_text_tag_ctx_t *ctx,
3b666b75	216	uint32_t fcc, unsigned number, unsigned total)
cbb23cdb	217	{
cbb23cdb	218	char buf[128];
	219	aacenc_tag_entry_t entry = { 0 };
	220
cbb23cdb	221	if (number) {
	222	if (total) sprintf(buf, "%u/%u", number, total);
	223	else sprintf(buf, "%u", number);
	224	entry.tag = fcc;
	225	entry.data = buf;
	226	entry.data_size = strlen(buf);
3b666b75	227	ctx->add(ctx->add_ctx, &entry);
	228	}
	229	}
	230
	231	void aacenc_translate_generic_text_tag(void pctx, const char key,
	232	const char *val, uint32_t size)
	233	{
	234	aacenc_translate_generic_text_tag_ctx_t *ctx = pctx;
	235	aacenc_tag_entry_t entry = { 0 };
	236	uint32_t fcc;
	237	/*
	238	* Since track/disc number pair (number and total) can be stored within
	239	* either single tag or separately, we cannot instantly translate
	240	* them in one-to-one manner.
	241	* Instead, we keep and store them until all tags are processed,
	242	* then finally submit.
	243	*/
	244	if (!key) {
	245	/* use null key as flushing signal */
	246	tag_put_number_pair(ctx, M4AF_TAG_TRACK, ctx->track, ctx->track_total);
	247	tag_put_number_pair(ctx, M4AF_TAG_DISK, ctx->disc, ctx->disc_total);
	248	return;
	249	}
	250	if (!val \|\| !size)
	251	return;
	252	if ((fcc = get_tag_fcc_from_name(key)) == 0)
	253	return;
	254
	255	switch (fcc) {
	256	case TAG_TOTAL_DISCS:
	257	sscanf(val, "%d", &ctx->disc_total); break;
	258	case TAG_TOTAL_TRACKS:
	259	sscanf(val, "%d", &ctx->track_total); break;
	260	case M4AF_TAG_DISK:
	261	sscanf(val, "%d/%d", &ctx->disc, &ctx->disc_total); break;
	262	case M4AF_TAG_TRACK:
	263	sscanf(val, "%d/%d", &ctx->track, &ctx->track_total); break;
	264	default:
	265	{
	266	entry.tag = fcc;
	267	entry.data = (char *)val;
	268	entry.data_size = (size == ~0U) ? strlen(val) : size;
	269	ctx->add(ctx->add_ctx, &entry);
	270	}
cbb23cdb	271	}
	272	}
	273
1184a1f5	274	static
	275	const char aacenc_json_object_get_string(JSON_Object obj, const char *key,
	276	char *buf)
	277	{
	278	JSON_Value_Type type;
	279	const char *val = 0;
	280
	281	type = json_value_get_type(json_object_get_value(obj, key));
	282	if (type == JSONString)
	283	val = json_object_get_string(obj, key);
	284	else if (type == JSONNumber) {
	285	double num = json_object_get_number(obj, key);
	286	sprintf(buf, "%.15g", num);
	287	val = buf;
	288	} else if (type == JSONBoolean) {
	289	int n = json_object_get_boolean(obj, key);
	290	sprintf(buf, "%d", n);
	291	val = buf;
	292	}
	293	return val;
	294	}
	295
3b666b75	296	void aacenc_write_tags_from_json(m4af_ctx_t m4af, const char json_filename)
cbb23cdb	297	{
	298	char *data = 0;
	299	JSON_Value *json = 0;
	300	JSON_Object *root;
	301	size_t i, nelts;
	302	uint32_t data_size;
	303	char *json_dot_path;
	304	char *filename = 0;
3b666b75	305	aacenc_translate_generic_text_tag_ctx_t ctx = { 0 };
	306
	307	ctx.add = aacenc_write_tag_entry;
	308	ctx.add_ctx = m4af;
	309
cbb23cdb	310	filename = strdup(json_filename);
	311	if ((json_dot_path = strchr(filename, '?')) != 0)
	312	*json_dot_path++ = '\0';
	313
	314	if (!(data = aacenc_load_tag_from_file(filename, &data_size)))
	315	goto DONE;
	316	if (!(json = json_parse_string(data))) {
	317	aacenc_fprintf(stderr, "WARNING: failed to parse JSON\n");
	318	goto DONE;
	319	}
	320	root = json_value_get_object(json);
	321	if (json_dot_path) {
	322	if (!(root = json_object_dotget_object(root, json_dot_path))) {
	323	aacenc_fprintf(stderr, "WARNING: %s not found in JSON\n",
	324	json_dot_path);
	325	goto DONE;
	326	}
	327	}
	328	nelts = json_object_get_count(root);
	329	for (i = 0; i < nelts; ++i) {
	330	char buf[256];
1184a1f5	331	const char *key = json_object_get_name(root, i);
1184a1f5	332	const char *val = aacenc_json_object_get_string(root, key, buf);
3b666b75	333	if (val) aacenc_translate_generic_text_tag(&ctx, key, val, ~0U);
cbb23cdb	334	}
3b666b75	335	aacenc_translate_generic_text_tag(&ctx, 0, 0, 0);
cbb23cdb	336	DONE:
cbb23cdb	337	if (data) free(data);
	338	if (filename) free(filename);
	339	if (json) json_value_free(json);
	340	}
	341
3b666b75	342	void aacenc_free_tag_store(aacenc_tag_store_t *store)
	343	{
	344	if (store->tag_table) {
	345	unsigned i;
	346	for (i = 0; i < store->tag_count; ++i) {
	347	aacenc_tag_entry_t *ent = &store->tag_table[i];
	348	free(ent->name);
	349	free(ent->data);
	350	}
	351	free(store->tag_table);
	352	store->tag_table = 0;
	353	store->tag_count = 0;
	354	}
	355	}
	356
	357	void aacenc_write_tag_entry(void ctx, const aacenc_tag_entry_t tag)
cbb23cdb	358	{
3b666b75	359	m4af_ctx_t *m4af = ctx;
cbb23cdb	360	unsigned m, n = 0;
cbb23cdb	361	const char *data = tag->data;
cbb23cdb	362
cbb23cdb	363	switch (tag->tag) {
	364	case M4AF_TAG_TRACK:
	365	if (sscanf(data, "%u/%u", &m, &n) >= 1)
	366	m4af_add_itmf_track_tag(m4af, m, n);
	367	break;
	368	case M4AF_TAG_DISK:
	369	if (sscanf(data, "%u/%u", &m, &n) >= 1)
	370	m4af_add_itmf_disk_tag(m4af, m, n);
	371	break;
	372	case M4AF_TAG_GENRE_ID3:
	373	if (sscanf(data, "%u", &n) == 1)
	374	m4af_add_itmf_genre_tag(m4af, n);
	375	break;
	376	case M4AF_TAG_TEMPO:
	377	if (sscanf(data, "%u", &n) == 1)
	378	m4af_add_itmf_int16_tag(m4af, tag->tag, n);
	379	break;
	380	case M4AF_TAG_COMPILATION:
	381	case M4AF_FOURCC('a','k','I','D'):
	382	case M4AF_FOURCC('h','d','v','d'):
	383	case M4AF_FOURCC('p','c','s','t'):
	384	case M4AF_FOURCC('p','g','a','p'):
	385	case M4AF_FOURCC('r','t','n','g'):
	386	case M4AF_FOURCC('s','t','i','k'):
	387	if (sscanf(data, "%u", &n) == 1)
	388	m4af_add_itmf_int8_tag(m4af, tag->tag, n);
	389	break;
	390	case M4AF_FOURCC('a','t','I','D'):
	391	case M4AF_FOURCC('c','m','I','D'):
	392	case M4AF_FOURCC('c','n','I','D'):
	393	case M4AF_FOURCC('g','e','I','D'):
	394	case M4AF_FOURCC('s','f','I','D'):
	395	case M4AF_FOURCC('t','v','s','n'):
	396	case M4AF_FOURCC('t','v','s','s'):
	397	if (sscanf(data, "%u", &n) == 1)
	398	m4af_add_itmf_int32_tag(m4af, tag->tag, n);
	399	break;
	400	case M4AF_FOURCC('p','l','I','D'):
	401	{
	402	int64_t qn;
	403	if (sscanf(data, "%" SCNd64, &qn) == 1)
	404	m4af_add_itmf_int64_tag(m4af, tag->tag, qn);
	405	break;
	406	}
	407	case M4AF_TAG_ARTWORK:
	408	{
	409	int data_type = 0;
	410	if (!memcmp(data, "GIF", 3))
	411	data_type = M4AF_GIF;
	412	else if (!memcmp(data, "\xff\xd8\xff", 3))
	413	data_type = M4AF_JPEG;
	414	else if (!memcmp(data, "\x89PNG", 4))
	415	data_type = M4AF_PNG;
	416	if (data_type)
	417	m4af_add_itmf_short_tag(m4af, tag->tag, data_type,
3b666b75	418	data, tag->data_size);
cbb23cdb	419	break;
	420	}
	421	case M4AF_FOURCC('-','-','-','-'):
	422	{
3b666b75	423	m4af_add_itmf_long_tag(m4af, tag->name, data);
cbb23cdb	424	break;
	425	}
	426	default:
3b666b75	427	if (aacenc_is_string_tag(tag->tag))
	428	m4af_add_itmf_string_tag(m4af, tag->tag, data);
	429	else
	430	fprintf(stderr, "WARNING: unknown/unsupported tag: %c%c%c%c\n",
	431	tag->tag >> 24, (tag->tag >> 16) & 0xff,
	432	(tag->tag >> 8) & 0xff, tag->tag & 0xff);
cbb23cdb	433	}
cbb23cdb	434	}
	435
	436