X-Git-Url: http://git.ieval.ro/?a=blobdiff_plain;f=src%2Fmain.c;h=4397c86bfd150dad098cd4e065dc705b7c8b5efa;hb=a56831da9f42ad230f3f7cc698067ff7d6b8d16c;hp=1f1f0dd7e32c39423b0ce30a4c0504e75b6a5709;hpb=34b319e08b3ffbf0ecc6bfea2612bd82a98dbc61;p=fdkaac.git diff --git a/src/main.c b/src/main.c index 1f1f0dd..4397c86 100644 --- a/src/main.c +++ b/src/main.c @@ -8,9 +8,15 @@ #if HAVE_STDINT_H # include #endif +#if HAVE_INTTYPES_H +# include +#elif defined(_MSC_VER) +# define SCNd64 "I64d" +#endif #include #include #include +#include #include #include #include @@ -97,12 +103,27 @@ PROGNAME " %s\n" " 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 StreamMuxConfig/PCE repetition period in\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" +" assumed)\n" +" --raw-channels Number of channels (default: 2)\n" +" --raw-rate Sample rate (default: 44100)\n" +" --raw-format 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 \n" @@ -117,12 +138,19 @@ PROGNAME " %s\n" " --track \n" " --disk \n" " --tempo \n" +" --tag : Set iTunes predefined tag with four char code.\n" +" --tag-from-file :\n" +" Same as above, but value is read from file.\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; + int is_file_name; } aacenc_tag_entry_t; typedef struct aacenc_param_ex_t { @@ -131,18 +159,53 @@ 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' }, @@ -154,28 +217,38 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) { "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': @@ -248,6 +321,29 @@ 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; + 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: @@ -260,18 +356,42 @@ 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), 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; @@ -279,6 +399,7 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) } if (argc == optind) return usage(), -1; + if (!params->bitrate && !params->bitrate_mode) { fprintf(stderr, "bitrate or bitrate-mode is mandatory\n"); return -1; @@ -290,6 +411,15 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params) } 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; }; @@ -313,7 +443,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; @@ -342,8 +473,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) @@ -354,7 +486,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); @@ -363,67 +497,194 @@ END: 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; @@ -431,17 +692,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) { @@ -452,7 +702,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; @@ -462,9 +712,45 @@ char *generate_output_filename(const char *filename, const char *ext) 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 }; @@ -493,13 +779,30 @@ int main(int argc, char **argv) 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); @@ -521,10 +824,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; @@ -533,12 +836,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,