[fdkaac.git] / src / metadata.c

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