X-Git-Url: http://git.ieval.ro/?a=blobdiff_plain;f=src%2Fmain.c;h=9aa72d0502bd5ee292ffc5d120b3c820f7c232c2;hb=9b8f9915c2cac2887e52bb38d263f171b5f7d69d;hp=84e910ecf718e2d653c9f13baaa9cd713d656989;hpb=2d744bd56cd0be236006b7e4a26c3c06442a46e1;p=fdkaac.git

diff --git a/src/main.c b/src/main.c
index 84e910e..9aa72d0 100644
--- a/src/main.c
+++ b/src/main.c
@@ -34,6 +34,7 @@
 #endif
 #include "compat.h"
 #include "wav_reader.h"
+#include "caf_reader.h"
 #include "aacenc.h"
 #include "m4af.h"
 #include "progress.h"
@@ -132,10 +133,6 @@ PROGNAME " %s\n"
 "                                 0: Off\n"
 "                                 1: On(default)\n"
 " -L, --lowdelay-sbr            Enable ELD-SBR (AAC ELD only)\n"
-" -s, --sbr-signaling <n>       SBR signaling mode\n"
-"                                 0: Implicit, backward compatible(default)\n"
-"                                 1: Explicit SBR and implicit PS\n"
-"                                 2: Explicit hierarchical signaling\n"
 " -f, --transport-format <n>    Transport format\n"
 "                                 0: RAW (default, muxed into M4A)\n"
 "                                 1: ADIF\n"
@@ -216,7 +213,9 @@ typedef struct aacenc_param_ex_t {
     unsigned raw_rate;
     const char *raw_format;
 
-    aacenc_tag_param_t tags;
+    aacenc_tag_store_t tags;
+    aacenc_tag_store_t source_tags;
+    aacenc_translate_generic_text_tag_ctx_t source_tag_ctx;
 
     char *json_filename;
 } aacenc_param_ex_t;
@@ -244,7 +243,6 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         { "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' },
         { "header-period",    required_argument, 0, 'P' },
@@ -323,13 +321,6 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         case 'L':
             params->lowdelay_sbr = 1;
             break;
-        case 's':
-            if (sscanf(optarg, "%u", &n) != 1 || n > 2) {
-                fprintf(stderr, "invalid arg for sbr-signaling\n");
-                return -1;
-            }
-            params->sbr_signaling = n;
-            break;
         case 'f':
             if (sscanf(optarg, "%u", &n) != 1) {
                 fprintf(stderr, "invalid arg for transport-format\n");
@@ -398,8 +389,8 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         case M4AF_TAG_TRACK:
         case M4AF_TAG_DISK:
         case M4AF_TAG_TEMPO:
-            aacenc_param_add_itmf_entry(&params->tags, ch, 0, optarg,
-                                        strlen(optarg), 0);
+            aacenc_add_tag_to_store(&params->tags, ch, 0, optarg,
+                                    strlen(optarg), 0);
             break;
         case OPT_SHORT_TAG:
         case OPT_SHORT_TAG_FILE:
@@ -432,9 +423,9 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
                     for (; *optarg; ++optarg)
                         fcc = ((fcc << 8) | (*optarg & 0xff));
                 }
-                aacenc_param_add_itmf_entry(&params->tags, fcc, optarg,
-                                            val, strlen(val),
-                                            ch == OPT_SHORT_TAG_FILE);
+                aacenc_add_tag_to_store(&params->tags, fcc, optarg,
+                                        val, strlen(val),
+                                        ch == OPT_SHORT_TAG_FILE);
             }
             break;
         case OPT_TAG_FROM_JSON:
@@ -493,9 +484,7 @@ int encode(pcm_reader_t *reader, HANDLE_AACENCODER encoder,
            uint32_t frame_length, FILE *ofp, m4af_ctx_t *m4af,
            int show_progress)
 {
-    uint8_t *ibuf = 0;
-    int16_t *pcmbuf = 0;
-    uint32_t pcmsize = 0;
+    int16_t *ibuf = 0;
     uint8_t *obuf = 0;
     uint32_t olen;
     uint32_t osize = 0;
@@ -515,18 +504,12 @@ int encode(pcm_reader_t *reader, HANDLE_AACENCODER encoder,
             if ((nread = pcm_read_frames(reader, ibuf, frame_length)) < 0) {
                 fprintf(stderr, "ERROR: read failed\n");
                 goto END;
-            } else if (nread > 0) {
-                if (pcm_convert_to_native_sint16(fmt, ibuf, nread,
-                                                 &pcmbuf, &pcmsize) < 0) {
-                    fprintf(stderr, "ERROR: unsupported sample format\n");
-                    goto END;
-                }
             }
             if (show_progress)
                 aacenc_progress_update(&progress, pcm_get_position(reader),
                                        fmt->sample_rate * 2);
         }
-        if ((consumed = aac_encode_frame(encoder, fmt, pcmbuf, nread,
+        if ((consumed = aac_encode_frame(encoder, fmt, ibuf, nread,
                                          &obuf, &olen, &osize)) < 0)
             goto END;
         if (olen > 0) {
@@ -541,7 +524,6 @@ int encode(pcm_reader_t *reader, HANDLE_AACENCODER encoder,
     rc = frames_written;
 END:
     if (ibuf) free(ibuf);
-    if (pcmbuf) free(pcmbuf);
     if (obuf) free(obuf);
     return rc;
 }
@@ -579,13 +561,18 @@ int finalize_m4a(m4af_ctx_t *m4af, const aacenc_param_ex_t *params,
                  HANDLE_AACENCODER encoder)
 {
     unsigned i;
-    aacenc_tag_entry_t *tag = params->tags.tag_table;
+    aacenc_tag_entry_t *tag;
+    
+    tag = params->source_tags.tag_table;
+    for (i = 0; i < params->source_tags.tag_count; ++i, ++tag)
+        aacenc_write_tag_entry(m4af, tag);
 
     if (params->json_filename)
-        aacenc_put_tags_from_json(m4af, params->json_filename);
+        aacenc_write_tags_from_json(m4af, params->json_filename);
 
+    tag = params->tags.tag_table;
     for (i = 0; i < params->tags.tag_count; ++i, ++tag)
-        aacenc_put_tag_entry(m4af, tag);
+        aacenc_write_tag_entry(m4af, tag);
 
     put_tool_tag(m4af, params, encoder);
 
@@ -652,12 +639,15 @@ int parse_raw_spec(const char *spec, pcm_sample_description_t *desc)
     return 0;
 }
 
+static pcm_io_vtbl_t pcm_io_vtbl = {
+    read_callback, seek_callback, tell_callback
+};
+static pcm_io_vtbl_t pcm_io_vtbl_noseek = { read_callback, 0, 0 };
+
 static
 pcm_reader_t *open_input(aacenc_param_ex_t *params)
 {
-    wav_io_context_t wav_io = {
-        read_callback, seek_callback, tell_callback
-    };
+    pcm_io_context_t io = { 0 };
     pcm_reader_t *reader = 0;
     struct stat stb = { 0 };
 
@@ -666,11 +656,13 @@ pcm_reader_t *open_input(aacenc_param_ex_t *params)
                        strerror(errno));
         goto END;
     }
+    io.cookie = params->input_fp;
     if (fstat(fileno(params->input_fp), &stb) == 0
-            && (stb.st_mode & S_IFMT) != S_IFREG) {
-        wav_io.seek = 0;
-        wav_io.tell = 0;
-    }
+            && (stb.st_mode & S_IFMT) == S_IFREG)
+        io.vtbl = &pcm_io_vtbl;
+    else
+        io.vtbl = &pcm_io_vtbl_noseek;
+
     if (params->is_raw) {
         int bytes_per_channel;
         pcm_sample_description_t desc = { 0 };
@@ -682,19 +674,38 @@ pcm_reader_t *open_input(aacenc_param_ex_t *params)
         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 ((reader = raw_open(&wav_io, params->input_fp, &desc)) == 0) {
+        if ((reader = raw_open(&io, &desc)) == 0) {
             fprintf(stderr, "ERROR: failed to open raw input\n");
             goto END;
         }
     } else {
-        if ((reader = wav_open(&wav_io, params->input_fp,
-                               params->ignore_length)) == 0) {
-            fprintf(stderr, "ERROR: broken / unsupported input file\n");
+        int c;
+        ungetc(c = getc(params->input_fp), params->input_fp);
+
+        switch (c) {
+        case 'R':
+            if ((reader = wav_open(&io, params->ignore_length)) == 0) {
+                fprintf(stderr, "ERROR: broken / unsupported input file\n");
+                goto END;
+            }
+            break;
+        case 'c':
+            params->source_tag_ctx.add = aacenc_add_tag_entry_to_store;
+            params->source_tag_ctx.add_ctx = &params->source_tags;
+            if ((reader = caf_open(&io,
+                                   aacenc_translate_generic_text_tag,
+                                   &params->source_tag_ctx)) == 0) {
+                fprintf(stderr, "ERROR: broken / unsupported input file\n");
+                goto END;
+            }
+            break;
+        default:
             goto END;
         }
     }
+    return pcm_open_sint16_converter(reader);
 END:
-    return reader;
+    return 0;
 }
 
 int main(int argc, char **argv)
@@ -713,6 +724,7 @@ int main(int argc, char **argv)
     const pcm_sample_description_t *sample_format;
     int downsampled_timescale = 0;
     int frame_count = 0;
+    int sbr_mode = 0;
 
     setlocale(LC_CTYPE, "");
     setbuf(stderr, 0);
@@ -725,6 +737,17 @@ int main(int argc, char **argv)
 
     sample_format = pcm_get_format(reader);
 
+    /*
+     * We use explicit/hierarchical signaling for LOAS.
+     * Other than that, we request implicit signaling to FDK library, then 
+     * append explicit/backward-compatible signaling to ASC in case of MP4FF.
+     *
+     * Explicit/backward-compatible signaling of SBR is the most recommended
+     * way in MPEG4 part3 spec, and seems the only way supported by iTunes.
+     * Since FDK library does not support it, we have to do it on our side.
+     */
+    params.sbr_signaling = (params.transport_format == TT_MP4_LOAS) ? 2 : 0;
+
     if (aacenc_init(&encoder, (aacenc_param_t*)&params, sample_format,
                     &aacinfo) < 0)
         goto END;
@@ -741,19 +764,21 @@ int main(int argc, char **argv)
         goto END;
     }
     handle_signals();
+    sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)&params);
     if (!params.transport_format) {
         uint32_t scale;
+        uint8_t mp4asc[32];
+        uint32_t ascsize = sizeof(mp4asc);
         unsigned framelen = aacinfo.frameLength;
-        int sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)&params);
-        int sig_mode = aacEncoder_GetParam(encoder, AACENC_SIGNALING_MODE);
-        if (sbr_mode && !sig_mode)
+        if (sbr_mode)
             downsampled_timescale = 1;
         scale = sample_format->sample_rate >> downsampled_timescale;
         if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io,
                                 params.output_fp)) < 0)
             goto END;
-        m4af_set_decoder_specific_info(m4af, 0, aacinfo.confBuf,
-                                       aacinfo.confSize);
+        aacenc_mp4asc((aacenc_param_t*)&params, aacinfo.confBuf,
+                      aacinfo.confSize, mp4asc, &ascsize);
+        m4af_set_decoder_specific_info(m4af, 0, mp4asc, ascsize);
         m4af_set_fixed_frame_duration(m4af, 0,
                                       framelen >> downsampled_timescale);
         m4af_set_vbr_mode(m4af, 0, params.bitrate_mode);
@@ -782,7 +807,10 @@ END:
     if (params.output_fp) fclose(params.output_fp);
     if (encoder) aacEncClose(&encoder);
     if (output_filename) free(output_filename);
-    if (params.tags.tag_table) free(params.tags.tag_table);
+    if (params.tags.tag_table)
+        aacenc_free_tag_store(&params.tags);
+    if (params.source_tags.tag_table)
+        aacenc_free_tag_store(&params.source_tags);
 
     return result;
 }