#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 <locale.h>
#include <errno.h>
#include <sys/stat.h>
static
int read_callback(void *cookie, void *data, uint32_t size)
{
- return fread(data, 1, size, (FILE*)cookie);
+ size_t rc = fread(data, 1, size, (FILE*)cookie);
+ return ferror((FILE*)cookie) ? -1 : (int)rc;
}
static
int write_callback(void *cookie, const void *data, uint32_t size)
{
- return fwrite(data, 1, size, (FILE*)cookie);
+ size_t rc = fwrite(data, 1, size, (FILE*)cookie);
+ return ferror((FILE*)cookie) ? -1 : (int)rc;
}
static
" 6: LATM MCP=1\n"
" 7: LATM MCP=0\n"
" 10: LOAS/LATM (LATM within LOAS)\n"
-" -c, --adts-crc-check Add CRC protection on ADTS header\n"
+" -C, --adts-crc-check Add CRC protection on ADTS header\n"
" -h, --header-period <n> StreamMuxConfig/PCE repetition period in\n"
" transport layer\n"
"\n"
" -o <filename> 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"
+" assumed)\n"
+" --raw-channels <n> Number of channels (default: 2)\n"
+" --raw-rate <n> Sample rate (default: 44100)\n"
+" --raw-format <spec> Sample format, default is \"S16L\".\n"
+" Spec is as follows:\n"
+" 1st char: S(igned)|U(nsigned)|F(loat)\n"
+" 2nd part: bits per channel\n"
+" Last char: L(ittle)|B(ig)\n"
+" Last char can be omitted, in which case L is\n"
+" assumed. Spec is case insensitive, therefore\n"
+" \"u16b\" is same as \"U16B\".\n"
"\n"
"Tagging options:\n"
" --title <string>\n"
" --track <number[/total]>\n"
" --disk <number[/total]>\n"
" --tempo <n>\n"
+" --tag <fcc>:<value> Set iTunes predefined tag with four char code.\n"
+" --tag-from-file <fcc>:<filename>\n"
+" Same as above, but value is read from file.\n"
+" --long-tag <name>:<value> 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;
+ int is_file_name;
} aacenc_tag_entry_t;
typedef struct aacenc_param_ex_t {
char *input_filename;
char *output_filename;
unsigned ignore_length;
+ int silent;
+
+ int is_raw;
+ unsigned raw_channels;
+ unsigned raw_rate;
+ const char *raw_format;
aacenc_tag_entry_t *tag_table;
unsigned tag_count;
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,
+ int is_file_name)
+{
+ 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;
+ entry->is_file_name = is_file_name;
+ 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_SHORT_TAG_FILE M4AF_FOURCC('s','t','g','f')
+#define OPT_LONG_TAG M4AF_FOURCC('l','t','a','g')
static struct option long_options[] = {
{ "help", no_argument, 0, 'h' },
{ "profile", required_argument, 0, 'p' },
{ "bitrate", required_argument, 0, 'b' },
- { "biterate-mode", required_argument, 0, 'm' },
+ { "bitrate-mode", required_argument, 0, 'm' },
{ "bandwidth", required_argument, 0, 'w' },
{ "afterburner", required_argument, 0, 'a' },
{ "lowdelay-sbr", no_argument, 0, 'L' },
{ "sbr-signaling", required_argument, 0, 's' },
{ "transport-format", required_argument, 0, 'f' },
- { "adts-crc-check", no_argument, 0, 'c' },
+ { "adts-crc-check", no_argument, 0, 'C' },
{ "header-period", required_argument, 0, 'P' },
- { "ignore-length", no_argument, 0, 'I' },
-
- { "title", required_argument, 0, M4AF_TAG_TITLE },
- { "artist", required_argument, 0, M4AF_TAG_ARTIST },
- { "album", required_argument, 0, M4AF_TAG_ALBUM },
- { "genre", required_argument, 0, M4AF_TAG_GENRE },
- { "date", required_argument, 0, M4AF_TAG_DATE },
- { "composer", required_argument, 0, M4AF_TAG_COMPOSER },
- { "grouping", required_argument, 0, M4AF_TAG_GROUPING },
- { "comment", required_argument, 0, M4AF_TAG_COMMENT },
- { "album-artist", required_argument, 0, M4AF_TAG_ALBUM_ARTIST },
- { "track", required_argument, 0, M4AF_TAG_TRACK },
- { "disk", required_argument, 0, M4AF_TAG_DISK },
- { "tempo", required_argument, 0, M4AF_TAG_TEMPO },
+ { "ignorelength", no_argument, 0, 'I' },
+ { "silent", no_argument, 0, 'S' },
+
+ { "raw", no_argument, 0, 'R' },
+ { "raw-channels", required_argument, 0, OPT_RAW_CHANNELS },
+ { "raw-rate", required_argument, 0, OPT_RAW_RATE },
+ { "raw-format", required_argument, 0, OPT_RAW_FORMAT },
+
+ { "title", required_argument, 0, M4AF_TAG_TITLE },
+ { "artist", required_argument, 0, M4AF_TAG_ARTIST },
+ { "album", required_argument, 0, M4AF_TAG_ALBUM },
+ { "genre", required_argument, 0, M4AF_TAG_GENRE },
+ { "date", required_argument, 0, M4AF_TAG_DATE },
+ { "composer", required_argument, 0, M4AF_TAG_COMPOSER },
+ { "grouping", required_argument, 0, M4AF_TAG_GROUPING },
+ { "comment", required_argument, 0, M4AF_TAG_COMMENT },
+ { "album-artist", required_argument, 0, M4AF_TAG_ALBUM_ARTIST },
+ { "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 },
+ { "tag-from-file", required_argument, 0, OPT_SHORT_TAG_FILE },
+ { "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:",
+ while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:CP:Io:SR",
long_options, 0)) != EOF) {
switch (ch) {
case 'h':
case 'I':
params->ignore_length = 1;
break;
+ case 'S':
+ params->silent = 1;
+ break;
+ case 'R':
+ params->is_raw = 1;
+ break;
+ case OPT_RAW_CHANNELS:
+ if (sscanf(optarg, "%u", &n) != 1) {
+ fprintf(stderr, "invalid arg for raw-channels\n");
+ return -1;
+ }
+ params->raw_channels = n;
+ break;
+ case OPT_RAW_RATE:
+ if (sscanf(optarg, "%u", &n) != 1) {
+ fprintf(stderr, "invalid arg for raw-rate\n");
+ return -1;
+ }
+ params->raw_rate = n;
+ break;
+ case OPT_RAW_FORMAT:
+ params->raw_format = optarg;
+ break;
case M4AF_TAG_TITLE:
case M4AF_TAG_ARTIST:
case M4AF_TAG_ALBUM:
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), 0);
+ break;
+ case OPT_SHORT_TAG:
+ case OPT_SHORT_TAG_FILE:
+ 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 || ch == OPT_SHORT_TAG_FILE) {
+ /*
+ * 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),
+ ch == OPT_SHORT_TAG_FILE);
}
- tag = params->tag_table + params->tag_count;
- tag->tag = ch;
- tag->data = optarg;
- params->tag_count++;
break;
default:
return usage(), -1;
}
if (argc == optind)
return usage(), -1;
+
if (!params->bitrate && !params->bitrate_mode) {
fprintf(stderr, "bitrate or bitrate-mode is mandatory\n");
return -1;
}
if (params->bitrate && params->bitrate < 10000)
params->bitrate *= 1000;
+
+ if (params->is_raw) {
+ if (!params->raw_channels)
+ params->raw_channels = 2;
+ if (!params->raw_rate)
+ params->raw_rate = 44100;
+ if (!params->raw_format)
+ params->raw_format = "S16L";
+ }
params->input_filename = argv[optind];
return 0;
};
const void *data, uint32_t size, uint32_t duration)
{
if (!m4af) {
- if (fwrite(data, 1, size, ofp) < 0) {
+ fwrite(data, 1, size, ofp);
+ if (ferror(ofp)) {
fprintf(stderr, "ERROR: fwrite(): %s\n", strerror(errno));
return -1;
}
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;
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)
++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);
return rc;
}
+static
+char *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
+void put_tag_entry(m4af_writer_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 = 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);
+}
+
+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;
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)
{
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;
return p;
}
+static
+int parse_raw_spec(const char *spec, pcm_sample_description_t *desc)
+{
+ unsigned bits;
+ unsigned char c_type, c_endian = 'L';
+ int type;
+
+ if (sscanf(spec, "%c%u%c", &c_type, &bits, &c_endian) < 2)
+ return -1;
+ c_type = toupper(c_type);
+ c_endian = toupper(c_endian);
+
+ if (c_type == 'S')
+ type = 1;
+ else if (c_type == 'U')
+ type = 2;
+ else if (c_type == 'F')
+ type = 4;
+ else
+ return -1;
+
+ if (c_endian == 'B')
+ type |= 8;
+ else if (c_endian != 'L')
+ return -1;
+
+ if (c_type == 'F' && bits != 32 && bits != 64)
+ return -1;
+ if (c_type != 'F' && (bits < 8 || bits > 32))
+ return -1;
+
+ desc->sample_type = type;
+ desc->bits_per_channel = bits;
+ return 0;
+}
+
int main(int argc, char **argv)
{
- wav_io_context_t wav_io = { read_callback, seek_callback };
+ wav_io_context_t wav_io = { read_callback, seek_callback, tell_callback };
m4af_io_callbacks_t m4af_io = {
write_callback, seek_callback, tell_callback };
aacenc_param_ex_t params = { 0 };
strerror(errno));
goto END;
}
-
- if (fstat(fileno(ifp), &stb) == 0 && (stb.st_mode & S_IFMT) != S_IFREG)
+ if (fstat(fileno(ifp), &stb) == 0 && (stb.st_mode & S_IFMT) != S_IFREG) {
wav_io.seek = 0;
-
- if ((wavf = wav_open(&wav_io, ifp, params.ignore_length)) == 0) {
- fprintf(stderr, "ERROR: broken / unsupported input file\n");
- goto END;
+ wav_io.tell = 0;
+ }
+ if (!params.is_raw) {
+ if ((wavf = wav_open(&wav_io, ifp, params.ignore_length)) == 0) {
+ fprintf(stderr, "ERROR: broken / unsupported input file\n");
+ goto END;
+ }
+ } else {
+ int bytes_per_channel;
+ pcm_sample_description_t desc = { 0 };
+ if (parse_raw_spec(params.raw_format, &desc) < 0) {
+ fprintf(stderr, "ERROR: invalid raw-format spec\n");
+ goto END;
+ }
+ desc.sample_rate = params.raw_rate;
+ desc.channels_per_frame = params.raw_channels;
+ bytes_per_channel = (desc.bits_per_channel + 7) / 8;
+ desc.bytes_per_frame = params.raw_channels * bytes_per_channel;
+ if ((wavf = raw_open(&wav_io, ifp, &desc)) == 0) {
+ fprintf(stderr, "ERROR: failed to open raw input\n");
+ goto END;
+ }
}
sample_format = wav_get_format(wavf);
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;
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,
projects / fdkaac.git / blobdiff