X-Git-Url: http://git.ieval.ro/?a=blobdiff_plain;f=src%2Fmain.c;h=8c78c8edfe170dbcdb79134aebddbbf45facd94d;hb=aa2ca1e3487019fe143a17bedbe9b667e816d095;hp=2054adf25db05b1be8151685822fd850fd584028;hpb=685431760612807639f0dfab6d5da8937cf39f0f;p=fdkaac.git diff --git a/src/main.c b/src/main.c index 2054adf..8c78c8e 100644 --- a/src/main.c +++ b/src/main.c @@ -8,6 +8,11 @@ #if HAVE_STDINT_H # include #endif +#if HAVE_INTTYPES_H +# include +#elif defined(_MSC_VER) +# define SCNd64 "I64d" +#endif #include #include #include @@ -103,7 +108,8 @@ PROGNAME " %s\n" " transport layer\n" "\n" " -o Output filename\n" -" --ignore-length Ignore length of WAV header\n" +" --ignorelength Ignore length of WAV header\n" +" -S, --silent Don't print progress messages\n" "\n" "Options for raw (headerless) input:\n" " -R, --raw Treat input as raw (by default WAV is\n" @@ -132,12 +138,16 @@ PROGNAME " %s\n" " --track \n" " --disk \n" " --tempo \n" +" --tag : Set iTunes predefined tag with four char code.\n" +" --long-tag : Set arbitrary tag as iTunes custom metadata.\n" , fdkaac_version); } typedef struct aacenc_tag_entry_t { uint32_t tag; + const char *name; const char *data; + uint32_t data_size; } aacenc_tag_entry_t; typedef struct aacenc_param_ex_t { @@ -146,6 +156,7 @@ typedef struct aacenc_param_ex_t { char *input_filename; char *output_filename; unsigned ignore_length; + int silent; int is_raw; unsigned raw_channels; @@ -157,16 +168,38 @@ typedef struct aacenc_param_ex_t { unsigned tag_table_capacity; } aacenc_param_ex_t; +static +void param_add_itmf_entry(aacenc_param_ex_t *params, uint32_t tag, + const char *key, const char *value, uint32_t size) +{ + aacenc_tag_entry_t *entry; + 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; + params->tag_count++; +} + static int parse_options(int argc, char **argv, aacenc_param_ex_t *params) { int ch; unsigned n; - aacenc_tag_entry_t *tag; #define OPT_RAW_CHANNELS M4AF_FOURCC('r','c','h','n') #define OPT_RAW_RATE M4AF_FOURCC('r','r','a','t') #define OPT_RAW_FORMAT M4AF_FOURCC('r','f','m','t') +#define OPT_SHORT_TAG M4AF_FOURCC('s','t','a','g') +#define OPT_LONG_TAG M4AF_FOURCC('l','t','a','g') static struct option long_options[] = { { "help", no_argument, 0, 'h' }, @@ -181,7 +214,8 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) { "adts-crc-check", no_argument, 0, 'C' }, { "header-period", required_argument, 0, 'P' }, - { "ignore-length", no_argument, 0, 'I' }, + { "ignorelength", no_argument, 0, 'I' }, + { "silent", no_argument, 0, 'S' }, { "raw", no_argument, 0, 'R' }, { "raw-channels", required_argument, 0, OPT_RAW_CHANNELS }, @@ -200,11 +234,14 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) { "track", required_argument, 0, M4AF_TAG_TRACK }, { "disk", required_argument, 0, M4AF_TAG_DISK }, { "tempo", required_argument, 0, M4AF_TAG_TEMPO }, + { "tag", required_argument, 0, OPT_SHORT_TAG }, + { "long-tag", required_argument, 0, OPT_LONG_TAG }, + { 0, 0, 0, 0 }, }; params->afterburner = 1; aacenc_getmainargs(&argc, &argv); - while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:CP:Io:R", + while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:CP:Io:SR", long_options, 0)) != EOF) { switch (ch) { case 'h': @@ -277,6 +314,9 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) case 'I': params->ignore_length = 1; break; + case 'S': + params->silent = 1; + break; case 'R': params->is_raw = 1; break; @@ -309,18 +349,40 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) case M4AF_TAG_TRACK: case M4AF_TAG_DISK: case M4AF_TAG_TEMPO: - 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; + param_add_itmf_entry(params, ch, 0, optarg, strlen(optarg)); + break; + case OPT_SHORT_TAG: + case OPT_LONG_TAG: + { + char *val; + size_t klen; + unsigned fcc = M4AF_FOURCC('-','-','-','-'); + + if ((val = strchr(optarg, ':')) == 0) { + fprintf(stderr, "invalid arg for tag\n"); + return -1; + } + *val++ = '\0'; + if (ch == OPT_SHORT_TAG) { + /* + * take care of U+00A9(COPYRIGHT SIGN). + * 1) if length of fcc is 3, we prepend '\xa9'. + * 2) U+00A9 becomes "\xc2\xa9" in UTF-8. Therefore + * we remove first '\xc2'. + */ + if (optarg[0] == '\xc2') + ++optarg; + if ((klen = strlen(optarg))== 3) + fcc = 0xa9; + else if (klen != 4) { + fprintf(stderr, "invalid arg for tag\n"); + return -1; + } + for (; *optarg; ++optarg) + fcc = ((fcc << 8) | (*optarg & 0xff)); + } + param_add_itmf_entry(params, fcc, optarg, val, strlen(val)); } - tag = params->tag_table + params->tag_count; - tag->tag = ch; - tag->data = optarg; - params->tag_count++; break; default: return usage(), -1; @@ -372,7 +434,8 @@ int write_sample(FILE *ofp, m4af_writer_t *m4af, static int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder, - uint32_t frame_length, FILE *ofp, m4af_writer_t *m4af) + uint32_t frame_length, FILE *ofp, m4af_writer_t *m4af, + int show_progress) { uint8_t *ibuf = 0; int16_t *pcmbuf = 0; @@ -401,8 +464,9 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder, goto END; } } - aacenc_progress_update(&progress, wav_get_position(wavf), - format->sample_rate * 2); + if (show_progress) + aacenc_progress_update(&progress, wav_get_position(wavf), + format->sample_rate * 2); } if ((consumed = aac_encode_frame(encoder, format, pcmbuf, nread, &obuf, &olen, &osize)) < 0) @@ -413,7 +477,9 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder, ++frames_written; } } while (nread > 0 || olen > 0); - aacenc_progress_finish(&progress, wav_get_position(wavf)); + + if (show_progress) + aacenc_progress_finish(&progress, wav_get_position(wavf)); rc = frames_written; END: if (ibuf) free(ibuf); @@ -422,67 +488,159 @@ END: return rc; } +static +void put_tag_entry(m4af_writer_t *m4af, const aacenc_tag_entry_t *tag) +{ + unsigned m, n = 0; + + switch (tag->tag) { + case M4AF_TAG_TRACK: + if (sscanf(tag->data, "%u/%u", &m, &n) >= 1) + m4af_add_itmf_track_tag(m4af, m, n); + break; + case M4AF_TAG_DISK: + if (sscanf(tag->data, "%u/%u", &m, &n) >= 1) + m4af_add_itmf_disk_tag(m4af, m, n); + break; + case M4AF_TAG_GENRE_ID3: + if (sscanf(tag->data, "%u", &n) == 1) + m4af_add_itmf_genre_tag(m4af, n); + break; + case M4AF_TAG_TEMPO: + if (sscanf(tag->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(tag->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(tag->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(tag->data, "%" SCNd64, &qn) == 1) + m4af_add_itmf_int64_tag(m4af, tag->tag, qn); + break; + } + case M4AF_TAG_ARTWORK: + { + int data_type = 0; + if (!memcmp(tag->data, "GIF", 3)) + data_type = M4AF_GIF; + else if (!memcmp(tag->data, "\xff\xd8\xff", 3)) + data_type = M4AF_JPEG; + else if (!memcmp(tag->data, "\x89PNG", 4)) + data_type = M4AF_PNG; + if (data_type) + m4af_add_itmf_short_tag(m4af, tag->tag, data_type, + tag->data, tag->data_size); + break; + } + case M4AF_FOURCC('-','-','-','-'): + { + char *u8 = aacenc_to_utf8(tag->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(tag->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); + } +} + +static +void put_tool_tag(m4af_writer_t *m4af, const aacenc_param_ex_t *params, + HANDLE_AACENCODER encoder) +{ + char tool_info[256]; + char *p = tool_info; + LIB_INFO *lib_info = 0; + + p += sprintf(p, PROGNAME " %s, ", fdkaac_version); + + lib_info = calloc(FDK_MODULE_LAST, sizeof(LIB_INFO)); + if (aacEncGetLibInfo(lib_info) == AACENC_OK) { + int i; + for (i = 0; i < FDK_MODULE_LAST; ++i) + if (lib_info[i].module_id == FDK_AACENC) + break; + p += sprintf(p, "libfdk-aac %s, ", lib_info[i].versionStr); + } + free(lib_info); + if (params->bitrate_mode) + sprintf(p, "VBR mode %d", params->bitrate_mode); + else + sprintf(p, "CBR %dkbps", + aacEncoder_GetParam(encoder, AACENC_BITRATE) / 1000); + + m4af_add_itmf_string_tag(m4af, M4AF_TAG_TOOL, tool_info); +} + static int finalize_m4a(m4af_writer_t *m4af, const aacenc_param_ex_t *params, HANDLE_AACENCODER encoder) { unsigned i; aacenc_tag_entry_t *tag = params->tag_table; + for (i = 0; i < params->tag_count; ++i, ++tag) + put_tag_entry(m4af, tag); + + put_tool_tag(m4af, params, encoder); - for (i = 0; i < params->tag_count; ++i, ++tag) { - switch (tag->tag) { - case M4AF_TAG_TRACK: - { - unsigned m, n = 0; - if (sscanf(tag->data, "%u/%u", &m, &n) >= 1) - m4af_add_itmf_track_tag(m4af, m, n); - break; - } - case M4AF_TAG_DISK: - { - unsigned m, n = 0; - if (sscanf(tag->data, "%u/%u", &m, &n) >= 1) - m4af_add_itmf_disk_tag(m4af, m, n); - break; - } - case M4AF_TAG_TEMPO: - { - unsigned n; - if (sscanf(tag->data, "%u", &n) == 1) - m4af_add_itmf_int16_tag(m4af, tag->tag, n); - break; - } - default: - { - char *u8 = aacenc_to_utf8(tag->data); - m4af_add_itmf_string_tag(m4af, tag->tag, u8); - free(u8); - } - } - } - { - char tool_info[256]; - char *p = tool_info; - LIB_INFO *lib_info = 0; - - p += sprintf(p, PROGNAME " %s, ", fdkaac_version); - - lib_info = calloc(FDK_MODULE_LAST, sizeof(LIB_INFO)); - if (aacEncGetLibInfo(lib_info) == AACENC_OK) { - for (i = 0; i < FDK_MODULE_LAST; ++i) - if (lib_info[i].module_id == FDK_AACENC) - break; - p += sprintf(p, "libfdk-aac %s, ", lib_info[i].versionStr); - } - free(lib_info); - if (params->bitrate_mode) - sprintf(p, "VBR mode %d", params->bitrate_mode); - else - sprintf(p, "CBR %dkbps", - aacEncoder_GetParam(encoder, AACENC_BITRATE) / 1000); - - m4af_add_itmf_string_tag(m4af, M4AF_TAG_TOOL, tool_info); - } if (m4af_finalize(m4af) < 0) { fprintf(stderr, "ERROR: failed to finalize m4a\n"); return -1; @@ -490,17 +648,6 @@ int finalize_m4a(m4af_writer_t *m4af, const aacenc_param_ex_t *params, return 0; } -static -const char *basename(const char *filename) -{ - char *p = strrchr(filename, '/'); -#ifdef _WIN32 - char *q = strrchr(filename, '\\'); - if (p < q) p = q; -#endif - return p ? p + 1 : filename; -} - static char *generate_output_filename(const char *filename, const char *ext) { @@ -511,7 +658,7 @@ char *generate_output_filename(const char *filename, const char *ext) p = malloc(ext_len + 6); sprintf(p, "stdin%s", ext); } else { - const char *base = basename(filename); + const char *base = aacenc_basename(filename); size_t ilen = strlen(base); const char *ext_org = strrchr(base, '.'); if (ext_org) ilen = ext_org - base; @@ -633,10 +780,10 @@ int main(int argc, char **argv) if (!params.transport_format) { uint32_t scale; unsigned framelen = aacinfo.frameLength; - int sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)¶ms); - int sig_mode = aacEncoder_GetParam(encoder, AACENC_SIGNALING_MODE); - if (sbr_mode && !sig_mode) - downsampled_timescale = 1; + int sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)¶ms); + int sig_mode = aacEncoder_GetParam(encoder, AACENC_SIGNALING_MODE); + if (sbr_mode && !sig_mode) + downsampled_timescale = 1; scale = sample_format->sample_rate >> downsampled_timescale; if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io, ofp)) < 0) goto END; @@ -645,12 +792,13 @@ int main(int argc, char **argv) framelen >> downsampled_timescale); m4af_begin_write(m4af); } - frame_count = encode(wavf, encoder, aacinfo.frameLength, ofp, m4af); + frame_count = encode(wavf, encoder, aacinfo.frameLength, ofp, m4af, + !params.silent); if (frame_count < 0) goto END; if (m4af) { uint32_t delay = aacinfo.encoderDelay; - int64_t frames_read = wav_get_position(wavf); + int64_t frames_read = wav_get_position(wavf); uint32_t padding = frame_count * aacinfo.frameLength - frames_read - aacinfo.encoderDelay; m4af_set_priming(m4af, 0, delay >> downsampled_timescale,