bump version

MSVC/fdkaac.vcxproj

@@ -96,12 +96,14 @@ 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" />
@@ -115,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>

Makefile.am

@@ -5,11 +5,13 @@ 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

@@ -34,9 +34,16 @@ MSVC solution for Visual Studio 2010 is under MSVC directory.
 
 Available input format
 ----------------------
-WAV (or RF64), upto 32bit int / 64bit float format is supported.
-However, since FDK AAC encoder is implemented based on fixed point integer,
-encoder itself treats 16bit input only.
+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

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/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"
@@ -216,7 +217,9 @@ typedef struct aacenc_param_ex_t {
     unsigned raw_rate;
     const char *raw_format;
 
-    aacenc_tag_param_t tags;
+    aacenc_tag_store_t tags;
+    aacenc_tag_store_t source_tags;
+    aacenc_translate_generic_text_tag_ctx_t source_tag_ctx;
 
     char *json_filename;
 } aacenc_param_ex_t;
@@ -398,8 +401,8 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         case M4AF_TAG_TRACK:
         case M4AF_TAG_DISK:
         case M4AF_TAG_TEMPO:
-            aacenc_param_add_itmf_entry(&params->tags, ch, 0, optarg,
-                                        strlen(optarg), 0);
+            aacenc_add_tag_to_store(&params->tags, ch, 0, optarg,
+                                    strlen(optarg), 0);
             break;
         case OPT_SHORT_TAG:
         case OPT_SHORT_TAG_FILE:
@@ -432,9 +435,9 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
                     for (; *optarg; ++optarg)
                         fcc = ((fcc << 8) | (*optarg & 0xff));
                 }
-                aacenc_param_add_itmf_entry(&params->tags, fcc, optarg,
-                                            val, strlen(val),
-                                            ch == OPT_SHORT_TAG_FILE);
+                aacenc_add_tag_to_store(&params->tags, fcc, optarg,
+                                        val, strlen(val),
+                                        ch == OPT_SHORT_TAG_FILE);
             }
             break;
         case OPT_TAG_FROM_JSON:
@@ -570,13 +573,18 @@ int finalize_m4a(m4af_ctx_t *m4af, const aacenc_param_ex_t *params,
                  HANDLE_AACENCODER encoder)
 {
     unsigned i;
-    aacenc_tag_entry_t *tag = params->tags.tag_table;
+    aacenc_tag_entry_t *tag;
+    
+    tag = params->source_tags.tag_table;
+    for (i = 0; i < params->source_tags.tag_count; ++i, ++tag)
+        aacenc_write_tag_entry(m4af, tag);
 
     if (params->json_filename)
-        aacenc_put_tags_from_json(m4af, params->json_filename);
+        aacenc_write_tags_from_json(m4af, params->json_filename);
 
+    tag = params->tags.tag_table;
     for (i = 0; i < params->tags.tag_count; ++i, ++tag)
-        aacenc_put_tag_entry(m4af, tag);
+        aacenc_write_tag_entry(m4af, tag);
 
     put_tool_tag(m4af, params, encoder);
 
@@ -643,12 +651,15 @@ int parse_raw_spec(const char *spec, pcm_sample_description_t *desc)
     return 0;
 }
 
+static pcm_io_vtbl_t pcm_io_vtbl = {
+    read_callback, seek_callback, tell_callback
+};
+static pcm_io_vtbl_t pcm_io_vtbl_noseek = { read_callback, 0, 0 };
+
 static
 pcm_reader_t *open_input(aacenc_param_ex_t *params)
 {
-    wav_io_context_t wav_io = {
-        read_callback, seek_callback, tell_callback
-    };
+    pcm_io_context_t io = { 0 };
     pcm_reader_t *reader = 0;
     struct stat stb = { 0 };
 
@@ -657,11 +668,13 @@ pcm_reader_t *open_input(aacenc_param_ex_t *params)
                        strerror(errno));
         goto END;
     }
-    if (fstat(fileno(params->input_fp), &stb) == 0
-            && (stb.st_mode & S_IFMT) != S_IFREG) {
-        wav_io.seek = 0;
-        wav_io.tell = 0;
-    }
+    io.cookie = params->input_fp;
+    if (fstat(fileno(io.cookie), &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 };
@@ -673,14 +686,32 @@ pcm_reader_t *open_input(aacenc_param_ex_t *params)
         desc.channels_per_frame = params->raw_channels;
         bytes_per_channel = (desc.bits_per_channel + 7) / 8;
         desc.bytes_per_frame = params->raw_channels * bytes_per_channel;
-        if ((reader = raw_open(&wav_io, params->input_fp, &desc)) == 0) {
+        if ((reader = raw_open(&io, &desc)) == 0) {
             fprintf(stderr, "ERROR: failed to open raw input\n");
             goto END;
         }
     } else {
-        if ((reader = wav_open(&wav_io, params->input_fp,
-                               params->ignore_length)) == 0) {
-            fprintf(stderr, "ERROR: broken / unsupported input file\n");
+        int c;
+        ungetc(c = getc(params->input_fp), params->input_fp);
+
+        switch (c) {
+        case 'R':
+            if ((reader = wav_open(&io, params->ignore_length)) == 0) {
+                fprintf(stderr, "ERROR: broken / unsupported input file\n");
+                goto END;
+            }
+            break;
+        case 'c':
+            params->source_tag_ctx.add = aacenc_add_tag_entry_to_store;
+            params->source_tag_ctx.add_ctx = &params->source_tags;
+            if ((reader = caf_open(&io,
+                                   aacenc_translate_generic_text_tag,
+                                   &params->source_tag_ctx)) == 0) {
+                fprintf(stderr, "ERROR: broken / unsupported input file\n");
+                goto END;
+            }
+            break;
+        default:
             goto END;
         }
     }
@@ -774,7 +805,10 @@ END:
     if (params.output_fp) fclose(params.output_fp);
     if (encoder) aacEncClose(&encoder);
     if (output_filename) free(output_filename);
-    if (params.tags.tag_table) free(params.tags.tag_table);
+    if (params.tags.tag_table)
+        aacenc_free_tag_store(&params.tags);
+    if (params.source_tags.tag_table)
+        aacenc_free_tag_store(&params.source_tags);
 
     return result;
 }

src/metadata.c

@@ -50,12 +50,13 @@ 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              },
+    { "performer",                  M4AF_TAG_ARTIST              },
     { "title",                      M4AF_TAG_TITLE               },
     { "titlesort",                  M4AF_FOURCC('s','o','n','m') },
     { "titlesortorder",             M4AF_FOURCC('s','o','n','m') },
@@ -95,6 +96,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,48 +123,152 @@ END:
     return data;
 }
 
-void aacenc_param_add_itmf_entry(aacenc_tag_param_t *params, uint32_t tag,
-                                 const char *key, const char *value,
-                                 uint32_t size, int is_file_name)
+static
+int aacenc_is_string_tag(uint32_t tag)
 {
-    aacenc_tag_entry_t *entry;
+    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 = { 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_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);
+        }
     }
 }
 
@@ -188,7 +294,7 @@ const char *aacenc_json_object_get_string(JSON_Object *obj, const char *key,
     return val;
 }
 
-void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
+void aacenc_write_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
 {
     char *data = 0;
     JSON_Value *json = 0;
@@ -197,12 +303,11 @@ 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)
         *json_dot_path++ = '\0';
@@ -226,59 +331,36 @@ void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
         char buf[256];
         const char *key = json_object_get_name(root, i);
         const char *val = aacenc_json_object_get_string(root, key, buf);
-        uint32_t fcc = get_tag_fcc_from_name(key);
-        if (!val || !fcc)
-            continue;
-
-        switch (fcc) {
-        case TAG_TOTAL_DISCS:
-            total_discs = realloc(total_discs, strlen(val) + 1);
-            strcpy(total_discs, val);
-            break;
-        case TAG_TOTAL_TRACKS:
-            total_tracks = realloc(total_tracks, strlen(val) + 1);
-            strcpy(total_tracks, val);
-            break;
-        case M4AF_TAG_DISK:
-            disc = realloc(disc, strlen(val) + 1);
-            strcpy(disc, val);
-            break;
-        case M4AF_TAG_TRACK:
-            track = realloc(track, strlen(val) + 1);
-            strcpy(track, val);
-            break;
-        default:
-            {
-                entry.tag = fcc;
-                entry.data = val;
-                entry.data_size = strlen(val);
-                aacenc_put_tag_entry(m4af, &entry);
-            }
-        }
+        if (val) aacenc_translate_generic_text_tag(&ctx, key, val, ~0U);
     }
-    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)
@@ -334,59 +416,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:
-        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 (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;
-    uint32_t    data_size;
-    int         is_file_name;
+    uint32_t tag;
+    char    *name;
+    char    *data;
+    uint32_t data_size;
 } 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,
-                                 const char *key, const char *value,
-                                 uint32_t size, int is_file_name);
+typedef void (*aacenc_tag_callback_t)(void *ctx, const char *key,
+                                      const char *value, uint32_t size);
 
-void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename);
+void aacenc_translate_generic_text_tag(void *ctx, const char *key,
+                                       const char *val, uint32_t size);
 
-void aacenc_put_tag_entry(m4af_ctx_t *m4af, const aacenc_tag_entry_t *tag);
+
+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_add_tag_entry_to_store(void *store, 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

@@ -17,6 +17,21 @@ 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)
 {
@@ -47,6 +62,51 @@ 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/wav_reader.c

@@ -15,36 +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
@@ -74,144 +56,11 @@ static void wav_teardown(pcm_reader_t **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;
 }
 
 static
@@ -225,7 +74,7 @@ int wav_read_frames(pcm_reader_t *preader, void *buffer, unsigned nframes)
         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;
@@ -240,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;
@@ -259,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 &&
-                  nBlockAlign && wBitsPerSample && !(wBitsPerSample & 7) &&
-                  nBlockAlign == nChannels * wBitsPerSample / 8);
+    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;
@@ -318,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'))
@@ -338,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;
     }
@@ -356,8 +195,7 @@ static pcm_reader_vtbl_t wav_vtable = {
     wav_teardown
 };
 
-pcm_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
-                       int ignore_length)
+pcm_reader_t *wav_open(pcm_io_context_t *io, int ignore_length)
 {
     wav_reader_t *reader = 0;
     int64_t data_length;
@@ -365,8 +203,7 @@ pcm_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);
@@ -378,39 +215,34 @@ pcm_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);
         }
     }
     reader->vtbl = &wav_vtable;
     return (pcm_reader_t *)reader;
 }
 
-pcm_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 (size > 0)
-                reader->length = size / desc->bytes_per_frame;
-            reader->io.seek(reader->io_cookie, reader->data_offset, SEEK_SET);
-        }
+    if (pcm_seek(&reader->io, 0, SEEK_END) >= 0) {
+        int64_t size = pcm_tell(&reader->io);
+        if (size > 0)
+            reader->length = size / reader->sample_format.bytes_per_frame;
+        pcm_seek(&reader->io, 0, SEEK_SET);
     } else
         reader->length = INT64_MAX;
     reader->vtbl = &wav_vtable;
     return (pcm_reader_t *)reader;
 }
-
-

src/wav_reader.h

@@ -8,28 +8,8 @@
 #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;
-
-pcm_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
-                       int ignore_length);
-pcm_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);
 
 #endif

version.h

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