bump version

Instead, we always use explicit/backward compatible SBR signaling by
ASC extension in case of m4a, which is not supported by FDK library
(so we do it on our side).
For LOAS, we use explicit hierarchical signaling.

ChangeLog

@@ -0,0 +1,226 @@
+2013-10-25  nu774 <honeycomb77@gmail.com>
+
+  * update ChangeLog [HEAD]
+
+  * bump version [v0.4.0]
+
+  * update README
+
+2013-10-24  nu774 <honeycomb77@gmail.com>
+
+  * caf input support
+
+  * refactor pcm io routines
+
+2013-10-23  nu774 <honeycomb77@gmail.com>
+
+  * cleanup metadata handling
+
+  * --tag-from-json: properly support number/total format in json track field
+
+2013-10-22  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.3.3]
+
+  * fixed bogus sgpd written on --gapless-mode=1 and 2
+
+2013-10-21  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.3.2]
+
+2013-10-20  nu774 <honeycomb77@gmail.com>
+
+  * reimplement int16 conversion as pcm_reader
+
+  * add abstraction layer for pcm reading
+
+  * improve handling of avgBitrate
+
+2013-10-19  nu774 <honeycomb77@gmail.com>
+
+  * update ChangeLog and git2changelog.py
+
+2013-10-18  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.3.1]
+
+  * update README
+
+  * set avgBitrate field to zero for 14496-1 compliance
+
+2013-09-07  nu774 <honeycomb77@gmail.com>
+
+  * updated ChangeLog with new git2changelog.py
+
+2013-06-14  nu774 <honeycomb77@gmail.com>
+
+  * add --moov-before-mdat [v0.3.0]
+
+2013-03-04  nu774 <honeycomb77@gmail.com>
+
+  * fix an error message
+
+2013-03-03  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.2.0]
+
+  * add --gapless-mode
+
+2013-02-20  nu774 <honeycomb77@gmail.com>
+
+  * simplify __timeb64 condition
+
+  * use fseeko64() on i686-pc-mingw32
+
+2013-02-18  nu774 <honeycomb77@gmail.com>
+
+  * fix build issue on i686-pc-mingw (struct __timeb64 is missing)
+
+2013-02-17  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.9]
+
+  * fix to accept option -C
+
+2013-02-16  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.8]
+
+  * refine json metadata importing
+
+  * m4af: duplication check on adding tags
+
+2013-02-15  nu774 <honeycomb77@gmail.com>
+
+  * add --tag-from-json [v0.1.7]
+
+  * fix implicit int variable decl.
+
+  * update m4af
+
+2013-02-03  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.6]
+
+  * win32: change _wfopen() -> wfsopen()
+
+2013-01-30  nu774 <honeycomb77@gmail.com>
+
+  * update README (add note for character encoding)
+
+2013-01-28  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.5]
+
+  * gracefully shutdown on signals
+
+2013-01-27  nu774 <honeycomb77@gmail.com>
+
+  * fix MSVC project build issue
+
+2013-01-25  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.4]
+
+  * add --tag-from-file
+
+2013-01-24  nu774 <honeycomb77@gmail.com>
+
+  * add --silent
+
+2013-01-19  nu774 <honeycomb77@gmail.com>
+
+  * retab
+
+  * bump version [v0.1.3]
+
+  * fix crash on wrong long option, rename --ignore-length to --ignorelength
+
+2013-01-17  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.2]
+
+  * compat_win32: free argv with atexit()
+
+  * take care of COPYRIGHT-SIGN in UTF-8
+
+2013-01-15  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.1.1]
+
+  * fix return type of put_type_entry() to void
+
+  * add ADTS header size(7) to output byte length
+
+2013-01-13  nu774 <honeycomb77@gmail.com>
+
+  * fix mp4 duration & version calcuration [v0.1.0]
+
+2013-01-11  nu774 <honeycomb77@gmail.com>
+
+  * add support for xid
+
+  * support for i686-pc-mingw32 (missing _vscprintf)
+
+2013-01-10  nu774 <honeycomb77@gmail.com>
+
+  * bump version [v0.0.9]
+
+  * rename basename() -> aacenc_basename() and move to compat layer
+
+2013-01-09  nu774 <honeycomb77@gmail.com>
+
+  * add --tag and --long-tag
+
+  * fix corner case of progress display
+
+  * calculate length from file size
+
+  * raw input support
+
+2013-01-08  nu774 <honeycomb77@gmail.com>
+
+  * insert a white space in progress message
+
+2013-01-07  nu774 <honeycomb77@gmail.com>
+
+  * fix typo of bitrate-mode option [v0.0.8]
+
+  * more static inlining (missed on the previous commit) [v0.0.7]
+
+  * check error of fread() and fwrite() [v0.0.6]
+
+  * change inline->static inline to follow C99 semantics (for Clang)
+
+  * explicitly add -lfdk-aac to LDADD in Makefile.am
+
+  * add some files to EXTRA_DIST in Makefile.am
+
+  * fixed a typo in usage message [v0.0.5]
+
+2013-01-06  nu774 <honeycomb77@gmail.com>
+
+  * add MSVC projects
+
+  * add .gitattributes
+
+  * more tweak on configure.ac and Makefile.am (take care of getopt_long) [v0.0.4]
+
+  * use fstat() to test seekability of input file
+
+  * retrieve bitrate for tool tag with aacEncoder_GetParam()
+
+  * output to current working directory by default
+
+2013-01-05  nu774 <honeycomb77@gmail.com>
+
+  * zero clear LIB_INFO before calling aacEncGetLibInfo() [v0.0.3]
+
+  * tweak configure.ac and Makefile.am
+
+  * update version.h [v0.0.2]
+
+  * fixed to clip before converting float to int
+
+  * initial commit [v0.0.1]
+

MSVC/fdkaac.vcxproj

@@ -96,12 +96,15 @@ copy ..\fdk-aac\libSYS\include\machine_type.h include\fdk-aac\ </Command>
   <ItemGroup>
     <ClCompile Include="..\missings\getopt.c" />
     <ClCompile Include="..\src\aacenc.c" />
+    <ClCompile Include="..\src\caf_reader.c" />
     <ClCompile Include="..\src\compat_win32.c" />
     <ClCompile Include="..\src\lpcm.c" />
     <ClCompile Include="..\src\m4af.c" />
     <ClCompile Include="..\src\main.c" />
     <ClCompile Include="..\src\metadata.c" />
     <ClCompile Include="..\src\parson.c" />
+    <ClCompile Include="..\src\pcm_readhelper.c" />
+    <ClCompile Include="..\src\pcm_sint16_converter.c" />
     <ClCompile Include="..\src\progress.c" />
     <ClCompile Include="..\src\wav_reader.c" />
   </ItemGroup>
@@ -114,6 +117,7 @@ copy ..\fdk-aac\libSYS\include\machine_type.h include\fdk-aac\ </Command>
     <ClInclude Include="..\src\m4af_endian.h" />
     <ClInclude Include="..\src\metadata.h" />
     <ClInclude Include="..\src\parson.h" />
+    <ClInclude Include="..\src\pcm_reader.h" />
     <ClInclude Include="..\src\progress.h" />
     <ClInclude Include="..\src\wav_reader.h" />
   </ItemGroup>

MSVC/fdkaac.vcxproj.filters

@@ -18,6 +18,9 @@
     <ClCompile Include="..\src\aacenc.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\caf_reader.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\src\compat_win32.c">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -30,6 +33,12 @@
     <ClCompile Include="..\src\main.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\pcm_readhelper.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\pcm_sint16_converter.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\src\progress.c">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -44,6 +53,12 @@
     <ClInclude Include="..\src\aacenc.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\src\caf_reader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\catypes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="..\src\compat.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -56,6 +71,9 @@
     <ClInclude Include="..\src\m4af_endian.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\src\pcm_reader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="..\src\progress.h">
       <Filter>Header Files</Filter>
     </ClInclude>

Makefile.am

@@ -5,11 +5,14 @@ bin_PROGRAMS = fdkaac
 
 fdkaac_SOURCES = \
     src/aacenc.c               \
+    src/caf_reader.c           \
     src/lpcm.c                 \
     src/m4af.c                 \
     src/main.c                 \
     src/metadata.c             \
     src/parson.c               \
+    src/pcm_readhelper.c       \
+    src/pcm_sint16_converter.c \
     src/progress.c             \
     src/wav_reader.c
 

README

@@ -32,6 +32,26 @@ look like the following:
 
 MSVC solution for Visual Studio 2010 is under MSVC directory.
 
+Available input format
+----------------------
+WAV, RF64, CAF, RAW, upto 32bit int / 64bit float format is supported.
+Metadata in CAF info chunk can be read and copied to the resulting m4a.
+This is especially useful and works well when you pipe from ffmpeg via CAF.
+For example, you can copy tag from original "foo.flac" to "foo.m4a"
+through the following pipeline:
+
+$ ffmpeg -i foo.flac -f caf - | fdkaac -m3 - -o foo.m4a
+
+Since FDK AAC encoder is implemented based on fixed point integer,
+encoder itself handles 16bit input only.
+Therefore, when feeding non-integer input, be careful so that input doesn't
+exceed 0dBFS to avoid hard clips.
+You might also want to apply dither/noise shape beforehand when your input
+has higher resolution.
+
+Note that fdkaac doesn't automatically resample for you
+when input samplerate is not supported by AAC spec.
+
 Tagging Options
 ---------------
 Generic tagging options like --tag, --tag-from-file, --long-tag allows you

configure.ac

@@ -31,8 +31,9 @@ AC_TYPE_UINT8_T
 AC_CHECK_TYPES([ptrdiff_t])
 
 AC_SYS_LARGEFILE
+AC_CHECK_TYPES([struct __timeb64],[],[],[[#include <sys/timeb.h>]])
 AC_FUNC_FSEEKO
-AC_CHECK_FUNCS([sigaction gettimeofday nl_langinfo strdup _vscprintf])
+AC_CHECK_FUNCS([sigaction gettimeofday nl_langinfo _vscprintf fseeko64])
 AC_CHECK_FUNC(getopt_long)
 AM_CONDITIONAL([FDK_NO_GETOPT_LONG],[test "$ac_cv_func_getopt_long" != "yes"])
 AC_SEARCH_LIBS([aacEncOpen],[fdk-aac],[],[],[])

git2changelog.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+# Copyright (C) 2013 nu774
+# For conditions of distribution and use, see copyright notice in COPYING
+
+import sys
+import re
+from subprocess import Popen, PIPE
+from itertools import groupby
+from collections import namedtuple
+
+GITLOG_FMT = 'commit %H%nauthor %cn <%ae>%ndate %ad%nsubject %s%nref %d%n%n'
+GITLOG_CMD = ['git','log','--date=short','--format={0}'.format(GITLOG_FMT)]
+
+Commit = namedtuple('Commit', 'commit author date subject ref')
+
+def parse_gitlog(stream):
+    re_decode_ref = re.compile(r'(?<=\()([^,)]+)')
+    re_strip_tag = re.compile(r'^tag: ')
+    commit = dict()
+    for line in stream:
+        fields = line.decode('utf-8').rstrip('\r\n').split(' ', 1)
+        if len(fields) == 2:
+            key, value = fields
+            if key == 'ref':
+                m = re_decode_ref.search(value)
+                if m:
+                    value = ' [{0}]'.format(re_strip_tag.sub('', m.group()))
+                else:
+                    value = ''
+            commit[key] = value
+        elif commit:
+            yield Commit(**commit) 
+            commit = dict()
+
+output=sys.stdout.write
+
+with Popen(GITLOG_CMD, shell=False, stdout=PIPE).stdout as pipe:
+    commits = parse_gitlog(pipe)
+    commits_by_date_author = groupby(commits, key=lambda x: (x.date, x.author))
+    for (date, author), commits in commits_by_date_author:
+        output('{0}  {1}\n\n'.format(date, author))
+        for c in commits:
+            output('  * {0}{1}\n\n'.format(c.subject, c.ref))

src/aacenc.c

@@ -10,6 +10,7 @@
 #endif
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include "aacenc.h"
 
 int aacenc_is_sbr_active(const aacenc_param_t *params)
@@ -25,6 +26,68 @@ int aacenc_is_sbr_active(const aacenc_param_t *params)
     return 0;
 }
 
+static const unsigned aacenc_sampling_freq_tab[] = {
+    96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 
+    16000, 12000, 11025, 8000, 7350, 0, 0, 0
+};
+
+static
+unsigned sampling_freq_index(unsigned rate)
+{
+    unsigned i;
+    for (i = 0; aacenc_sampling_freq_tab[i]; ++i)
+        if (aacenc_sampling_freq_tab[i] == rate)
+            return i;
+    return 0xf;
+}
+
+/*
+ * Append backward compatible SBR/PS signaling to implicit signaling ASC,
+ * if SBR/PS is present.
+ */
+int aacenc_mp4asc(const aacenc_param_t *params,
+                  const uint8_t *asc, uint32_t ascsize,
+                  uint8_t *outasc, uint32_t *outsize)
+{
+    unsigned asc_sfreq = aacenc_sampling_freq_tab[(asc[0]&0x7)<<1 |asc[1]>>7];
+
+    switch (params->profile) {
+    case AOT_SBR:
+    case AOT_PS:
+        if (*outsize < ascsize + 3)
+            return -1;
+        memcpy(outasc, asc, ascsize);
+        /* syncExtensionType:11 (value:0x2b7) */
+        outasc[ascsize+0] = 0x2b << 1;
+        outasc[ascsize+1] = 0x7 << 5;
+        /* extensionAudioObjectType:5 (value:5)*/
+        outasc[ascsize+1] |= 5;
+        /* sbrPresentFlag:1 (value:1) */
+        outasc[ascsize+2] = 0x80;
+        /* extensionSamplingFrequencyIndex:4 */
+        outasc[ascsize+2] |= sampling_freq_index(asc_sfreq << 1) << 3;
+        if (params->profile == AOT_SBR) {
+            *outsize = ascsize + 3;
+            break;
+        }
+        if (*outsize < ascsize + 5)
+            return -1;
+        /* syncExtensionType:11 (value:0x548) */
+        outasc[ascsize+2] |= 0x5;
+        outasc[ascsize+3] = 0x48;
+        /* psPresentFlag:1 (value:1) */
+        outasc[ascsize+4] = 0x80;
+        *outsize = ascsize + 5;
+        break;
+    default:
+        if (*outsize < ascsize)
+            return -1;
+        memcpy(outasc, asc, ascsize);
+        *outsize = ascsize;
+    }
+    return 0;
+}
+
 static
 int aacenc_channel_mode(const pcm_sample_description_t *format)
 {
@@ -97,7 +160,7 @@ int aacenc_init(HANDLE_AACENCODER *encoder, const aacenc_param_t *params,
     }
     if (aacEncoder_SetParam(*encoder, AACENC_SIGNALING_MODE,
                             params->sbr_signaling) != AACENC_OK) {
-        fprintf(stderr, "ERROR: unsupported transport format\n");
+        fprintf(stderr, "ERROR: failed to set SBR signaling mode\n");
         goto FAIL;
     }
     if (params->adts_crc_check)

src/aacenc.h

@@ -26,6 +26,10 @@ typedef struct aacenc_param_t {
 
 int aacenc_is_sbr_active(const aacenc_param_t *params);
 
+int aacenc_mp4asc(const aacenc_param_t *params,
+                  const uint8_t *asc, uint32_t ascsize,
+                  uint8_t *outasc, uint32_t *outsize);
+
 int aacenc_init(HANDLE_AACENCODER *encoder, const aacenc_param_t *params,
                 const pcm_sample_description_t *format,
                 AACENC_InfoStruct *info);

src/caf_reader.c

@@ -0,0 +1,253 @@
+/* 
+ * 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
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include "caf_reader.h"
+#include "m4af.h"
+
+typedef struct caf_reader_t {
+    pcm_reader_vtbl_t *vtbl;
+    pcm_sample_description_t sample_format;
+    int64_t length;
+    int64_t position;
+    int64_t data_offset;
+    pcm_io_context_t io;
+    aacenc_tag_callback_t tag_callback;
+    void *tag_ctx;
+    uint8_t chanmap[8];
+} caf_reader_t;
+
+static const pcm_sample_description_t *caf_get_format(pcm_reader_t *reader)
+{
+    return &((caf_reader_t *)reader)->sample_format;
+}
+
+static int64_t caf_get_length(pcm_reader_t *reader)
+{
+    return ((caf_reader_t *)reader)->length;
+}
+
+static int64_t caf_get_position(pcm_reader_t *reader)
+{
+    return ((caf_reader_t *)reader)->position;
+}
+
+static void caf_teardown(pcm_reader_t **reader)
+{
+    free(*reader);
+    *reader = 0;
+}
+
+static
+uint32_t caf_next_chunk(caf_reader_t *reader, int64_t *chunk_size)
+{
+    uint32_t fcc;
+    if (pcm_scanb(&reader->io, "LQ", &fcc, chunk_size) == 2)
+        return fcc;
+    return 0;
+}
+
+static
+int caf_desc(caf_reader_t *reader, int64_t chunk_size)
+{
+    double mSampleRate;
+    uint32_t mFormatID, mFormatFlags, mBytesPerPacket, mFramesPerPacket,
+             mChannelsPerFrame, mBitsPerChannel;
+    pcm_sample_description_t *desc = &reader->sample_format;
+
+    ENSURE(chunk_size >= 32);
+    TRY_IO(pcm_scanb(&reader->io, "QLLLLLL", &mSampleRate, &mFormatID,
+                     &mFormatFlags, &mBytesPerPacket, &mFramesPerPacket,
+                     &mChannelsPerFrame, &mBitsPerChannel) != 7);
+
+    ENSURE(mFormatID == M4AF_FOURCC('l','p','c','m'));
+    ENSURE(mSampleRate && mBytesPerPacket &&
+           mChannelsPerFrame >= 1 && mChannelsPerFrame <= 8 &&
+           mBitsPerChannel && mFramesPerPacket == 1 &&
+           mBytesPerPacket % mChannelsPerFrame == 0 &&
+           mBytesPerPacket >= mChannelsPerFrame * ((mBitsPerChannel + 7) / 8));
+
+    desc->sample_rate        = mSampleRate;
+    desc->bits_per_channel   = mBitsPerChannel;
+    desc->bytes_per_frame    = mBytesPerPacket;
+    desc->channels_per_frame = mChannelsPerFrame;
+
+    switch (mFormatFlags) {
+    case 0: desc->sample_type = PCM_TYPE_SINT_BE;  break;
+    case 1: desc->sample_type = PCM_TYPE_FLOAT_BE; break;
+    case 2: desc->sample_type = PCM_TYPE_SINT;     break;
+    case 3: desc->sample_type = PCM_TYPE_FLOAT;    break;
+    default: goto FAIL;
+    }
+
+    TRY_IO(pcm_skip(&reader->io, chunk_size - 32));
+    return 0;
+FAIL:
+    return -1;
+}
+
+static
+int caf_info(caf_reader_t *reader, int64_t chunk_size)
+{
+    char *buf, *key, *val, *end;
+    size_t len;
+
+    if (chunk_size < 4 || (buf = malloc(chunk_size)) == 0)
+        return -1;
+    pcm_read(&reader->io, buf, chunk_size);
+    key = buf + 4;
+    end = buf + chunk_size;
+    do {
+        if ((val = key + strlen(key) + 1) < end) {
+            len = strlen(val);
+            if (reader->tag_callback)
+                reader->tag_callback(reader->tag_ctx, key, val, len);
+            key = val + len + 1;
+        }
+    } while (key < end && val < end);
+
+    if (reader->tag_callback)
+        reader->tag_callback(reader->tag_ctx, 0, 0, 0);
+    free(buf);
+    return 0;
+}
+
+static
+int caf_read_frames(pcm_reader_t *preader, void *buffer, unsigned nframes)
+{
+    int rc;
+    unsigned i, j, nbytes;
+    caf_reader_t *reader = (caf_reader_t *)preader;
+    unsigned bpf = reader->sample_format.bytes_per_frame;
+    unsigned nchannels = reader->sample_format.channels_per_frame;
+    unsigned bpc = bpf / nchannels;
+    uint8_t tmp[64]; /* enough room for maximum bpf: 8ch float64 */
+    uint8_t *bp;
+    uint8_t *chanmap = reader->chanmap;
+
+    if (nframes > reader->length - reader->position)
+        nframes = reader->length - reader->position;
+    nbytes = nframes * bpf;
+    if (nbytes) {
+        if ((rc = pcm_read(&reader->io, buffer, nbytes)) < 0)
+            return -1;
+        nframes = rc / bpf;
+        for (bp = buffer, i = 0; i < nframes; ++i, bp += bpf) {
+            memcpy(tmp, bp, bpf);
+            for (j = 0; j < nchannels; ++j)
+                memcpy(bp + bpc * j, tmp + bpc * chanmap[j], bpc);
+        }
+        reader->position += nframes;
+    }
+    if (nframes == 0) {
+        /* fetch info after data chunk */
+        uint32_t fcc;
+        int64_t chunk_size;
+        while ((fcc = caf_next_chunk(reader, &chunk_size)) != 0) {
+            if (fcc == M4AF_FOURCC('i','n','f','o'))
+                TRY_IO(caf_info(reader, chunk_size));
+            else
+                TRY_IO(pcm_skip(&reader->io, chunk_size));
+        }
+    }
+    return nframes;
+FAIL:
+    return 0;
+}
+
+static
+int caf_parse(caf_reader_t *reader, int64_t *data_length)
+{
+    uint32_t fcc;
+    int64_t chunk_size;
+
+    *data_length = 0;
+
+    /* CAFFileHeader */
+    TRY_IO(pcm_read32be(&reader->io, &fcc));
+    ENSURE(fcc == M4AF_FOURCC('c','a','f','f'));
+    TRY_IO(pcm_skip(&reader->io, 4)); /* mFileVersion, mFileFlags */
+
+    while ((fcc = caf_next_chunk(reader, &chunk_size)) != 0) {
+        if (fcc == M4AF_FOURCC('d','e','s','c'))
+            TRY_IO(caf_desc(reader, chunk_size));
+        else if (fcc == M4AF_FOURCC('i','n','f','o'))
+            TRY_IO(caf_info(reader, chunk_size));
+        else if (fcc == M4AF_FOURCC('c','h','a','n')) {
+            ENSURE(reader->sample_format.channels_per_frame);
+            if (apple_chan_chunk(&reader->io, chunk_size,
+                                 &reader->sample_format, reader->chanmap) < 0)
+                goto FAIL;
+        } else if (fcc == M4AF_FOURCC('d','a','t','a')) {
+            TRY_IO(pcm_skip(&reader->io, 4)); /* mEditCount */
+            *data_length = (chunk_size == ~0ULL) ? chunk_size : chunk_size - 4;
+            reader->data_offset += 12;
+            break;
+        } else
+            TRY_IO(pcm_skip(&reader->io, chunk_size));
+
+        reader->data_offset += (chunk_size + 8);
+    }
+    ENSURE(reader->sample_format.channels_per_frame);
+    ENSURE(fcc == M4AF_FOURCC('d','a','t','a'));
+    return 0;
+FAIL:
+    return -1;
+}
+
+static pcm_reader_vtbl_t caf_vtable = {
+    caf_get_format,
+    caf_get_length,
+    caf_get_position,
+    caf_read_frames,
+    caf_teardown
+};
+
+pcm_reader_t *caf_open(pcm_io_context_t *io,
+                       aacenc_tag_callback_t tag_callback, void *tag_ctx)
+{
+    caf_reader_t *reader = 0;
+    int64_t data_length;
+    unsigned bpf;
+
+    if ((reader = calloc(1, sizeof(caf_reader_t))) == 0)
+        return 0;
+    memcpy(&reader->io, io, sizeof(pcm_io_context_t));
+    reader->tag_callback = tag_callback;
+    reader->tag_ctx = tag_ctx;
+
+    if (caf_parse(reader, &data_length) < 0) {
+        free(reader);
+        return 0;
+    }
+    bpf = reader->sample_format.bytes_per_frame;
+
+    /* CAF uses -1 to indicate "unknown size" */
+    if (data_length < 0 || data_length % bpf)
+        reader->length = INT64_MAX;
+    else
+        reader->length = data_length / bpf;
+
+    if (reader->length == INT64_MAX) {
+        if (pcm_seek(&reader->io, 0, SEEK_END) >= 0) {
+            int64_t size = pcm_tell(&reader->io);
+            if (size > 0)
+                reader->length = (size - reader->data_offset) / bpf;
+            pcm_seek(&reader->io, reader->data_offset, SEEK_SET);
+        }
+    }
+    reader->vtbl = &caf_vtable;
+    return (pcm_reader_t *)reader;
+}

src/caf_reader.h

@@ -0,0 +1,15 @@
+/* 
+ * Copyright (C) 2013 nu774
+ * For conditions of distribution and use, see copyright notice in COPYING
+ */
+#ifndef CAF_READER_H
+#define CAF_READER_H
+
+#include "lpcm.h"
+#include "pcm_reader.h"
+#include "metadata.h"
+
+pcm_reader_t *caf_open(pcm_io_context_t *io,
+                       aacenc_tag_callback_t tag_callback, void *tag_ctx);
+
+#endif

src/catypes.h

@@ -0,0 +1,241 @@
+#if !defined(__CoreAudioTypes_h__)
+#define __CoreAudioTypes_h__
+
+enum { kVariableLengthArray = 1 };
+
+typedef uint32_t AudioChannelLabel;
+typedef uint32_t AudioChannelLayoutTag;
+
+struct AudioChannelDescription
+{
+    AudioChannelLabel mChannelLabel;
+    uint32_t          mChannelFlags;
+    float             mCoordinates[3];
+};
+typedef struct AudioChannelDescription AudioChannelDescription;
+
+struct AudioChannelLayout
+{
+    AudioChannelLayoutTag       mChannelLayoutTag;
+    uint32_t                    mChannelBitmap;
+    uint32_t                    mNumberChannelDescriptions;
+    AudioChannelDescription     mChannelDescriptions[kVariableLengthArray];
+};
+typedef struct AudioChannelLayout AudioChannelLayout;
+
+enum
+{
+    kAudioChannelLabel_Unknown                  = 0xFFFFFFFF,   // unknown or unspecified other use
+    kAudioChannelLabel_Unused                   = 0,            // channel is present, but has no intended use or destination
+    kAudioChannelLabel_UseCoordinates           = 100,          // channel is described by the mCoordinates fields.
+
+    kAudioChannelLabel_Left                     = 1,
+    kAudioChannelLabel_Right                    = 2,
+    kAudioChannelLabel_Center                   = 3,
+    kAudioChannelLabel_LFEScreen                = 4,
+    kAudioChannelLabel_LeftSurround             = 5,            // WAVE: "Back Left"
+    kAudioChannelLabel_RightSurround            = 6,            // WAVE: "Back Right"
+    kAudioChannelLabel_LeftCenter               = 7,
+    kAudioChannelLabel_RightCenter              = 8,
+    kAudioChannelLabel_CenterSurround           = 9,            // WAVE: "Back Center" or plain "Rear Surround"
+    kAudioChannelLabel_LeftSurroundDirect       = 10,           // WAVE: "Side Left"
+    kAudioChannelLabel_RightSurroundDirect      = 11,           // WAVE: "Side Right"
+    kAudioChannelLabel_TopCenterSurround        = 12,
+    kAudioChannelLabel_VerticalHeightLeft       = 13,           // WAVE: "Top Front Left"
+    kAudioChannelLabel_VerticalHeightCenter     = 14,           // WAVE: "Top Front Center"
+    kAudioChannelLabel_VerticalHeightRight      = 15,           // WAVE: "Top Front Right"
+
+    kAudioChannelLabel_TopBackLeft              = 16,
+    kAudioChannelLabel_TopBackCenter            = 17,
+    kAudioChannelLabel_TopBackRight             = 18,
+
+    kAudioChannelLabel_RearSurroundLeft         = 33,
+    kAudioChannelLabel_RearSurroundRight        = 34,
+    kAudioChannelLabel_LeftWide                 = 35,
+    kAudioChannelLabel_RightWide                = 36,
+    kAudioChannelLabel_LFE2                     = 37,
+    kAudioChannelLabel_LeftTotal                = 38,           // matrix encoded 4 channels
+    kAudioChannelLabel_RightTotal               = 39,           // matrix encoded 4 channels
+    kAudioChannelLabel_HearingImpaired          = 40,
+    kAudioChannelLabel_Narration                = 41,
+    kAudioChannelLabel_Mono                     = 42,
+    kAudioChannelLabel_DialogCentricMix         = 43,
+
+    kAudioChannelLabel_CenterSurroundDirect     = 44,           // back center, non diffuse
+    
+    kAudioChannelLabel_Haptic                   = 45,
+
+    // first order ambisonic channels
+    kAudioChannelLabel_Ambisonic_W              = 200,
+    kAudioChannelLabel_Ambisonic_X              = 201,
+    kAudioChannelLabel_Ambisonic_Y              = 202,
+    kAudioChannelLabel_Ambisonic_Z              = 203,
+
+    // Mid/Side Recording
+    kAudioChannelLabel_MS_Mid                   = 204,
+    kAudioChannelLabel_MS_Side                  = 205,
+
+    // X-Y Recording
+    kAudioChannelLabel_XY_X                     = 206,
+    kAudioChannelLabel_XY_Y                     = 207,
+
+    // other
+    kAudioChannelLabel_HeadphonesLeft           = 301,
+    kAudioChannelLabel_HeadphonesRight          = 302,
+    kAudioChannelLabel_ClickTrack               = 304,
+    kAudioChannelLabel_ForeignLanguage          = 305,
+
+    // generic discrete channel
+    kAudioChannelLabel_Discrete                 = 400,
+
+    // numbered discrete channel
+    kAudioChannelLabel_Discrete_0               = (1L<<16) | 0,
+    kAudioChannelLabel_Discrete_1               = (1L<<16) | 1,
+    kAudioChannelLabel_Discrete_2               = (1L<<16) | 2,
+    kAudioChannelLabel_Discrete_3               = (1L<<16) | 3,
+    kAudioChannelLabel_Discrete_4               = (1L<<16) | 4,
+    kAudioChannelLabel_Discrete_5               = (1L<<16) | 5,
+    kAudioChannelLabel_Discrete_6               = (1L<<16) | 6,
+    kAudioChannelLabel_Discrete_7               = (1L<<16) | 7,
+    kAudioChannelLabel_Discrete_8               = (1L<<16) | 8,
+    kAudioChannelLabel_Discrete_9               = (1L<<16) | 9,
+    kAudioChannelLabel_Discrete_10              = (1L<<16) | 10,
+    kAudioChannelLabel_Discrete_11              = (1L<<16) | 11,
+    kAudioChannelLabel_Discrete_12              = (1L<<16) | 12,
+    kAudioChannelLabel_Discrete_13              = (1L<<16) | 13,
+    kAudioChannelLabel_Discrete_14              = (1L<<16) | 14,
+    kAudioChannelLabel_Discrete_15              = (1L<<16) | 15,
+    kAudioChannelLabel_Discrete_65535           = (1L<<16) | 65535
+};
+
+#define AudioChannelLayoutTag_GetNumberOfChannels(layoutTag) \
+    ((uint32_t)((layoutTag) & 0x0000FFFF))
+
+enum
+{
+    kAudioChannelLayoutTag_UseChannelDescriptions   = (0L<<16) | 0,     // use the array of AudioChannelDescriptions to define the mapping.
+    kAudioChannelLayoutTag_UseChannelBitmap         = (1L<<16) | 0,     // use the bitmap to define the mapping.
+
+    kAudioChannelLayoutTag_Mono                     = (100L<<16) | 1,   // a standard mono stream
+    kAudioChannelLayoutTag_Stereo                   = (101L<<16) | 2,   // a standard stereo stream (L R) - implied playback
+    kAudioChannelLayoutTag_StereoHeadphones         = (102L<<16) | 2,   // a standard stereo stream (L R) - implied headphone playbac
+    kAudioChannelLayoutTag_MatrixStereo             = (103L<<16) | 2,   // a matrix encoded stereo stream (Lt, Rt)
+    kAudioChannelLayoutTag_MidSide                  = (104L<<16) | 2,   // mid/side recording
+    kAudioChannelLayoutTag_XY                       = (105L<<16) | 2,   // coincident mic pair (often 2 figure 8's)
+    kAudioChannelLayoutTag_Binaural                 = (106L<<16) | 2,   // binaural stereo (left, right)
+    kAudioChannelLayoutTag_Ambisonic_B_Format       = (107L<<16) | 4,   // W, X, Y, Z
+
+    kAudioChannelLayoutTag_Quadraphonic             = (108L<<16) | 4,   // front left, front right, back left, back right
+
+    kAudioChannelLayoutTag_Pentagonal               = (109L<<16) | 5,   // left, right, rear left, rear right, center
+
+    kAudioChannelLayoutTag_Hexagonal                = (110L<<16) | 6,   // left, right, rear left, rear right, center, rear
+
+    kAudioChannelLayoutTag_Octagonal                = (111L<<16) | 8,   // front left, front right, rear left, rear right,
+                                                                        // front center, rear center, side left, side right
+
+    kAudioChannelLayoutTag_Cube                     = (112L<<16) | 8,   // left, right, rear left, rear right
+                                                                        // top left, top right, top rear left, top rear right
+
+    //  MPEG defined layouts
+    kAudioChannelLayoutTag_MPEG_1_0                 = kAudioChannelLayoutTag_Mono,          //  C
+    kAudioChannelLayoutTag_MPEG_2_0                 = kAudioChannelLayoutTag_Stereo,        //  L R
+    kAudioChannelLayoutTag_MPEG_3_0_A               = (113L<<16) | 3,                       //  L R C
+    kAudioChannelLayoutTag_MPEG_3_0_B               = (114L<<16) | 3,                       //  C L R
+    kAudioChannelLayoutTag_MPEG_4_0_A               = (115L<<16) | 4,                       //  L R C Cs
+    kAudioChannelLayoutTag_MPEG_4_0_B               = (116L<<16) | 4,                       //  C L R Cs
+    kAudioChannelLayoutTag_MPEG_5_0_A               = (117L<<16) | 5,                       //  L R C Ls Rs
+    kAudioChannelLayoutTag_MPEG_5_0_B               = (118L<<16) | 5,                       //  L R Ls Rs C
+    kAudioChannelLayoutTag_MPEG_5_0_C               = (119L<<16) | 5,                       //  L C R Ls Rs
+    kAudioChannelLayoutTag_MPEG_5_0_D               = (120L<<16) | 5,                       //  C L R Ls Rs
+    kAudioChannelLayoutTag_MPEG_5_1_A               = (121L<<16) | 6,                       //  L R C LFE Ls Rs
+    kAudioChannelLayoutTag_MPEG_5_1_B               = (122L<<16) | 6,                       //  L R Ls Rs C LFE
+    kAudioChannelLayoutTag_MPEG_5_1_C               = (123L<<16) | 6,                       //  L C R Ls Rs LFE
+    kAudioChannelLayoutTag_MPEG_5_1_D               = (124L<<16) | 6,                       //  C L R Ls Rs LFE
+    kAudioChannelLayoutTag_MPEG_6_1_A               = (125L<<16) | 7,                       //  L R C LFE Ls Rs Cs
+    kAudioChannelLayoutTag_MPEG_7_1_A               = (126L<<16) | 8,                       //  L R C LFE Ls Rs Lc Rc
+    kAudioChannelLayoutTag_MPEG_7_1_B               = (127L<<16) | 8,                       //  C Lc Rc L R Ls Rs LFE    (doc: IS-13818-7 MPEG2-AAC Table 3.1)
+    kAudioChannelLayoutTag_MPEG_7_1_C               = (128L<<16) | 8,                       //  L R C LFE Ls Rs Rls Rrs
+    kAudioChannelLayoutTag_Emagic_Default_7_1       = (129L<<16) | 8,                       //  L R Ls Rs C LFE Lc Rc
+    kAudioChannelLayoutTag_SMPTE_DTV                = (130L<<16) | 8,                       //  L R C LFE Ls Rs Lt Rt
+                                                                                            //      (kAudioChannelLayoutTag_ITU_5_1 plus a matrix encoded stereo mix)
+
+    //  ITU defined layouts
+    kAudioChannelLayoutTag_ITU_1_0                  = kAudioChannelLayoutTag_Mono,          //  C
+    kAudioChannelLayoutTag_ITU_2_0                  = kAudioChannelLayoutTag_Stereo,        //  L R
+
+    kAudioChannelLayoutTag_ITU_2_1                  = (131L<<16) | 3,                       //  L R Cs
+    kAudioChannelLayoutTag_ITU_2_2                  = (132L<<16) | 4,                       //  L R Ls Rs
+    kAudioChannelLayoutTag_ITU_3_0                  = kAudioChannelLayoutTag_MPEG_3_0_A,    //  L R C
+    kAudioChannelLayoutTag_ITU_3_1                  = kAudioChannelLayoutTag_MPEG_4_0_A,    //  L R C Cs
+
+    kAudioChannelLayoutTag_ITU_3_2                  = kAudioChannelLayoutTag_MPEG_5_0_A,    //  L R C Ls Rs
+    kAudioChannelLayoutTag_ITU_3_2_1                = kAudioChannelLayoutTag_MPEG_5_1_A,    //  L R C LFE Ls Rs
+    kAudioChannelLayoutTag_ITU_3_4_1                = kAudioChannelLayoutTag_MPEG_7_1_C,    //  L R C LFE Ls Rs Rls Rrs
+
+    // DVD defined layouts
+    kAudioChannelLayoutTag_DVD_0                    = kAudioChannelLayoutTag_Mono,          // C (mono)
+    kAudioChannelLayoutTag_DVD_1                    = kAudioChannelLayoutTag_Stereo,        // L R
+    kAudioChannelLayoutTag_DVD_2                    = kAudioChannelLayoutTag_ITU_2_1,       // L R Cs
+    kAudioChannelLayoutTag_DVD_3                    = kAudioChannelLayoutTag_ITU_2_2,       // L R Ls Rs
+    kAudioChannelLayoutTag_DVD_4                    = (133L<<16) | 3,                       // L R LFE
+    kAudioChannelLayoutTag_DVD_5                    = (134L<<16) | 4,                       // L R LFE Cs
+    kAudioChannelLayoutTag_DVD_6                    = (135L<<16) | 5,                       // L R LFE Ls Rs
+    kAudioChannelLayoutTag_DVD_7                    = kAudioChannelLayoutTag_MPEG_3_0_A,    // L R C
+    kAudioChannelLayoutTag_DVD_8                    = kAudioChannelLayoutTag_MPEG_4_0_A,    // L R C Cs
+    kAudioChannelLayoutTag_DVD_9                    = kAudioChannelLayoutTag_MPEG_5_0_A,    // L R C Ls Rs
+    kAudioChannelLayoutTag_DVD_10                   = (136L<<16) | 4,                       // L R C LFE
+    kAudioChannelLayoutTag_DVD_11                   = (137L<<16) | 5,                       // L R C LFE Cs
+    kAudioChannelLayoutTag_DVD_12                   = kAudioChannelLayoutTag_MPEG_5_1_A,    // L R C LFE Ls Rs
+    // 13 through 17 are duplicates of 8 through 12.
+    kAudioChannelLayoutTag_DVD_13                   = kAudioChannelLayoutTag_DVD_8,         // L R C Cs
+    kAudioChannelLayoutTag_DVD_14                   = kAudioChannelLayoutTag_DVD_9,         // L R C Ls Rs
+    kAudioChannelLayoutTag_DVD_15                   = kAudioChannelLayoutTag_DVD_10,        // L R C LFE
+    kAudioChannelLayoutTag_DVD_16                   = kAudioChannelLayoutTag_DVD_11,        // L R C LFE Cs
+    kAudioChannelLayoutTag_DVD_17                   = kAudioChannelLayoutTag_DVD_12,        // L R C LFE Ls Rs
+    kAudioChannelLayoutTag_DVD_18                   = (138L<<16) | 5,                       // L R Ls Rs LFE
+    kAudioChannelLayoutTag_DVD_19                   = kAudioChannelLayoutTag_MPEG_5_0_B,    // L R Ls Rs C
+    kAudioChannelLayoutTag_DVD_20                   = kAudioChannelLayoutTag_MPEG_5_1_B,    // L R Ls Rs C LFE
+
+    // These layouts are recommended for AudioUnit usage
+        // These are the symmetrical layouts
+    kAudioChannelLayoutTag_AudioUnit_4              = kAudioChannelLayoutTag_Quadraphonic,
+    kAudioChannelLayoutTag_AudioUnit_5              = kAudioChannelLayoutTag_Pentagonal,
+    kAudioChannelLayoutTag_AudioUnit_6              = kAudioChannelLayoutTag_Hexagonal,
+    kAudioChannelLayoutTag_AudioUnit_8              = kAudioChannelLayoutTag_Octagonal,
+        // These are the surround-based layouts
+    kAudioChannelLayoutTag_AudioUnit_5_0            = kAudioChannelLayoutTag_MPEG_5_0_B,    // L R Ls Rs C
+    kAudioChannelLayoutTag_AudioUnit_6_0            = (139L<<16) | 6,                       // L R Ls Rs C Cs
+    kAudioChannelLayoutTag_AudioUnit_7_0            = (140L<<16) | 7,                       // L R Ls Rs C Rls Rrs
+    kAudioChannelLayoutTag_AudioUnit_7_0_Front      = (148L<<16) | 7,                       // L R Ls Rs C Lc Rc
+    kAudioChannelLayoutTag_AudioUnit_5_1            = kAudioChannelLayoutTag_MPEG_5_1_A,    // L R C LFE Ls Rs
+    kAudioChannelLayoutTag_AudioUnit_6_1            = kAudioChannelLayoutTag_MPEG_6_1_A,    // L R C LFE Ls Rs Cs
+    kAudioChannelLayoutTag_AudioUnit_7_1            = kAudioChannelLayoutTag_MPEG_7_1_C,    // L R C LFE Ls Rs Rls Rrs
+    kAudioChannelLayoutTag_AudioUnit_7_1_Front      = kAudioChannelLayoutTag_MPEG_7_1_A,    // L R C LFE Ls Rs Lc Rc
+
+    kAudioChannelLayoutTag_AAC_3_0                  = kAudioChannelLayoutTag_MPEG_3_0_B,    // C L R
+    kAudioChannelLayoutTag_AAC_Quadraphonic         = kAudioChannelLayoutTag_Quadraphonic,  // L R Ls Rs
+    kAudioChannelLayoutTag_AAC_4_0                  = kAudioChannelLayoutTag_MPEG_4_0_B,    // C L R Cs
+    kAudioChannelLayoutTag_AAC_5_0                  = kAudioChannelLayoutTag_MPEG_5_0_D,    // C L R Ls Rs
+    kAudioChannelLayoutTag_AAC_5_1                  = kAudioChannelLayoutTag_MPEG_5_1_D,    // C L R Ls Rs Lfe
+    kAudioChannelLayoutTag_AAC_6_0                  = (141L<<16) | 6,                       // C L R Ls Rs Cs
+    kAudioChannelLayoutTag_AAC_6_1                  = (142L<<16) | 7,                       // C L R Ls Rs Cs Lfe
+    kAudioChannelLayoutTag_AAC_7_0                  = (143L<<16) | 7,                       // C L R Ls Rs Rls Rrs
+    kAudioChannelLayoutTag_AAC_7_1                  = kAudioChannelLayoutTag_MPEG_7_1_B,    // C Lc Rc L R Ls Rs Lfe
+    kAudioChannelLayoutTag_AAC_Octagonal            = (144L<<16) | 8,                       // C L R Ls Rs Rls Rrs Cs
+
+    kAudioChannelLayoutTag_TMH_10_2_std             = (145L<<16) | 16,                      // L R C Vhc Lsd Rsd Ls Rs Vhl Vhr Lw Rw Csd Cs LFE1 LFE2
+    kAudioChannelLayoutTag_TMH_10_2_full            = (146L<<16) | 21,                      // TMH_10_2_std plus: Lc Rc HI VI Haptic
+
+    kAudioChannelLayoutTag_AC3_1_0_1                = (149L<<16) | 2,                       // C LFE
+    kAudioChannelLayoutTag_AC3_3_0                  = (150L<<16) | 3,                       // L C R
+    kAudioChannelLayoutTag_AC3_3_1                  = (151L<<16) | 4,                       // L C R Cs
+    kAudioChannelLayoutTag_AC3_3_0_1                = (152L<<16) | 4,                       // L C R LFE
+    kAudioChannelLayoutTag_AC3_2_1_1                = (153L<<16) | 4,                       // L R Cs LFE
+    kAudioChannelLayoutTag_AC3_3_1_1                = (154L<<16) | 5,                       // L C R Cs LFE
+
+    kAudioChannelLayoutTag_DiscreteInOrder          = (147L<<16) | 0,                       // needs to be ORed with the actual number of channels  
+    kAudioChannelLayoutTag_Unknown                  = 0xFFFF0000                            // needs to be ORed with the actual number of channels  
+};
+
+#endif

src/compat.h

@@ -6,7 +6,10 @@
 #define COMPAT_H
 
 #ifndef HAVE_FSEEKO
-#  if _MSC_VER >= 1400
+#  if HAVE_FSEEKO64
+#    define fseeko fseeko64
+#    define ftello ftello64
+#  elif _MSC_VER >= 1400
 #    define fseeko _fseeki64
 #    define ftello _ftelli64
 #  else

src/compat_win32.c

@@ -31,8 +31,13 @@ int __wgetmainargs(int *, wchar_t ***, wchar_t ***, int, _startupinfo *);
 
 int64_t aacenc_timer(void)
 {
+#if HAVE_STRUCT___TIMEB64
     struct __timeb64 tv;
     _ftime64(&tv);
+#else
+    struct timeb tv;
+    ftime(&tv);
+#endif
     return (int64_t)tv.time * 1000 + tv.millitm;
 }
 

src/lpcm.c

@@ -13,8 +13,7 @@
 #include "lpcm.h"
 #include "m4af_endian.h"
 
-#ifdef _MSC_VER
-#  define inline __inline
+#if defined(_MSC_VER) && _MSC_VER < 1800
 #  ifdef _M_IX86
 inline int lrint(double x)
 {
@@ -187,14 +186,14 @@ inline int16_t pcm_f64be_to_s16(int64_t n)
 
 int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
                                  const void *input, uint32_t nframes,
-                                 int16_t **result, uint32_t *osize)
+                                 int16_t *result)
 {
 #define CONVERT(type, conv) \
     do { \
         unsigned i; \
         type *ip = (type *)input; \
         for (i = 0; i < count; ++i) { \
-            (*result)[i] = conv(ip[i]); \
+            result[i] = conv(ip[i]); \
         } \
     } while(0)
 
@@ -204,7 +203,7 @@ int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
         uint8_t *ip = (uint8_t *)input; \
         bytes_per_channel = PCM_BYTES_PER_CHANNEL(format); \
         for (i = 0; i < count; ++i) { \
-            (*result)[i] = conv(ip); \
+            result[i] = conv(ip); \
             ip += bytes_per_channel; \
         } \
     } while(0)
@@ -212,11 +211,6 @@ int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
     uint32_t count = nframes * format->channels_per_frame;
     if (!count)
         return 0;
-    if (!*result || *osize < count) {
-        *osize  = count;
-        *result = realloc(*result, count * sizeof(int16_t));
-    }
-
     switch (PCM_BYTES_PER_CHANNEL(format) | format->sample_type<<4) {
     case 1 | PCM_TYPE_SINT<<4:
         CONVERT(int8_t, pcm_s8_to_s16); break;

src/lpcm.h

@@ -33,5 +33,5 @@ typedef struct pcm_sample_description_t {
 
 int pcm_convert_to_native_sint16(const pcm_sample_description_t *format,
                                  const void *input, uint32_t nframes,
-                                 int16_t **result, uint32_t *osize);
+                                 int16_t *result);
 #endif

src/m4af.c

@@ -23,6 +23,7 @@
 
 #define m4af_realloc(memory,size) realloc(memory, size)
 #define m4af_free(memory) free(memory)
+#define m4af_max(a,b) ((a)<(b)?(b):(a))
 
 #define M4AF_ATOM_WILD  0xffffffff
 
@@ -52,6 +53,7 @@ typedef struct m4af_track_t {
     uint32_t bufferSizeDB;
     uint32_t maxBitrate;
     uint32_t avgBitrate;
+    int is_vbr;
 
     m4af_sample_entry_t *sample_table;
     uint32_t num_samples;
@@ -79,6 +81,7 @@ struct m4af_ctx_t {
     int64_t modification_time;
     int64_t mdat_pos;
     int64_t mdat_size;
+    int priming_mode;
     int last_error;
 
     m4af_itmf_entry_t *itmf_table;
@@ -148,6 +151,13 @@ int m4af_write(m4af_ctx_t *ctx, const void *data, uint32_t size)
     return rc;
 }
 
+static
+int m4af_write16(m4af_ctx_t *ctx, uint32_t data)
+{
+    data = m4af_htob16(data);
+    return m4af_write(ctx, &data, 2);
+}
+
 static
 int m4af_write32(m4af_ctx_t *ctx, uint32_t data)
 {
@@ -269,6 +279,12 @@ DONE:
     return ctx->last_error;
 }
 
+void m4af_set_vbr_mode(m4af_ctx_t *ctx, uint32_t track_idx, int is_vbr)
+{
+    m4af_track_t *track = &ctx->track[track_idx];
+    track->is_vbr = is_vbr;
+}
+
 void m4af_set_priming(m4af_ctx_t *ctx, uint32_t track_idx,
                       uint32_t encoder_delay, uint32_t padding)
 {
@@ -277,6 +293,11 @@ void m4af_set_priming(m4af_ctx_t *ctx, uint32_t track_idx,
     track->padding = padding;
 }
 
+void m4af_set_priming_mode(m4af_ctx_t *ctx, int mode)
+{
+    ctx->priming_mode = mode;
+}
+
 static
 int m4af_add_sample_entry(m4af_ctx_t *ctx, uint32_t track_idx,
                           uint32_t size, uint32_t delta)
@@ -426,52 +447,68 @@ int m4af_write_sample(m4af_ctx_t *ctx, uint32_t track_idx, const void *data,
 }
 
 static
-int m4af_add_itmf_entry(m4af_ctx_t *ctx)
+m4af_itmf_entry_t *m4af_find_itmf_slot(m4af_ctx_t *ctx, uint32_t fcc,
+                                       const char *name)
 {
-    m4af_itmf_entry_t *entry;
+    m4af_itmf_entry_t *entry = ctx->itmf_table;
+
+    if (name)
+        fcc = M4AF_FOURCC('-','-','-','-');
+
+    if (fcc != M4AF_TAG_ARTWORK)
+        for (; entry != ctx->itmf_table + ctx->num_tags; ++entry)
+            if (fcc == entry->fcc && (!name || !strcmp(name, entry->name)))
+                return entry;
+
     if (ctx->num_tags == ctx->itmf_table_capacity) {
         uint32_t new_size = ctx->itmf_table_capacity;
         new_size = new_size ? new_size * 2 : 1;
         entry = m4af_realloc(ctx->itmf_table, new_size * sizeof(*entry));
         if (entry == 0) {
             ctx->last_error = M4AF_NO_MEMORY;
-            return -1;
+            return 0;
         }
         ctx->itmf_table = entry;
         ctx->itmf_table_capacity = new_size;
     }
-    ++ctx->num_tags;
+    entry = &ctx->itmf_table[ctx->num_tags++];
+    memset(entry, 0, sizeof(m4af_itmf_entry_t));
+    entry->fcc = fcc;
+    if (name) {
+        char *name_copy = m4af_realloc(0, strlen(name) + 1);
+        if (!name_copy) {
+            ctx->last_error = M4AF_NO_MEMORY;
+            --ctx->num_tags;
             return 0;
         }
+        strcpy(name_copy, name);
+        entry->name = name_copy;
+    }
+    return entry;
+}
 
 int m4af_add_itmf_long_tag(m4af_ctx_t *ctx, const char *name,
                            const char *data)
 {
     m4af_itmf_entry_t *entry;
+    char *data_copy = 0;
     size_t name_len = strlen(name);
     size_t data_len = strlen(data);
-    char *name_copy = m4af_realloc(0, name_len + 1);
-    char *data_copy = m4af_realloc(0, data_len);
-    if (!name_copy || !data_copy) {
+    if (!name_len || !data_len)
+        return 0;
+
+    if ((entry = m4af_find_itmf_slot(ctx, 0, name)) == 0)
+        goto FAIL;
+    entry->type_code = M4AF_UTF8;
+    if ((data_copy = m4af_realloc(entry->data, data_len)) == 0) {
         ctx->last_error = M4AF_NO_MEMORY;
         goto FAIL;
     }
-    if (m4af_add_itmf_entry(ctx) < 0)
-        goto FAIL;
-    memcpy(name_copy, name, name_len + 1);
     memcpy(data_copy, data, data_len);
-    entry = ctx->itmf_table + ctx->num_tags - 1;
-    entry->fcc = M4AF_FOURCC('-','-','-','-');
-    entry->name = name_copy;
-    entry->type_code = M4AF_UTF8;
     entry->data = data_copy;
     entry->data_size = data_len;
     return 0;
 FAIL:
-    if (name_copy)
-        m4af_free(name_copy);
-    if (data_copy)
-        m4af_free(data_copy);
     return ctx->last_error;
 }
 
@@ -480,24 +517,22 @@ int m4af_add_itmf_short_tag(m4af_ctx_t *ctx, uint32_t fcc,
                             uint32_t data_size)
 {
     m4af_itmf_entry_t *entry;
-    char *data_copy = m4af_realloc(0, data_size);
-    if (!data_copy) {
+    char *data_copy = 0;
+    
+    if (!data_size)
+        return 0;
+    if ((entry = m4af_find_itmf_slot(ctx, fcc, 0)) == 0)
+        goto FAIL;
+    entry->type_code = type_code;
+    if ((data_copy = m4af_realloc(entry->data, data_size)) == 0) {
         ctx->last_error = M4AF_NO_MEMORY;
         goto FAIL;
     }
-    if (m4af_add_itmf_entry(ctx) < 0)
-        goto FAIL;
-    entry = ctx->itmf_table + ctx->num_tags - 1;
-    entry->fcc = fcc;
-    entry->name = 0;
-    entry->type_code = type_code;
     memcpy(data_copy, data, data_size);
     entry->data = data_copy;
     entry->data_size = data_size;
     return 0;
 FAIL:
-    if (data_copy)
-        m4af_free(data_copy);
     return ctx->last_error;
 }
 
@@ -569,12 +604,13 @@ int m4af_set_iTunSMPB(m4af_ctx_t *ctx)
 }
 
 static
-void m4af_update_box_size(m4af_ctx_t *ctx, int64_t pos)
+uint32_t m4af_update_box_size(m4af_ctx_t *ctx, int64_t pos)
 {
     int64_t current_pos = m4af_tell(ctx);
     m4af_set_pos(ctx, pos);
     m4af_write32(ctx, current_pos - pos);
     m4af_set_pos(ctx, current_pos);
+    return current_pos - pos;
 }
 
 static
@@ -742,7 +778,7 @@ void m4af_write_esds_box(m4af_ctx_t *ctx, uint32_t track_idx)
                , 2);
     m4af_write24(ctx, track->bufferSizeDB);
     m4af_write32(ctx, track->maxBitrate);
-    m4af_write32(ctx, track->avgBitrate);
+    m4af_write32(ctx, track->is_vbr ? 0: track->avgBitrate);
     /* DecoderSpecificInfo */
     m4af_write_descriptor(ctx, 5, track->decSpecificInfoSize);
     m4af_write(ctx, track->decSpecificInfo, track->decSpecificInfoSize);
@@ -809,12 +845,49 @@ void m4af_write_stsd_box(m4af_ctx_t *ctx, uint32_t track_idx)
     m4af_update_box_size(ctx, pos);
 }
 
+static
+void m4af_write_sbgp_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+    m4af_track_t *track = &ctx->track[track_idx];
+    m4af_write(ctx,
+               "\0\0\0\034"  /* size: 28                */
+               "sbgp"        /* type                    */
+               "\0"          /* version                 */
+               "\0\0\0"      /* flags                   */
+               "roll"        /* grouping_type           */
+               "\0\0\0\001"  /* entry_count: 1          */
+               , 20);
+    m4af_write32(ctx, track->num_samples);
+    m4af_write32(ctx, 1);    /* group_description_index */
+}
+
+static
+void m4af_write_sgpd_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+    m4af_track_t *track = &ctx->track[track_idx];
+    m4af_write(ctx,
+               "\0\0\0\026"  /* size: 22           */
+               "sgpd"        /* type               */
+               "\0"          /* version            */
+               "\0\0\0"      /* flags              */
+               "roll"        /* grouping_type      */
+               "\0\0\0\001"  /* entry_count: 1     */
+               "\377\377"    /* payload_data: -1   */
+               , 22);
+}
+
 static
 void m4af_write_stbl_box(m4af_ctx_t *ctx, uint32_t track_idx)
 {
+    m4af_track_t *track = &ctx->track[track_idx];
     int64_t pos = m4af_tell(ctx);
     m4af_write(ctx, "\0\0\0\0stbl", 8);
     m4af_write_stsd_box(ctx, track_idx);
+    if ((ctx->priming_mode & M4AF_PRIMING_MODE_EDTS) &&
+        (track->encoder_delay || track->padding)) {
+        m4af_write_sbgp_box(ctx, track_idx);
+        m4af_write_sgpd_box(ctx, track_idx);
+    }
     m4af_write_stts_box(ctx, track_idx);
     m4af_write_stsc_box(ctx, track_idx);
     m4af_write_stsz_box(ctx, track_idx);
@@ -948,6 +1021,42 @@ void m4af_write_mdia_box(m4af_ctx_t *ctx, uint32_t track_idx)
     m4af_update_box_size(ctx, pos);
 }
 
+static
+void m4af_write_elst_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+    m4af_track_t *track = &ctx->track[track_idx];
+    uint8_t version;
+    int64_t duration = track->duration - track->encoder_delay - track->padding;
+    int64_t pos = m4af_tell(ctx);
+    duration = (double)duration / track->timescale * ctx->timescale + .5;
+    version  = (duration > UINT32_MAX);
+
+    m4af_write(ctx, "\0\0\0\0elst", 8);
+    m4af_write(ctx, &version, 1);
+    m4af_write(ctx, "\0\0\0", 3);  /* flags          */
+    m4af_write32(ctx, 1);          /* entry_count: 1 */
+    if (version) {
+        m4af_write64(ctx, duration);
+        m4af_write64(ctx, track->encoder_delay);
+    } else {
+        m4af_write32(ctx, duration);
+        m4af_write32(ctx, track->encoder_delay);
+    }
+    m4af_write16(ctx, 1);    /* media_rate_integer  */
+    m4af_write16(ctx, 0);    /* media_rate_fraction */
+    m4af_update_box_size(ctx, pos);
+}
+
+static
+void m4af_write_edts_box(m4af_ctx_t *ctx, uint32_t track_idx)
+{
+    m4af_track_t *track = &ctx->track[track_idx];
+    int64_t pos = m4af_tell(ctx);
+    m4af_write(ctx, "\0\0\0\0edts", 8);
+    m4af_write_elst_box(ctx, track_idx);
+    m4af_update_box_size(ctx, pos);
+}
+
 static
 void m4af_write_tkhd_box(m4af_ctx_t *ctx, uint32_t track_idx)
 {
@@ -1001,9 +1110,13 @@ void m4af_write_tkhd_box(m4af_ctx_t *ctx, uint32_t track_idx)
 static
 void m4af_write_trak_box(m4af_ctx_t *ctx, uint32_t track_idx)
 {
+    m4af_track_t *track = &ctx->track[track_idx];
     int64_t pos = m4af_tell(ctx);
     m4af_write(ctx, "\0\0\0\0trak", 8);
     m4af_write_tkhd_box(ctx, track_idx);
+    if ((ctx->priming_mode & M4AF_PRIMING_MODE_EDTS) &&
+        (track->encoder_delay || track->padding))
+        m4af_write_edts_box(ctx, track_idx);
     m4af_write_mdia_box(ctx, track_idx);
     m4af_update_box_size(ctx, pos);
 }
@@ -1168,7 +1281,7 @@ void m4af_write_udta_box(m4af_ctx_t *ctx)
 }
 
 static
-void m4af_write_moov_box(m4af_ctx_t *ctx)
+uint32_t m4af_write_moov_box(m4af_ctx_t *ctx)
 {
     unsigned i;
     int64_t pos = m4af_tell(ctx);
@@ -1178,7 +1291,7 @@ void m4af_write_moov_box(m4af_ctx_t *ctx)
         m4af_write_trak_box(ctx, i);
     if (ctx->num_tags)
         m4af_write_udta_box(ctx);
-    m4af_update_box_size(ctx, pos);
+    return m4af_update_box_size(ctx, pos);
 }
 
 static
@@ -1196,10 +1309,35 @@ void m4af_finalize_mdat(m4af_ctx_t *ctx)
     m4af_set_pos(ctx, ctx->mdat_pos + ctx->mdat_size);
 }
 
-int m4af_finalize(m4af_ctx_t *ctx)
+static
+void m4af_shift_mdat_pos(m4af_ctx_t *ctx, uint32_t offset)
+{
+    unsigned i, j;
+    int64_t begin, end;
+    char buf[8192];
+
+    end = ctx->mdat_pos + ctx->mdat_size;
+    for (; (begin = m4af_max(ctx->mdat_pos, end - 8192)) < end; end = begin) {
+        m4af_set_pos(ctx, begin);
+        ctx->io.read(ctx->io_cookie, buf, end - begin);
+        m4af_set_pos(ctx, begin + offset);
+        m4af_write(ctx, buf, end - begin);
+    }
+    for (i = 0; i < ctx->num_tracks; ++i)
+        for (j = 0; j < ctx->track[i].num_chunks; ++j)
+            ctx->track[i].chunk_table[j].offset += offset;
+    ctx->mdat_pos += offset;
+    m4af_set_pos(ctx, ctx->mdat_pos - 16);
+    m4af_write_free_box(ctx, 0);
+    m4af_write(ctx, "\0\0\0\0mdat", 8);
+    m4af_finalize_mdat(ctx);
+}
+
+int m4af_finalize(m4af_ctx_t *ctx, int optimize)
 {
     unsigned i;
     m4af_track_t *track;
+    uint32_t moov_size;
 
     for (i = 0; i < ctx->num_tracks; ++i) {
         track = ctx->track + i;
@@ -1213,9 +1351,19 @@ int m4af_finalize(m4af_ctx_t *ctx)
         }
         m4af_flush_chunk(ctx, i);
     }
-    if (ctx->track[0].encoder_delay || ctx->track[0].padding)
+    track = ctx->track;
+    if ((ctx->priming_mode & M4AF_PRIMING_MODE_ITUNSMPB) &&
+        (track->encoder_delay || track->padding))
         m4af_set_iTunSMPB(ctx);
     m4af_finalize_mdat(ctx);
+    moov_size = m4af_write_moov_box(ctx);
+    if (optimize) {
+        int64_t pos;
+        m4af_shift_mdat_pos(ctx, moov_size + 1024);
+        m4af_set_pos(ctx, 32);
         m4af_write_moov_box(ctx);
+        pos = m4af_tell(ctx);
+        m4af_write_free_box(ctx, ctx->mdat_pos - pos - 24);
+    }
     return ctx->last_error;
 }

src/m4af.h

@@ -52,6 +52,12 @@ enum m4af_codec_type {
     M4AF_CODEC_TEXT = M4AF_FOURCC('t','e','x','t'),
 };
 
+enum m4af_priming_mode {
+    M4AF_PRIMING_MODE_ITUNSMPB = 1,
+    M4AF_PRIMING_MODE_EDTS = 2,
+    M4AF_PRIMING_MODE_BOTH = 3
+};
+
 typedef int (*m4af_read_callback)(void *cookie, void *buffer, uint32_t size);
 typedef int (*m4af_write_callback)(void *cookie, const void *data,
                                    uint32_t size);
@@ -81,7 +87,7 @@ m4af_ctx_t *m4af_create(uint32_t codec, uint32_t timescale,
 
 int m4af_begin_write(m4af_ctx_t *ctx);
 
-int m4af_finalize(m4af_ctx_t *ctx);
+int m4af_finalize(m4af_ctx_t *ctx, int optimize);
 
 void m4af_teardown(m4af_ctx_t **ctx);
 
@@ -91,9 +97,13 @@ int m4af_write_sample(m4af_ctx_t *ctx, uint32_t track_idx, const void *data,
 int m4af_set_decoder_specific_info(m4af_ctx_t *ctx, uint32_t track_idx,
                                    uint8_t *data, uint32_t size);
 
+void m4af_set_vbr_mode(m4af_ctx_t *ctx, uint32_t track_idx, int is_vbr);
+
 void m4af_set_priming(m4af_ctx_t *ctx, uint32_t track_idx,
                       uint32_t encoder_delay, uint32_t padding);
 
+void m4af_set_priming_mode(m4af_ctx_t *ctx, int mode);
+
 void m4af_set_fixed_frame_duration(m4af_ctx_t *ctx, uint32_t track_idx,
                                    uint32_t length);
 

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"
@@ -148,8 +145,16 @@ PROGNAME " %s\n"
 "                               transport layer\n"
 "\n"
 " -o <filename>                 Output filename\n"
-" --ignorelength                Ignore length of WAV header\n"
+" -G, --gapless-mode <n>        Encoder delay signaling for gapless playback\n"
+"                                 0: iTunSMPB (default)\n"
+"                                 1: ISO standard (edts + sgpd)\n"
+"                                 2: Both\n"
+" --include-sbr-delay           Count SBR decoder delay in encoder delay\n"
+"                               This is not iTunes compatible, but is default\n"
+"                               behavior of FDK library.\n"
+" -I, --ignorelength            Ignore length of WAV header\n"
 " -S, --silent                  Don't print progress messages\n"
+" --moov-before-mdat            Place moov box before mdat box on m4a output\n"
 "\n"
 "Options for raw (headerless) input:\n"
 " -R, --raw                     Treat input as raw (by default WAV is\n"
@@ -198,16 +203,23 @@ typedef struct aacenc_param_ex_t {
     AACENC_PARAMS
 
     char *input_filename;
+    FILE *input_fp;
     char *output_filename;
+    FILE *output_fp;
+    unsigned gapless_mode;
+    unsigned include_sbr_delay;
     unsigned ignore_length;
     int silent;
+    int moov_before_mdat;
 
     int is_raw;
     unsigned raw_channels;
     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;
@@ -218,6 +230,8 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
     int ch;
     unsigned n;
 
+#define OPT_INCLUDE_SBR_DELAY    M4AF_FOURCC('s','d','l','y')
+#define OPT_MOOV_BEFORE_MDAT     M4AF_FOURCC('m','o','o','v')
 #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')
@@ -234,13 +248,15 @@ 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' },
 
+        { "gapless-mode",     required_argument, 0, 'G' },
+        { "include-sbr-delay", no_argument,      0, OPT_INCLUDE_SBR_DELAY  },
         { "ignorelength",     no_argument,       0, 'I' },
         { "silent",           no_argument,       0, 'S' },
+        { "moov-before-mdat", no_argument,       0, OPT_MOOV_BEFORE_MDAT   },
 
         { "raw",              no_argument,       0, 'R' },
         { "raw-channels",     required_argument, 0, OPT_RAW_CHANNELS       },
@@ -268,7 +284,7 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
     params->afterburner = 1;
 
     aacenc_getmainargs(&argc, &argv);
-    while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:CP:Io:SR",
+    while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:CP:G:Io:SR",
                              long_options, 0)) != EOF) {
         switch (ch) {
         case 'h':
@@ -311,13 +327,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");
@@ -325,7 +334,7 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
             }
             params->transport_format = n;
             break;
-        case 'c':
+        case 'C':
             params->adts_crc_check = 1;
             break;
         case 'P':
@@ -338,12 +347,25 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         case 'o':
             params->output_filename = optarg;
             break;
+        case 'G':
+            if (sscanf(optarg, "%u", &n) != 1 || n > 2) {
+                fprintf(stderr, "invalid arg for gapless-mode\n");
+                return -1;
+            }
+            params->gapless_mode = n;
+            break;
+        case OPT_INCLUDE_SBR_DELAY:
+            params->include_sbr_delay = 1;
+            break;
         case 'I':
             params->ignore_length = 1;
             break;
         case 'S':
             params->silent = 1;
             break;
+        case OPT_MOOV_BEFORE_MDAT:
+            params->moov_before_mdat = 1;
+            break;
         case 'R':
             params->is_raw = 1;
             break;
@@ -376,7 +398,7 @@ 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,
+            aacenc_add_tag_to_store(&params->tags, ch, 0, optarg,
                                     strlen(optarg), 0);
             break;
         case OPT_SHORT_TAG:
@@ -410,7 +432,7 @@ 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,
+                aacenc_add_tag_to_store(&params->tags, fcc, optarg,
                                         val, strlen(val),
                                         ch == OPT_SHORT_TAG_FILE);
             }
@@ -467,13 +489,11 @@ int write_sample(FILE *ofp, m4af_ctx_t *m4af,
 }
 
 static
-int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
+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;
@@ -482,29 +502,23 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
     int rc = -1;
     int frames_written = 0;
     aacenc_progress_t progress = { 0 };
-    const pcm_sample_description_t *format = wav_get_format(wavf);
+    const pcm_sample_description_t *fmt = pcm_get_format(reader);
 
-    ibuf = malloc(frame_length * format->bytes_per_frame);
-    aacenc_progress_init(&progress, wav_get_length(wavf), format->sample_rate);
+    ibuf = malloc(frame_length * fmt->bytes_per_frame);
+    aacenc_progress_init(&progress, pcm_get_length(reader), fmt->sample_rate);
     do {
         if (g_interrupted)
             nread = 0;
         else if (nread) {
-            if ((nread = wav_read_frames(wavf, ibuf, frame_length)) < 0) {
+            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(format, ibuf, nread,
-                                                 &pcmbuf, &pcmsize) < 0) {
-                    fprintf(stderr, "ERROR: unsupported sample format\n");
-                    goto END;
-                }
             }
             if (show_progress)
-                aacenc_progress_update(&progress, wav_get_position(wavf),
-                                       format->sample_rate * 2);
+                aacenc_progress_update(&progress, pcm_get_position(reader),
+                                       fmt->sample_rate * 2);
         }
-        if ((consumed = aac_encode_frame(encoder, format, pcmbuf, nread,
+        if ((consumed = aac_encode_frame(encoder, fmt, ibuf, nread,
                                          &obuf, &olen, &osize)) < 0)
             goto END;
         if (olen > 0) {
@@ -515,11 +529,10 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
     } while (nread > 0 || olen > 0);
 
     if (show_progress)
-        aacenc_progress_finish(&progress, wav_get_position(wavf));
+        aacenc_progress_finish(&progress, pcm_get_position(reader));
     rc = frames_written;
 END:
     if (ibuf) free(ibuf);
-    if (pcmbuf) free(pcmbuf);
     if (obuf) free(obuf);
     return rc;
 }
@@ -557,17 +570,22 @@ 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);
 
-    if (m4af_finalize(m4af) < 0) {
+    if (m4af_finalize(m4af, params->moov_before_mdat) < 0) {
         fprintf(stderr, "ERROR: failed to finalize m4a\n");
         return -1;
     }
@@ -630,25 +648,92 @@ 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)
+{
+    pcm_io_context_t io = { 0 };
+    pcm_reader_t *reader = 0;
+    struct stat stb = { 0 };
+
+    if ((params->input_fp = aacenc_fopen(params->input_filename, "rb")) == 0) {
+        aacenc_fprintf(stderr, "ERROR: %s: %s\n", params->input_filename,
+                       strerror(errno));
+        goto END;
+    }
+    io.cookie = params->input_fp;
+    if (fstat(fileno(params->input_fp), &stb) == 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 };
+        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 ((reader = raw_open(&io, &desc)) == 0) {
+            fprintf(stderr, "ERROR: failed to open raw input\n");
+            goto END;
+        }
+    } else {
+        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 0;
+}
+
 int main(int argc, char **argv)
 {
-    wav_io_context_t wav_io = { read_callback, seek_callback, tell_callback };
-    m4af_io_callbacks_t
-        m4af_io = { 0, write_callback, seek_callback, tell_callback };
+    static m4af_io_callbacks_t m4af_io = {
+        read_callback, write_callback, seek_callback, tell_callback
+    };
     aacenc_param_ex_t params = { 0 };
 
     int result = 2;
-    FILE *ifp = 0;
-    FILE *ofp = 0;
     char *output_filename = 0;
-    wav_reader_t *wavf = 0;
+    pcm_reader_t *reader = 0;
     HANDLE_AACENCODER encoder = 0;
     AACENC_InfoStruct aacinfo = { 0 };
     m4af_ctx_t *m4af = 0;
     const pcm_sample_description_t *sample_format;
     int downsampled_timescale = 0;
     int frame_count = 0;
-    struct stat stb = { 0 };
+    int sbr_mode = 0;
 
     setlocale(LC_CTYPE, "");
     setbuf(stderr, 0);
@@ -656,37 +741,21 @@ int main(int argc, char **argv)
     if (parse_options(argc, argv, &params) < 0)
         return 1;
 
-    if ((ifp = aacenc_fopen(params.input_filename, "rb")) == 0) {
-        aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.input_filename,
-                       strerror(errno));
+    if ((reader = open_input(&params)) == 0)
         goto END;
-    }
-    if (fstat(fileno(ifp), &stb) == 0 && (stb.st_mode & S_IFMT) != S_IFREG) {
-        wav_io.seek = 0;
-        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);
+
+    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)
@@ -698,37 +767,48 @@ int main(int argc, char **argv)
         params.output_filename = output_filename;
     }
 
-    if ((ofp = aacenc_fopen(params.output_filename, "wb")) == 0) {
+    if ((params.output_fp = aacenc_fopen(params.output_filename, "wb+")) == 0) {
         aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.output_filename,
                        strerror(errno));
         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, ofp)) < 0)
+        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);
+        m4af_set_priming_mode(m4af, params.gapless_mode + 1);
         m4af_begin_write(m4af);
     }
-    frame_count = encode(wavf, encoder, aacinfo.frameLength, ofp, m4af,
-                         !params.silent);
+    frame_count = encode(reader, encoder, aacinfo.frameLength,
+                         params.output_fp, m4af, !params.silent);
     if (frame_count < 0)
         goto END;
     if (m4af) {
         uint32_t delay = aacinfo.encoderDelay;
-        int64_t frames_read = wav_get_position(wavf);
-        uint32_t padding = frame_count * aacinfo.frameLength
-                            - frames_read - aacinfo.encoderDelay;
+        uint32_t padding;
+        int64_t frames_read = pcm_get_position(reader);
+
+        if (sbr_mode && params.profile != AOT_ER_AAC_ELD &&
+            !params.include_sbr_delay)
+            delay -= 481 << 1;
+        if (sbr_mode && (delay & 1))
+            ++delay;
+        padding = frame_count * aacinfo.frameLength - frames_read - delay;
         m4af_set_priming(m4af, 0, delay >> downsampled_timescale,
                          padding >> downsampled_timescale);
         if (finalize_m4a(m4af, &params, encoder) < 0)
@@ -736,13 +816,16 @@ int main(int argc, char **argv)
     }
     result = 0;
 END:
-    if (wavf) wav_teardown(&wavf);
-    if (ifp) fclose(ifp);
+    if (reader) pcm_teardown(&reader);
+    if (params.input_fp) fclose(params.input_fp);
     if (m4af) m4af_teardown(&m4af);
-    if (ofp) fclose(ofp);
+    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;
 }

src/metadata.c

@@ -50,12 +50,14 @@ static tag_key_mapping_t tag_mapping_table[] = {
     { "copyright",                  M4AF_TAG_COPYRIGHT           },
     { "date",                       M4AF_TAG_DATE                },
     { "disc",                       M4AF_TAG_DISK                },
-    { "disctotal",                  TAG_TOTAL_DISCS              },
     { "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') },
@@ -95,6 +97,7 @@ uint32_t get_tag_fcc_from_name(const char *name)
     return ent ? ent->fcc : 0;
 }
 
+static
 char *aacenc_load_tag_from_file(const char *path, uint32_t *data_size)
 {
     FILE *fp = 0;
@@ -121,52 +124,178 @@ END:
     return data;
 }
 
-void aacenc_param_add_itmf_entry(aacenc_tag_param_t *params, uint32_t tag,
+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;
+    aacenc_tag_entry_t entry = { 0 };
+    char *dp = 0;
 
     if (!is_file_name && !size)
         return;
-    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;
+    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++;
+        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(m4af_ctx_t *m4af, uint32_t fcc,
-                         const char *snumber, const char *stotal)
+void tag_put_number_pair(aacenc_translate_generic_text_tag_ctx_t *ctx,
+                         uint32_t fcc, unsigned number, unsigned total)
 {
-    unsigned number = 0, total = 0;
     char buf[128];
     aacenc_tag_entry_t entry = { 0 };
 
-    if (snumber) sscanf(snumber, "%u", &number);
-    if (stotal)  sscanf(stotal,  "%u", &total);
     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);
-        aacenc_put_tag_entry(m4af, &entry);
+        ctx->add(ctx->add_ctx, &entry);
     }
 }
 
-void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
+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;
@@ -175,11 +304,10 @@ void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
     uint32_t data_size;
     char *json_dot_path;
     char *filename = 0;
-    char *disc = 0;
-    char *track = 0;
-    char *total_discs = 0;
-    char *total_tracks = 0;
-    aacenc_tag_entry_t entry = { 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)
@@ -202,69 +330,38 @@ void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
     nelts = json_object_get_count(root);
     for (i = 0; i < nelts; ++i) {
         char buf[256];
-        const char *key = 0;
-        const char *val = 0;
-        uint32_t fcc = 0;
-        JSON_Value_Type type;
-
-        key = json_object_get_name(root, i);
-        type = json_value_get_type(json_object_get_value(root, key));
-        if (type == JSONString)
-            val = json_object_get_string(root, key);
-        else if (type == JSONNumber) {
-            double num = json_object_get_number(root, key);
-            sprintf(buf, "%g", num);
-            val = buf;
-        } else if (type == JSONBoolean) {
-            int n = json_object_get_boolean(root, key);
-            sprintf(buf, "%d", n);
-            val = buf;
+        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);
     }
-        fcc = get_tag_fcc_from_name(key);
-        if (!val || !fcc)
-            continue;
-
-        switch (fcc) {
-        case TAG_TOTAL_DISCS:
-            total_discs = strdup(val); break;
-        case TAG_TOTAL_TRACKS:
-            total_tracks = strdup(val); break;
-        case M4AF_TAG_DISK:
-            disc = strdup(val); break;
-        case M4AF_TAG_TRACK:
-            track = strdup(val); break;
-        default:
-            {
-                entry.tag = fcc;
-                entry.data = val;
-                entry.data_size = strlen(val);
-                aacenc_put_tag_entry(m4af, &entry);
-            }
-        }
-    }
-    tag_put_number_pair(m4af, M4AF_TAG_TRACK, track, total_tracks);
-    tag_put_number_pair(m4af, M4AF_TAG_DISK,  disc,  total_discs);
+    aacenc_translate_generic_text_tag(&ctx, 0, 0, 0);
 DONE:
-    if (track) free(track);
-    if (disc) free(disc);
-    if (total_tracks) free(total_tracks);
-    if (total_discs) free(total_discs);
     if (data) free(data);
     if (filename) free(filename);
     if (json) json_value_free(json);
 }
 
-void aacenc_put_tag_entry(m4af_ctx_t *m4af, const aacenc_tag_entry_t *tag)
+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;
-    uint32_t data_size = tag->data_size;
-    char *file_contents = 0;
 
-    if (tag->is_file_name) {
-        data = file_contents = aacenc_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)
@@ -320,59 +417,22 @@ void aacenc_put_tag_entry(m4af_ctx_t *m4af, const aacenc_tag_entry_t *tag)
                 data_type = M4AF_PNG;
             if (data_type)
                 m4af_add_itmf_short_tag(m4af, tag->tag, data_type,
-                                        data, data_size);
+                                        data, tag->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);
+            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);
     }
-    if (file_contents) free(file_contents);
 }
 
 

src/metadata.h

@@ -1,28 +1,44 @@
 #ifndef METADATA_H
 #define METADATA_H
 
+#include "m4af.h"
+
 typedef struct aacenc_tag_entry_t {
     uint32_t tag;
-    const char *name;
-    const char *data;
+    char    *name;
+    char    *data;
     uint32_t data_size;
-    int         is_file_name;
 } aacenc_tag_entry_t;
 
-typedef struct aacenc_tag_param_t {
+typedef struct aacenc_tag_store_t {
     aacenc_tag_entry_t *tag_table;
     unsigned tag_count;
     unsigned tag_table_capacity;
-} aacenc_tag_param_t;
+} aacenc_tag_store_t;
 
-char *aacenc_load_tag_from_file(const char *path, uint32_t *data_size);
+typedef struct aacenc_translate_generic_text_tag_ctx_t {
+    unsigned track, track_total, disc, disc_total;
+    void   (*add)(void *, const aacenc_tag_entry_t *);
+    void    *add_ctx;
+} aacenc_translate_generic_text_tag_ctx_t;
 
-void aacenc_param_add_itmf_entry(aacenc_tag_param_t *params, uint32_t tag,
+typedef void (*aacenc_tag_callback_t)(void *ctx, const char *key,
+                                      const char *value, uint32_t size);
+
+void aacenc_translate_generic_text_tag(void *ctx, const char *key,
+                                       const char *val, uint32_t size);
+
+
+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);
 
-void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename);
+void aacenc_add_tag_entry_to_store(void *store, const aacenc_tag_entry_t *tag);
 
-void aacenc_put_tag_entry(m4af_ctx_t *m4af, const aacenc_tag_entry_t *tag);
+void aacenc_free_tag_store(aacenc_tag_store_t *store);
+
+void aacenc_write_tags_from_json(m4af_ctx_t *m4af, const char *json_filename);
+
+void aacenc_write_tag_entry(void *m4af, const aacenc_tag_entry_t *tag);
 
 #endif

src/pcm_reader.h

@@ -0,0 +1,112 @@
+#ifndef PCM_READER_H
+#define PCM_READER_H
+
+#include "lpcm.h"
+
+typedef struct pcm_reader_t pcm_reader_t;
+
+typedef struct pcm_reader_vtbl_t {
+    const pcm_sample_description_t *(*get_format)(pcm_reader_t *);
+    int64_t (*get_length)(pcm_reader_t *);
+    int64_t (*get_position)(pcm_reader_t *);
+    int (*read_frames)(pcm_reader_t *, void *, unsigned);
+    void (*teardown)(pcm_reader_t **);
+} pcm_reader_vtbl_t;
+
+struct pcm_reader_t {
+    pcm_reader_vtbl_t *vtbl;
+};
+
+typedef int (*pcm_read_callback)(void *cookie, void *data, uint32_t count);
+typedef int (*pcm_seek_callback)(void *cookie, int64_t off, int whence);
+typedef int64_t (*pcm_tell_callback)(void *cookie);
+
+typedef struct pcm_io_vtbl_t {
+    pcm_read_callback read;
+    pcm_seek_callback seek;
+    pcm_tell_callback tell;
+} pcm_io_vtbl_t;
+
+typedef struct pcm_io_context_t {
+    pcm_io_vtbl_t *vtbl;
+    void *cookie;
+} pcm_io_context_t;
+
+static inline
+const pcm_sample_description_t *pcm_get_format(pcm_reader_t *r)
+{
+    return r->vtbl->get_format(r);
+}
+
+static inline
+int64_t pcm_get_length(pcm_reader_t *r)
+{
+    return r->vtbl->get_length(r);
+}
+
+static inline
+int64_t pcm_get_position(pcm_reader_t *r)
+{
+    return r->vtbl->get_position(r);
+}
+
+static inline
+int64_t pcm_read_frames(pcm_reader_t *r, void *data, unsigned nframes)
+{
+    return r->vtbl->read_frames(r, data, nframes);
+}
+
+static inline
+void pcm_teardown(pcm_reader_t **r)
+{
+    (*r)->vtbl->teardown(r);
+}
+
+static inline
+uint32_t bitcount(uint32_t bits)
+{
+    bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
+    bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
+    bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
+    bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
+    return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
+}
+
+#define TRY_IO(expr) \
+    do { \
+        if ((expr)) goto FAIL; \
+    } while (0)
+
+#define ENSURE(expr) \
+    do { \
+        if (!(expr)) goto FAIL;\
+    } while (0)
+
+int pcm_read(pcm_io_context_t *io, void *buffer, uint32_t size);
+int pcm_skip(pcm_io_context_t *io, int64_t count);
+
+static int pcm_seek(pcm_io_context_t *io, int64_t off, int whence)
+{
+    return io->vtbl->seek ? io->vtbl->seek(io->cookie, off, whence) : -1;
+}
+
+static inline int64_t pcm_tell(pcm_io_context_t *io)
+{
+    return io->vtbl->tell ? io->vtbl->tell(io->cookie) : -1;
+}
+
+int pcm_read16le(pcm_io_context_t *io, uint16_t *value);
+int pcm_read16be(pcm_io_context_t *io, uint16_t *value);
+int pcm_read32le(pcm_io_context_t *io, uint32_t *value);
+int pcm_read32be(pcm_io_context_t *io, uint32_t *value);
+int pcm_read64le(pcm_io_context_t *io, uint64_t *value);
+int pcm_read64be(pcm_io_context_t *io, uint64_t *value);
+int pcm_scanl(pcm_io_context_t *io, const char *fmt, ...);
+int pcm_scanb(pcm_io_context_t *io, const char *fmt, ...);
+
+int apple_chan_chunk(pcm_io_context_t *io, uint32_t chunk_size,
+                     pcm_sample_description_t *fmt, uint8_t *mapping);
+
+pcm_reader_t *pcm_open_sint16_converter(pcm_reader_t *reader);
+
+#endif

src/pcm_readhelper.c

@@ -0,0 +1,356 @@
+/* 
+ * 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
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include "pcm_reader.h"
+#include "m4af_endian.h"
+#include "catypes.h"
+
+int pcm_read(pcm_io_context_t *io, void *buffer, uint32_t size)
+{
+    int rc;
+    uint32_t count = 0;
+
+    do {
+        rc = io->vtbl->read(io->cookie, buffer, size - count);
+        if (rc > 0)
+            count += rc;
+    } while (rc > 0 && count < size);
+    return count > 0 ? count : rc;
+}
+
+int pcm_skip(pcm_io_context_t *io, int64_t count)
+{
+    char buff[8192];
+    int rc;
+    pcm_io_vtbl_t *vp = io->vtbl;
+
+    if (count == 0 || pcm_seek(io, count, SEEK_CUR) >= 0)
+        return 0;
+    do {
+        if ((rc = vp->read(io->cookie, buff, count > 8192 ? 8192 : count)) > 0)
+            count -= rc;
+    } while (rc > 0 && count > 0);
+
+    return count == 0 ? 0 : -1;
+}
+
+int pcm_read16le(pcm_io_context_t *io, uint16_t *value)
+{
+    if (pcm_read(io, value, 2) == 2) {
+        *value = m4af_ltoh16(*value);
+        return 0;
+    }
+    return -1;
+}
+
+int pcm_read16be(pcm_io_context_t *io, uint16_t *value)
+{
+    if (pcm_read(io, value, 2) == 2) {
+        *value = m4af_btoh16(*value);
+        return 0;
+    }
+    return -1;
+}
+
+int pcm_read32le(pcm_io_context_t *io, uint32_t *value)
+{
+    if (pcm_read(io, value, 4) == 4) {
+        *value = m4af_ltoh32(*value);
+        return 0;
+    }
+    return -1;
+}
+
+int pcm_read32be(pcm_io_context_t *io, uint32_t *value)
+{
+    if (pcm_read(io, value, 4) == 4) {
+        *value = m4af_btoh32(*value);
+        return 0;
+    }
+    return -1;
+}
+
+int pcm_read64le(pcm_io_context_t *io, uint64_t *value)
+{
+    if (pcm_read(io, value, 8) == 8) {
+        *value = m4af_ltoh64(*value);
+        return 0;
+    }
+    return -1;
+}
+
+int pcm_read64be(pcm_io_context_t *io, uint64_t *value)
+{
+    if (pcm_read(io, value, 8) == 8) {
+        *value = m4af_btoh64(*value);
+        return 0;
+    }
+    return -1;
+}
+
+int pcm_scanl(pcm_io_context_t *io, const char *fmt, ...)
+{
+    int c, count = 0;
+    va_list ap;
+
+    va_start(ap, fmt);
+    while ((c = *fmt++)) {
+        switch (c) {
+        case 'S':
+            TRY_IO(pcm_read16le(io, va_arg(ap, uint16_t*)));
+            ++count;
+            break;
+        case 'L':
+            TRY_IO(pcm_read32le(io, va_arg(ap, uint32_t*)));
+            ++count;
+            break;
+        case 'Q':
+            TRY_IO(pcm_read64le(io, va_arg(ap, uint64_t*)));
+            ++count;
+            break;
+        }
+    }
+FAIL:
+    va_end(ap);
+    return count;
+}
+
+int pcm_scanb(pcm_io_context_t *io, const char *fmt, ...)
+{
+    int c, count = 0;
+    va_list ap;
+
+    va_start(ap, fmt);
+    while ((c = *fmt++)) {
+        switch (c) {
+        case 'S':
+            TRY_IO(pcm_read16be(io, va_arg(ap, uint16_t*)));
+            ++count;
+            break;
+        case 'L':
+            TRY_IO(pcm_read32be(io, va_arg(ap, uint32_t*)));
+            ++count;
+            break;
+        case 'Q':
+            TRY_IO(pcm_read64be(io, va_arg(ap, uint64_t*)));
+            ++count;
+            break;
+        }
+    }
+FAIL:
+    va_end(ap);
+    return count;
+}
+
+static
+int channel_compare(const void *a, const void *b)
+{
+    return (*(const uint8_t **)a)[0] - (*(const uint8_t **)b)[0];
+}
+
+void apple_translate_channel_labels(uint8_t *channels, unsigned n)
+{
+    unsigned i;
+    char *has_side = strpbrk((char*)channels, "\x0A\x0B");
+
+    for (i = 0; i < n; ++i) {
+        switch (channels[i]) {
+        case kAudioChannelLabel_LeftSurround:
+        case kAudioChannelLabel_RightSurround:
+            if (!has_side) channels[i] += 5; // map to SL/SR
+            break;
+        case kAudioChannelLabel_RearSurroundLeft:
+        case kAudioChannelLabel_RearSurroundRight:
+            if (!has_side) channels[i] -= 28; // map to BL/BR
+            break;
+        case kAudioChannelLabel_Mono:
+            channels[i] = kAudioChannelLabel_Center;
+            break;
+        }
+    }
+}
+
+int apple_chan_chunk(pcm_io_context_t *io, uint32_t chunk_size,
+                     pcm_sample_description_t *fmt, uint8_t *mapping)
+{
+    /*
+     * Although FDK encoder supports upto 5.1ch, we handle upto
+     * 8 channels here.
+     */
+    uint32_t i, mChannelLayoutTag, mChannelBitmap, mNumberChannelDescriptions;
+    uint32_t mask = 0;
+    const uint32_t nchannels = fmt->channels_per_frame;
+    uint8_t channels[9] = { 0 };
+    uint8_t *index[8] = { 0 };
+    const char *layout = 0;
+
+    ENSURE(chunk_size >= 12);
+    TRY_IO(pcm_scanb(io, "LLL", &mChannelLayoutTag, &mChannelBitmap,
+                     &mNumberChannelDescriptions) != 3);
+
+    switch (mChannelLayoutTag) {
+    case kAudioChannelLayoutTag_UseChannelBitmap:
+        ENSURE(bitcount(mask) == nchannels);
+        TRY_IO(pcm_skip(io, chunk_size - 12));
+        fmt->channel_mask = mChannelBitmap;
+        for (i = 0; i < nchannels; ++i)
+            mapping[i] = i;
+        return 0;
+    case kAudioChannelLayoutTag_UseChannelDescriptions:
+        ENSURE(mNumberChannelDescriptions == nchannels);
+        ENSURE(chunk_size >= 12 + nchannels * 20);
+        for (i = 0; i < mNumberChannelDescriptions; ++i) {
+            uint32_t mChannelLabel;
+            TRY_IO(pcm_read32be(io, &mChannelLabel));
+            ENSURE(mChannelLabel && mChannelLabel <= 0xff);
+            channels[i] = mChannelLabel;
+            TRY_IO(pcm_skip(io, 16));
+        }
+        TRY_IO(pcm_skip(io, chunk_size - 12 - nchannels * 20));
+        apple_translate_channel_labels(channels, nchannels);
+        for (i = 0; i < nchannels; ++i)
+            if (channels[i] > kAudioChannelLabel_TopBackLeft)
+                goto FAIL;
+        break;
+    default:
+        ENSURE((mChannelLayoutTag & 0xffff) == nchannels);
+        TRY_IO(pcm_skip(io, chunk_size - 12));
+
+        switch (mChannelLayoutTag) {
+        /* 1ch */
+        case kAudioChannelLayoutTag_Mono:
+            layout = "\x03"; break;
+        /* 1.1ch */
+        case kAudioChannelLayoutTag_AC3_1_0_1:
+            layout = "\x03\x04"; break;
+        /* 2ch */
+        case kAudioChannelLayoutTag_Stereo:
+        case kAudioChannelLayoutTag_MatrixStereo:
+        case kAudioChannelLayoutTag_Binaural:
+            layout = "\x01\x02"; break;
+        /* 2.1ch */
+        case kAudioChannelLayoutTag_DVD_4:
+            layout = "\x01\x02\x04"; break;
+        /* 3ch */
+        case kAudioChannelLayoutTag_MPEG_3_0_A:
+            layout = "\x01\x02\x03"; break;
+        case kAudioChannelLayoutTag_AC3_3_0:
+            layout = "\x01\x03\x02"; break;
+        case kAudioChannelLayoutTag_MPEG_3_0_B:
+            layout = "\x03\x01\x02"; break;
+        case kAudioChannelLayoutTag_ITU_2_1:
+            layout = "\x01\x02\x09"; break;
+        /* 3.1ch */
+        case kAudioChannelLayoutTag_DVD_10:
+            layout = "\x01\x02\x03\x04"; break;
+        case kAudioChannelLayoutTag_AC3_3_0_1:
+            layout = "\x01\x03\x02\x04"; break;
+        case kAudioChannelLayoutTag_DVD_5:
+            layout = "\x01\x02\x04\x09"; break;
+        case kAudioChannelLayoutTag_AC3_2_1_1:
+            layout = "\x01\x02\x09\x04"; break;
+        /* 4ch */
+        case kAudioChannelLayoutTag_Quadraphonic:
+        case kAudioChannelLayoutTag_ITU_2_2:
+            layout = "\x01\x02\x0A\x0B"; break;
+        case kAudioChannelLayoutTag_MPEG_4_0_A:
+            layout = "\x01\x02\x03\x09"; break;
+        case kAudioChannelLayoutTag_MPEG_4_0_B:
+            layout = "\x03\x01\x02\x09"; break;
+        case kAudioChannelLayoutTag_AC3_3_1:
+            layout = "\x01\x03\x02\x09"; break;
+        /* 4.1ch */
+        case kAudioChannelLayoutTag_DVD_6:
+            layout = "\x01\x02\x04\x0A\x0B"; break;
+        case kAudioChannelLayoutTag_DVD_18:
+            layout = "\x01\x02\x0A\x0B\x04"; break;
+        case kAudioChannelLayoutTag_DVD_11:
+            layout = "\x01\x02\x03\x04\x09"; break;
+        case kAudioChannelLayoutTag_AC3_3_1_1:
+            layout = "\x01\x03\x02\x09\x04"; break;
+        /* 5ch */
+        case kAudioChannelLayoutTag_MPEG_5_0_A:
+            layout = "\x01\x02\x03\x0A\x0B"; break;
+        case kAudioChannelLayoutTag_Pentagonal:
+        case kAudioChannelLayoutTag_MPEG_5_0_B:
+            layout = "\x01\x02\x0A\x0B\x03"; break;
+        case kAudioChannelLayoutTag_MPEG_5_0_C:
+            layout = "\x01\x03\x02\x0A\x0B"; break;
+        case kAudioChannelLayoutTag_MPEG_5_0_D:
+            layout = "\x03\x01\x02\x0A\x0B"; break;
+        /* 5.1ch */
+        case kAudioChannelLayoutTag_MPEG_5_1_A:
+            layout = "\x01\x02\x03\x04\x0A\x0B"; break;
+        case kAudioChannelLayoutTag_MPEG_5_1_B:
+            layout = "\x01\x02\x0A\x0B\x03\x04"; break;
+        case kAudioChannelLayoutTag_MPEG_5_1_C:
+            layout = "\x01\x03\x02\x0A\x0B\x04"; break;
+        case kAudioChannelLayoutTag_MPEG_5_1_D:
+            layout = "\x03\x01\x02\x0A\x0B\x04"; break;
+        /* 6ch */
+        case kAudioChannelLayoutTag_Hexagonal:
+        case kAudioChannelLayoutTag_AudioUnit_6_0:
+            layout = "\x01\x02\x0A\x0B\x03\x09"; break;
+        case kAudioChannelLayoutTag_AAC_6_0:
+            layout = "\x03\x01\x02\x0A\x0B\x09"; break;
+        /* 6.1ch */
+        case kAudioChannelLayoutTag_MPEG_6_1_A:
+            layout = "\x01\x02\x03\x04\x0A\x0B\x09"; break;
+        case kAudioChannelLayoutTag_AAC_6_1:
+            layout = "\x03\x01\x02\x0A\x0B\x09\x04"; break;
+        /* 7ch */
+        case kAudioChannelLayoutTag_AudioUnit_7_0:
+            layout = "\x01\x02\x0A\x0B\x03\x05\x06"; break;
+        case kAudioChannelLayoutTag_AudioUnit_7_0_Front:
+            layout = "\x01\x02\x0A\x0B\x03\x07\x08"; break;
+        case kAudioChannelLayoutTag_AAC_7_0:
+            layout = "\x03\x01\x02\x0A\x0B\x05\x06"; break;
+        /* 7.1ch */
+        case kAudioChannelLayoutTag_MPEG_7_1_A:
+            layout = "\x01\x02\x03\x04\x0A\x0B\x07\x08"; break;
+        case kAudioChannelLayoutTag_MPEG_7_1_B:
+            layout = "\x03\x07\x08\x01\x02\x05\x06\x04"; break;
+        case kAudioChannelLayoutTag_MPEG_7_1_C:
+            layout = "\x01\x02\x03\x04\x0A\x0B\x05\x06"; break;
+        case kAudioChannelLayoutTag_Emagic_Default_7_1:
+            layout = "\x01\x02\x0A\x0B\x03\x04\x07\x08"; break;
+        /* 8ch */
+        case kAudioChannelLayoutTag_Octagonal:
+            layout = "\x01\x02\x05\x06\x03\x09\x0A\x0B"; break;
+        case kAudioChannelLayoutTag_AAC_Octagonal:
+            layout = "\x03\x01\x02\x0A\x0B\x05\x06\x09"; break;
+        default:
+            goto FAIL;
+        }
+        strcpy((char*)channels, layout);
+    }
+
+    for (i = 0; i < nchannels; ++i)
+        mask |= 1 << (channels[i] - 1);
+    fmt->channel_mask = mask;
+    ENSURE(bitcount(mask) == nchannels);
+
+    for (i = 0; i < nchannels; ++i) 
+        index[i] = channels + i;
+    qsort(index, nchannels, sizeof(char*), channel_compare);
+    for (i = 0; i < nchannels; ++i) 
+        mapping[i] = index[i] - channels;
+
+    return 0;
+FAIL:
+    return -1;
+}

src/pcm_sint16_converter.c

@@ -0,0 +1,90 @@
+#if HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#if HAVE_STDINT_H
+#  include <stdint.h>
+#endif
+#include "pcm_reader.h"
+
+typedef struct pcm_sint16_converter_t {
+    pcm_reader_vtbl_t *vtbl;
+    pcm_reader_t *src;
+    pcm_sample_description_t format;
+    void *pivot;
+    unsigned capacity;
+} pcm_sint16_converter_t;
+
+static inline pcm_reader_t *get_source(pcm_reader_t *reader)
+{
+    return ((pcm_sint16_converter_t *)reader)->src;
+}
+
+static const
+pcm_sample_description_t *get_format(pcm_reader_t *reader)
+{
+    return &((pcm_sint16_converter_t *)reader)->format;
+}
+
+static int64_t get_length(pcm_reader_t *reader)
+{
+    return pcm_get_length(get_source(reader));
+}
+
+static int64_t get_position(pcm_reader_t *reader)
+{
+    return pcm_get_position(get_source(reader));
+}
+
+static int read_frames(pcm_reader_t *reader, void *buffer, unsigned nframes)
+{
+    pcm_sint16_converter_t *self = (pcm_sint16_converter_t *)reader;
+    const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
+    unsigned bytes = nframes * sfmt->bytes_per_frame;
+
+    if (self->capacity < bytes) {
+        void *p = realloc(self->pivot, bytes);
+        if (!p) return -1;
+        self->pivot = p;
+        self->capacity = bytes;
+    }
+    nframes = pcm_read_frames(self->src, self->pivot, nframes);
+    if (pcm_convert_to_native_sint16(sfmt, self->pivot, nframes, buffer) < 0)
+        return -1;
+    return nframes;
+}
+
+static void teardown(pcm_reader_t **reader)
+{
+    pcm_sint16_converter_t *self = (pcm_sint16_converter_t *)*reader;
+    pcm_teardown(&self->src);
+    free(self->pivot);
+    free(self);
+    *reader = 0;
+}
+
+static pcm_reader_vtbl_t my_vtable = {
+    get_format, get_length, get_position, read_frames, teardown
+};
+
+pcm_reader_t *pcm_open_sint16_converter(pcm_reader_t *reader)
+{
+    pcm_sint16_converter_t *self = 0;
+    pcm_sample_description_t *fmt;
+
+    if ((self = calloc(1, sizeof(pcm_sint16_converter_t))) == 0)
+        return 0;
+    self->src = reader;
+    self->vtbl = &my_vtable;
+    memcpy(&self->format, pcm_get_format(reader), sizeof(self->format));
+    fmt = &self->format;
+#if WORDS_BIGENDIAN
+    fmt->sample_type = PCM_TYPE_SINT_BE;
+#else
+    fmt->sample_type = PCM_TYPE_SINT;
+#endif
+    fmt->bits_per_channel = 16;
+    fmt->bytes_per_frame = 2 * fmt->channels_per_frame;
+    return (pcm_reader_t *)self;
+}

src/wav_reader.c

@@ -15,35 +15,18 @@
 #include <string.h>
 #include <stdarg.h>
 #include "wav_reader.h"
-#include "m4af_endian.h"
 
 #define RIFF_FOURCC(a,b,c,d) ((a)|((b)<<8)|((c)<<16)|((d)<<24))
 
-#define TRY_IO(expr) \
-    do { \
-        if (expr) \
-            goto FAIL; \
-    } while (0)
-
-#define ASSERT_FORMAT(ctx, expr) \
-    do { \
-        if (!expr) { \
-            if (!ctx->last_error) \
-                ctx->last_error = WAV_INVALID_FORMAT; \
-            goto FAIL;\
-        } \
-    } while (0)
-
-struct wav_reader_t {
+typedef struct wav_reader_t {
+    pcm_reader_vtbl_t *vtbl;
     pcm_sample_description_t sample_format;
     int64_t length;
     int64_t position;
     int32_t data_offset;
     int ignore_length;
-    int last_error;
-    wav_io_context_t io;
-    void *io_cookie;
-};
+    pcm_io_context_t io;
+} wav_reader_t;
 
 static const uint8_t WAV_GUID_PCM[] = {
     1, 0, 0, 0, 0, 0, 0x10, 0, 0x80, 0, 0, 0xaa, 0, 0x38, 0x9b, 0x71
@@ -52,177 +35,46 @@ static const uint8_t WAV_GUID_FLOAT[] = {
     3, 0, 0, 0, 0, 0, 0x10, 0, 0x80, 0, 0, 0xaa, 0, 0x38, 0x9b, 0x71
 };
 
-const pcm_sample_description_t *wav_get_format(wav_reader_t *reader)
+static const pcm_sample_description_t *wav_get_format(pcm_reader_t *reader)
 {
-    return &reader->sample_format;
+    return &((wav_reader_t *)reader)->sample_format;
 }
 
-int64_t wav_get_length(wav_reader_t *reader)
+static int64_t wav_get_length(pcm_reader_t *reader)
 {
-    return reader->length;
+    return ((wav_reader_t *)reader)->length;
 }
 
-int64_t wav_get_position(wav_reader_t *reader)
+static int64_t wav_get_position(pcm_reader_t *reader)
 {
-    return reader->position;
+    return ((wav_reader_t *)reader)->position;
 }
 
-void wav_teardown(wav_reader_t **reader)
+static void wav_teardown(pcm_reader_t **reader)
 {
     free(*reader);
     *reader = 0;
 }
 
-static
-int riff_read(wav_reader_t *reader, void *buffer, uint32_t size)
-{
-    int rc;
-    uint32_t count = 0;
-
-    if (reader->last_error)
-        return -1;
-    do {
-        rc = reader->io.read(reader->io_cookie, buffer, size - count);
-        if (rc > 0)
-            count += rc;
-        else if (rc < 0)
-            reader->last_error = WAV_IO_ERROR;
-    } while (rc > 0 && count < size);
-    return count > 0 ? count : rc;
-}
-
-static
-int riff_skip(wav_reader_t *reader, int64_t count)
-{
-    char buff[8192];
-    int rc;
-
-    if (reader->last_error)
-        return -1;
-    if (count == 0)
-        return 0;
-    if (reader->io.seek &&
-        reader->io.seek(reader->io_cookie, count, SEEK_CUR) >= 0)
-        return 0;
-
-    do {
-        if ((rc = riff_read(reader, buff, count > 8192 ? 8192 : count)) > 0)
-            count -= rc;
-    } while (rc > 0 && count > 0);
-
-    if (count > 0)
-        reader->last_error = WAV_IO_ERROR;
-    return reader->last_error ? -1 : 0;
-}
-
-static
-int riff_seek(wav_reader_t *reader, int64_t off, int whence)
-{
-    int rc;
-    if (reader->last_error)
-        return -1;
-    if (!reader->io.seek)
-        goto FAIL;
-    if ((rc = reader->io.seek(reader->io_cookie, off, whence)) < 0)
-        goto FAIL;
-    return 0;
-FAIL:
-    reader->last_error = WAV_IO_ERROR;
-    return -1;
-}
-
-static
-int64_t riff_tell(wav_reader_t *reader)
-{
-    int64_t off;
-
-    if (reader->last_error || !reader->io.tell)
-        return -1;
-    off = reader->io.tell(reader->io_cookie);
-    if (off < 0) {
-        reader->last_error = WAV_IO_ERROR;
-        return -1;
-    }
-    return off;
-}
-
-static
-int riff_read16(wav_reader_t *reader, uint16_t *value)
-{
-    TRY_IO(riff_read(reader, value, 2) != 2);
-    *value = m4af_ltoh16(*value);
-    return 0;
-FAIL:
-    return -1;
-}
-
-static
-int riff_read32(wav_reader_t *reader, uint32_t *value)
-{
-    TRY_IO(riff_read(reader, value, 4) != 4);
-    *value = m4af_ltoh32(*value);
-    return 0;
-FAIL:
-    return -1;
-}
-
-static
-int riff_read64(wav_reader_t *reader, uint64_t *value)
-{
-    TRY_IO(riff_read(reader, value, 8) != 8);
-    *value = m4af_ltoh64(*value);
-    return 0;
-FAIL:
-    return -1;
-}
-
-static
-int riff_scan(wav_reader_t *reader, const char *fmt, ...)
-{
-    int c, count = 0;
-    va_list ap;
-
-    va_start(ap, fmt);
-    while ((c = *fmt++)) {
-        switch (c) {
-        case 'S':
-            TRY_IO(riff_read16(reader, va_arg(ap, uint16_t*)));
-            ++count;
-            break;
-        case 'L':
-            TRY_IO(riff_read32(reader, va_arg(ap, uint32_t*)));
-            ++count;
-            break;
-        case 'Q':
-            TRY_IO(riff_read64(reader, va_arg(ap, uint64_t*)));
-            ++count;
-            break;
-        }
-    }
-FAIL:
-    va_end(ap);
-    return count;
-}
-
 static
 uint32_t riff_next_chunk(wav_reader_t *reader, uint32_t *chunk_size)
 {
     uint32_t fcc;
-    if (riff_scan(reader, "LL", &fcc, chunk_size) == 2)
-        return fcc;
-    return 0;
+    return (pcm_scanl(&reader->io, "LL", &fcc, chunk_size) == 2) ? fcc : 0;
 }
 
-int wav_read_frames(wav_reader_t *reader, void *buffer, unsigned nframes)
+static
+int wav_read_frames(pcm_reader_t *preader, void *buffer, unsigned nframes)
 {
     int rc;
     unsigned nbytes;
+    wav_reader_t *reader = (wav_reader_t *)preader;
 
     if (!reader->ignore_length && nframes > reader->length - reader->position)
         nframes = reader->length - reader->position;
     nbytes = nframes * reader->sample_format.bytes_per_frame;
     if (nbytes) {
-        if ((rc = riff_read(reader, buffer, nbytes)) < 0)
+        if ((rc = pcm_read(&reader->io, buffer, nbytes)) < 0)
             return -1;
         nframes = rc / reader->sample_format.bytes_per_frame;
         reader->position += nframes;
@@ -237,11 +89,10 @@ int riff_ds64(wav_reader_t *reader, int64_t *length)
     uint64_t riff_size, sample_count;
 
     fcc = riff_next_chunk(reader, &chunk_size);
-    ASSERT_FORMAT(reader,
-                  fcc == RIFF_FOURCC('d','s','6','4') && chunk_size >= 28);
-    TRY_IO(riff_scan(reader, "QQQL",
+    ENSURE(fcc == RIFF_FOURCC('d','s','6','4') && chunk_size >= 28);
+    TRY_IO(pcm_scanl(&reader->io, "QQQL",
                      &riff_size, length, &sample_count, &table_size) != 4);
-    TRY_IO(riff_skip(reader, (chunk_size - 27) & ~1));
+    TRY_IO(pcm_skip(&reader->io, (chunk_size - 27) & ~1));
     reader->data_offset += (chunk_size + 9) & ~1;
 FAIL:
     return -1;
@@ -256,41 +107,34 @@ int wav_fmt(wav_reader_t *reader, uint32_t size)
     uint8_t guid[16];
     int is_float = 0;
 
-    ASSERT_FORMAT(reader, size >= 16);
-    TRY_IO(riff_scan(reader, "SSLLSS", &wFormatTag, &nChannels,
+    ENSURE(size >= 16);
+    TRY_IO(pcm_scanl(&reader->io, "SSLLSS", &wFormatTag, &nChannels,
                      &nSamplesPerSec, &nAvgBytesPerSec, &nBlockAlign,
                      &wBitsPerSample) != 6);
     wValidBitsPerSample = wBitsPerSample;
 
-    if (wFormatTag != 1 && wFormatTag != 3 && wFormatTag != 0xfffe) {
-        reader->last_error = WAV_UNSUPPORTED_FORMAT;
-        goto FAIL;
-    }
-    ASSERT_FORMAT(reader,
-                  nChannels && nSamplesPerSec && nAvgBytesPerSec &&
+    ENSURE(wFormatTag == 1 || wFormatTag == 3 || wFormatTag == 0xfffe);
+    ENSURE(nChannels && nSamplesPerSec && nAvgBytesPerSec &&
            nBlockAlign && wBitsPerSample && !(wBitsPerSample & 7) &&
            nBlockAlign == nChannels * wBitsPerSample / 8);
+
     if (wFormatTag == 3)
         is_float = 1;
 
     if (wFormatTag != 0xfffe)
-        TRY_IO(riff_skip(reader, (size - 15) & ~1));
+        TRY_IO(pcm_skip(&reader->io, (size - 15) & ~1));
     else {
-        ASSERT_FORMAT(reader, size >= 40);
-        TRY_IO(riff_scan(reader, "SSL",
+        ENSURE(size >= 40);
+        TRY_IO(pcm_scanl(&reader->io, "SSL",
                          &cbSize, &wValidBitsPerSample, &dwChannelMask) != 3);
-        TRY_IO(riff_read(reader, guid, 16) != 16);
+        TRY_IO(pcm_read(&reader->io, guid, 16) != 16);
 
         if (memcmp(guid, WAV_GUID_FLOAT, 16) == 0)
             is_float = 1;
-        else if (memcmp(guid, WAV_GUID_PCM, 16) != 0) {
-            reader->last_error = WAV_UNSUPPORTED_FORMAT;
+        else if (memcmp(guid, WAV_GUID_PCM, 16) != 0)
             goto FAIL;
-        }
-        ASSERT_FORMAT(reader,
-                      wValidBitsPerSample &&
-                      wValidBitsPerSample <= wBitsPerSample);
-        TRY_IO(riff_skip(reader, (size - 39) & ~1));
+        ENSURE(wValidBitsPerSample && wValidBitsPerSample <= wBitsPerSample);
+        TRY_IO(pcm_skip(&reader->io, (size - 39) & ~1));
     }
     reader->sample_format.sample_rate = nSamplesPerSec;
     reader->sample_format.bits_per_channel = wValidBitsPerSample;
@@ -315,12 +159,10 @@ int wav_parse(wav_reader_t *reader, int64_t *data_length)
 
     *data_length = 0;
     container = riff_next_chunk(reader, &chunk_size);
-    if (container != RIFF_FOURCC('R','I','F','F') &&
-        container != RIFF_FOURCC('R','F','6','4'))
-        goto FAIL;
-    TRY_IO(riff_read32(reader, &fcc));
-    if (fcc != RIFF_FOURCC('W','A','V','E'))
-        goto FAIL;
+    ENSURE(container == RIFF_FOURCC('R','I','F','F') ||
+           container == RIFF_FOURCC('R','F','6','4'));
+    TRY_IO(pcm_read32le(&reader->io, &fcc));
+    ENSURE(fcc == RIFF_FOURCC('W','A','V','E'));
     reader->data_offset = 12;
 
     if (container == RIFF_FOURCC('R','F','6','4'))
@@ -335,7 +177,7 @@ int wav_parse(wav_reader_t *reader, int64_t *data_length)
             reader->data_offset += 8;
             break;
         } else {
-            TRY_IO(riff_skip(reader, (chunk_size + 1) & ~1));
+            TRY_IO(pcm_skip(&reader->io, (chunk_size + 1) & ~1));
         }
         reader->data_offset += (chunk_size + 9) & ~1;
     }
@@ -345,8 +187,15 @@ FAIL:
     return -1;
 }
 
-wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
-                       int ignore_length)
+static pcm_reader_vtbl_t wav_vtable = {
+    wav_get_format,
+    wav_get_length,
+    wav_get_position,
+    wav_read_frames,
+    wav_teardown
+};
+
+pcm_reader_t *wav_open(pcm_io_context_t *io, int ignore_length)
 {
     wav_reader_t *reader = 0;
     int64_t data_length;
@@ -354,8 +203,7 @@ wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
 
     if ((reader = calloc(1, sizeof(wav_reader_t))) == 0)
         return 0;
-    memcpy(&reader->io, io_ctx, sizeof(wav_io_context_t));
-    reader->io_cookie = io_cookie;
+    memcpy(&reader->io, io, sizeof(pcm_io_context_t));
     reader->ignore_length = ignore_length;
     if (wav_parse(reader, &data_length) < 0) {
         free(reader);
@@ -367,37 +215,34 @@ wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
     else
         reader->length = data_length / bpf;
 
-    if (reader->length == INT64_MAX && reader->io.seek && reader->io.tell) {
-        if (reader->io.seek(reader->io_cookie, 0, SEEK_END) >= 0) {
-            int64_t size = reader->io.tell(reader->io_cookie);
+    if (reader->length == INT64_MAX) {
+        if (pcm_seek(&reader->io, 0, SEEK_END) >= 0) {
+            int64_t size = pcm_tell(&reader->io);
             if (size > 0)
                 reader->length = (size - reader->data_offset) / bpf;
-            reader->io.seek(reader->io_cookie, reader->data_offset, SEEK_SET);
+            pcm_seek(&reader->io, reader->data_offset, SEEK_SET);
         }
     }
-    return reader;
+    reader->vtbl = &wav_vtable;
+    return (pcm_reader_t *)reader;
 }
 
-wav_reader_t *raw_open(wav_io_context_t *io_ctx, void *io_cookie,
+pcm_reader_t *raw_open(pcm_io_context_t *io,
                        const pcm_sample_description_t *desc)
 {
     wav_reader_t *reader = 0;
 
     if ((reader = calloc(1, sizeof(wav_reader_t))) == 0)
         return 0;
-    memcpy(&reader->io, io_ctx, sizeof(wav_io_context_t));
+    memcpy(&reader->io, io, sizeof(pcm_io_context_t));
     memcpy(&reader->sample_format, desc, sizeof(pcm_sample_description_t));
-    reader->io_cookie = io_cookie;
-    if (io_ctx->seek && io_ctx->tell) {
-        if (reader->io.seek(reader->io_cookie, 0, SEEK_END) >= 0) {
-            int64_t size = reader->io.tell(reader->io_cookie);
+    if (pcm_seek(&reader->io, 0, SEEK_END) >= 0) {
+        int64_t size = pcm_tell(&reader->io);
         if (size > 0)
-                reader->length = size / desc->bytes_per_frame;
-            reader->io.seek(reader->io_cookie, reader->data_offset, SEEK_SET);
-        }
+            reader->length = size / reader->sample_format.bytes_per_frame;
+        pcm_seek(&reader->io, 0, SEEK_SET);
     } else
         reader->length = INT64_MAX;
-    return reader;
+    reader->vtbl = &wav_vtable;
+    return (pcm_reader_t *)reader;
 }
-
-

src/wav_reader.h

@@ -6,34 +6,10 @@
 #define WAV_READER_H
 
 #include "lpcm.h"
+#include "pcm_reader.h"
 
-enum wav_error_code {
-    WAV_IO_ERROR = 1,
-    WAV_NO_MEMORY,
-    WAV_INVALID_FORMAT,
-    WAV_UNSUPPORTED_FORMAT
-};
-
-typedef int (*wav_read_callback)(void *cookie, void *data, uint32_t size);
-typedef int (*wav_seek_callback)(void *cookie, int64_t off, int whence);
-typedef int64_t (*wav_tell_callback)(void *cookie);
-
-typedef struct wav_io_context_t {
-    wav_read_callback read;
-    wav_seek_callback seek;
-    wav_tell_callback tell;
-} wav_io_context_t;
-
-typedef struct wav_reader_t wav_reader_t;
-
-wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
-                       int ignore_length);
-wav_reader_t *raw_open(wav_io_context_t *io_ctx, void *io_cookie,
+pcm_reader_t *wav_open(pcm_io_context_t *io, int ignore_length);
+pcm_reader_t *raw_open(pcm_io_context_t *io,
                        const pcm_sample_description_t *desc);
-const pcm_sample_description_t *wav_get_format(wav_reader_t *reader);
-int wav_read_frames(wav_reader_t *reader, void *buffer, unsigned nframes);
-int64_t wav_get_length(wav_reader_t *reader);
-int64_t wav_get_position(wav_reader_t *reader);
-void wav_teardown(wav_reader_t **reader);
 
 #endif

version.h

@@ -1,4 +1,4 @@
 #ifndef VERSION_H
 #define VERSION_H
-const char *fdkaac_version = "0.1.7";
+const char *fdkaac_version = "0.4.1";
 #endif