bump version

.gitattributes

@@ -0,0 +1,3 @@
+* text=auto
+*.sln text eol=crlf
+*.lib binary

MSVC/fdk-aac.vcxproj

@@ -0,0 +1,264 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D7D4B982-8B16-4A10-8B1C-9527BD789709}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>fdkaac</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <IntDir>$(Configuration)Lib\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <IntDir>$(Configuration)Lib\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../fdk-aac/libaacenc/include;../fdk-aac/libFDK/include;../fdk-aac/libMpegTPEnc/include;../fdk-aac/libPCMutils/include;../fdk-aac/libSBRenc/include;../fdk-aac/libSYS/include</AdditionalIncludeDirectories>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>../fdk-aac/libaacenc/include;../fdk-aac/libFDK/include;../fdk-aac/libMpegTPEnc/include;../fdk-aac/libPCMutils/include;../fdk-aac/libSBRenc/include;../fdk-aac/libSYS/include</AdditionalIncludeDirectories>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_hcr.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_lib.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_pns.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacEnc_ram.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacEnc_rom.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_tns.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\adj_thr.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\bandwidth.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\band_nrg.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\bitenc.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\bit_cnt.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\block_switch.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\channel_map.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\chaosmeasure.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\dyn_bits.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\grp_data.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\intensity.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\line_pe.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\metadata_compressor.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\metadata_main.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\ms_stereo.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\noisedet.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\pnsparam.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\pre_echo_control.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\psy_configuration.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\psy_main.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\qc_main.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\quantize.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\sf_estim.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\spreading.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\tonality.cpp" />
+    <ClCompile Include="..\fdk-aac\libAACenc\src\transform.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\autocorr2nd.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\dct.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_bitbuffer.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_core.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_crc.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_hybrid.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_tools_rom.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_trigFcts.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\fft.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\fft_rad2.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\fixpoint_math.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\mdct.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\qmf.cpp" />
+    <ClCompile Include="..\fdk-aac\libFDK\src\scale.cpp" />
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adif.cpp" />
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adts.cpp" />
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_asc.cpp" />
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_latm.cpp" />
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_lib.cpp" />
+    <ClCompile Include="..\fdk-aac\libPCMutils\src\pcmutils_lib.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\bit_sbr.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\code_env.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\env_bit.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\env_est.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\fram_gen.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\invf_est.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\mh_det.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\nf_est.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ps_bitenc.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ps_encode.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ps_main.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\resampler.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbrenc_freq_sca.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_encoder.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_misc.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_ram.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_rom.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ton_corr.cpp" />
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\tran_det.cpp" />
+    <ClCompile Include="..\fdk-aac\libSYS\src\conv_string.cpp" />
+    <ClCompile Include="..\fdk-aac\libSYS\src\genericStds.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\fdk-aac\libAACenc\include\aacenc_lib.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc_hcr.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc_pns.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacEnc_ram.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacEnc_rom.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc_tns.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\adj_thr.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\adj_thr_data.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\bandwidth.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\band_nrg.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\bitenc.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\bit_cnt.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\block_switch.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\channel_map.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\chaosmeasure.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\dyn_bits.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\grp_data.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\intensity.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\interface.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\line_pe.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\metadata_compressor.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\metadata_main.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\ms_stereo.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\noisedet.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\pnsparam.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\pns_func.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\pre_echo_control.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_configuration.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_const.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_data.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_main.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\qc_data.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\qc_main.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\quantize.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\sf_estim.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\spreading.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\tns_func.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\tonality.h" />
+    <ClInclude Include="..\fdk-aac\libAACenc\src\transform.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\abs.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\autocorr2nd.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\clz.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\common_fix.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\cplx_mul.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\dct.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_archdef.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_bitbuffer.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_bitstream.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_core.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_crc.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_hybrid.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_tools_rom.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_trigFcts.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\fft.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\fft_rad2.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixmadd.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixminmax.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixmul.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixpoint_math.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\mdct.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\qmf.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\scale.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\scramble.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\x86\abs_x86.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\x86\clz_x86.h" />
+    <ClInclude Include="..\fdk-aac\libFDK\include\x86\fixmul_x86.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\include\mpegFileWrite.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\include\tpenc_lib.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\include\tp_data.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adif.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adts.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_asc.h" />
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_latm.h" />
+    <ClInclude Include="..\fdk-aac\libPCMutils\include\pcmutils_lib.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\include\sbr_encoder.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\bit_sbr.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\cmondata.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\code_env.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\env_bit.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\env_est.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\fram_gen.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\invf_est.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\mh_det.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\nf_est.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_bitenc.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_const.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_encode.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_main.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\resampler.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbrenc_freq_sca.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_def.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_misc.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_ram.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_rom.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ton_corr.h" />
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\tran_det.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\audio.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\cmdl_parser.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\conv_string.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\FDK_audio.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\genericStds.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\machine_type.h" />
+    <ClInclude Include="..\fdk-aac\libSYS\include\wav_file.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

MSVC/fdk-aac.vcxproj.filters

@@ -0,0 +1,558 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_hcr.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_lib.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_pns.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacEnc_ram.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacEnc_rom.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\aacenc_tns.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\adj_thr.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\bandwidth.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\band_nrg.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\bitenc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\bit_cnt.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\block_switch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\channel_map.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\chaosmeasure.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\dyn_bits.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\grp_data.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\intensity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\line_pe.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\metadata_compressor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\metadata_main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\ms_stereo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\noisedet.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\pnsparam.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\pre_echo_control.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\psy_configuration.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\psy_main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\qc_main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\quantize.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\sf_estim.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\spreading.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\tonality.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libAACenc\src\transform.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\autocorr2nd.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\dct.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_bitbuffer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_core.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_crc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_hybrid.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_tools_rom.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\FDK_trigFcts.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\fft.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\fft_rad2.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\fixpoint_math.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\mdct.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\qmf.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libFDK\src\scale.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adif.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adts.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_asc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_latm.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libMpegTPEnc\src\tpenc_lib.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libPCMutils\src\pcmutils_lib.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\bit_sbr.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\code_env.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\env_bit.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\env_est.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\fram_gen.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\invf_est.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\mh_det.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\nf_est.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ps_bitenc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ps_encode.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ps_main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\resampler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbrenc_freq_sca.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_encoder.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_misc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_ram.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\sbr_rom.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\ton_corr.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSBRenc\src\tran_det.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSYS\src\conv_string.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fdk-aac\libSYS\src\genericStds.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\fdk-aac\libAACenc\include\aacenc_lib.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc_hcr.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc_pns.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacEnc_ram.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacEnc_rom.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\aacenc_tns.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\adj_thr.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\adj_thr_data.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\bandwidth.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\band_nrg.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\bitenc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\bit_cnt.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\block_switch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\channel_map.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\chaosmeasure.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\dyn_bits.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\grp_data.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\intensity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\interface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\line_pe.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\metadata_compressor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\metadata_main.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\ms_stereo.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\noisedet.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\pnsparam.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\pns_func.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\pre_echo_control.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_configuration.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_const.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_data.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\psy_main.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\qc_data.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\qc_main.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\quantize.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\sf_estim.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\spreading.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\tns_func.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\tonality.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libAACenc\src\transform.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\abs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\autocorr2nd.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\clz.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\common_fix.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\cplx_mul.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\dct.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_archdef.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_bitbuffer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_bitstream.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_core.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_crc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_hybrid.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_tools_rom.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\FDK_trigFcts.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\fft.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\fft_rad2.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixmadd.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixminmax.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixmul.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\fixpoint_math.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\mdct.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\qmf.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\scale.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\scramble.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\x86\abs_x86.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\x86\clz_x86.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libFDK\include\x86\fixmul_x86.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\include\mpegFileWrite.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\include\tpenc_lib.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\include\tp_data.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adif.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_adts.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_asc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libMpegTPEnc\src\tpenc_latm.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libPCMutils\include\pcmutils_lib.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\include\sbr_encoder.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\bit_sbr.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\cmondata.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\code_env.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\env_bit.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\env_est.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\fram_gen.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\invf_est.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\mh_det.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\nf_est.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_bitenc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_const.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_encode.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ps_main.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\resampler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbrenc_freq_sca.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_def.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_misc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_ram.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\sbr_rom.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\ton_corr.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSBRenc\src\tran_det.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\audio.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\cmdl_parser.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\conv_string.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\FDK_audio.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\genericStds.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\machine_type.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fdk-aac\libSYS\include\wav_file.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

MSVC/fdkaac.sln

@@ -0,0 +1,26 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fdkaac", "fdkaac.vcxproj", "{E62D32CF-E308-40BD-9FF0-8266C6CAA9AA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fdk-aac", "fdk-aac.vcxproj", "{D7D4B982-8B16-4A10-8B1C-9527BD789709}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E62D32CF-E308-40BD-9FF0-8266C6CAA9AA}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E62D32CF-E308-40BD-9FF0-8266C6CAA9AA}.Debug|Win32.Build.0 = Debug|Win32
+		{E62D32CF-E308-40BD-9FF0-8266C6CAA9AA}.Release|Win32.ActiveCfg = Release|Win32
+		{E62D32CF-E308-40BD-9FF0-8266C6CAA9AA}.Release|Win32.Build.0 = Release|Win32
+		{D7D4B982-8B16-4A10-8B1C-9527BD789709}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D7D4B982-8B16-4A10-8B1C-9527BD789709}.Debug|Win32.Build.0 = Debug|Win32
+		{D7D4B982-8B16-4A10-8B1C-9527BD789709}.Release|Win32.ActiveCfg = Release|Win32
+		{D7D4B982-8B16-4A10-8B1C-9527BD789709}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

MSVC/fdkaac.vcxproj

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E62D32CF-E308-40BD-9FF0-8266C6CAA9AA}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>fdkaac</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IntDir>cli_$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IntDir>$(Configuration)Cli\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>HAVE_STDINT_H;inline=__inline;_CRT_SECURE_NO_WARNINGS;WIN32;_CONSOLE;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./include;../missings;.;..</AdditionalIncludeDirectories>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <PreBuildEvent>
+      <Command>copy ..\fdk-aac\libAACdec\include\aacdecoder_lib.h include\fdk-aac\ 
+copy ..\fdk-aac\libAACenc\include\aacenc_lib.h include\fdk-aac\ 
+copy ..\fdk-aac\libSYS\include\FDK_Audio.h include\fdk-aac\
+copy ..\fdk-aac\libSYS\include\genericStds.h include\fdk-aac\ 
+copy ..\fdk-aac\libSYS\include\machine_type.h include\fdk-aac\ </Command>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>HAVE_STDINT_H;inline=__inline;_CRT_SECURE_NO_WARNINGS;WIN32;_CONSOLE;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./include;../missings;.;..</AdditionalIncludeDirectories>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+    <PreBuildEvent>
+      <Command>copy ..\fdk-aac\libAACdec\include\aacdecoder_lib.h include\fdk-aac\ 
+copy ..\fdk-aac\libAACenc\include\aacenc_lib.h include\fdk-aac\ 
+copy ..\fdk-aac\libSYS\include\FDK_Audio.h include\fdk-aac\
+copy ..\fdk-aac\libSYS\include\genericStds.h include\fdk-aac\ 
+copy ..\fdk-aac\libSYS\include\machine_type.h include\fdk-aac\ </Command>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\missings\getopt.c" />
+    <ClCompile Include="..\src\aacenc.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\progress.c" />
+    <ClCompile Include="..\src\wav_reader.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\missings\getopt.h" />
+    <ClInclude Include="..\src\aacenc.h" />
+    <ClInclude Include="..\src\compat.h" />
+    <ClInclude Include="..\src\lpcm.h" />
+    <ClInclude Include="..\src\m4af.h" />
+    <ClInclude Include="..\src\m4af_endian.h" />
+    <ClInclude Include="..\src\metadata.h" />
+    <ClInclude Include="..\src\parson.h" />
+    <ClInclude Include="..\src\progress.h" />
+    <ClInclude Include="..\src\wav_reader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="fdk-aac.vcxproj">
+      <Project>{d7d4b982-8b16-4a10-8b1c-9527bd789709}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

MSVC/fdkaac.vcxproj.filters

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\src\aacenc.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\compat_win32.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\lpcm.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\m4af.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\main.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\progress.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\wav_reader.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\missings\getopt.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\src\aacenc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\compat.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\lpcm.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\m4af.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\m4af_endian.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\progress.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\src\wav_reader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\missings\getopt.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

Makefile.am

@@ -1,5 +1,5 @@
 ACLOCAL_AMFLAGS = -I m4
-EXTRA_DIST = COPYING
+AUTOMAKE_OPTIONS = subdir-objects
 
 bin_PROGRAMS = fdkaac
 
@@ -8,11 +8,13 @@ fdkaac_SOURCES = \
     src/lpcm.c       \
     src/m4af.c       \
     src/main.c       \
+    src/metadata.c   \
+    src/parson.c     \
     src/progress.c   \
     src/wav_reader.c
 
 fdkaac_LDADD = \
-	@LIBICONV@ -lm
+    @LIBICONV@ -lfdk-aac -lm
 
 if FDK_PLATFORM_POSIX
     fdkaac_SOURCES += \
@@ -23,3 +25,18 @@ if FDK_PLATFORM_WIN32
     fdkaac_SOURCES += \
 	src/compat_win32.c
 endif
+
+if FDK_NO_GETOPT_LONG
+    fdkaac_SOURCES += \
+	missings/getopt.c
+    AM_CPPFLAGS = -Imissings
+endif
+
+EXTRA_DIST = \
+    m4/.gitkeep  \
+    src/*.h      \
+    missings/*.c \
+    missings/*.h \
+    MSVC/*.vcxproj \
+    MSVC/*.vcxproj.filters \
+    MSVC/*.sln

README

@@ -4,11 +4,99 @@ fdkaac - command line frontend encoder for libfdk-aac
 
 Prerequisites
 -------------
-You need libfdk-aac, GNU autoconf and automake, and C compiler.
+You need libfdk-aac.
-On Posix environment, you will also need GNU gettext (for iconv.m4).
+On Posix environment, you will also need GNU gettext (for iconv.m4) and
+GNU autoconf/automake.
+
+How to build on Posix environment
+---------------------------------
+First, you need to build libfdk-aac and install on your system.
+Once you have done it, the following will do the task.
+(MinGW build can be done the same way, and doesn't require gettext/iconv)
 
-How to build
-------------
 $ autoreconf -i
-$ ./configure
+$ ./configure && make && make install
-$ make
+
+How to build on MSVC
+--------------------
+First you have to extract libfdk-aac source here, so that directory tree will
+look like the following:
++- fdk-aac ---+-documentation
+|             +-libAACdec
+|             +-libAACenc
+|             :
++- m4
++- missings
++- MSVC
++- src
+
+MSVC solution for Visual Studio 2010 is under MSVC directory.
+
+Tagging Options
+---------------
+Generic tagging options like --tag, --tag-from-file, --long-tag allows you
+to set arbitrary tags.
+Available tags and their fcc (four char code) for --tag and --tag-from-file
+can be found at http://code.google.com/p/mp4v2/wiki/iTunesMetadata
+
+For tags such as Artist where first char of fcc is copyright sign,
+you can skip first char and just say like --tag="ART:Foo Bar" or
+--tag-from-file=lyr:/path/to/your/lyrics.txt
+
+Currently, --tag-from-file just stores file contents into m4a without any
+character encoding / line terminater conversion.
+Therefore, only use UTF-8 (without BOM) when setting text tags by this option.
+
+On the other hand, --tag / --long-tag (and other command line arguments) are
+converted from locale character encoding to UTF-8 on Posix environment.
+On Windows, command line arguments are always treated as Unicode.
+
+Tagging using JSON
+------------------
+With --tag-from-json, fdkaac can read JSON file and set tags from it.
+By default, tags are assumed to be in the root object(dictionary) like this:
+
+{
+  "title": "No Expectations",
+  "artist": "The Rolling Stones",
+  "album": "Beggars Banquet",
+  "track": 2
+}
+
+In this case, you can simply specify the filename like:
+--tag-from-json=/path/to/json
+
+If the object containing tags is placed somewhere else, you can optionally
+specify the path of the object with dotted notation.
+
+{
+  "format" : {
+    "filename" : "Middle Curse.flac",
+    "nb_streams" : 1,
+    "format_name" : "flac",
+    "format_long_name" : "raw FLAC",
+    "start_time" : "N/A",
+    "duration" : "216.146667",
+    "size" : "11851007.000000",
+    "bit_rate" : "438628.000000",
+    "tags" : {
+      "ALBUM" : "Scary World Theory",
+      "ARTIST" : "Lali Puna",
+      "DATE" : "2001",
+      "DISCID" : "9208CC0A",
+      "TITLE" : "Middle Curse",
+      "TRACKTOTAL" : "10",
+      "track" : "2"
+    }
+  }
+}
+
+In this example, tags are placed under the object "format.tags".
+("format" is a child of the root, and "tags" is a child of the "format").
+In this case, you can say:
+--tag-from-json=/path/to/json?format.tags
+
+For your information, ffprobe of ffmpeg project (or avprobe of libav) can
+output media information/metadata in json format like this.
+
+Note that not all tags can be read/written this way.

configure.ac

@@ -10,8 +10,9 @@ AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE
 
 AC_PROG_CC
+AM_PROG_CC_C_O
 
-AC_CHECK_HEADERS([getopt.h sys/time.h])
+AC_CHECK_HEADERS([sys/time.h])
 AC_CHECK_HEADERS([localcharset.h langinfo.h endian.h byteswap.h])
 AC_CHECK_HEADERS([fdk-aac/aacenc_lib.h], ,
                  AC_MSG_ERROR([libfdk-aac is required]))
@@ -30,9 +31,12 @@ 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([gettimeofday nl_langinfo strdup])
+AC_CHECK_FUNCS([sigaction gettimeofday nl_langinfo _vscprintf fseeko64])
-AC_SEARCH_LIBS([aacEncOpen],[fdk-aac])
+AC_CHECK_FUNC(getopt_long)
+AM_CONDITIONAL([FDK_NO_GETOPT_LONG],[test "$ac_cv_func_getopt_long" != "yes"])
+AC_SEARCH_LIBS([aacEncOpen],[fdk-aac],[],[],[])
 
 AC_CANONICAL_HOST
 

src/aacenc.c

@@ -142,7 +142,7 @@ int aac_encode_frame(HANDLE_AACENCODER encoder,
     unsigned channel_mode, obytes;
 
     channel_mode = aacEncoder_GetParam(encoder, AACENC_CHANNELMODE);
-    obytes = 6144 / 8 * channel_mode;
+    obytes = 6144 / 8 * channel_mode + 7;
     if (!*output || *osize < obytes) {
         *osize = obytes;
         *output = realloc(*output, obytes);

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
@@ -20,5 +23,6 @@ FILE *aacenc_fopen(const char *name, const char *mode);
 void aacenc_getmainargs(int *argc, char ***argv);
 char *aacenc_to_utf8(const char *s);
 int aacenc_fprintf(FILE *fp, const char *fmt, ...);
+const char *aacenc_basename(const char *path);
 
 #endif

src/compat_posix.c

@@ -48,6 +48,16 @@ int aacenc_fprintf(FILE *fp, const char *fmt, ...)
     return cnt;
 }
 
+/*
+ * Different from POSIX basename() when path ends with /.
+ * Since we use this only for a regular file, the difference doesn't matter.
+ */
+const char *aacenc_basename(const char *path)
+{
+    const char *p = strrchr(path, '/');
+    return p ? p + 1: path;
+}
+
 #ifndef HAVE_ICONV
 char *aacenc_to_utf8(const char *s)
 {

src/compat_win32.c

@@ -12,8 +12,10 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <assert.h>
 #include <io.h>
 #include <fcntl.h>
+#include <share.h>
 #include <sys/timeb.h>
 #include "compat.h"
 #define WIN32_LEAN_AND_MEAN
@@ -29,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;
 }
 
@@ -65,15 +72,29 @@ FILE *aacenc_fopen(const char *name, const char *mode)
         fp = (mode[0] == 'r') ? stdin : stdout;
         _setmode(_fileno(fp), _O_BINARY);
     } else {
+        int share = _SH_DENYRW;
+        if (strchr(mode, 'r') && !strchr(mode, '+'))
+            share = _SH_DENYWR;
         codepage_decode_wchar(CP_UTF8, name, &wname);
         codepage_decode_wchar(CP_UTF8, mode, &wmode);
-        fp = _wfopen(wname, wmode);
+        fp = _wfsopen(wname, wmode, share);
         free(wname);
         free(wmode);
     }
     return fp;
 }
 
+static char **__aacenc_argv__;
+
+static
+void aacenc_free_mainargs(void)
+{
+    char **p = __aacenc_argv__;
+    for (; *p; ++p)
+        free(*p);
+    free(__aacenc_argv__);
+}
+
 void aacenc_getmainargs(int *argc, char ***argv)
 {
     int i;
@@ -85,6 +106,8 @@ void aacenc_getmainargs(int *argc, char ***argv)
     for (i = 0; i < *argc; ++i)
         codepage_encode_wchar(CP_UTF8, wargv[i], &(*argv)[i]);
     (*argv)[*argc] = 0;
+    __aacenc_argv__ = *argv;
+    atexit(aacenc_free_mainargs);
 }
 
 char *aacenc_to_utf8(const char *s)
@@ -92,6 +115,20 @@ char *aacenc_to_utf8(const char *s)
     return _strdup(s);
 }
 
+#if defined(__MINGW32__) && !defined(HAVE__VSCPRINTF)
+int _vscprintf(const char *fmt, va_list ap) 
+{
+    static int (*fp_vscprintf)(const char *, va_list) = 0;
+    if (!fp_vscprintf) {
+        HANDLE h = GetModuleHandleA("msvcrt.dll");
+        FARPROC fp = GetProcAddress(h, "_vscprintf");
+        InterlockedCompareExchangePointer(&fp_vscprintf, fp, 0);
+    }
+    assert(fp_vscprintf);
+    return fp_vscprintf(fmt, ap);
+}
+#endif
+
 int aacenc_fprintf(FILE *fp, const char *fmt, ...)
 {
     va_list ap;
@@ -126,3 +163,15 @@ int aacenc_fprintf(FILE *fp, const char *fmt, ...)
     return cnt;
 }
 
+const char *aacenc_basename(const char *path)
+{
+/*
+ * Since path is encoded with UTF-8, naive usage of strrchr() shoule be safe.
+ */
+    const char *p = strrchr(path, '/');
+    const char *q = strrchr(path, '\\');
+    const char *r = strrchr(path, ':');
+    if (q > p) p = q;
+    if (r > p) p = r;
+    return p ? p + 1 : path;
+}

src/lpcm.c

@@ -34,6 +34,7 @@ inline int lrint(double x)
 #  endif
 #endif
 
+static
 inline double pcm_clip(double n, double min_value, double max_value)
 {
     if (n < min_value)
@@ -42,6 +43,7 @@ inline double pcm_clip(double n, double min_value, double max_value)
         return max_value;
     return n;
 }
+static
 inline float pcm_i2f(int32_t n)
 {
     union {
@@ -51,6 +53,7 @@ inline float pcm_i2f(int32_t n)
     u.ivalue = n;
     return u.fvalue;
 }
+static
 inline double pcm_i2d(int64_t n)
 {
     union {
@@ -60,99 +63,123 @@ inline double pcm_i2d(int64_t n)
     u.ivalue = n;
     return u.fvalue;
 }
+static
 inline int16_t pcm_quantize_s32(int32_t n)
 {
     n = ((n >> 15) + 1) >> 1;
     return (n == 0x8000) ? 0x7fff : n;
 }
+static
 inline int16_t pcm_quantize_f64(double v)
 {
     return (int16_t)lrint(pcm_clip(v * 32768.0, -32768.0, 32767.0));
 }
+static
 inline int16_t pcm_s8_to_s16(int8_t n)
 {
     return n << 8;
 }
+static
 inline int16_t pcm_u8_to_s16(uint8_t n)
 {
     return (n << 8) ^ 0x8000;
 }
+static
 inline int16_t pcm_s16le_to_s16(int16_t n)
 {
     return m4af_ltoh16(n);
 }
+static
 inline int16_t pcm_s16be_to_s16(int16_t n)
 {
     return m4af_btoh16(n);
 }
+static
 inline int16_t pcm_u16le_to_s16(uint16_t n)
 {
     return m4af_ltoh16(n) ^ 0x8000;
 }
+static
 inline int16_t pcm_u16be_to_s16(uint16_t n)
 {
     return m4af_btoh16(n) ^ 0x8000;
 }
+static
 inline int32_t pcm_s24le_to_s32(uint8_t *p)
 {
     return p[0]<<8 | p[1]<<16 | p[2]<<24;
 }
+static
 inline int32_t pcm_s24be_to_s32(uint8_t *p)
 {
     return p[0]<<24 | p[1]<<16 | p[2]<<8;
 }
+static
 inline int32_t pcm_u24le_to_s32(uint8_t *p)
 {
     return pcm_s24le_to_s32(p) ^ 0x80000000;
 }
+static
 inline int32_t pcm_u24be_to_s32(uint8_t *p)
 {
     return pcm_s24be_to_s32(p) ^ 0x80000000;
 }
+static
 inline int16_t pcm_s24le_to_s16(uint8_t *p)
 {
     return pcm_quantize_s32(pcm_s24le_to_s32(p));
 }
+static
 inline int16_t pcm_s24be_to_s16(uint8_t *p)
 {
     return pcm_quantize_s32(pcm_s24be_to_s32(p));
 }
+static
 inline int16_t pcm_u24le_to_s16(uint8_t *p)
 {
     return pcm_quantize_s32(pcm_u24le_to_s32(p));
 }
+static
 inline int16_t pcm_u24be_to_s16(uint8_t *p)
 {
     return pcm_quantize_s32(pcm_u24be_to_s32(p));
 }
+static
 inline int16_t pcm_s32le_to_s16(int32_t n)
 {
     return pcm_quantize_s32(m4af_ltoh32(n));
 }
+static
 inline int16_t pcm_s32be_to_s16(int32_t n)
 {
     return pcm_quantize_s32(m4af_btoh32(n));
 }
+static
 inline int16_t pcm_u32le_to_s16(int32_t n)
 {
     return pcm_quantize_s32(m4af_ltoh32(n) ^ 0x80000000);
 }
+static
 inline int16_t pcm_u32be_to_s16(int32_t n)
 {
     return pcm_quantize_s32(m4af_btoh32(n) ^ 0x80000000);
 }
+static
 inline int16_t pcm_f32le_to_s16(int32_t n)
 {
     return pcm_quantize_f64(pcm_i2f(m4af_ltoh32(n)));
 }
+static
 inline int16_t pcm_f32be_to_s16(int32_t n)
 {
     return pcm_quantize_f64(pcm_i2f(m4af_btoh32(n)));
 }
+static
 inline int16_t pcm_f64le_to_s16(int64_t n)
 {
     return pcm_quantize_f64(pcm_i2d(m4af_ltoh64(n)));
 }
+static
 inline int16_t pcm_f64be_to_s16(int64_t n)
 {
     return pcm_quantize_f64(pcm_i2d(m4af_btoh64(n)));

src/m4af.h

@@ -8,8 +8,10 @@
 #define M4AF_FOURCC(a,b,c,d) (((a)<<24)|((b)<<16)|((c)<<8)|(d))
 
 enum m4af_error_code {
-    M4AF_IO_ERROR = 1,
+    M4AF_IO_ERROR      = -1,
-    M4AF_NO_MEMORY,
+    M4AF_NO_MEMORY     = -2,
+    M4AF_FORMAT_ERROR  = -3,
+    M4AF_NOT_SUPPORTED = -4,
 };
 
 enum m4af_itmf_tag {
@@ -50,65 +52,78 @@ 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);
 typedef int (*m4af_seek_callback)(void *cookie, int64_t off, int whence);
 typedef int64_t (*m4af_tell_callback)(void *cookie);
 
 typedef struct m4af_io_callbacks_t {
+    m4af_read_callback read;
     m4af_write_callback write;
     m4af_seek_callback seek;
     m4af_tell_callback tell;
 } m4af_io_callbacks_t;
 
-typedef struct m4af_writer_t m4af_writer_t;
+typedef struct m4af_itmf_entry_t {
+    uint32_t fcc;
+    char *name;
+    uint32_t type_code;
+    char *data;
+    uint32_t data_size;
+} m4af_itmf_entry_t;
 
-m4af_writer_t *m4af_create(uint32_t codec, uint32_t timescale,
+typedef struct m4af_ctx_t m4af_ctx_t;
+
+
+m4af_ctx_t *m4af_create(uint32_t codec, uint32_t timescale,
                         m4af_io_callbacks_t *io, void *io_cookie);
 
-void m4af_teardown(m4af_writer_t **ctx);
+int m4af_begin_write(m4af_ctx_t *ctx);
 
-int m4af_begin_write(m4af_writer_t *ctx);
+int m4af_finalize(m4af_ctx_t *ctx);
 
-int m4af_finalize(m4af_writer_t *ctx);
+void m4af_teardown(m4af_ctx_t **ctx);
 
-/* can be called before m4af_write_sample() */
+int m4af_write_sample(m4af_ctx_t *ctx, uint32_t track_idx, const void *data,
-void m4af_set_fixed_frame_duration(m4af_writer_t *ctx, int track_idx,
-                                   uint32_t length);
-
-/* can be called between mfa4_begin_write() and m4af_finalize() */
-int m4af_write_sample(m4af_writer_t *ctx, int track_idx, const void *data,
                       uint32_t size, uint32_t duration);
 
-
+int m4af_set_decoder_specific_info(m4af_ctx_t *ctx, uint32_t track_idx,
-/* the following can be called at anytime before m4af_finalize() */
-
-int m4af_decoder_specific_info(m4af_writer_t *ctx, int track_idx,
                                    uint8_t *data, uint32_t size);
 
-void m4af_set_priming(m4af_writer_t *ctx, int track_idx,
+void m4af_set_priming(m4af_ctx_t *ctx, uint32_t track_idx,
                       uint32_t encoder_delay, uint32_t padding);
 
-int m4af_add_itmf_long_tag(m4af_writer_t *ctx, const char *name,
+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);
+
+int m4af_add_itmf_long_tag(m4af_ctx_t *ctx, const char *name,
                            const char *data);
 
-int m4af_add_itmf_short_tag(m4af_writer_t *ctx, uint32_t type,
+int m4af_add_itmf_short_tag(m4af_ctx_t *ctx, uint32_t fcc, uint32_t type_code,
-                            uint32_t type_code, const void *data,
+                            const void *data, uint32_t data_size);
-                            uint32_t data_size);
 
-int m4af_add_itmf_string_tag(m4af_writer_t *ctx, uint32_t type,
+int m4af_add_itmf_string_tag(m4af_ctx_t *ctx, uint32_t fcc, const char *data);
-                             const char *data);
 
-int m4af_add_itmf_int8_tag(m4af_writer_t *ctx, uint32_t type, int value);
+int m4af_add_itmf_int8_tag(m4af_ctx_t *ctx, uint32_t fcc, int value);
 
-int m4af_add_itmf_int16_tag(m4af_writer_t *ctx, uint32_t type, int value);
+int m4af_add_itmf_int16_tag(m4af_ctx_t *ctx, uint32_t fcc, int value);
 
-int m4af_add_itmf_int32_tag(m4af_writer_t *ctx, uint32_t type, int value);
+int m4af_add_itmf_int32_tag(m4af_ctx_t *ctx, uint32_t fcc, uint32_t value);
 
-int m4af_add_itmf_track_tag(m4af_writer_t *ctx, int track, int total);
+int m4af_add_itmf_int64_tag(m4af_ctx_t *ctx, uint32_t fcc, uint64_t value);
 
-int m4af_add_itmf_disk_tag(m4af_writer_t *ctx, int disk, int total);
+int m4af_add_itmf_track_tag(m4af_ctx_t *ctx, int track, int total);
 
-int m4af_add_itmf_genre_tag(m4af_writer_t *ctx, int genre);
+int m4af_add_itmf_disk_tag(m4af_ctx_t *ctx, int disk, int total);
 
+int m4af_add_itmf_genre_tag(m4af_ctx_t *ctx, int genre);
 #endif

src/main.c

@@ -8,31 +8,86 @@
 #if HAVE_STDINT_H
 #  include <stdint.h>
 #endif
+#if HAVE_INTTYPES_H
+#  include <inttypes.h>
+#elif defined(_MSC_VER)
+#  define SCNd64 "I64d"
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 #include <locale.h>
 #include <errno.h>
+#include <sys/stat.h>
 #include <getopt.h>
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_SIGACTION
+#include <signal.h>
+#endif
+#ifdef _WIN32
+#include <io.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
 #include "compat.h"
 #include "wav_reader.h"
 #include "aacenc.h"
 #include "m4af.h"
 #include "progress.h"
 #include "version.h"
+#include "metadata.h"
 
 #define PROGNAME "fdkaac"
 
+static volatile int g_interrupted = 0;
+
+#if HAVE_SIGACTION
+static void signal_handler(int signum)
+{
+    g_interrupted = 1;
+}
+static void handle_signals(void)
+{
+    int i, sigs[] = { SIGINT, SIGHUP, SIGTERM };
+    for (i = 0; i < sizeof(sigs)/sizeof(sigs[0]); ++i) {
+        struct sigaction sa = { 0 };
+        sa.sa_handler = signal_handler;
+        sa.sa_flags |= SA_RESTART;
+        sigaction(sigs[i], &sa, 0);
+    }
+}
+#elif defined(_WIN32)
+static BOOL WINAPI signal_handler(DWORD type)
+{
+    g_interrupted = 1;
+    return TRUE;
+}
+
+static void handle_signals(void)
+{
+    SetConsoleCtrlHandler(signal_handler, TRUE);
+}
+#else
+static void handle_signals(void)
+{
+}
+#endif
+
 static
 int read_callback(void *cookie, void *data, uint32_t size)
 {
-    return fread(data, 1, size, (FILE*)cookie);
+    size_t rc = fread(data, 1, size, (FILE*)cookie);
+    return ferror((FILE*)cookie) ? -1 : (int)rc;
 }
 
 static
 int write_callback(void *cookie, const void *data, uint32_t size)
 {
-    return fwrite(data, 1, size, (FILE*)cookie);
+    size_t rc = fwrite(data, 1, size, (FILE*)cookie);
+    return ferror((FILE*)cookie) ? -1 : (int)rc;
 }
 
 static
@@ -73,7 +128,7 @@ PROGNAME " %s\n"
 "                                parameter settings, sample rate, and\n"
 "                                channel configuration)\n"
 " -w, --bandwidth <n>           Frequency bandwidth in Hz (AAC LC only)\n"
-" -a, --afterurner <n>          Afterburner\n"
+" -a, --afterburner <n>         Afterburner\n"
 "                                 0: Off\n"
 "                                 1: On(default)\n"
 " -L, --lowdelay-sbr            Enable ELD-SBR (AAC ELD only)\n"
@@ -88,12 +143,31 @@ PROGNAME " %s\n"
 "                                 6: LATM MCP=1\n"
 "                                 7: LATM MCP=0\n"
 "                                10: LOAS/LATM (LATM within LOAS)\n"
-" -c, --adts-crc-check          Add CRC protection on ADTS header\n"
+" -C, --adts-crc-check          Add CRC protection on ADTS header\n"
 " -h, --header-period <n>       StreamMuxConfig/PCE repetition period in\n"
 "                               transport layer\n"
 "\n"
 " -o <filename>                 Output filename\n"
-" --ignore-length               Ignore length of WAV header\n"
+" -G, --gapless-mode <n>        Encoder delay signaling for gapless playback\n"
+"                                 0: iTunSMPB (default)\n"
+"                                 1: ISO standard (edts + sgpd)\n"
+"                                 2: Both\n"
+" --ignorelength                Ignore length of WAV header\n"
+" -S, --silent                  Don't print progress messages\n"
+"\n"
+"Options for raw (headerless) input:\n"
+" -R, --raw                     Treat input as raw (by default WAV is\n"
+"                               assumed)\n"
+" --raw-channels <n>            Number of channels (default: 2)\n"
+" --raw-rate     <n>            Sample rate (default: 44100)\n"
+" --raw-format   <spec>         Sample format, default is \"S16L\".\n"
+"                               Spec is as follows:\n"
+"                                1st char: S(igned)|U(nsigned)|F(loat)\n"
+"                                2nd part: bits per channel\n"
+"                                Last char: L(ittle)|B(ig)\n"
+"                               Last char can be omitted, in which case L is\n"
+"                               assumed. Spec is case insensitive, therefore\n"
+"                               \"u16b\" is same as \"U16B\".\n"
 "\n"
 "Tagging options:\n"
 " --title <string>\n"
@@ -108,24 +182,39 @@ PROGNAME " %s\n"
 " --track <number[/total]>\n"
 " --disk <number[/total]>\n"
 " --tempo <n>\n"
+" --tag <fcc>:<value>          Set iTunes predefined tag with four char code.\n"
+" --tag-from-file <fcc>:<filename>\n"
+"                              Same as above, but value is read from file.\n"
+" --long-tag <name>:<value>    Set arbitrary tag as iTunes custom metadata.\n"
+" --tag-from-json <filename[?dot_notation]>\n"
+"                              Read tags from JSON. By default, tags are\n"
+"                              assumed to be direct children of the root\n"
+"                              object(dictionary).\n"
+"                              Optionally, position of the dictionary\n"
+"                              that contains tags can be specified with\n"
+"                              dotted notation.\n"
+"                              Example:\n"
+"                                --tag-from-json /path/to/json?format.tags\n"
     , fdkaac_version);
 }
 
-typedef struct aacenc_tag_entry_t {
-    uint32_t tag;
-    const char *data;
-} aacenc_tag_entry_t;
-
 typedef struct aacenc_param_ex_t {
     AACENC_PARAMS
 
     char *input_filename;
     char *output_filename;
+    unsigned gapless_mode;
     unsigned ignore_length;
+    int silent;
 
-    aacenc_tag_entry_t *tag_table;
+    int is_raw;
-    unsigned tag_count;
+    unsigned raw_channels;
-    unsigned tag_table_capacity;
+    unsigned raw_rate;
+    const char *raw_format;
+
+    aacenc_tag_param_t tags;
+
+    char *json_filename;
 } aacenc_param_ex_t;
 
 static
@@ -133,22 +222,36 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
 {
     int ch;
     unsigned n;
-    aacenc_tag_entry_t *tag;
+
+#define OPT_RAW_CHANNELS         M4AF_FOURCC('r','c','h','n')
+#define OPT_RAW_RATE             M4AF_FOURCC('r','r','a','t')
+#define OPT_RAW_FORMAT           M4AF_FOURCC('r','f','m','t')
+#define OPT_SHORT_TAG            M4AF_FOURCC('s','t','a','g')
+#define OPT_SHORT_TAG_FILE       M4AF_FOURCC('s','t','g','f')
+#define OPT_LONG_TAG             M4AF_FOURCC('l','t','a','g')
+#define OPT_TAG_FROM_JSON        M4AF_FOURCC('t','f','j','s')
 
     static struct option long_options[] = {
         { "help",             no_argument,       0, 'h' },
         { "profile",          required_argument, 0, 'p' },
         { "bitrate",          required_argument, 0, 'b' },
-        { "biterate-mode",    required_argument, 0, 'm' },
+        { "bitrate-mode",     required_argument, 0, 'm' },
         { "bandwidth",        required_argument, 0, 'w' },
         { "afterburner",      required_argument, 0, 'a' },
         { "lowdelay-sbr",     no_argument,       0, 'L' },
         { "sbr-signaling",    required_argument, 0, 's' },
         { "transport-format", required_argument, 0, 'f' },
-        { "adts-crc-check",   no_argument,       0, 'c' },
+        { "adts-crc-check",   no_argument,       0, 'C' },
         { "header-period",    required_argument, 0, 'P' },
 
-        { "ignore-length",    no_argument,       0, 'I' },
+        { "gapless-mode",     required_argument, 0, 'G' },
+        { "ignorelength",     no_argument,       0, 'I' },
+        { "silent",           no_argument,       0, 'S' },
+
+        { "raw",              no_argument,       0, 'R' },
+        { "raw-channels",     required_argument, 0, OPT_RAW_CHANNELS       },
+        { "raw-rate",         required_argument, 0, OPT_RAW_RATE           },
+        { "raw-format",       required_argument, 0, OPT_RAW_FORMAT         },
 
         { "title",            required_argument, 0, M4AF_TAG_TITLE         },
         { "artist",           required_argument, 0, M4AF_TAG_ARTIST        },
@@ -162,11 +265,16 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         { "track",            required_argument, 0, M4AF_TAG_TRACK         },
         { "disk",             required_argument, 0, M4AF_TAG_DISK          },
         { "tempo",            required_argument, 0, M4AF_TAG_TEMPO         },
+        { "tag",              required_argument, 0, OPT_SHORT_TAG          },
+        { "tag-from-file",    required_argument, 0, OPT_SHORT_TAG_FILE     },
+        { "long-tag",         required_argument, 0, OPT_LONG_TAG           },
+        { "tag-from-json",    required_argument, 0, OPT_TAG_FROM_JSON      },
+        { 0,                  0,                 0, 0                      },
     };
     params->afterburner = 1;
 
     aacenc_getmainargs(&argc, &argv);
-    while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:cP:Io:",
+    while ((ch = getopt_long(argc, argv, "hp:b:m:w:a:Ls:f:CP:G:Io:SR",
                              long_options, 0)) != EOF) {
         switch (ch) {
         case 'h':
@@ -223,7 +331,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':
@@ -236,9 +344,39 @@ 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 'R':
+            params->is_raw = 1;
+            break;
+        case OPT_RAW_CHANNELS:
+            if (sscanf(optarg, "%u", &n) != 1) {
+                fprintf(stderr, "invalid arg for raw-channels\n");
+                return -1;
+            }
+            params->raw_channels = n;
+            break;
+        case OPT_RAW_RATE:
+            if (sscanf(optarg, "%u", &n) != 1) {
+                fprintf(stderr, "invalid arg for raw-rate\n");
+                return -1;
+            }
+            params->raw_rate = n;
+            break;
+        case OPT_RAW_FORMAT:
+            params->raw_format = optarg;
+            break;
         case M4AF_TAG_TITLE:
         case M4AF_TAG_ARTIST:
         case M4AF_TAG_ALBUM:
@@ -251,18 +389,47 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
         case M4AF_TAG_TRACK:
         case M4AF_TAG_DISK:
         case M4AF_TAG_TEMPO:
-            if (params->tag_count == params->tag_table_capacity) {
+            aacenc_param_add_itmf_entry(&params->tags, ch, 0, optarg,
-                unsigned newsize = params->tag_table_capacity;
+                                        strlen(optarg), 0);
-                newsize = newsize ? newsize * 2 : 1;
+            break;
-                params->tag_table =
+        case OPT_SHORT_TAG:
-                    realloc(params->tag_table,
+        case OPT_SHORT_TAG_FILE:
-                            newsize * sizeof(aacenc_tag_entry_t));
+        case OPT_LONG_TAG:
-                params->tag_table_capacity = newsize;
+            {
+                char *val;
+                size_t klen;
+                unsigned fcc = M4AF_FOURCC('-','-','-','-');
+
+                if ((val = strchr(optarg, ':')) == 0) {
+                    fprintf(stderr, "invalid arg for tag\n");
+                    return -1;
                 }
-            tag = params->tag_table + params->tag_count;
+                *val++ = '\0';
-            tag->tag = ch;
+                if (ch == OPT_SHORT_TAG || ch == OPT_SHORT_TAG_FILE) {
-            tag->data = optarg;
+                    /*
-            params->tag_count++;
+                     * take care of U+00A9(COPYRIGHT SIGN).
+                     * 1) if length of fcc is 3, we prepend '\xa9'.
+                     * 2) U+00A9 becomes "\xc2\xa9" in UTF-8. Therefore
+                     *    we remove first '\xc2'.
+                     */
+                    if (optarg[0] == '\xc2')
+                        ++optarg;
+                    if ((klen = strlen(optarg))== 3)
+                        fcc = 0xa9;
+                    else if (klen != 4) {
+                        fprintf(stderr, "invalid arg for tag\n");
+                        return -1;
+                    }
+                    for (; *optarg; ++optarg)
+                        fcc = ((fcc << 8) | (*optarg & 0xff));
+                }
+                aacenc_param_add_itmf_entry(&params->tags, fcc, optarg,
+                                            val, strlen(val),
+                                            ch == OPT_SHORT_TAG_FILE);
+            }
+            break;
+        case OPT_TAG_FROM_JSON:
+            params->json_filename = optarg;
             break;
         default:
             return usage(), -1;
@@ -270,6 +437,7 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
     }
     if (argc == optind)
         return usage(), -1;
+
     if (!params->bitrate && !params->bitrate_mode) {
         fprintf(stderr, "bitrate or bitrate-mode is mandatory\n");
         return -1;
@@ -281,16 +449,26 @@ int parse_options(int argc, char **argv, aacenc_param_ex_t *params)
     }
     if (params->bitrate && params->bitrate < 10000)
         params->bitrate *= 1000;
+
+    if (params->is_raw) {
+        if (!params->raw_channels)
+            params->raw_channels = 2;
+        if (!params->raw_rate)
+            params->raw_rate = 44100;
+        if (!params->raw_format)
+            params->raw_format = "S16L";
+    }
     params->input_filename = argv[optind];
     return 0;
 };
 
 static
-int write_sample(FILE *ofp, m4af_writer_t *m4af,
+int write_sample(FILE *ofp, m4af_ctx_t *m4af,
                  const void *data, uint32_t size, uint32_t duration)
 {
     if (!m4af) {
-        if (fwrite(data, 1, size, ofp) < 0) {
+        fwrite(data, 1, size, ofp);
+        if (ferror(ofp)) {
             fprintf(stderr, "ERROR: fwrite(): %s\n", strerror(errno));
             return -1;
         }
@@ -303,7 +481,8 @@ int write_sample(FILE *ofp, m4af_writer_t *m4af,
 
 static
 int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
-           uint32_t frame_length, FILE *ofp, m4af_writer_t *m4af)
+           uint32_t frame_length, FILE *ofp, m4af_ctx_t *m4af,
+           int show_progress)
 {
     uint8_t *ibuf = 0;
     int16_t *pcmbuf = 0;
@@ -321,7 +500,9 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
     ibuf = malloc(frame_length * format->bytes_per_frame);
     aacenc_progress_init(&progress, wav_get_length(wavf), format->sample_rate);
     do {
-        if (nread) {
+        if (g_interrupted)
+            nread = 0;
+        else if (nread) {
             if ((nread = wav_read_frames(wavf, ibuf, frame_length)) < 0) {
                 fprintf(stderr, "ERROR: read failed\n");
                 goto END;
@@ -332,6 +513,7 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
                     goto END;
                 }
             }
+            if (show_progress)
                 aacenc_progress_update(&progress, wav_get_position(wavf),
                                        format->sample_rate * 2);
         }
@@ -344,6 +526,8 @@ int encode(wav_reader_t *wavf, HANDLE_AACENCODER encoder,
             ++frames_written;
         }
     } while (nread > 0 || olen > 0);
+
+    if (show_progress)
         aacenc_progress_finish(&progress, wav_get_position(wavf));
     rc = frames_written;
 END:
@@ -354,53 +538,18 @@ END:
 }
 
 static
-int finalize_m4a(m4af_writer_t *m4af, const aacenc_param_ex_t *params,
+void put_tool_tag(m4af_ctx_t *m4af, const aacenc_param_ex_t *params,
                   HANDLE_AACENCODER encoder)
 {
-    unsigned i;
-    aacenc_tag_entry_t *tag = params->tag_table;
-
-    for (i = 0; i < params->tag_count; ++i, ++tag) {
-        switch (tag->tag) {
-        case M4AF_TAG_TRACK:
-            {
-                unsigned m, n = 0;
-                if (sscanf(tag->data, "%u/%u", &m, &n) >= 1)
-                    m4af_add_itmf_track_tag(m4af, m, n);
-                break;
-            }
-        case M4AF_TAG_DISK:
-            {
-                unsigned m, n = 0;
-                if (sscanf(tag->data, "%u/%u", &m, &n) >= 1)
-                    m4af_add_itmf_disk_tag(m4af, m, n);
-                break;
-            }
-        case M4AF_TAG_TEMPO:
-            {
-                unsigned n;
-                if (sscanf(tag->data, "%u", &n) == 1)
-                    m4af_add_itmf_int16_tag(m4af, tag->tag, n);
-                break;
-            }
-        default:
-            {
-                char *u8 = aacenc_to_utf8(tag->data);
-                m4af_add_itmf_string_tag(m4af, tag->tag, u8);
-                free(u8);
-            }
-        }
-    }
-    {
     char tool_info[256];
     char *p = tool_info;
     LIB_INFO *lib_info = 0;
 
     p += sprintf(p, PROGNAME " %s, ", fdkaac_version);
 
-        lib_info = malloc(FDK_MODULE_LAST * sizeof(LIB_INFO));
+    lib_info = calloc(FDK_MODULE_LAST, sizeof(LIB_INFO));
-        /* XXX: aacEncGetLibInfo() seems buggy and sometimes fails */
     if (aacEncGetLibInfo(lib_info) == AACENC_OK) {
+        int i;
         for (i = 0; i < FDK_MODULE_LAST; ++i)
             if (lib_info[i].module_id == FDK_AACENC)
                 break;
@@ -410,10 +559,27 @@ int finalize_m4a(m4af_writer_t *m4af, const aacenc_param_ex_t *params,
     if (params->bitrate_mode)
         sprintf(p, "VBR mode %d", params->bitrate_mode);
     else
-            sprintf(p, "CBR %dkbps", params->bitrate / 1000);
+        sprintf(p, "CBR %dkbps",
+                aacEncoder_GetParam(encoder, AACENC_BITRATE) / 1000);
 
     m4af_add_itmf_string_tag(m4af, M4AF_TAG_TOOL, tool_info);
-    }
+}
+
+static
+int finalize_m4a(m4af_ctx_t *m4af, const aacenc_param_ex_t *params,
+                 HANDLE_AACENCODER encoder)
+{
+    unsigned i;
+    aacenc_tag_entry_t *tag = params->tags.tag_table;
+
+    if (params->json_filename)
+        aacenc_put_tags_from_json(m4af, params->json_filename);
+
+    for (i = 0; i < params->tags.tag_count; ++i, ++tag)
+        aacenc_put_tag_entry(m4af, tag);
+
+    put_tool_tag(m4af, params, encoder);
+
     if (m4af_finalize(m4af) < 0) {
         fprintf(stderr, "ERROR: failed to finalize m4a\n");
         return -1;
@@ -421,11 +587,67 @@ int finalize_m4a(m4af_writer_t *m4af, const aacenc_param_ex_t *params,
     return 0;
 }
 
+static
+char *generate_output_filename(const char *filename, const char *ext)
+{
+    char *p = 0;
+    size_t ext_len = strlen(ext);
+
+    if (strcmp(filename, "-") == 0) {
+        p = malloc(ext_len + 6);
+        sprintf(p, "stdin%s", ext);
+    } else {
+        const char *base = aacenc_basename(filename);
+        size_t ilen = strlen(base);
+        const char *ext_org = strrchr(base, '.');
+        if (ext_org) ilen = ext_org - base;
+        p = malloc(ilen + ext_len + 1);
+        sprintf(p, "%.*s%s", ilen, base, ext);
+    }
+    return p;
+}
+
+static
+int parse_raw_spec(const char *spec, pcm_sample_description_t *desc)
+{
+    unsigned bits;
+    unsigned char c_type, c_endian = 'L';
+    int type;
+
+    if (sscanf(spec, "%c%u%c", &c_type, &bits, &c_endian) < 2)
+        return -1;
+    c_type = toupper(c_type);
+    c_endian = toupper(c_endian);
+
+    if (c_type == 'S')
+        type = 1;
+    else if (c_type == 'U')
+        type = 2;
+    else if (c_type == 'F')
+        type = 4;
+    else
+        return -1;
+
+    if (c_endian == 'B')
+        type |= 8;
+    else if (c_endian != 'L')
+        return -1;
+
+    if (c_type == 'F' && bits != 32 && bits != 64)
+        return -1;
+    if (c_type != 'F' && (bits < 8 || bits > 32))
+        return -1;
+
+    desc->sample_type = type;
+    desc->bits_per_channel = bits;
+    return 0;
+}
+
 int main(int argc, char **argv)
 {
-    wav_io_context_t wav_io = { read_callback, seek_callback };
+    wav_io_context_t wav_io = { read_callback, seek_callback, tell_callback };
-    m4af_io_callbacks_t m4af_io = {
+    m4af_io_callbacks_t
-        write_callback, seek_callback, tell_callback };
+        m4af_io = { 0, write_callback, seek_callback, tell_callback };
     aacenc_param_ex_t params = { 0 };
 
     int result = 2;
@@ -435,10 +657,11 @@ int main(int argc, char **argv)
     wav_reader_t *wavf = 0;
     HANDLE_AACENCODER encoder = 0;
     AACENC_InfoStruct aacinfo = { 0 };
-    m4af_writer_t *m4af = 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);
@@ -451,14 +674,31 @@ int main(int argc, char **argv)
                        strerror(errno));
         goto END;
     }
-
+    if (fstat(fileno(ifp), &stb) == 0 && (stb.st_mode & S_IFMT) != S_IFREG) {
-    if (ifp == stdin)
         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,
@@ -466,12 +706,8 @@ int main(int argc, char **argv)
         goto END;
 
     if (!params.output_filename) {
-        size_t ilen = strlen(params.input_filename);
+        const char *ext = params.transport_format ? ".aac" : ".m4a";
-        const char *ext = strrchr(params.input_filename, '.');
+        output_filename = generate_output_filename(params.input_filename, ext);
-        if (ext) ilen = ext - params.input_filename;
-        output_filename = malloc(ilen + 5);
-        sprintf(output_filename, "%.*s%s", ilen, params.input_filename,
-                params.transport_format ? ".aac" : ".m4a");
         params.output_filename = output_filename;
     }
 
@@ -480,6 +716,7 @@ int main(int argc, char **argv)
                        strerror(errno));
         goto END;
     }
+    handle_signals();
     if (!params.transport_format) {
         uint32_t scale;
         unsigned framelen = aacinfo.frameLength;
@@ -490,12 +727,15 @@ int main(int argc, char **argv)
         scale = sample_format->sample_rate >> downsampled_timescale;
         if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io, ofp)) < 0)
             goto END;
-        m4af_decoder_specific_info(m4af, 0, aacinfo.confBuf, aacinfo.confSize);
+        m4af_set_decoder_specific_info(m4af, 0, aacinfo.confBuf,
+                                       aacinfo.confSize);
         m4af_set_fixed_frame_duration(m4af, 0,
                                       framelen >> downsampled_timescale);
+        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(wavf, encoder, aacinfo.frameLength, ofp, m4af,
+                         !params.silent);
     if (frame_count < 0)
         goto END;
     if (m4af) {
@@ -516,7 +756,7 @@ END:
     if (ofp) fclose(ofp);
     if (encoder) aacEncClose(&encoder);
     if (output_filename) free(output_filename);
-    if (params.tag_table) free(params.tag_table);
+    if (params.tags.tag_table) free(params.tags.tag_table);
 
     return result;
 }

src/metadata.c

@@ -0,0 +1,392 @@
+#if HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#if HAVE_STDINT_H
+#  include <stdint.h>
+#endif
+#if HAVE_INTTYPES_H
+#  include <inttypes.h>
+#elif defined(_MSC_VER)
+#  define SCNd64 "I64d"
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include "m4af.h"
+#include "metadata.h"
+#include "compat.h"
+#include "parson.h"
+
+typedef struct tag_key_mapping_t {
+    const char *name;
+    uint32_t fcc;
+} tag_key_mapping_t;
+
+enum {
+    TAG_TOTAL_DISCS  = 1,
+    TAG_TOTAL_TRACKS = 2
+};
+
+static tag_key_mapping_t tag_mapping_table[] = {
+    { "album",                      M4AF_TAG_ALBUM               },
+    { "albumartist",                M4AF_TAG_ALBUM_ARTIST        },
+    { "albumartistsort",            M4AF_FOURCC('s','o','a','a') },
+    { "albumartistsortorder",       M4AF_FOURCC('s','o','a','a') },
+    { "albumsort",                  M4AF_FOURCC('s','o','a','l') },
+    { "albumsortorder",             M4AF_FOURCC('s','o','a','l') },
+    { "artist",                     M4AF_TAG_ARTIST              },
+    { "artistsort",                 M4AF_FOURCC('s','o','a','r') },
+    { "artistsortorder",            M4AF_FOURCC('s','o','a','r') },
+    { "band",                       M4AF_TAG_ALBUM_ARTIST        },
+    { "bpm",                        M4AF_TAG_TEMPO               },
+    { "comment",                    M4AF_TAG_COMMENT             },
+    { "compilation",                M4AF_TAG_COMPILATION         },
+    { "composer",                   M4AF_TAG_COMPOSER            },
+    { "composersort",               M4AF_FOURCC('s','o','c','o') },
+    { "composersortorder",          M4AF_FOURCC('s','o','c','o') },
+    { "contentgroup",               M4AF_TAG_GROUPING            },
+    { "copyright",                  M4AF_TAG_COPYRIGHT           },
+    { "date",                       M4AF_TAG_DATE                },
+    { "disc",                       M4AF_TAG_DISK                },
+    { "disctotal",                  TAG_TOTAL_DISCS              },
+    { "discnumber",                 M4AF_TAG_DISK                },
+    { "genre",                      M4AF_TAG_GENRE               },
+    { "grouping",                   M4AF_TAG_GROUPING            },
+    { "itunescompilation",          M4AF_TAG_COMPILATION         },
+    { "lyrics",                     M4AF_TAG_LYRICS              },
+    { "title",                      M4AF_TAG_TITLE               },
+    { "titlesort",                  M4AF_FOURCC('s','o','n','m') },
+    { "titlesortorder",             M4AF_FOURCC('s','o','n','m') },
+    { "totaldiscs",                 TAG_TOTAL_DISCS              },
+    { "totaltracks",                TAG_TOTAL_TRACKS             },
+    { "track",                      M4AF_TAG_TRACK               },
+    { "tracknumber",                M4AF_TAG_TRACK               },
+    { "tracktotal",                 TAG_TOTAL_TRACKS             },
+    { "unsyncedlyrics",             M4AF_TAG_LYRICS              },
+    { "year",                       M4AF_TAG_DATE                },
+};
+
+static
+int tag_key_comparator(const void *k, const void *v)
+{
+    return strcmp((const char *)k, ((tag_key_mapping_t*)v)->name);
+}
+
+static
+uint32_t get_tag_fcc_from_name(const char *name)
+{
+    char *name_p = 0, *p;
+    const tag_key_mapping_t *ent;
+
+    name_p = malloc(strlen(name) + 1);
+    for (p = name_p; *name; ++name) {
+        unsigned char c = *name;
+        if (c != ' ' && c != '-' && c != '_')
+            *p++ = tolower(c);
+    }
+    *p = 0;
+    ent = bsearch(name_p, tag_mapping_table,
+                  sizeof(tag_mapping_table) / sizeof(tag_mapping_table[0]),
+                  sizeof(tag_mapping_table[0]),
+                  tag_key_comparator);
+    free(name_p);
+    return ent ? ent->fcc : 0;
+}
+
+char *aacenc_load_tag_from_file(const char *path, uint32_t *data_size)
+{
+    FILE *fp = 0;
+    char *data = 0;
+    int64_t size;
+
+    if ((fp = aacenc_fopen(path, "rb")) == NULL) {
+        aacenc_fprintf(stderr, "WARNING: %s: %s\n", path, strerror(errno));
+        goto END;
+    }
+    fseeko(fp, 0, SEEK_END);
+    size = ftello(fp);
+    if (size > 5*1024*1024) {
+        aacenc_fprintf(stderr, "WARNING: %s: size too large\n", path);
+        goto END;
+    }
+    fseeko(fp, 0, SEEK_SET);
+    data = malloc(size + 1);
+    if (data) fread(data, 1, size, fp);
+    data[size] = 0;
+    *data_size = (uint32_t)size;
+END:
+    if (fp) fclose(fp);
+    return data;
+}
+
+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)
+{
+    aacenc_tag_entry_t *entry;
+
+    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;
+    if (tag == M4AF_FOURCC('-','-','-','-'))
+        entry->name = key;
+    entry->data = value;
+    entry->data_size = size;
+    entry->is_file_name = is_file_name;
+    params->tag_count++;
+}
+
+static
+void tag_put_number_pair(m4af_ctx_t *m4af, uint32_t fcc,
+                         const char *snumber, const char *stotal)
+{
+    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);
+    }
+}
+
+static
+const char *aacenc_json_object_get_string(JSON_Object *obj, const char *key,
+                                          char *buf)
+{
+    JSON_Value_Type type;
+    const char *val = 0;
+
+    type = json_value_get_type(json_object_get_value(obj, key));
+    if (type == JSONString)
+        val = json_object_get_string(obj, key);
+    else if (type == JSONNumber) {
+        double num = json_object_get_number(obj, key);
+        sprintf(buf, "%.15g", num);
+        val = buf;
+    } else if (type == JSONBoolean) {
+        int n = json_object_get_boolean(obj, key);
+        sprintf(buf, "%d", n);
+        val = buf;
+    }
+    return val;
+}
+
+void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename)
+{
+    char *data = 0;
+    JSON_Value *json = 0;
+    JSON_Object *root;
+    size_t i, nelts;
+    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 };
+    
+    filename = strdup(json_filename);
+    if ((json_dot_path = strchr(filename, '?')) != 0)
+        *json_dot_path++ = '\0';
+
+    if (!(data = aacenc_load_tag_from_file(filename, &data_size)))
+        goto DONE;
+    if (!(json = json_parse_string(data))) {
+        aacenc_fprintf(stderr, "WARNING: failed to parse JSON\n");
+        goto DONE;
+    }
+    root = json_value_get_object(json);
+    if (json_dot_path) {
+        if (!(root = json_object_dotget_object(root, json_dot_path))) {
+            aacenc_fprintf(stderr, "WARNING: %s not found in JSON\n",
+                           json_dot_path);
+            goto DONE;
+        }
+    }
+    nelts = json_object_get_count(root);
+    for (i = 0; i < nelts; ++i) {
+        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);
+            }
+        }
+    }
+    tag_put_number_pair(m4af, M4AF_TAG_TRACK, track, total_tracks);
+    tag_put_number_pair(m4af, M4AF_TAG_DISK,  disc,  total_discs);
+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)
+{
+    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)
+            m4af_add_itmf_track_tag(m4af, m, n);
+        break;
+    case M4AF_TAG_DISK:
+        if (sscanf(data, "%u/%u", &m, &n) >= 1)
+            m4af_add_itmf_disk_tag(m4af, m, n);
+        break;
+    case M4AF_TAG_GENRE_ID3:
+        if (sscanf(data, "%u", &n) == 1)
+            m4af_add_itmf_genre_tag(m4af, n);
+        break;
+    case M4AF_TAG_TEMPO:
+        if (sscanf(data, "%u", &n) == 1)
+            m4af_add_itmf_int16_tag(m4af, tag->tag, n);
+        break;
+    case M4AF_TAG_COMPILATION:
+    case M4AF_FOURCC('a','k','I','D'):
+    case M4AF_FOURCC('h','d','v','d'):
+    case M4AF_FOURCC('p','c','s','t'):
+    case M4AF_FOURCC('p','g','a','p'):
+    case M4AF_FOURCC('r','t','n','g'):
+    case M4AF_FOURCC('s','t','i','k'):
+        if (sscanf(data, "%u", &n) == 1)
+            m4af_add_itmf_int8_tag(m4af, tag->tag, n);
+        break;
+    case M4AF_FOURCC('a','t','I','D'):
+    case M4AF_FOURCC('c','m','I','D'):
+    case M4AF_FOURCC('c','n','I','D'):
+    case M4AF_FOURCC('g','e','I','D'):
+    case M4AF_FOURCC('s','f','I','D'):
+    case M4AF_FOURCC('t','v','s','n'):
+    case M4AF_FOURCC('t','v','s','s'):
+        if (sscanf(data, "%u", &n) == 1)
+            m4af_add_itmf_int32_tag(m4af, tag->tag, n);
+        break;
+    case M4AF_FOURCC('p','l','I','D'):
+        {
+            int64_t qn;
+            if (sscanf(data, "%" SCNd64, &qn) == 1)
+                m4af_add_itmf_int64_tag(m4af, tag->tag, qn);
+            break;
+        }
+    case M4AF_TAG_ARTWORK:
+        {
+            int data_type = 0;
+            if (!memcmp(data, "GIF", 3))
+                data_type = M4AF_GIF;
+            else if (!memcmp(data, "\xff\xd8\xff", 3))
+                data_type = M4AF_JPEG;
+            else if (!memcmp(data, "\x89PNG", 4))
+                data_type = M4AF_PNG;
+            if (data_type)
+                m4af_add_itmf_short_tag(m4af, tag->tag, data_type,
+                                        data, data_size);
+            break;
+        }
+    case M4AF_FOURCC('-','-','-','-'):
+        {
+            char *u8 = aacenc_to_utf8(data);
+            m4af_add_itmf_long_tag(m4af, tag->name, u8);
+            free(u8);
+            break;
+        }
+    case M4AF_TAG_TITLE:
+    case M4AF_TAG_ARTIST:
+    case M4AF_TAG_ALBUM:
+    case M4AF_TAG_GENRE:
+    case M4AF_TAG_DATE:
+    case M4AF_TAG_COMPOSER:
+    case M4AF_TAG_GROUPING:
+    case M4AF_TAG_COMMENT:
+    case M4AF_TAG_LYRICS:
+    case M4AF_TAG_TOOL:
+    case M4AF_TAG_ALBUM_ARTIST:
+    case M4AF_TAG_DESCRIPTION:
+    case M4AF_TAG_LONG_DESCRIPTION:
+    case M4AF_TAG_COPYRIGHT:
+    case M4AF_FOURCC('a','p','I','D'):
+    case M4AF_FOURCC('c','a','t','g'):
+    case M4AF_FOURCC('k','e','y','w'):
+    case M4AF_FOURCC('p','u','r','d'):
+    case M4AF_FOURCC('p','u','r','l'):
+    case M4AF_FOURCC('s','o','a','a'):
+    case M4AF_FOURCC('s','o','a','l'):
+    case M4AF_FOURCC('s','o','a','r'):
+    case M4AF_FOURCC('s','o','c','o'):
+    case M4AF_FOURCC('s','o','n','m'):
+    case M4AF_FOURCC('s','o','s','n'):
+    case M4AF_FOURCC('t','v','e','n'):
+    case M4AF_FOURCC('t','v','n','n'):
+    case M4AF_FOURCC('t','v','s','h'):
+    case M4AF_FOURCC('x','i','d',' '):
+    case M4AF_FOURCC('\xa9','e','n','c'):
+    case M4AF_FOURCC('\xa9','s','t','3'):
+        {
+            char *u8 = aacenc_to_utf8(data);
+            m4af_add_itmf_string_tag(m4af, tag->tag, u8);
+            free(u8);
+            break;
+        }
+    default:
+        fprintf(stderr, "WARNING: unknown/unsupported tag: %c%c%c%c\n",
+                tag->tag >> 24, (tag->tag >> 16) & 0xff,
+                (tag->tag >> 8) & 0xff, tag->tag & 0xff);
+    }
+    if (file_contents) free(file_contents);
+}
+
+

src/metadata.h

@@ -0,0 +1,28 @@
+#ifndef METADATA_H
+#define METADATA_H
+
+typedef struct aacenc_tag_entry_t {
+    uint32_t    tag;
+    const char *name;
+    const char *data;
+    uint32_t    data_size;
+    int         is_file_name;
+} aacenc_tag_entry_t;
+
+typedef struct aacenc_tag_param_t {
+    aacenc_tag_entry_t *tag_table;
+    unsigned tag_count;
+    unsigned tag_table_capacity;
+} aacenc_tag_param_t;
+
+char *aacenc_load_tag_from_file(const char *path, uint32_t *data_size);
+
+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);
+
+void aacenc_put_tags_from_json(m4af_ctx_t *m4af, const char *json_filename);
+
+void aacenc_put_tag_entry(m4af_ctx_t *m4af, const aacenc_tag_entry_t *tag);
+
+#endif

src/parson.c

@@ -0,0 +1,647 @@
+/*
+ Parson ( http://kgabis.github.com/parson/ )
+ Copyright (c) 2012 Krzysztof Gabis
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#include "parson.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define ERROR                      0
+#define SUCCESS                    1
+#define STARTING_CAPACITY         15
+#define ARRAY_MAX_CAPACITY    122880 /* 15*(2^13) */
+#define OBJECT_MAX_CAPACITY      960 /* 15*(2^6)  */
+#define MAX_NESTING               19
+#define sizeof_token(a)       (sizeof(a) - 1)
+#define skip_char(str)        ((*str)++)
+#define skip_whitespaces(str) while (isspace(**string)) { skip_char(string); }
+#define MAX(a, b)             ((a) > (b) ? (a) : (b))
+
+#define parson_malloc(a)     malloc(a)
+#define parson_free(a)       free((void*)a)
+#define parson_realloc(a, b) realloc(a, b)
+
+/* Type definitions */
+typedef union json_value_value {
+    const char  *string;
+    double       number;
+    JSON_Object *object;
+    JSON_Array  *array;
+    int          boolean;
+    int          null;
+} JSON_Value_Value;
+
+struct json_value_t {
+    JSON_Value_Type     type;
+    JSON_Value_Value    value;
+};
+
+struct json_object_t {
+    const char **names;
+    JSON_Value **values;
+    size_t       count;
+    size_t       capacity;
+};
+
+struct json_array_t {
+    JSON_Value **items;
+    size_t       count;
+    size_t       capacity;
+};
+
+/* Various */
+static int    try_realloc(void **ptr, size_t new_size);
+static char * parson_strndup(const char *string, size_t n);
+static int    is_utf(const unsigned char *string);
+static int    is_decimal(const char *string, size_t length);
+
+/* JSON Object */
+static JSON_Object * json_object_init(void);
+static int           json_object_add(JSON_Object *object, const char *name, JSON_Value *value);
+static int           json_object_resize(JSON_Object *object, size_t capacity);
+static JSON_Value  * json_object_nget_value(const JSON_Object *object, const char *name, size_t n);
+static void          json_object_free(JSON_Object *object);
+
+/* JSON Array */
+static JSON_Array * json_array_init(void);
+static int          json_array_add(JSON_Array *array, JSON_Value *value);
+static int          json_array_resize(JSON_Array *array, size_t capacity);
+static void         json_array_free(JSON_Array *array);
+
+/* JSON Value */
+static JSON_Value * json_value_init_object(void);
+static JSON_Value * json_value_init_array(void);
+static JSON_Value * json_value_init_string(const char *string);
+static JSON_Value * json_value_init_number(double number);
+static JSON_Value * json_value_init_boolean(int boolean);
+static JSON_Value * json_value_init_null(void);
+
+/* Parser */
+static void         skip_quotes(const char **string);
+static const char * get_processed_string(const char **string);
+static JSON_Value * parse_object_value(const char **string, size_t nesting);
+static JSON_Value * parse_array_value(const char **string, size_t nesting);
+static JSON_Value * parse_string_value(const char **string);
+static JSON_Value * parse_boolean_value(const char **string);
+static JSON_Value * parse_number_value(const char **string);
+static JSON_Value * parse_null_value(const char **string);
+static JSON_Value * parse_value(const char **string, size_t nesting);
+
+/* Various */
+static int try_realloc(void **ptr, size_t new_size) {
+    void *reallocated_ptr = parson_realloc(*ptr, new_size);
+    if (!reallocated_ptr) { return ERROR; }
+    *ptr = reallocated_ptr;
+    return SUCCESS;
+}
+
+static char * parson_strndup(const char *string, size_t n) {
+    char *output_string = (char*)parson_malloc(n + 1);
+    if (!output_string) { return NULL; }
+    output_string[n] = '\0';
+    strncpy(output_string, string, n);
+    return output_string;
+}
+
+static int is_utf(const unsigned char *s) {
+    return isxdigit(s[0]) && isxdigit(s[1]) && isxdigit(s[2]) && isxdigit(s[3]);
+}
+
+static int is_decimal(const char *string, size_t length) {
+    if (length > 1 && string[0] == '0' && string[1] != '.') { return 0; }
+    if (length > 2 && !strncmp(string, "-0", 2) && string[2] != '.') { return 0; }
+    while (length--) { if (strchr("xX", string[length])) { return 0; } }
+    return 1;
+}
+
+/* JSON Object */
+static JSON_Object * json_object_init(void) {
+    JSON_Object *new_obj = (JSON_Object*)parson_malloc(sizeof(JSON_Object));
+    if (!new_obj) { return NULL; }
+    new_obj->names = (const char**)NULL;
+    new_obj->values = (JSON_Value**)NULL;
+    new_obj->capacity = 0;
+    new_obj->count = 0;
+    return new_obj;
+}
+
+static int json_object_add(JSON_Object *object, const char *name, JSON_Value *value) {
+    size_t index;
+    if (object->count >= object->capacity) {
+        size_t new_capacity = MAX(object->capacity * 2, STARTING_CAPACITY);
+        if (new_capacity > OBJECT_MAX_CAPACITY) { return ERROR; }
+        if (json_object_resize(object, new_capacity) == ERROR) { return ERROR; }
+    }
+    if (json_object_get_value(object, name) != NULL) { return ERROR; }
+    index = object->count;
+    object->names[index] = parson_strndup(name, strlen(name));
+    if (!object->names[index]) { return ERROR; }
+    object->values[index] = value;
+    object->count++;
+    return SUCCESS;
+}
+
+static int json_object_resize(JSON_Object *object, size_t capacity) {
+    if (try_realloc((void**)&object->names, capacity * sizeof(char*)) == ERROR) { return ERROR; }
+    if (try_realloc((void**)&object->values, capacity * sizeof(JSON_Value*)) == ERROR) { return ERROR; }
+    object->capacity = capacity;
+    return SUCCESS;
+}
+
+static JSON_Value * json_object_nget_value(const JSON_Object *object, const char *name, size_t n) {
+    size_t i, name_length;
+    for (i = 0; i < json_object_get_count(object); i++) {
+        name_length = strlen(object->names[i]);
+        if (name_length != n) { continue; }
+        if (strncmp(object->names[i], name, n) == 0) { return object->values[i]; }
+    }
+    return NULL;
+}
+
+static void json_object_free(JSON_Object *object) {
+    while(object->count--) {
+        parson_free(object->names[object->count]);
+        json_value_free(object->values[object->count]);
+    }
+    parson_free(object->names);
+    parson_free(object->values);
+    parson_free(object);
+}
+
+/* JSON Array */
+static JSON_Array * json_array_init(void) {
+    JSON_Array *new_array = (JSON_Array*)parson_malloc(sizeof(JSON_Array));
+    if (!new_array) { return NULL; }
+    new_array->items = (JSON_Value**)NULL;
+    new_array->capacity = 0;
+    new_array->count = 0;
+    return new_array;
+}
+
+static int json_array_add(JSON_Array *array, JSON_Value *value) {
+    if (array->count >= array->capacity) {
+        size_t new_capacity = MAX(array->capacity * 2, STARTING_CAPACITY);
+        if (new_capacity > ARRAY_MAX_CAPACITY) { return ERROR; }
+        if (!json_array_resize(array, new_capacity)) { return ERROR; }
+    }
+    array->items[array->count] = value;
+    array->count++;
+    return SUCCESS;
+}
+
+static int json_array_resize(JSON_Array *array, size_t capacity) {
+    if (try_realloc((void**)&array->items, capacity * sizeof(JSON_Value*)) == ERROR) { return ERROR; }
+    array->capacity = capacity;
+    return SUCCESS;
+}
+
+static void json_array_free(JSON_Array *array) {
+    while (array->count--) { json_value_free(array->items[array->count]); }
+    parson_free(array->items);
+    parson_free(array);
+}
+
+/* JSON Value */
+static JSON_Value * json_value_init_object(void) {
+    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
+    if (!new_value) { return NULL; }
+    new_value->type = JSONObject;
+    new_value->value.object = json_object_init();
+    if (!new_value->value.object) { parson_free(new_value); return NULL; }
+    return new_value;
+}
+
+static JSON_Value * json_value_init_array(void) {
+    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
+    if (!new_value) { return NULL; }
+    new_value->type = JSONArray;
+    new_value->value.array = json_array_init();
+    if (!new_value->value.array) { parson_free(new_value); return NULL; }
+    return new_value;
+}
+
+static JSON_Value * json_value_init_string(const char *string) {
+    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
+    if (!new_value) { return NULL; }
+    new_value->type = JSONString;
+    new_value->value.string = string;
+    return new_value;
+}
+
+static JSON_Value * json_value_init_number(double number) {
+    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
+    if (!new_value) { return NULL; }
+    new_value->type = JSONNumber;
+    new_value->value.number = number;
+    return new_value;
+}
+
+static JSON_Value * json_value_init_boolean(int boolean) {
+    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
+    if (!new_value) { return NULL; }
+    new_value->type = JSONBoolean;
+    new_value->value.boolean = boolean;
+    return new_value;
+}
+
+static JSON_Value * json_value_init_null(void) {
+    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
+    if (!new_value) { return NULL; }
+    new_value->type = JSONNull;
+    return new_value;
+}
+
+/* Parser */
+static void skip_quotes(const char **string) {
+    skip_char(string);
+    while (**string != '\"') {
+        if (**string == '\0') { return; }
+        if (**string == '\\') { skip_char(string); if (**string == '\0') { return; }}
+        skip_char(string);
+    }
+    skip_char(string);
+}
+
+/* Returns contents of a string inside double quotes and parses escaped
+ characters inside.
+ Example: "\u006Corem ipsum" -> lorem ipsum */
+static const char * get_processed_string(const char **string) {
+    const char *string_start = *string;
+    char *output, *processed_ptr, *unprocessed_ptr, current_char;
+    unsigned int utf_val;
+    skip_quotes(string);
+    if (**string == '\0') { return NULL; }
+    output = parson_strndup(string_start + 1, *string  - string_start - 2);
+    if (!output) { return NULL; }
+    processed_ptr = unprocessed_ptr = output;
+    while (*unprocessed_ptr) {
+        current_char = *unprocessed_ptr;
+        if (current_char == '\\') {
+            unprocessed_ptr++;
+            current_char = *unprocessed_ptr;
+            switch (current_char) {
+                case '\"': case '\\': case '/': break;
+                case 'b': current_char = '\b'; break;
+                case 'f': current_char = '\f'; break;
+                case 'n': current_char = '\n'; break;
+                case 'r': current_char = '\r'; break;
+                case 't': current_char = '\t'; break;
+                case 'u':
+                    unprocessed_ptr++;
+                    if (!is_utf((const unsigned char*)unprocessed_ptr) ||
+                        sscanf(unprocessed_ptr, "%4x", &utf_val) == EOF) {
+                        parson_free(output); return NULL;
+                    }
+                    if (utf_val < 0x80) {
+                        current_char = utf_val;
+                    } else if (utf_val < 0x800) {
+                        *processed_ptr++ = (utf_val >> 6) | 0xC0;
+                        current_char = ((utf_val | 0x80) & 0xBF);
+                    } else {
+                        *processed_ptr++ = (utf_val >> 12) | 0xE0;
+                        *processed_ptr++ = (((utf_val >> 6) | 0x80) & 0xBF);
+                        current_char = ((utf_val | 0x80) & 0xBF);
+                    }
+                    unprocessed_ptr += 3;
+                    break;
+                default:
+                    parson_free(output);
+                    return NULL;
+                    break;
+            }
+        } else if ((unsigned char)current_char < 0x20) { /* 0x00-0x19 are invalid characters for json string (http://www.ietf.org/rfc/rfc4627.txt) */
+            parson_free(output);
+            return NULL;
+        }
+        *processed_ptr = current_char;
+        processed_ptr++;
+        unprocessed_ptr++;
+    }
+    *processed_ptr = '\0';
+    if (try_realloc((void**)&output, strlen(output) + 1) == ERROR) { return NULL; }
+    return output;
+}
+
+static JSON_Value * parse_value(const char **string, size_t nesting) {
+    if (nesting > MAX_NESTING) { return NULL; }
+    skip_whitespaces(string);
+    switch (**string) {
+        case '{':
+            return parse_object_value(string, nesting + 1);
+        case '[':
+            return parse_array_value(string, nesting + 1);
+        case '\"':
+            return parse_string_value(string);
+        case 'f': case 't':
+            return parse_boolean_value(string);
+        case '-':
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+            return parse_number_value(string);
+        case 'n':
+            return parse_null_value(string);
+        default:
+            return NULL;
+    }
+}
+
+static JSON_Value * parse_object_value(const char **string, size_t nesting) {
+    JSON_Value *output_value = json_value_init_object(), *new_value = NULL;
+    JSON_Object *output_object = json_value_get_object(output_value);
+    const char *new_key = NULL;
+    if (!output_value) { return NULL; }
+    skip_char(string);
+    skip_whitespaces(string);
+    if (**string == '}') { skip_char(string); return output_value; } /* empty object */
+    while (**string != '\0') {
+        new_key = get_processed_string(string);
+        skip_whitespaces(string);
+        if (!new_key || **string != ':') {
+            json_value_free(output_value);
+            return NULL;
+        }
+        skip_char(string);
+        new_value = parse_value(string, nesting);
+        if (!new_value) {
+            parson_free(new_key);
+            json_value_free(output_value);
+            return NULL;
+        }
+        if(!json_object_add(output_object, new_key, new_value)) {
+            parson_free(new_key);
+            parson_free(new_value);
+            json_value_free(output_value);
+            return NULL;
+        }
+        parson_free(new_key);
+        skip_whitespaces(string);
+        if (**string != ',') { break; }
+        skip_char(string);
+        skip_whitespaces(string);
+    }
+    skip_whitespaces(string);
+    if (**string != '}' || /* Trim object after parsing is over */
+         json_object_resize(output_object, json_object_get_count(output_object)) == ERROR) {
+        json_value_free(output_value);
+        return NULL;
+    }
+    skip_char(string);
+    return output_value;
+}
+
+static JSON_Value * parse_array_value(const char **string, size_t nesting) {
+    JSON_Value *output_value = json_value_init_array(), *new_array_value = NULL;
+    JSON_Array *output_array = json_value_get_array(output_value);
+    if (!output_value) { return NULL; }
+    skip_char(string);
+    skip_whitespaces(string);
+    if (**string == ']') { /* empty array */
+        skip_char(string);
+        return output_value;
+    }
+    while (**string != '\0') {
+        new_array_value = parse_value(string, nesting);
+        if (!new_array_value) {
+            json_value_free(output_value);
+            return NULL;
+        }
+        if(json_array_add(output_array, new_array_value) == ERROR) {
+            parson_free(new_array_value);
+            json_value_free(output_value);
+            return NULL;
+        }
+        skip_whitespaces(string);
+        if (**string != ',') { break; }
+        skip_char(string);
+        skip_whitespaces(string);
+    }
+    skip_whitespaces(string);
+    if (**string != ']' || /* Trim array after parsing is over */
+         json_array_resize(output_array, json_array_get_count(output_array)) == ERROR) {
+        json_value_free(output_value);
+        return NULL;
+    }
+    skip_char(string);
+    return output_value;
+}
+
+static JSON_Value * parse_string_value(const char **string) {
+    const char *new_string = get_processed_string(string);
+    if (!new_string) { return NULL; }
+    return json_value_init_string(new_string);
+}
+
+static JSON_Value * parse_boolean_value(const char **string) {
+    size_t true_token_size = sizeof_token("true");
+    size_t false_token_size = sizeof_token("false");
+    if (strncmp("true", *string, true_token_size) == 0) {
+        *string += true_token_size;
+        return json_value_init_boolean(1);
+    } else if (strncmp("false", *string, false_token_size) == 0) {
+        *string += false_token_size;
+        return json_value_init_boolean(0);
+    }
+    return NULL;
+}
+
+static JSON_Value * parse_number_value(const char **string) {
+    char *end;
+    double number = strtod(*string, &end);
+    JSON_Value *output_value;
+    if (is_decimal(*string, end - *string)) {
+        *string = end;
+        output_value = json_value_init_number(number);
+    } else {
+        output_value = NULL;
+    }
+    return output_value;
+}
+
+static JSON_Value * parse_null_value(const char **string) {
+    size_t token_size = sizeof_token("null");
+    if (strncmp("null", *string, token_size) == 0) {
+        *string += token_size;
+        return json_value_init_null();
+    }
+    return NULL;
+}
+
+/* Parser API */
+JSON_Value * json_parse_file(const char *filename) {
+    FILE *fp = fopen(filename, "r");
+    size_t file_size;
+    char *file_contents;
+    JSON_Value *output_value;
+    if (!fp) { return NULL; }
+    fseek(fp, 0L, SEEK_END);
+    file_size = ftell(fp);
+    rewind(fp);
+    file_contents = (char*)parson_malloc(sizeof(char) * (file_size + 1));
+    if (!file_contents) { fclose(fp); return NULL; }
+    fread(file_contents, file_size, 1, fp);
+    fclose(fp);
+    file_contents[file_size] = '\0';
+    output_value = json_parse_string(file_contents);
+    parson_free(file_contents);
+    return output_value;
+}
+
+JSON_Value * json_parse_string(const char *string) {
+    if (!string || (*string != '{' && *string != '[')) { return NULL; }
+    return parse_value((const char**)&string, 0);
+}
+
+/* JSON Object API */
+JSON_Value * json_object_get_value(const JSON_Object *object, const char *name) {
+    return json_object_nget_value(object, name, strlen(name));
+}
+
+const char * json_object_get_string(const JSON_Object *object, const char *name) {
+    return json_value_get_string(json_object_get_value(object, name));
+}
+
+double json_object_get_number(const JSON_Object *object, const char *name) {
+    return json_value_get_number(json_object_get_value(object, name));
+}
+
+JSON_Object * json_object_get_object(const JSON_Object *object, const char *name) {
+    return json_value_get_object(json_object_get_value(object, name));
+}
+
+JSON_Array * json_object_get_array(const JSON_Object *object, const char *name) {
+    return json_value_get_array(json_object_get_value(object, name));
+}
+
+int json_object_get_boolean(const JSON_Object *object, const char *name) {
+    return json_value_get_boolean(json_object_get_value(object, name));
+}
+
+JSON_Value * json_object_dotget_value(const JSON_Object *object, const char *name) {
+    const char *dot_position = strchr(name, '.');
+    if (!dot_position) { return json_object_get_value(object, name); }
+    object = json_value_get_object(json_object_nget_value(object, name, dot_position - name));
+    return json_object_dotget_value(object, dot_position + 1);
+}
+
+const char * json_object_dotget_string(const JSON_Object *object, const char *name) {
+    return json_value_get_string(json_object_dotget_value(object, name));
+}
+
+double json_object_dotget_number(const JSON_Object *object, const char *name) {
+    return json_value_get_number(json_object_dotget_value(object, name));
+}
+
+JSON_Object * json_object_dotget_object(const JSON_Object *object, const char *name) {
+    return json_value_get_object(json_object_dotget_value(object, name));
+}
+
+JSON_Array * json_object_dotget_array(const JSON_Object *object, const char *name) {
+    return json_value_get_array(json_object_dotget_value(object, name));
+}
+
+int json_object_dotget_boolean(const JSON_Object *object, const char *name) {
+    return json_value_get_boolean(json_object_dotget_value(object, name));
+}
+
+size_t json_object_get_count(const JSON_Object *object) {
+    return object ? object->count : 0;
+}
+
+const char * json_object_get_name(const JSON_Object *object, size_t index) {
+    if (index >= json_object_get_count(object)) { return NULL; }
+    return object->names[index];
+}
+
+/* JSON Array API */
+JSON_Value * json_array_get_value(const JSON_Array *array, size_t index) {
+    if (index >= json_array_get_count(array)) { return NULL; }
+    return array->items[index];
+}
+
+const char * json_array_get_string(const JSON_Array *array, size_t index) {
+    return json_value_get_string(json_array_get_value(array, index));
+}
+
+double json_array_get_number(const JSON_Array *array, size_t index) {
+    return json_value_get_number(json_array_get_value(array, index));
+}
+
+JSON_Object * json_array_get_object(const JSON_Array *array, size_t index) {
+    return json_value_get_object(json_array_get_value(array, index));
+}
+
+JSON_Array * json_array_get_array(const JSON_Array *array, size_t index) {
+    return json_value_get_array(json_array_get_value(array, index));
+}
+
+int json_array_get_boolean(const JSON_Array *array, size_t index) {
+    return json_value_get_boolean(json_array_get_value(array, index));
+}
+
+size_t json_array_get_count(const JSON_Array *array) {
+    return array ? array->count : 0;
+}
+
+/* JSON Value API */
+JSON_Value_Type json_value_get_type(const JSON_Value *value) {
+    return value ? value->type : JSONError;
+}
+
+JSON_Object * json_value_get_object(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONObject ? value->value.object : NULL;
+}
+
+JSON_Array * json_value_get_array(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONArray ? value->value.array : NULL;
+}
+
+const char * json_value_get_string(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONString ? value->value.string : NULL;
+}
+
+double json_value_get_number(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONNumber ? value->value.number : 0;
+}
+
+int json_value_get_boolean(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONBoolean ? value->value.boolean : -1;
+}
+
+void json_value_free(JSON_Value *value) {
+    switch (json_value_get_type(value)) {
+        case JSONObject:
+            json_object_free(value->value.object);
+            break;
+        case JSONString:
+            if (value->value.string) { parson_free(value->value.string); }
+            break;
+        case JSONArray:
+            json_array_free(value->value.array);
+            break;
+        default:
+            break;
+    }
+    parson_free(value);
+}

src/parson.h

@@ -0,0 +1,100 @@
+/*
+ Parson ( http://kgabis.github.com/parson/ )
+ Copyright (c) 2012 Krzysztof Gabis
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#ifndef parson_parson_h
+#define parson_parson_h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif    
+    
+#include <stddef.h>   /* size_t */    
+    
+/* Types and enums */
+typedef struct json_object_t JSON_Object;
+typedef struct json_array_t  JSON_Array;
+typedef struct json_value_t  JSON_Value;
+
+typedef enum json_value_type {
+    JSONError   = 0,
+    JSONNull    = 1,
+    JSONString  = 2,
+    JSONNumber  = 3,
+    JSONObject  = 4,
+    JSONArray   = 5,
+    JSONBoolean = 6
+} JSON_Value_Type;
+
+/* Parses first JSON value in a file, returns NULL in case of error */
+JSON_Value  * json_parse_file(const char *filename);
+
+/*  Parses first JSON value in a string, returns NULL in case of error */
+JSON_Value  * json_parse_string(const char *string);
+
+/* JSON Object */
+JSON_Value  * json_object_get_value  (const JSON_Object *object, const char *name);
+const char  * json_object_get_string (const JSON_Object *object, const char *name);
+JSON_Object * json_object_get_object (const JSON_Object *object, const char *name);
+JSON_Array  * json_object_get_array  (const JSON_Object *object, const char *name);
+double        json_object_get_number (const JSON_Object *object, const char *name);
+int           json_object_get_boolean(const JSON_Object *object, const char *name);
+
+/* dotget functions enable addressing values with dot notation in nested objects,
+ just like in structs or c++/java/c# objects (e.g. objectA.objectB.value).
+ Because valid names in JSON can contain dots, some values may be inaccessible
+ this way. */
+JSON_Value  * json_object_dotget_value  (const JSON_Object *object, const char *name);
+const char  * json_object_dotget_string (const JSON_Object *object, const char *name);
+JSON_Object * json_object_dotget_object (const JSON_Object *object, const char *name);
+JSON_Array  * json_object_dotget_array  (const JSON_Object *object, const char *name);
+double        json_object_dotget_number (const JSON_Object *object, const char *name);
+int           json_object_dotget_boolean(const JSON_Object *object, const char *name);
+
+/* Functions to get available names */
+size_t        json_object_get_count(const JSON_Object *object);
+const char  * json_object_get_name (const JSON_Object *object, size_t index);
+    
+/* JSON Array */
+JSON_Value  * json_array_get_value  (const JSON_Array *array, size_t index);
+const char  * json_array_get_string (const JSON_Array *array, size_t index);
+JSON_Object * json_array_get_object (const JSON_Array *array, size_t index);
+JSON_Array  * json_array_get_array  (const JSON_Array *array, size_t index);
+double        json_array_get_number (const JSON_Array *array, size_t index);
+int           json_array_get_boolean(const JSON_Array *array, size_t index);
+size_t        json_array_get_count  (const JSON_Array *array);
+
+/* JSON Value */
+JSON_Value_Type json_value_get_type   (const JSON_Value *value);
+JSON_Object *   json_value_get_object (const JSON_Value *value);
+JSON_Array  *   json_value_get_array  (const JSON_Value *value);
+const char  *   json_value_get_string (const JSON_Value *value);
+double          json_value_get_number (const JSON_Value *value);
+int             json_value_get_boolean(const JSON_Value *value);
+void            json_value_free       (JSON_Value *value);
+    
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/progress.c

@@ -6,6 +6,8 @@
 #  include "config.h"
 #endif
 #include <stdio.h>
+#include <limits.h>
+#include <float.h>
 #include <time.h>
 #if HAVE_STDINT_H
 #  include <stdint.h>
@@ -51,11 +53,14 @@ void aacenc_progress_init(aacenc_progress_t *progress, int64_t total,
 void aacenc_progress_update(aacenc_progress_t *progress, int64_t current,
                             int period)
 {
-    int percent = 100.0 * current / progress->total + .5;
     double seconds = current / progress->timescale;
     double ellapsed = (aacenc_timer() - progress->start) / 1000.0;
-    double eta = ellapsed * (progress->total / (double)current - 1.0);
+    double speed = ellapsed ? seconds / ellapsed : 1.0;
-    double speed = ellapsed ? seconds / ellapsed : 0.0;
+    int percent = progress->total ? 100.0 * current / progress->total + .5
+                                  : 100;
+    double eta = current ? ellapsed * (progress->total / (double)current - 1.0)
+                         : progress->total ? DBL_MAX : 0;
+
     if (current < progress->processed + period)
         return;
 
@@ -80,7 +85,7 @@ void aacenc_progress_finish(aacenc_progress_t *progress, int64_t current)
     double ellapsed = (aacenc_timer() - progress->start) / 1000.0;
     aacenc_progress_update(progress, current, 0);
     if (progress->total == INT64_MAX)
-        fprintf(stderr, "\n%" PRId64 "samples processed in ", current);
+        fprintf(stderr, "\n%" PRId64 " samples processed in ", current);
     else
         fprintf(stderr, "\n%" PRId64 "/%" PRId64 " samples processed in ",
                 current, progress->total);

src/wav_reader.c

@@ -38,6 +38,7 @@ struct wav_reader_t {
     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;
@@ -91,7 +92,7 @@ int riff_read(wav_reader_t *reader, void *buffer, uint32_t size)
 }
 
 static
-int riff_skip(wav_reader_t *reader, uint32_t count)
+int riff_skip(wav_reader_t *reader, int64_t count)
 {
     char buff[8192];
     int rc;
@@ -114,6 +115,37 @@ int riff_skip(wav_reader_t *reader, uint32_t count)
     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)
 {
@@ -209,9 +241,8 @@ int riff_ds64(wav_reader_t *reader, int64_t *length)
                   fcc == RIFF_FOURCC('d','s','6','4') && chunk_size >= 28);
     TRY_IO(riff_scan(reader, "QQQL",
                      &riff_size, length, &sample_count, &table_size) != 4);
-    if (table_size == 0)
+    TRY_IO(riff_skip(reader, (chunk_size - 27) & ~1));
-        return 0;
+    reader->data_offset += (chunk_size + 9) & ~1;
-    reader->last_error = WAV_UNSUPPORTED_FORMAT;
 FAIL:
     return -1;
 }
@@ -290,6 +321,8 @@ int wav_parse(wav_reader_t *reader, int64_t *data_length)
     TRY_IO(riff_read32(reader, &fcc));
     if (fcc != RIFF_FOURCC('W','A','V','E'))
         goto FAIL;
+    reader->data_offset = 12;
+
     if (container == RIFF_FOURCC('R','F','6','4'))
         riff_ds64(reader, data_length);
     while ((fcc = riff_next_chunk(reader, &chunk_size)) != 0) {
@@ -299,10 +332,13 @@ int wav_parse(wav_reader_t *reader, int64_t *data_length)
         } else if (fcc == RIFF_FOURCC('d','a','t','a')) {
             if (container == RIFF_FOURCC('R','I','F','F'))
                 *data_length = chunk_size;
+            reader->data_offset += 8;
             break;
-        } else
+        } else {
             TRY_IO(riff_skip(reader, (chunk_size + 1) & ~1));
         }
+        reader->data_offset += (chunk_size + 9) & ~1;
+    }
     if (fcc == RIFF_FOURCC('d','a','t','a'))
         return 0;
 FAIL:
@@ -312,8 +348,9 @@ FAIL:
 wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
                        int ignore_length)
 {
-    wav_reader_t *reader;
+    wav_reader_t *reader = 0;
     int64_t data_length;
+    unsigned bpf;
 
     if ((reader = calloc(1, sizeof(wav_reader_t))) == 0)
         return 0;
@@ -324,10 +361,43 @@ wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
         free(reader);
         return 0;
     }
-    if (ignore_length || !data_length ||
+    bpf = reader->sample_format.bytes_per_frame;
-        data_length % reader->sample_format.bytes_per_frame != 0)
+    if (ignore_length || !data_length || data_length % bpf)
         reader->length = INT64_MAX;
     else
-        reader->length = data_length / reader->sample_format.bytes_per_frame;
+        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 (size > 0)
+                reader->length = (size - reader->data_offset) / bpf;
+            reader->io.seek(reader->io_cookie, reader->data_offset, SEEK_SET);
+        }
+    }
     return reader;
 }
+
+wav_reader_t *raw_open(wav_io_context_t *io_ctx, void *io_cookie,
+                       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->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);
+        }
+    } else
+        reader->length = INT64_MAX;
+    return reader;
+}
+
+

src/wav_reader.h

@@ -16,16 +16,20 @@ enum wav_error_code {
 
 typedef int (*wav_read_callback)(void *cookie, void *data, uint32_t size);
 typedef int (*wav_seek_callback)(void *cookie, int64_t off, int whence);
+typedef int64_t (*wav_tell_callback)(void *cookie);
 
 typedef struct wav_io_context_t {
     wav_read_callback read;
     wav_seek_callback seek;
+    wav_tell_callback tell;
 } wav_io_context_t;
 
 typedef struct wav_reader_t wav_reader_t;
 
 wav_reader_t *wav_open(wav_io_context_t *io_ctx, void *io_cookie,
                        int ignore_length);
+wav_reader_t *raw_open(wav_io_context_t *io_ctx, void *io_cookie,
+                       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);

version.h

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