bump version

ChangeLog

@@ -0,0 +1,206 @@
+2013-10-22  nu774 <honeycomb77@gmail.com>
+
+  * bump version [HEAD]
+
+  * 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

@@ -102,6 +102,7 @@ copy ..\fdk-aac\libSYS\include\machine_type.h include\fdk-aac\ </Command>
     <ClCompile Include="..\src\main.c" />
     <ClCompile Include="..\src\metadata.c" />
     <ClCompile Include="..\src\parson.c" />
+    <ClCompile Include="..\src\pcm_sint16_converter.c" />
     <ClCompile Include="..\src\progress.c" />
     <ClCompile Include="..\src\wav_reader.c" />
   </ItemGroup>

MSVC/fdkaac.vcxproj.filters

@@ -56,6 +56,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

@@ -4,13 +4,14 @@ AUTOMAKE_OPTIONS = subdir-objects
 bin_PROGRAMS = fdkaac
 
 fdkaac_SOURCES = \
-    src/aacenc.c     \
+    src/aacenc.c               \
-    src/lpcm.c       \
+    src/lpcm.c                 \
-    src/m4af.c       \
+    src/m4af.c                 \
-    src/main.c       \
+    src/main.c                 \
-    src/metadata.c   \
+    src/metadata.c             \
-    src/parson.c     \
+    src/parson.c               \
-    src/progress.c   \
+    src/pcm_sint16_converter.c \
+    src/progress.c             \
     src/wav_reader.c
 
 fdkaac_LDADD = \

README

@@ -32,6 +32,19 @@ look like the following:
 
 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.
+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

@@ -97,7 +97,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/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

@@ -187,14 +187,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 +204,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 +212,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)
@@ -583,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
@@ -756,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);
@@ -823,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);
@@ -962,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)
 {
@@ -1015,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);
 }
@@ -1182,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);
@@ -1192,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
@@ -1210,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;
@@ -1227,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);
-    m4af_write_moov_box(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

@@ -148,8 +148,13 @@ PROGNAME " %s\n"
 "                               transport layer\n"
 "\n"
 " -o <filename>                 Output filename\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"
 " --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,9 +203,13 @@ typedef struct aacenc_param_ex_t {
     AACENC_PARAMS
 
     char *input_filename;
+    FILE *input_fp;
     char *output_filename;
+    FILE *output_fp;
+    unsigned gapless_mode;
     unsigned ignore_length;
     int silent;
+    int moov_before_mdat;
 
     int is_raw;
     unsigned raw_channels;
@@ -218,6 +227,7 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
     int ch;
     unsigned n;
 
+#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')
@@ -239,8 +249,10 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         { "adts-crc-check",   no_argument,       0, 'C' },
         { "header-period",    required_argument, 0, 'P' },
 
+        { "gapless-mode",     required_argument, 0, 'G' },
         { "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 +280,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':
@@ -325,7 +337,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 +350,22 @@ 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 '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;
@@ -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 *ibuf = 0;
-    int16_t *pcmbuf = 0;
-    uint32_t pcmsize = 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);
+    ibuf = malloc(frame_length * fmt->bytes_per_frame);
-    aacenc_progress_init(&progress, wav_get_length(wavf), format->sample_rate);
+    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),
+                aacenc_progress_update(&progress, pcm_get_position(reader),
-                                       format->sample_rate * 2);
+                                       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;
 }
@@ -567,7 +580,7 @@ int finalize_m4a(m4af_ctx_t *m4af, const aacenc_param_ex_t *params,
 
     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 +643,68 @@ int parse_raw_spec(const char *spec, pcm_sample_description_t *desc)
     return 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_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;
+    }
+    if (fstat(fileno(params->input_fp), &stb) == 0
+            && (stb.st_mode & S_IFMT) != S_IFREG) {
+        wav_io.seek = 0;
+        wav_io.tell = 0;
+    }
+    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(&wav_io, params->input_fp, &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");
+            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 };
+    static m4af_io_callbacks_t m4af_io = {
-    m4af_io_callbacks_t
+        read_callback, write_callback, seek_callback, tell_callback
-        m4af_io = { 0, 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 };
 
     setlocale(LC_CTYPE, "");
     setbuf(stderr, 0);
@@ -656,37 +712,10 @@ int main(int argc, char **argv)
     if (parse_options(argc, argv, &params) < 0)
         return 1;
 
-    if ((ifp = aacenc_fopen(params.input_filename, "rb")) == 0) {
+    if ((reader = open_input(&params)) == 0)
-        aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.input_filename,
-                       strerror(errno));
         goto END;
-    }
+
-    if (fstat(fileno(ifp), &stb) == 0 && (stb.st_mode & S_IFMT) != S_IFREG) {
+    sample_format = pcm_get_format(reader);
-        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);
 
     if (aacenc_init(&encoder, (aacenc_param_t*)&params, sample_format,
                     &aacinfo) < 0)
@@ -698,7 +727,7 @@ 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;
@@ -712,21 +741,24 @@ int main(int argc, char **argv)
         if (sbr_mode && !sig_mode)
             downsampled_timescale = 1;
         scale = sample_format->sample_rate >> downsampled_timescale;
-        if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io, ofp)) < 0)
+        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);
         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,
+    frame_count = encode(reader, encoder, aacinfo.frameLength,
-                         !params.silent);
+                         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);
+        int64_t frames_read = pcm_get_position(reader);
         uint32_t padding = frame_count * aacinfo.frameLength
                             - frames_read - aacinfo.encoderDelay;
         m4af_set_priming(m4af, 0, delay >> downsampled_timescale,
@@ -736,10 +768,10 @@ int main(int argc, char **argv)
     }
     result = 0;
 END:
-    if (wavf) wav_teardown(&wavf);
+    if (reader) pcm_teardown(&reader);
-    if (ifp) fclose(ifp);
+    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);

src/pcm_reader.h

@@ -0,0 +1,52 @@
+#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;
+};
+
+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);
+}
+
+pcm_reader_t *pcm_open_sint16_converter(pcm_reader_t *reader);
+
+#endif

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

@@ -35,6 +35,7 @@
     } while (0)
 
 struct wav_reader_t {
+    pcm_reader_vtbl_t *vtbl;
     pcm_sample_description_t sample_format;
     int64_t length;
     int64_t position;
@@ -52,22 +53,22 @@ 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;
@@ -213,10 +214,12 @@ uint32_t riff_next_chunk(wav_reader_t *reader, uint32_t *chunk_size)
     return 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;
@@ -345,7 +348,15 @@ FAIL:
     return -1;
 }
 
-wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
+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(wav_io_context_t *io_ctx, void *io_cookie,
                        int ignore_length)
 {
     wav_reader_t *reader = 0;
@@ -375,10 +386,11 @@ wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
             reader->io.seek(reader->io_cookie, 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(wav_io_context_t *io_ctx, void *io_cookie,
                        const pcm_sample_description_t *desc)
 {
     wav_reader_t *reader = 0;
@@ -397,7 +409,8 @@ wav_reader_t *raw_open(wav_io_context_t *io_ctx, void *io_cookie,
         }
     } else
         reader->length = INT64_MAX;
-    return reader;
+    reader->vtbl = &wav_vtable;
+    return (pcm_reader_t *)reader;
 }
 
 

src/wav_reader.h

@@ -6,6 +6,7 @@
 #define WAV_READER_H
 
 #include "lpcm.h"
+#include "pcm_reader.h"
 
 enum wav_error_code {
     WAV_IO_ERROR = 1,
@@ -26,14 +27,9 @@ typedef struct 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,
+pcm_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 *raw_open(wav_io_context_t *io_ctx, void *io_cookie,
                        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.8";
+const char *fdkaac_version = "0.3.3";
 #endif