diff --git a/exhale_vs2012.sln b/exhale_vs2012.sln new file mode 100644 index 0000000..cbf5be2 --- /dev/null +++ b/exhale_vs2012.sln @@ -0,0 +1,38 @@ +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2012 +Project("{EC0D1500-2018-1700-4865-6C6D72696368}") = "exhaleLib", "src\lib\exhaleLib_vs2012.vcxproj", "{EC0D1501-2018-1700-4865-6C6D72696368}" +EndProject +Project("{EC0D1500-2018-1700-4865-6C6D72696368}") = "exhaleApp", "src\app\exhaleApp_vs2012.vcxproj", "{EC0D1502-2018-1700-4865-6C6D72696368}" + ProjectSection(ProjectDependencies) = postProject + {EC0D1501-2018-1700-4865-6C6D72696368} = {EC0D1501-2018-1700-4865-6C6D72696368} + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {EC0D1501-2018-1700-4865-6C6D72696368}.Debug|Win32.ActiveCfg = Debug|Win32 + {EC0D1501-2018-1700-4865-6C6D72696368}.Debug|Win32.Build.0 = Debug|Win32 + {EC0D1501-2018-1700-4865-6C6D72696368}.Debug|x64.ActiveCfg = Debug|x64 + {EC0D1501-2018-1700-4865-6C6D72696368}.Debug|x64.Build.0 = Debug|x64 + {EC0D1501-2018-1700-4865-6C6D72696368}.Release|Win32.ActiveCfg = Release|Win32 + {EC0D1501-2018-1700-4865-6C6D72696368}.Release|Win32.Build.0 = Release|Win32 + {EC0D1501-2018-1700-4865-6C6D72696368}.Release|x64.ActiveCfg = Release|x64 + {EC0D1501-2018-1700-4865-6C6D72696368}.Release|x64.Build.0 = Release|x64 + {EC0D1502-2018-1700-4865-6C6D72696368}.Debug|Win32.ActiveCfg = Debug|Win32 + {EC0D1502-2018-1700-4865-6C6D72696368}.Debug|Win32.Build.0 = Debug|Win32 + {EC0D1502-2018-1700-4865-6C6D72696368}.Debug|x64.ActiveCfg = Debug|x64 + {EC0D1502-2018-1700-4865-6C6D72696368}.Debug|x64.Build.0 = Debug|x64 + {EC0D1502-2018-1700-4865-6C6D72696368}.Release|Win32.ActiveCfg = Release|Win32 + {EC0D1502-2018-1700-4865-6C6D72696368}.Release|Win32.Build.0 = Release|Win32 + {EC0D1502-2018-1700-4865-6C6D72696368}.Release|x64.ActiveCfg = Release|x64 + {EC0D1502-2018-1700-4865-6C6D72696368}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/include/License.htm b/include/License.htm new file mode 100644 index 0000000..b2163f4 --- /dev/null +++ b/include/License.htm @@ -0,0 +1,53 @@ + + + + + + + + + + +ecodis :: exhale :: License Text + + + + +++++++ + + + + + +
+ +


exhale - ecodis extended high-efficiency and low-complexity encoder

referred to as «Software» below; additions to original BSD license text marked by [ ]

+

   This Software is being made available and/or distributed under the following Modified BSD-style License. For a list of authors which have contributed to this Software, called «contributors» in the text below, please refer to the respective files provided with this distribution (source files or binary executable) to which modifications were contributed.

+


Licensor's Copyright Notice

+

   Copyright © 2018–2019 Christian R. Helmrich, ecodis (Licensor). All rights reserved.

+


List of License Conditions

+

   Redistribution and use [of this Software] in source and binary forms, with or without modification, are permitted provided that [all of] the following [four] conditions are met:

+
    +

  • Redistributions of source code must retain the above copyright notice [in each file provided with the distribution], this list of conditions, and the following disclaimer.

    • +

  • Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other files provided with the distribution.

    • +

  • [Redistributions of modified versions of this Software, whether in source or binary form, must reproduce a notice in each file provided with the distribution and affec­ted by the modification, documenting the name of the contributor having authored the modification and the year of the modification.]

    • +

  • Neither the name of the Licensor nor the names of the contributors may be used to endorse or promote products derived from this Software without specific prior written permission [from the Licensor].

    • +
+


Liability and Patent Disclaimer

+

   THIS SOFTWARE IS PROVIDED BY THE LICENSOR AND THE CONTRIBUTORS «AS IS» AND ANY EXPRESS OR IMPLIED WARRANTIES (INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PUR­POSE) ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR OR ANY CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

  [This Software may be subject to other third-party and/or contributor rights, including patent rights. In particular, this Software may implement methods and/or technologies required to perform in compliance with certain specifications of the ISO/IEC (MPEG-D) international standard 23003-3, which may be subject to said other rights. NO express or implied licenses to any patent claims related to the use of this Software are granted under this license, and the Licensor provides NO WARRANTY of patent non-infringement with respect to this Software. Patent licenses required for the use of this Software to generate digital bit-streams according to any specifications of ISO/IEC 23003-3 may be obtained through Via Licensing and/or the corresponding patent holders individually.]

+

Written by C. R. Helmrich for exhale 1.0.0, Dec. 2019. Available at www.ecodis.de/exhale/license.htm.

+ +		 +


   exhale

+
+

+ + + diff --git a/include/Release.htm b/include/Release.htm new file mode 100644 index 0000000..11deac6 --- /dev/null +++ b/include/Release.htm @@ -0,0 +1,66 @@ + + + + + + + + + + +ecodis :: exhale :: Release Notes + + + + +++++++ + + + + + +
+ +


exhale - ecodis extended high-efficiency and low-complexity encoder

Software Release Notes, Version History, Known Issues, Upcoming Feature Roadmap

+

   The version of this distribution of the «exhale» software release is 1.0.0 (official pub­lic release candidate) from January 2020. Please check www.ecodis.de regularly for new versions of this software. A summary of each version up to this release, a list of known issues with this release, and a roadmap of additional functionality are provided below.

+


Chronological Version History

+

   Version 1.0.0  Jan. 2020, this release

+
    +

  • compilation fixes and executable printout changes for Linux and MacOS™ platform

    • +
+

   Version 1.0RC Dec. 2019

+
    +

  • initial release for testing with only basic channel-independent coding functionality

    • +

  • only support for Microsoft Windows™ (32-bit and 64-bit) platform provided so far.

    • +
+


Known Issues with This Release

+

   If you notice an issue with this release not mentioned below, please contact ecodis or a contributor with the details (configuration, input file) needed to reproduce the issue.

+
    +

  • exhaleLib: Coding of stereo or multichannel input yields suboptimal audio quality because the joint-channel coding functionality provided by the ISO/IEC 23003-3 standard has not been implemented so far. See the functionality roadmap below.

    • +

  • exhaleApp: Only basic WAVE input file reading functionality has been implemen­ted. Specifically, 8-bit WAVE input is assumed to contain an even number of audio samples, and the Broadcast and Extensible WAVE file formats are not supported.

    • +
+


Roadmap of Upcoming Features

+

   If you are in need of an additional library or application feature not mentioned below, please contact ecodis or a contributor with a request, and we will see what we can do.

+
    +

  • support for MPEG-D DRC-style peak-level and loudness metadata, no version plan

    • +

  • support for compilation as dynamically linked library in Windows™, no version plan

    • +

  • exhaleLib: quality tuning and bug fixing for low-bitrate mono coding, version 1.0.1

    • +

  • exhaleLib: finalized integration of joint-channel coding functionality, version 1.0.2

    • +

  • exhaleLib: quality tuning and bug fixing for low-rate stereo coding, version 1.0.3.

    • +
+


+

Written by C. R. Helmrich for exhale 1.0.0, Dec. 2019. Available at www.ecodis.de/exhale/release.htm.

+ +		 +


   exhale

+
+

+ + + diff --git a/include/exhaleDecl.h b/include/exhaleDecl.h new file mode 100644 index 0000000..9349120 --- /dev/null +++ b/include/exhaleDecl.h @@ -0,0 +1,22 @@ +/* exhaleDecl.h - header file with declarations for exhale DLL export under Windows + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _EXHALE_DECL_H_ +#define _EXHALE_DECL_H_ + +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) +# ifdef EXHALE_DYN_LINK +# define EXHALE_DECL __declspec (dllexport) +# else +# define EXHALE_DECL +# endif +#endif + +#endif // _EXHALE_DECL_H_ diff --git a/include/styles.css b/include/styles.css new file mode 100644 index 0000000..fe71e49 --- /dev/null +++ b/include/styles.css @@ -0,0 +1,39 @@ +a:link, a:visited +{ color:#36f; font-weight:bold; text-decoration:none; } +a:active, a:focus, a:hover +{ color:#f36; font-weight:bold; text-decoration:none; } +a.current:link, a.current:visited +{ background:#fff; color:#000; } + +body +{ margin:0px; text-align:center; } + +h1 +{ color:#666; font-family:Segoe UI, Arial, sans-serif; font-size:13pt; font-weight:bold; } +h2 +{ color:#36f; font-family:Segoe UI, Arial, sans-serif; font-size:13pt; font-weight:bold; } +h3 +{ color:#000; font-family:Verdana, Arial, sans-serif; font-size:10pt; font-weight:normal; line-height:16pt; max-width:594px; text-align:justify; } +h4 +{ color:#000; font-family:Verdana, Arial, sans-serif; font-size:8pt; font-weight:normal; line-height:14pt; max-width:594px; } + +hr +{ border:1px solid; color:#ccc; height:1px; } + +img +{ border-width:0px; } + +td +{ background:#fff; } + +ul +{ list-style:square; } + +.block +{ text-align:justify; } +.center +{ text-align:center; } +.gray +{ color:#ccc; } +.pink +{ color:#f36; } diff --git a/include/version.h b/include/version.h new file mode 100644 index 0000000..acc460e --- /dev/null +++ b/include/version.h @@ -0,0 +1,19 @@ +/* version.h - header file with major and minor library version numbers as characters + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef EXHALELIB_VERSION_MAJOR +# define EXHALELIB_VERSION_MAJOR "1" +#endif +#ifndef EXHALELIB_VERSION_MINOR +# define EXHALELIB_VERSION_MINOR "0" +#endif +#ifndef EXHALELIB_VERSION_BUGFIX +# define EXHALELIB_VERSION_BUGFIX "RC" // "RC" or ".0", ".1", ... +#endif diff --git a/makefile b/makefile new file mode 100644 index 0000000..af801d3 --- /dev/null +++ b/makefile @@ -0,0 +1,30 @@ +## makefile - master user make-file for compiling exhale on Linux and MacOS platforms + # written by C. R. Helmrich, last modified 2019 - see License.txt for legal notices + # + # The copyright in this software is being made available under a Modified BSD License + # and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + # party rights, including patent rights. No such rights are granted under this License. + # + # Copyright (c) 2018-2019 Christian R. Helmrich, project ecodis. All rights reserved. + ## + +## BUILD32=1: compile for 32-bit platforms, BUILD32=0: compile for 64-bit platforms +BUILD32?=0 + +export BUILD32 + +all: + $(MAKE) -C src/lib MM32=$(BUILD32) + $(MAKE) -C src/app MM32=$(BUILD32) + +debug: + $(MAKE) -C src/lib debug MM32=$(BUILD32) + $(MAKE) -C src/app debug MM32=$(BUILD32) + +release: + $(MAKE) -C src/lib release MM32=$(BUILD32) + $(MAKE) -C src/app release MM32=$(BUILD32) + +clean: + $(MAKE) -C src/lib clean MM32=$(BUILD32) + $(MAKE) -C src/app clean MM32=$(BUILD32) diff --git a/src/app/basicMP4Writer.cpp b/src/app/basicMP4Writer.cpp new file mode 100644 index 0000000..a90fba1 --- /dev/null +++ b/src/app/basicMP4Writer.cpp @@ -0,0 +1,361 @@ +/* basicMP4Writer.cpp - source file for class with basic MPEG-4 file writing capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleAppPch.h" +#include "basicMP4Writer.h" + +#if 0 // DEBUG +static const uint8_t muLawHeader[44] = { + 0x52, 0x49, 0x46, 0x46, 0xF0, 0xFF, 0xFF, 0xFF, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20, + 0x10, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x08, 0x00, 0x64, 0x61, 0x74, 0x61, 0xF0, 0xFF, 0xFF, 0xFF +}; +#endif + +static const uint8_t staticHeaderTemplate[STAT_HEADER_SIZE] = { + 0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x6D, 0x70, 0x34, 0x32, 0x00, 0x00, 0x00, 0x00, // ftyp + 0x6D, 0x70, 0x34, 0x32, 0x69, 0x73, 0x6F, 0x6D, 0x00, 0x00, MOOV_BSIZE, 0x6D, 0x6F, 0x6F, 0x76, // moov + 0x00, 0x00, 0x00, 0x6C, 0x6D, 0x76, 0x68, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mvhd + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, // end atom 2.1 (mvhd) + 0x00, 0x00, 0x00, 0x18, 0x69, 0x6F, 0x64, 0x73, 0x00, 0x00, 0x00, 0x00, 0x10, 0x80, 0x80, 0x80, // iods + 0x07, 0x00, 0x4F, 0xFF, 0xFF, 0x49, 0xFF, 0xFF, 0x00, 0x00, TRAK_BSIZE, // end atom 2.2 (iods) + 0x74, 0x72, 0x61, 0x6B, 0x00, 0x00, 0x00, 0x5C, 0x74, 0x6B, 0x68, 0x64, 0x00, 0x00, 0x00, 0x07, // tkhd + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x24, 0x65, 0x64, 0x74, 0x73, 0x00, 0x00, 0x00, 0x1C, 0x65, 0x6C, 0x73, 0x74, // elst + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, MDIA_BSIZE, 0x6D, 0x64, 0x69, 0x61, 0x00, 0x00, 0x00, 0x20, // mdhd + 0x6D, 0x64, 0x68, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, + 0x68, 0x64, 0x6C, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, 0x6F, 0x75, 0x6E, // hdlr + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x72, 0x68, 0x00, + 0x00, 0x00, MINF_BSIZE, 0x6D, 0x69, 0x6E, 0x66, 0x00, 0x00, 0x00, 0x10, 0x73, 0x6D, 0x68, 0x64, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x64, 0x69, 0x6E, 0x66, // dinf + 0x00, 0x00, 0x00, 0x1C, 0x64, 0x72, 0x65, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x0C, 0x75, 0x72, 0x6C, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, STBL_BSIZE, + 0x73, 0x74, 0x62, 0x6C, 0x00, 0x00, 0x00, 0x20, 0x73, 0x74, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, // stts + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, STSD_BSIZE, 0x73, 0x74, 0x73, 0x64, 0x00, 0x00, 0x00, 0x00, // stsd + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, MP4A_BSIZE, 0x6D, 0x70, 0x34, 0x61, 0x00, 0x00, 0x00, 0x00, // mp4a + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ESDS_BSIZE, 0x65, 0x73, 0x64, 0x73, // esds + 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x80, 0x80, 0x25, 0x00, 0x00, 0x00, 0x04, 0x80, 0x80, 0x80, // tag4 + 0x17, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x80, // tag5 + 0x80, 0x80, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 // ASC continued in m_dynamicHeader if >5 bytes +}; + +// static helper functions +static uint32_t toBigEndian (const unsigned ui) // Motorola endianness +{ + return ((ui & UCHAR_MAX) << 24) | (((ui >> 8) & UCHAR_MAX) << 16) | (((ui >> 16) & UCHAR_MAX) << 8) | ((ui >> 24) & UCHAR_MAX); +} + +static uint16_t toUShortValue (const uint8_t hiByte, const uint8_t loByte) +{ + return ((uint16_t) hiByte << 8) | (uint16_t) loByte; +} + +// public functions +int BasicMP4Writer::addFrameAU (const uint8_t* byteBuf, const uint32_t byteOffset, const uint32_t byteCount) +{ + if ((m_fileHandle == -1) || (m_m4aMdatSize > 0xFFFFFFF0u - byteCount)) + { + return 1; // invalid file handle or file getting too big + } + + // add frame byte-size, in Big Endian format, to frame size list (stsz) + m_dynamicHeader.push_back ((byteCount >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((byteCount >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((byteCount >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( byteCount & UCHAR_MAX); + + if (((m_frameCount++) % m_rndAccPeriod) == 0) // add RAP to list (stco) + { + m_rndAccOffsets.push_back (m_m4aMdatSize); + } + m_m4aMdatSize += byteCount; + + return _WRITE (m_fileHandle, byteBuf, byteCount); // write access unit +} + +int BasicMP4Writer::finishFile (const unsigned avgBitrate, const unsigned maxBitrate, const uint32_t audioLength, + const uint32_t modifTime /*= 0*/) +{ + const unsigned numFramesFirstPeriod = __min (m_frameCount, m_rndAccPeriod); + const unsigned numFramesFinalPeriod = (m_frameCount <= m_rndAccPeriod ? 0 : m_frameCount % m_rndAccPeriod); + const unsigned numSamplesFinalFrame = (audioLength + m_pregapLength) % m_frameLength; + const uint32_t stszAtomSize = STSX_BSIZE + 4 /*bytes for sampleSize*/ + m_frameCount * 4; + const uint32_t stscAtomSize = STSX_BSIZE + (numFramesFinalPeriod == 0 ? 12 : 24); + const uint32_t stcoAtomSize = STSX_BSIZE + (uint32_t) m_rndAccOffsets.size () * 4; + const uint32_t stblIncrSize = m_ascSizeM5 + stszAtomSize + stscAtomSize + stcoAtomSize; + const uint32_t moovAtomSize = toBigEndian (toUShortValue (MOOV_BSIZE) + stblIncrSize); + const uint32_t trakAtomSize = toBigEndian (toUShortValue (TRAK_BSIZE) + stblIncrSize); + const uint32_t mdiaAtomSize = toBigEndian (toUShortValue (MDIA_BSIZE) + stblIncrSize); + const uint32_t minfAtomSize = toBigEndian (toUShortValue (MINF_BSIZE) + stblIncrSize); + const uint32_t stblAtomSize = toBigEndian (toUShortValue (STBL_BSIZE) + stblIncrSize); + const uint32_t numSamplesBE = toBigEndian (audioLength); + const uint32_t timeStampBE = toBigEndian (modifTime); + const uint32_t headerBytes = STAT_HEADER_SIZE + (uint32_t) m_dynamicHeader.size () + stscAtomSize + stcoAtomSize; + uint32_t* const header4Byte = (uint32_t* const) m_staticHeader; + int bytesWritten = 0; + + if ((m_fileHandle == -1) || (m_m4aMdatSize > 0xFFFFFFF0u - headerBytes)) + { + return 1; // invalid file handle or file getting too big + } + + // finish setup of fixed-length part of MPEG-4 file header + if (modifTime > 0) + { + header4Byte[ 48>>2] = timeStampBE; // mvhd + header4Byte[188>>2] = timeStampBE; // tkhd + header4Byte[324>>2] = timeStampBE; // mdhd + } + header4Byte[ 24>>2] = moovAtomSize; + header4Byte[ 56>>2] = numSamplesBE; + header4Byte[164>>2] = trakAtomSize; + header4Byte[200>>2] = numSamplesBE; + header4Byte[300>>2] = mdiaAtomSize; + header4Byte[332>>2] = toBigEndian (audioLength + m_pregapLength); + header4Byte[376>>2] = minfAtomSize; + header4Byte[288>>2] = numSamplesBE; // elst + header4Byte[436>>2] = stblAtomSize; + header4Byte[460>>2] = toBigEndian (m_frameCount - 1); // 2 entries used + header4Byte[472>>2] = toBigEndian (numSamplesFinalFrame == 0 ? m_frameLength : numSamplesFinalFrame); + + m_staticHeader[558] = ((maxBitrate >> 24) & UCHAR_MAX); + m_staticHeader[559] = ((maxBitrate >> 16) & UCHAR_MAX); + m_staticHeader[560] = ((maxBitrate >> 8) & UCHAR_MAX); + m_staticHeader[561] = ( maxBitrate & UCHAR_MAX); + m_staticHeader[562] = ((avgBitrate >> 24) & UCHAR_MAX); + m_staticHeader[563] = ((avgBitrate >> 16) & UCHAR_MAX); + m_staticHeader[564] = ((avgBitrate >> 8) & UCHAR_MAX); + m_staticHeader[565] = ( avgBitrate & UCHAR_MAX); + + // finish dynamically-sized 2nd part of MPEG-4 file header + m_dynamicHeader.at (m_ascSizeM5 + 6) = ((stszAtomSize >> 24) & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 7) = ((stszAtomSize >> 16) & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 8) = ((stszAtomSize >> 8) & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 9) = ( stszAtomSize & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 22) = ((m_frameCount >> 24) & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 23) = ((m_frameCount >> 16) & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 24) = ((m_frameCount >> 8) & UCHAR_MAX); + m_dynamicHeader.at (m_ascSizeM5 + 25) = ( m_frameCount & UCHAR_MAX); + + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (stscAtomSize); + m_dynamicHeader.push_back (0x73); m_dynamicHeader.push_back (0x74); + m_dynamicHeader.push_back (0x73); m_dynamicHeader.push_back (0x63); // stsc + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (numFramesFinalPeriod == 0 ? 1 : 2); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x01); // 1st + m_dynamicHeader.push_back ((numFramesFirstPeriod >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((numFramesFirstPeriod >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((numFramesFirstPeriod >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( numFramesFirstPeriod & UCHAR_MAX); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x01); // idx + + if (numFramesFinalPeriod > 0) + { + m_dynamicHeader.push_back ((m_rndAccOffsets.size () >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((m_rndAccOffsets.size () >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((m_rndAccOffsets.size () >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( m_rndAccOffsets.size () & UCHAR_MAX); + m_dynamicHeader.push_back ((numFramesFinalPeriod >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((numFramesFinalPeriod >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((numFramesFinalPeriod >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( numFramesFinalPeriod & UCHAR_MAX); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x01);// idx + } + + m_dynamicHeader.push_back ((stcoAtomSize >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((stcoAtomSize >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((stcoAtomSize >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( stcoAtomSize & UCHAR_MAX); + m_dynamicHeader.push_back (0x73); m_dynamicHeader.push_back (0x74); + m_dynamicHeader.push_back (0x63); m_dynamicHeader.push_back (0x6F); // stco + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back ((m_rndAccOffsets.size () >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((m_rndAccOffsets.size () >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((m_rndAccOffsets.size () >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( m_rndAccOffsets.size () & UCHAR_MAX); + + // add header size corrected random-access offsets to file + for (unsigned i = 0; i < m_rndAccOffsets.size (); i++) + { + const uint32_t rndAccOffset = m_rndAccOffsets.at (i) + headerBytes; + + m_dynamicHeader.push_back ((rndAccOffset >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((rndAccOffset >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((rndAccOffset >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( rndAccOffset & UCHAR_MAX); + } + m_dynamicHeader.push_back ((m_m4aMdatSize >> 24) & UCHAR_MAX); + m_dynamicHeader.push_back ((m_m4aMdatSize >> 16) & UCHAR_MAX); + m_dynamicHeader.push_back ((m_m4aMdatSize >> 8) & UCHAR_MAX); + m_dynamicHeader.push_back ( m_m4aMdatSize & UCHAR_MAX); + m_dynamicHeader.push_back (0x6D); m_dynamicHeader.push_back (0x64); + m_dynamicHeader.push_back (0x61); m_dynamicHeader.push_back (0x74); // mdat + + _SEEK (m_fileHandle, 0, 0 /*SEEK_SET*/); // back to start + + bytesWritten += _WRITE (m_fileHandle, m_staticHeader, STAT_HEADER_SIZE); + bytesWritten += _WRITE (m_fileHandle, &m_dynamicHeader.front (), (unsigned) m_dynamicHeader.size ()); + + return bytesWritten; +} + +int BasicMP4Writer::initHeader (const uint32_t audioLength) // reserve bytes for header in file +{ +#if 0 // DEBUG + const uint8_t numChannels = m_staticHeader[517]; + + // write basic µ-Law WAVE header for testing + memcpy (m_staticHeader, muLawHeader, 44 * sizeof (uint8_t)); + m_staticHeader[22] = numChannels; + m_staticHeader[24] = uint8_t (m_sampleRate & 0xFF); + m_staticHeader[25] = uint8_t (m_sampleRate >> 8u); + m_staticHeader[26] = uint8_t (m_sampleRate >> 16u); + m_staticHeader[28] = uint8_t ((m_sampleRate * numChannels) & 0xFF); + m_staticHeader[29] = uint8_t ((m_sampleRate * numChannels) >> 8u); + m_staticHeader[30] = uint8_t ((m_sampleRate * numChannels) >> 16u); + m_staticHeader[32] = numChannels; // byte count per frame + + return _WRITE (m_fileHandle, m_staticHeader, 44); +#else + const bool flushFrameUsed = ((audioLength + m_pregapLength) % m_frameLength) > 0; + const unsigned frameCount = ((audioLength + m_frameLength - 1) / m_frameLength) + (flushFrameUsed ? 2 : 1); + const unsigned chunkCount = ((frameCount + m_rndAccPeriod - 1) / m_rndAccPeriod); + const unsigned finalChunk = (frameCount <= m_rndAccPeriod ? 0 : frameCount % m_rndAccPeriod); + const int estimHeaderSize = STAT_HEADER_SIZE + m_ascSizeM5 + 6+4 + frameCount * 4 /*stsz*/ + STSX_BSIZE * 3 + + (finalChunk == 0 ? 12 : 24) /*stsc*/ + chunkCount * 4 /*stco*/ + 8 /*mdat*/; + int bytesWritten = 0; + + for (int i = estimHeaderSize; i > 0; i -= STAT_HEADER_SIZE) + { + bytesWritten += _WRITE (m_fileHandle, m_staticHeader, __min (i, STAT_HEADER_SIZE)); + } + return bytesWritten; +#endif +} + +unsigned BasicMP4Writer::open (const int mp4FileHandle, const unsigned sampleRate, const unsigned numChannels, + const unsigned bitDepth, const unsigned frameLength, const unsigned pregapLength, + const unsigned raPeriod, const uint8_t* ascBuf, const unsigned ascSize, + const uint32_t creatTime /*= 0*/, const char vbrQuality /*= 0*/) +{ + const uint32_t frameSizeBE = toBigEndian (frameLength); + const uint32_t pregapSizeBE = toBigEndian (pregapLength); + const uint32_t sampleRateBE = toBigEndian (sampleRate); + const uint32_t timeStampBE = toBigEndian (creatTime); + uint32_t* const header4Byte = (uint32_t* const) m_staticHeader; + + if ((mp4FileHandle == -1) || (frameLength == 0) || (sampleRate == 0) || (numChannels == 0) || (numChannels * 3 > UCHAR_MAX) || + (raPeriod == 0) || (ascBuf == nullptr) || (ascSize < 5) || (ascSize > 108) || (bitDepth == 0) || (bitDepth > UCHAR_MAX)) + { + return 1; // invalid file handle or other input variable + } + + m_fileHandle = mp4FileHandle; + reset (frameLength, pregapLength, raPeriod); +#if 0 // DEBUG + m_sampleRate = sampleRate; +#endif + // create fixed-length 576-byte part of MPEG-4 file header + memcpy (m_staticHeader, staticHeaderTemplate, STAT_HEADER_SIZE * sizeof (uint8_t)); + + header4Byte[ 44>>2] = timeStampBE; + header4Byte[ 48>>2] = timeStampBE; + header4Byte[ 52>>2] = sampleRateBE; + header4Byte[184>>2] = timeStampBE; + header4Byte[188>>2] = timeStampBE; + header4Byte[292>>2] = pregapSizeBE; // pregap size in elst + header4Byte[320>>2] = timeStampBE; + header4Byte[324>>2] = timeStampBE; + header4Byte[328>>2] = sampleRateBE; + header4Byte[332>>2] = pregapSizeBE; // +audio length later + header4Byte[464>>2] = frameSizeBE; + + m_staticHeader[339] = vbrQuality; + m_staticHeader[517] = (uint8_t) numChannels; + m_staticHeader[519] = (uint8_t) bitDepth; + m_staticHeader[523] = (sampleRate >> 16) & UCHAR_MAX; // ? + m_staticHeader[524] = (sampleRate >> 8) & UCHAR_MAX; + m_staticHeader[525] = sampleRate & UCHAR_MAX; + m_staticHeader[556] = (uint8_t) numChannels * 3; // 6144 bit/chan + + memcpy (&m_staticHeader[571], ascBuf, 5 * sizeof (uint8_t)); + + if (ascSize > 5) // increase atom byte-sizes + { + const uint8_t inc = m_ascSizeM5 = ascSize - 5; + + m_staticHeader[ 27] += inc; // MOOV_BSIZE + m_staticHeader[167] += inc; // TRAK_BSIZE + m_staticHeader[303] += inc; // MDIA_BSIZE + if (m_staticHeader[379] + m_ascSizeM5 > UCHAR_MAX) m_staticHeader[378]++; + m_staticHeader[379] += inc; // MINF_BSIZE + m_staticHeader[439] += inc; // STBL_BSIZE + m_staticHeader[479] += inc; // STSD_BSIZE + m_staticHeader[495] += inc; // MP4A_BSIZE + m_staticHeader[531] += inc; // ESDS_BSIZE + m_staticHeader[544] += inc; // esds tag 3 + m_staticHeader[552] += inc; // esds tag 4 + m_staticHeader[570] += inc; // esds tag 5 + + for (unsigned i = 0; i < m_ascSizeM5; i++) m_dynamicHeader.push_back (ascBuf[5 + i]); + } + + // prepare variable-length remainder of MPEG-4 file header + m_dynamicHeader.push_back (0x06); m_dynamicHeader.push_back (0x80); // esds + m_dynamicHeader.push_back (0x80); m_dynamicHeader.push_back (0x80); + m_dynamicHeader.push_back (0x01); m_dynamicHeader.push_back (0x02); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); // + 4N + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (STSX_BSIZE + 4); + m_dynamicHeader.push_back (0x73); m_dynamicHeader.push_back (0x74); + m_dynamicHeader.push_back (0x73); m_dynamicHeader.push_back (0x7A); // stsz + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); // := N + m_dynamicHeader.push_back (0x00); m_dynamicHeader.push_back (0x00); + + return 0; // correct operation +} + +void BasicMP4Writer::reset (const unsigned frameLength /*= 0*/, const unsigned pregapLength /*= 0*/, const unsigned raPeriod /*= 0*/) +{ + m_ascSizeM5 = 0; + m_frameCount = 0; + m_frameLength = frameLength; + m_m4aMdatSize = 8; // bytes for mdat header + m_pregapLength = pregapLength; + m_rndAccPeriod = raPeriod; + m_sampleRate = 0; + m_dynamicHeader.clear (); + m_rndAccOffsets.clear (); + + if (m_fileHandle != -1) _SEEK (m_fileHandle, 0, 0 /*SEEK_SET*/); +} diff --git a/src/app/basicMP4Writer.h b/src/app/basicMP4Writer.h new file mode 100644 index 0000000..4d73e7f --- /dev/null +++ b/src/app/basicMP4Writer.h @@ -0,0 +1,65 @@ +/* basicMP4Writer.h - header file for class with basic MPEG-4 file writing capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _BASIC_MP4_WRITER_H_ +#define _BASIC_MP4_WRITER_H_ + +#include "exhaleAppPch.h" + +// constant data sizes in bytes +#define STAT_HEADER_SIZE 576 +#define STSX_BSIZE 0x10 +#define ESDS_BSIZE 0x00, 0x36 // esds: 54 (+ m_ascSizeM5 later) +#define MP4A_BSIZE 0x00, 0x5A // mp4a: 36 + ESDS_BSIZE +#define STSD_BSIZE 0x00, 0x6A // mp4a: 16 + MP4A_BSIZE +#define STBL_BSIZE 0x00, 0x92 // stbl: 8 + 32 + STSD_BSIZE (+ rem later) +#define MINF_BSIZE 0x00, 0xCE // minf: 8 + 16 + 36 + STBL_BSIZE +#define MDIA_BSIZE 0x01, 0x1A // mdia: 8 + 32 + 36 + MINF_BSIZE +#define TRAK_BSIZE 0x01, 0xA2 // trak: 8 + 92 + 36 + MDIA_BSIZE +#define MOOV_BSIZE 0x02, 0x2E // moov: 8 +108 + 24 + TRAK_BSIZE + +// basic MPEG-4 write-out class +class BasicMP4Writer +{ +private: + + // member variables + unsigned m_ascSizeM5; // ASC + UsacConfig byte-size - 5 + int m_fileHandle; + unsigned m_frameCount; + unsigned m_frameLength; + unsigned m_m4aMdatSize; + unsigned m_pregapLength; // encoder look-ahead, pre-roll + unsigned m_rndAccPeriod; // random-access (RA) interval + unsigned m_sampleRate; + uint8_t m_staticHeader[STAT_HEADER_SIZE]; // fixed-size + std::vector m_dynamicHeader; // variable-sized + std::vector m_rndAccOffsets; // random access + +public: + + // constructor + BasicMP4Writer () { m_fileHandle = -1; reset (); } + // destructor + ~BasicMP4Writer() { m_dynamicHeader.clear (); m_rndAccOffsets.clear (); } + // public functions + int addFrameAU (const uint8_t* byteBuf, const uint32_t byteOffset, const uint32_t byteCount); + int finishFile (const unsigned avgBitrate, const unsigned maxBitrate, const uint32_t audioLength, + const uint32_t modifTime = 0); + unsigned getFrameCount () const { return m_frameCount; } + int initHeader (const uint32_t audioLength); + unsigned open (const int mp4FileHandle, const unsigned sampleRate, const unsigned numChannels, + const unsigned bitDepth, const unsigned frameLength, const unsigned pregapLength, + const unsigned raPeriod, const uint8_t* ascBuf, const unsigned ascSize, + const uint32_t creatTime = 0, const char vbrQuality = 0); + void reset (const unsigned frameLength = 0, const unsigned pregapLength = 0, const unsigned raPeriod = 0); +}; // BasicMP4Writer + +#endif // _BASIC_MP4_WRITER_H_ diff --git a/src/app/basicWavReader.cpp b/src/app/basicWavReader.cpp new file mode 100644 index 0000000..036770f --- /dev/null +++ b/src/app/basicWavReader.cpp @@ -0,0 +1,415 @@ +/* basicWavReader.cpp - source file for class with basic WAVE file reading capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleAppPch.h" +#include "basicWavReader.h" + +// static helper functions +static unsigned reverseFourBytes (const uint8_t* b) +{ + return ((unsigned) b[3] << 24) | ((unsigned) b[2] << 16) | ((unsigned) b[1] << 8) | (unsigned) b[0]; +} + +static int64_t fourBytesToLength (const uint8_t* b, const int64_t lengthLimit) +{ + int64_t chunkLength = (int64_t) reverseFourBytes (b); + + chunkLength += chunkLength & 1; // make sure it is even + + return __min (lengthLimit, chunkLength); // for security +} + +// private reader functions +bool BasicWavReader::readRiffHeader () +{ + uint8_t b[FILE_HEADER_SIZE] = {0}; // temp. byte buffer + + if ((m_bytesRead = _READ (m_fileHandle, b, FILE_HEADER_SIZE)) != FILE_HEADER_SIZE) return false; // error + m_bytesRemaining -= m_bytesRead; + m_chunkLength = fourBytesToLength (&b[4], m_bytesRemaining) - 4; // minus 4 bytes for WAVE tag + + return (b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F' && + b[8] == 'W' && b[9] == 'A' && b[10]== 'V' && b[11]== 'E' && + m_bytesRemaining > 32); // true: RIFF supported +} + +bool BasicWavReader::readFormatChunk () +{ + uint8_t b[CHUNK_FORMAT_MAX] = {0}; // temp. byte buffer + + if (!seekToChunkTag (b, 0x20746D66 /*fmt */) || (m_chunkLength < CHUNK_FORMAT_SIZE) || (m_chunkLength > CHUNK_FORMAT_MAX)) + { + return false; // fmt_ chunk invalid or read incomplete + } + if ((m_bytesRead = _READ (m_fileHandle, b, (unsigned) m_chunkLength)) != m_chunkLength) return false; // error + m_bytesRemaining -= m_bytesRead; + + m_waveDataType = WAV_TYPE (b[0]-1); // 1: PCM, 3: float + m_waveChannels = b[2]; // only 1, 2, ..., 63 supported + m_waveFrameRate = reverseFourBytes (&b[4]); // frames/s + m_waveBitRate = reverseFourBytes (&b[8]) * 8; // bit/s + m_waveFrameSize = b[12]; // bytes/s divided by frames/s + m_waveBitDepth = b[14]; // only 8, 16, 24, 32 supported + + return ((m_waveDataType == WAV_PCM || (m_waveDataType == WAV_FLOAT && (m_waveBitDepth & 15) == 0)) && + (m_waveChannels > 0 && m_waveChannels <= 63) && isSamplingRateSupported (m_waveFrameRate) && + (m_waveBitRate == 8 * m_waveFrameRate * m_waveFrameSize) && (b[ 1] == 0) && (b[ 3] == 0) && + (m_waveFrameSize * 8 == m_waveBitDepth * m_waveChannels) && (b[13] == 0) && (b[15] == 0) && + (m_waveBitDepth >= 8 && m_waveBitDepth <= 32 && (m_waveBitDepth & 7) == 0) && + m_bytesRemaining > 8); // true: format supported +} + +bool BasicWavReader::readDataHeader () +{ + uint8_t b[CHUNK_HEADER_SIZE] = {0}; // temp. byte buffer + + if (!seekToChunkTag (b, 0x61746164 /*data*/)) + { + return false; // data chunk invalid or read incomplete + } + return (m_chunkLength > 0); // true: WAVE data available +} + +// private helper function +bool BasicWavReader::seekToChunkTag (uint8_t* const buf, const uint32_t tagID) +{ + if ((m_bytesRead = _READ (m_fileHandle, buf, CHUNK_HEADER_SIZE)) != CHUNK_HEADER_SIZE) return false; // error + m_bytesRemaining -= m_bytesRead; + m_chunkLength = fourBytesToLength (&buf[4], m_bytesRemaining); + + while ((*((uint32_t* const) buf) != tagID) && + (m_bytesRemaining > 0)) // seek until tagID found + { + if ((m_readOffset = _SEEK (m_fileHandle, m_chunkLength, 1 /*SEEK_CUR*/)) == -1) + { + // for stdin compatibility, don't abort, try reading + for (int64_t i = m_chunkLength >> 1; i > 0; i--) + { + _READ (m_fileHandle, buf, 2); // as length is even + } + } + m_bytesRemaining -= m_chunkLength; + if (m_bytesRemaining <= 0) + { + return false; // an error which should never happen! + } + if ((m_bytesRead = _READ (m_fileHandle, buf, CHUNK_HEADER_SIZE)) != CHUNK_HEADER_SIZE) return false; // error + m_bytesRemaining -= m_bytesRead; + m_chunkLength = fourBytesToLength (&buf[4], m_bytesRemaining); + } + return (m_bytesRemaining > 0); +} + +// static reading functions +unsigned BasicWavReader::readDataFloat16 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf) +{ +#if BWR_BUFFERED_READ + const int16_t* fBuf = (const int16_t*) tempBuf; // words + const int bytesRead = _READ (fileHandle, tempBuf, frameCount * chanCount * 2); + unsigned framesRead = __max (0, bytesRead / (chanCount * 2)); + + for (unsigned i = framesRead * chanCount; i > 0; i--) + { + const int16_t i16 = *(fBuf++); + const int32_t e = ((i16 & 0x7C00) >> 10) - 18; // exp. + // an exponent e <= -12 will lead to zero-quantization + *frameBuf = int32_t (e < 0 ? (1024 + (i16 & 0x03FF) + (1 << (-1 - e)) /*rounding offset*/) >> -e + : (e > 12 ? MAX_VALUE_AUDIO24 /*inf*/ : (1024 + (i16 & 0x03FF)) << e)); + if ((i16 & 0x8000) != 0) *frameBuf *= -1; // neg. sign + frameBuf++; + } + if (framesRead < frameCount) // zero out missing samples + { + memset (frameBuf, 0, (frameCount - framesRead) * chanCount * sizeof (int32_t)); + } + return framesRead; +#else + unsigned bytesRead = 0; + + for (unsigned i = frameCount * chanCount; i > 0; i--) + { + int16_t i16 = 0; + + bytesRead += _READ (fileHandle, &i16, 2); // two bytes + + const int32_t e = ((i16 & 0x7C00) >> 10) - 18; // exp. + // an exponent e <= -12 will lead to zero-quantization + *frameBuf = int32_t (e < 0 ? (1024 + (i16 & 0x03FF) + (1 << (-1 - e)) /*rounding offset*/) >> -e + : (e > 12 ? MAX_VALUE_AUDIO24 /*inf*/ : (1024 + (i16 & 0x03FF)) << e)); + if ((i16 & 0x8000) != 0) *frameBuf *= -1; // neg. sign + frameBuf++; + } + return bytesRead / (chanCount * 2); +#endif +} + +unsigned BasicWavReader::readDataFloat32 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf) +{ +#if BWR_BUFFERED_READ + const float* fBuf = (const float*) tempBuf; // 4 bytes + const int bytesRead = _READ (fileHandle, tempBuf, frameCount * chanCount * 4); + unsigned framesRead = __max (0, bytesRead / (chanCount * 4)); + + for (unsigned i = framesRead * chanCount; i > 0; i--) + { + const float f32 = *fBuf * float (1 << 23); // * 2^23 + fBuf++; + *frameBuf = int32_t (f32 + (f32 < 0.0 ? -0.5 : 0.5)); // rounding + if (*frameBuf < MIN_VALUE_AUDIO24) *frameBuf = MIN_VALUE_AUDIO24; + else + if (*frameBuf > MAX_VALUE_AUDIO24) *frameBuf = MAX_VALUE_AUDIO24; + frameBuf++; + } + if (framesRead < frameCount) // zero out missing samples + { + memset (frameBuf, 0, (frameCount - framesRead) * chanCount * sizeof (int32_t)); + } + return framesRead; +#else + unsigned bytesRead = 0; + + for (unsigned i = frameCount * chanCount; i > 0; i--) + { + float f32 = 0.0; // IEEE-754 normalized floating point + + bytesRead += _READ (fileHandle, &f32, 4); // 4 bytes + *frameBuf = int32_t (f32 * (1 << 23) + (f32 < 0.0 ? -0.5 : 0.5)); // * 2^23 with rounding + if (*frameBuf < MIN_VALUE_AUDIO24) *frameBuf = MIN_VALUE_AUDIO24; + else + if (*frameBuf > MAX_VALUE_AUDIO24) *frameBuf = MAX_VALUE_AUDIO24; + frameBuf++; + } + return bytesRead / (chanCount * 4); +#endif +} + +unsigned BasicWavReader::readDataLnPcm08 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf) +{ +#if BWR_BUFFERED_READ + const uint8_t* iBuf = (uint8_t*) tempBuf; + const int bytesRead = _READ (fileHandle, tempBuf, frameCount * chanCount); + unsigned framesRead = __max (0, bytesRead / chanCount); + + for (unsigned i = framesRead * chanCount; i > 0; i--) + { + *(frameBuf++) = ((int32_t) *(iBuf++) - 128) << 16; // * 2^16 + } + if (framesRead < frameCount) // zero out missing samples + { + memset (frameBuf, 0, (frameCount - framesRead) * chanCount * sizeof (int32_t)); + } + return framesRead; +#else + unsigned bytesRead = 0; + + for (unsigned i = frameCount * chanCount; i > 0; i--) + { + uint8_t ui8 = 128; + + bytesRead += _READ (fileHandle, &ui8, 1); // one byte + *(frameBuf++) = ((int32_t) ui8 - 128) << 16; // * 2^16 + } + return bytesRead / chanCount; +#endif +} + +unsigned BasicWavReader::readDataLnPcm16 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf) +{ +#if BWR_BUFFERED_READ + const int16_t* iBuf = (const int16_t*) tempBuf; // words + const int bytesRead = _READ (fileHandle, tempBuf, frameCount * chanCount * 2); + unsigned framesRead = __max (0, bytesRead / (chanCount * 2)); + + for (unsigned i = framesRead * chanCount; i > 0; i--) + { + *(frameBuf++) = (int32_t) *(iBuf++) << 8; // * 2^8 + } + if (framesRead < frameCount) // zero out missing samples + { + memset (frameBuf, 0, (frameCount - framesRead) * chanCount * sizeof (int32_t)); + } + return framesRead; +#else + unsigned bytesRead = 0; + + for (unsigned i = frameCount * chanCount; i > 0; i--) + { + int16_t i16 = 0; + + bytesRead += _READ (fileHandle, &i16, 2); // two bytes + *(frameBuf++) = (int32_t) i16 << 8; // * 2^8 + } + return bytesRead / (chanCount * 2); +#endif +} + +unsigned BasicWavReader::readDataLnPcm24 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf) +{ +#if BWR_BUFFERED_READ + const uint8_t* iBuf = (uint8_t*) tempBuf; + const int bytesRead = _READ (fileHandle, tempBuf, frameCount * chanCount * 3); + unsigned framesRead = __max (0, bytesRead / (chanCount * 3)); + + for (unsigned i = framesRead * chanCount; i > 0; i--) + { + const int32_t i24 = (int32_t) iBuf[0] | ((int32_t) iBuf[1] << 8) | ((int32_t) iBuf[2] << 16); + iBuf += 3; + *(frameBuf++) = (i24 > MAX_VALUE_AUDIO24 ? i24 + 2 * MIN_VALUE_AUDIO24 : i24); + } + if (framesRead < frameCount) // zero out missing samples + { + memset (frameBuf, 0, (frameCount - framesRead) * chanCount * sizeof (int32_t)); + } + return framesRead; +#else + unsigned bytesRead = 0; + + for (unsigned i = frameCount * chanCount; i > 0; i--) + { + int32_t i24 = 0; + + bytesRead += _READ (fileHandle, &i24, 3); // 3 bytes + *(frameBuf++) = (i24 > MAX_VALUE_AUDIO24 ? i24 + 2 * MIN_VALUE_AUDIO24 : i24); + } + return bytesRead / (chanCount * 3); +#endif +} + +unsigned BasicWavReader::readDataLnPcm32 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf) +{ +#if BWR_BUFFERED_READ + const int32_t* iBuf = (const int32_t*) tempBuf; // dword + const int bytesRead = _READ (fileHandle, tempBuf, frameCount * chanCount * 4); + unsigned framesRead = __max (0, bytesRead / (chanCount * 4)); + + for (unsigned i = framesRead * chanCount; i > 0; i--) + { + const int32_t i24 = ((*iBuf >> 1) + (1 << 6)) >> 7; // * 2^-8 with rounding, overflow-safe + iBuf++; + *(frameBuf++) = __min (MAX_VALUE_AUDIO24, i24); + } + if (framesRead < frameCount) // zero out missing samples + { + memset (frameBuf, 0, (frameCount - framesRead) * chanCount * sizeof (int32_t)); + } + return framesRead; +#else + unsigned bytesRead = 0; + + for (unsigned i = frameCount * chanCount; i > 0; i--) + { + int32_t i24 = 0; + bytesRead += _READ (fileHandle, &i24, 4); // 4 bytes + i24 = ((i24 >> 1) + (1 << 6)) >> 7; // * 2^-8 with rounding, overflow-safe + *(frameBuf++) = __min (MAX_VALUE_AUDIO24, i24); + } + return bytesRead / (chanCount * 4); +#endif +} + +// public functions +unsigned BasicWavReader::open (const int wavFileHandle, const uint16_t maxFrameRead, const int64_t fileLength /*= LLONG_MAX*/) +{ + m_bytesRemaining = fileLength; + m_fileHandle = wavFileHandle; + + if ((m_fileHandle == -1) || (fileLength <= 44)) + { + return 1; // file handle invalid or file too small + } +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if ((fileLength < LLONG_MAX) && (m_readOffset = _telli64 (m_fileHandle)) != 0) +#else // Linux, MacOS, Unix + if ((fileLength < LLONG_MAX) && (m_readOffset = lseek (m_fileHandle, 0, 1 /*SEEK_CUR*/)) != 0) +#endif + { + m_readOffset = _SEEK (m_fileHandle, 0, 0 /*SEEK_SET*/); + } + if ((m_readOffset != 0) || !readRiffHeader ()) + { + return 2; // file type invalid or file seek failed + } + if (!readFormatChunk ()) + { + return 3; // audio format invalid or not supported + } + if (!readDataHeader ()) + { + return 4; // WAVE data part invalid or unsupported + } + if ((m_byteBuffer = (char*) malloc (m_waveFrameSize * maxFrameRead)) == nullptr) + { + return 5; // read-in byte buffer allocation failed + } + m_frameLimit = maxFrameRead; + + // ready to read audio data: initialize byte counter + if (m_bytesRemaining > m_chunkLength) + { + m_bytesRemaining = m_chunkLength; + } + m_chunkLength = 0; + + if (m_waveDataType == WAV_PCM) // & function pointer + { + switch (m_waveBitDepth) + { + case 8: + m_readDataFunc = readDataLnPcm08; break; + case 16: + m_readDataFunc = readDataLnPcm16; break; + case 24: + m_readDataFunc = readDataLnPcm24; break; + default: + m_readDataFunc = readDataLnPcm32; break; + } + } + else m_readDataFunc = (m_waveBitDepth == 16 ? readDataFloat16 : readDataFloat32); + + return (m_readDataFunc == nullptr ? 6 : 0); // 0: OK +} + +unsigned BasicWavReader::read (int32_t* const frameBuf, const uint16_t frameCount) +{ + unsigned framesRead; + + if ((frameBuf == nullptr) || (m_fileHandle == -1) || (__min (m_frameLimit, frameCount) == 0) || (m_byteBuffer == nullptr)) + { + return 0; // invalid args or class not initialized + } + framesRead = m_readDataFunc (m_fileHandle, frameBuf, __min (m_frameLimit, frameCount), m_waveChannels, m_byteBuffer); + m_bytesRead = m_waveFrameSize * framesRead; + m_bytesRemaining -= m_bytesRead; + m_chunkLength += m_bytesRead; + + return framesRead; +} + +void BasicWavReader::reset () +{ + m_byteBuffer = nullptr; + m_bytesRead = 0; + m_bytesRemaining = 0; + m_chunkLength = 0; + m_frameLimit = 0; + m_readDataFunc = nullptr; + m_readOffset = 0; + m_waveBitDepth = 0; + m_waveChannels = 0; + m_waveFrameRate = 0; + + if (m_fileHandle != -1) _SEEK (m_fileHandle, 0, 0 /*SEEK_SET*/); +} diff --git a/src/app/basicWavReader.h b/src/app/basicWavReader.h new file mode 100644 index 0000000..3eeb39a --- /dev/null +++ b/src/app/basicWavReader.h @@ -0,0 +1,92 @@ +/* basicWavReader.h - header file for class with basic WAVE file reading capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _BASIC_WAV_READER_H_ +#define _BASIC_WAV_READER_H_ + +#include "exhaleAppPch.h" + +// constant data sizes & limits +#define BWR_BUFFERED_READ 1 // faster reader +#define CHUNK_FORMAT_MAX 20 +#define CHUNK_FORMAT_SIZE 16 +#define CHUNK_HEADER_SIZE 8 +#define FILE_HEADER_SIZE 12 +#define MAX_VALUE_AUDIO24 8388607 // (1 << 23) - 1 +#define MIN_VALUE_AUDIO24 -8388608 // (1 << 23) *-1 + +// WAVE data format definitions +typedef enum WAV_TYPE +{ + WAV_PCM = 0, // linear PCM + WAV_ADPCM, // ADPCM + WAV_FLOAT // IEEE float +} WAV_TYPE; + +// data reader function pointer +typedef unsigned (*ReadFunc) (const int, int32_t*, const unsigned, const unsigned, void*); + +// basic WAV audio reader class +class BasicWavReader +{ +private: + + // member variables + char* m_byteBuffer; + unsigned m_bytesRead; + int64_t m_bytesRemaining; + int64_t m_chunkLength; + int m_fileHandle; + unsigned m_frameLimit; + ReadFunc m_readDataFunc; + int64_t m_readOffset; + unsigned m_waveBitDepth; + unsigned m_waveBitRate; + unsigned m_waveChannels; + WAV_TYPE m_waveDataType; + unsigned m_waveFrameRate; + unsigned m_waveFrameSize; + // private reader functions + bool readRiffHeader (); + bool readFormatChunk(); + bool readDataHeader (); + // private helper function + bool seekToChunkTag (uint8_t* const buf, const uint32_t tagName); + // static reading functions + static unsigned readDataFloat16 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf); + static unsigned readDataFloat32 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf); + static unsigned readDataLnPcm08 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf); + static unsigned readDataLnPcm16 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf); + static unsigned readDataLnPcm24 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf); + static unsigned readDataLnPcm32 (const int fileHandle, int32_t* frameBuf, const unsigned frameCount, + const unsigned chanCount, void* tempBuf); +public: + + // constructor + BasicWavReader () { m_fileHandle = -1; reset (); } + // destructor + ~BasicWavReader() { if (m_byteBuffer != nullptr) free ((void*) m_byteBuffer); } + // public functions + int64_t getDataBytesLeft () const { return m_bytesRemaining; } + int64_t getDataBytesRead () const { return m_chunkLength; } + unsigned getBitDepth () const { return m_waveBitDepth; } + unsigned getNumChannels () const { return m_waveChannels; } + unsigned getSampleRate () const { return m_waveFrameRate; } + unsigned open (const int wavFileHandle, const uint16_t maxFrameRead, const int64_t fileLength = LLONG_MAX /*for stdin*/); + unsigned read (int32_t* const frameBuf, const uint16_t frameCount); + void reset (); +}; // BasicWavReader + +#endif // _BASIC_WAV_READER_H_ diff --git a/src/app/basicWavReader.txt b/src/app/basicWavReader.txt new file mode 100644 index 0000000..122a9c9 --- /dev/null +++ b/src/app/basicWavReader.txt @@ -0,0 +1,5 @@ +basicWavReader.cpp - known issues +_________________________________ + +2019: for 8-bit PCM audio, the WAVE file must contain an even number of samples. + This is guaranteed for an even number of channels (e.g., 2-channel stereo) diff --git a/src/app/exhaleApp.cpp b/src/app/exhaleApp.cpp new file mode 100644 index 0000000..be940f8 --- /dev/null +++ b/src/app/exhaleApp.cpp @@ -0,0 +1,545 @@ +/* exhaleApp.cpp - source file with main() routine for exhale application executable + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleAppPch.h" +#include "basicMP4Writer.h" +#include "basicWavReader.h" +#include "../lib/exhaleEnc.h" +#include "version.h" + +#include +#include +#include +#include +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) +#include + +#define EXHALE_TEXT_BLUE (FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN) +#define EXHALE_TEXT_PINK (FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_RED) +#endif +#define IGNORE_WAV_LENGTH 0 // 1: ignore input size indicators (nasty) +#define XHE_AAC_LOW_DELAY 0 // 1: allow encoding with 768 frame length + +// main routine +int main (const int argc, char* argv[]) +{ + if (argc <= 0) return argc; // for safety + + const bool readStdin = (argc == 3); + BasicWavReader wavReader; + int32_t* inPcmData = nullptr; // 24-bit WAVE audio input buffer + uint8_t* outAuData = nullptr; // access unit (AU) output buffer + int inFileHandle = -1, outFileHandle = -1; + uint16_t i, exePathEnd = 0; + uint16_t compatibleExtensionFlag = 0; // 0: disabled, 1: enabled + uint16_t coreSbrFrameLengthIndex = 1; // 0: 768, 1: 1024 samples + uint16_t variableCoreBitRateMode = 3; // 0: lowest... 9: highest +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + const HANDLE hConsole = GetStdHandle (STD_OUTPUT_HANDLE); + CONSOLE_SCREEN_BUFFER_INFO csbi; +#endif + + for (i = 0; (argv[0][i] != 0) && (i < 65535); i++) + { +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if (argv[0][i] == '\\') exePathEnd = i + 1; +#else // Linux, MacOS, Unix + if (argv[0][i] == '/' ) exePathEnd = i + 1; +#endif + } + const char* const exeFileName = argv[0] + exePathEnd; + + if ((exeFileName[0] == 0) || (i == 65535)) + { + fprintf_s (stderr, " ERROR reading executable name or path: the string is invalid!\n\n"); + + return 32768; // bad executable string + } + + // print program header with compile info + fprintf_s (stdout, "\n ---------------------------------------------------------------------\n"); +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + GetConsoleScreenBufferInfo (hConsole, &csbi); /*save the text color*/ fprintf_s (stdout, " | "); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "exhale"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, " - "); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "e"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, "codis e"); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "x"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, "tended "); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "h"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, "igh-efficiency "); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "a"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, "nd "); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "l"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, "ow-complexity "); + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_PINK); fprintf_s (stdout, "e"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); fprintf_s (stdout, "ncoder |\n"); +#else + fprintf_s (stdout, " | exhale - ecodis extended high-efficiency and low-complexity encoder |\n"); +#endif + fprintf_s (stdout, " | |\n"); +#if defined (_WIN64) || defined (WIN64) || defined (__x86_64) + fprintf_s (stdout, " | version %s.%s%s (x64, built on %s) - written by C.R.Helmrich |\n", +#else // 32-bit OS + fprintf_s (stdout, " | version %s.%s%s (x86, built on %s) - written by C.R.Helmrich |\n", +#endif + EXHALELIB_VERSION_MAJOR, EXHALELIB_VERSION_MINOR, EXHALELIB_VERSION_BUGFIX, __DATE__); + fprintf_s (stdout, " ---------------------------------------------------------------------\n\n"); + + // check arg. list, print usage if needed + if ((argc < 3) || (argc > 4) || (argc > 1 && argv[1][1] != 0)) + { + fprintf_s (stdout, " Copyright 2018-2019 C.R.Helmrich, project ecodis. See License.txt for details.\n\n"); + + fprintf_s (stdout, " This software is being made available under a Modified BSD License and comes\n"); + fprintf_s (stdout, " with ABSOLUTELY NO WARRANTY. This software may be subject to other third-party\n"); + fprintf_s (stdout, " rights, including patent rights. No such rights are granted under this License.\n\n"); +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_BLUE); fprintf_s (stdout, " Usage:\t"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); +#else + fprintf_s (stdout, " Usage:\t"); +#endif + fprintf_s (stdout, "%s preset [inputWaveFile.wav] outputMP4File.m4a\n\n where\n\n", exeFileName); + fprintf_s (stdout, " preset\t= # (1-9) low-complexity standard compliant xHE-AAC at 16ú#+48 kbit/s\n"); +#if XHE_AAC_LOW_DELAY +// fprintf_s (stdout, " \t (a-i) low-complexity compatible xHE-AAC with BE at 16ú#+48 kbit/s\n"); + fprintf_s (stdout, " \t (A-I) 41ms low-delay compatible xHE-AAC with BE at 16ú#+48 kbit/s\n"); +#else +// fprintf_s (stdout, " \t (a-i) low-complexity compatible xHE-AAC with BE at 16ú#+48 kbit/s\n"); +#endif + fprintf_s (stdout, "\n inputWaveFile.wav lossless WAVE audio input, read from stdin if not specified\n\n"); + fprintf_s (stdout, " outputMP4File.m4a encoded MPEG-4 bit-stream, extension should be .m4a or .mp4\n\n\n"); +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_BLUE); fprintf_s (stdout, " Notes:\t"); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); +#else + fprintf_s (stdout, " Notes:\t"); +#endif + fprintf_s (stdout, "The above bit-rates are for stereo and change for mono or multichannel.\n"); + if (exePathEnd > 0) + { +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + fprintf_s (stdout, " \tUse filename prefix .\\ for the current directory if this executable was\n\tcalled with a path (call: %s).\n", argv[0]); +#else // Linux, MacOS, Unix + fprintf_s (stdout, " \tUse filename prefix ./ for the current directory if this executable was\n\tcalled with a path (call: %s).\n", argv[0]); +#endif + } + return 0; // no arguments, which is OK + } + + // check preset mode, derive coder config +#if XHE_AAC_LOW_DELAY + if ((*argv[1] >= '1' && *argv[1] <= '9') || (*argv[1] >= 'a' && *argv[1] <= 'i') || (*argv[1] >= 'A' && *argv[1] <= 'I')) +#else + if ((*argv[1] >= '1' && *argv[1] <= '9') || (*argv[1] >= 'a' && *argv[1] <= 'i')) +#endif + { + i = (uint16_t) argv[1][0]; + compatibleExtensionFlag = (i & 0x40) >> 6; + coreSbrFrameLengthIndex = (i & 0x20) >> 5; + variableCoreBitRateMode = (i & 0x0F); + } + else if (*argv[1] == '#') // default mode + { + fprintf_s (stdout, " Default preset is specified, encoding to low-complexity xHE-AAC, preset mode %d\n\n", variableCoreBitRateMode); + } + else + { +#if XHE_AAC_LOW_DELAY + fprintf_s (stderr, " ERROR reading preset mode: character %s is not supported! Use 1-9, a-i, or A-I.\n\n", argv[1]); +#else + fprintf_s (stderr, " ERROR reading preset mode: character %s is not supported! Use 1-9 or a-i.\n\n", argv[1]); +#endif + return 16384; // preset isn't supported + } + + const unsigned frameLength = (3 + coreSbrFrameLengthIndex) << 8; + + if (readStdin) // configure stdin + { +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + inFileHandle = _fileno (stdin); + if (_setmode (inFileHandle, _O_RDONLY | _O_BINARY) == -1) +#else // Linux, MacOS, Unix + inFileHandle = 0; // TODO + // if (::setmode (inFileHandle, O_RDONLY) == -1) +#endif + { + fprintf_s (stderr, " ERROR while trying to set stdin to binary mode! Has stdin been closed?\n\n"); + inFileHandle = -1; + + goto mainFinish; // stdin setup error + } + } + else // argc = 4, open input file + { + const char* inFileName = argv[2]; + uint16_t inPathEnd = 0; + + for (i = 0; (inFileName[i] != 0) && (i < 65535); i++) + { +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if (inFileName[i] == '\\') inPathEnd = i + 1; +#else // Linux, MacOS, Unix + if (inFileName[i] == '/' ) inPathEnd = i + 1; +#endif + } + if ((inFileName[0] == 0) || (i == 65535)) + { + fprintf_s (stderr, " ERROR reading input file name or path: the string is invalid!\n\n"); + + goto mainFinish; // bad input string + } + + if (inPathEnd == 0) // name has no path + { + inFileName = (const char*) malloc ((exePathEnd + i + 1) * sizeof (char)); // 0-terminated string + memcpy ((void*) inFileName, argv[0], exePathEnd * sizeof (char)); // prepend executable path ... + memcpy ((void*)(inFileName + exePathEnd), argv[2], (i + 1) * sizeof (char)); // ... to file name + } + +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if (_sopen_s (&inFileHandle, inFileName, _O_RDONLY | _O_SEQUENTIAL | _O_BINARY, _SH_DENYWR, _S_IREAD) != 0) +#else // Linux, MacOS, Unix + if ((inFileHandle = ::open (inFileName, O_RDONLY | O_LARGEFILE, 0666)) == -1) +#endif + { + fprintf_s (stderr, " ERROR while trying to open input file %s! Does it already exist?\n\n", inFileName); + inFileHandle = -1; + if (inPathEnd == 0) free ((void*) inFileName); + + goto mainFinish; // input file error + } + if (inPathEnd == 0) free ((void*) inFileName); + } + +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if ((wavReader.open (inFileHandle, frameLength, readStdin ? LLONG_MAX : _filelengthi64 (inFileHandle)) != 0) || +#else // Linux, MacOS, Unix + if ((wavReader.open (inFileHandle, frameLength, readStdin ? LLONG_MAX : lseek (inFileHandle, 0, 2 /*SEEK_END*/)) != 0) || +#endif + (wavReader.getNumChannels () >= 7)) + { + fprintf_s (stderr, " ERROR while trying to open WAVE file: invalid or unsupported audio format!\n\n"); + i = 8192; // return value + + goto mainFinish; // audio format invalid + } + else // WAVE OK, open output file + { + const char* outFileName = argv[argc - 1]; + uint16_t outPathEnd = readStdin ? 1 : 0; // no path prepends when the input is read from stdin + + for (i = 0; (outFileName[i] != 0) && (i < 65535); i++) + { +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if (outFileName[i] == '\\') outPathEnd = i + 1; +#else // Linux, MacOS, Unix + if (outFileName[i] == '/' ) outPathEnd = i + 1; +#endif + } + if ((outFileName[0] == 0) || (i == 65535)) + { + fprintf_s (stderr, " ERROR reading output file name or path: the string is invalid!\n\n"); + + goto mainFinish; // bad output string + } + + if ((variableCoreBitRateMode < 2) && (wavReader.getSampleRate () > 24000)) + { + fprintf_s (stderr, " ERROR during encoding! Input sample rate must be <=24 kHz for preset mode %d!\n\n", variableCoreBitRateMode); + i = 4096; // return value + + goto mainFinish; // resample to 24 kHz + } + if ((variableCoreBitRateMode < 3) && (wavReader.getSampleRate () > 32000)) + { + fprintf_s (stderr, " ERROR during encoding! Input sample rate must be <=32 kHz for preset mode %d!\n\n", variableCoreBitRateMode); + i = 4096; // return value + + goto mainFinish; // resample to 32 kHz + } + + if (outPathEnd == 0) // name has no path + { + outFileName = (const char*) malloc ((exePathEnd + i + 1) * sizeof (char)); // 0-terminated string + memcpy ((void*) outFileName, argv[0], exePathEnd * sizeof (char)); // prepend executable path ... + memcpy ((void*)(outFileName + exePathEnd), argv[argc - 1], (i + 1) * sizeof (char)); //...to name + } + + i = (readStdin ? O_RDWR : O_WRONLY); +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + if (_sopen_s (&outFileHandle, outFileName, i | _O_SEQUENTIAL | _O_CREAT | _O_EXCL | _O_BINARY, _SH_DENYRD, _S_IWRITE) != 0) +#else // Linux, MacOS, Unix + if ((outFileHandle = ::open (outFileName, i | O_LARGEFILE | O_CREAT | O_EXCL, 0666)) == -1) +#endif + { + fprintf_s (stderr, " ERROR while trying to open output file %s! Does it already exist?\n\n", outFileName); + outFileHandle = -1; + if (outPathEnd == 0) free ((void*) outFileName); + + goto mainFinish; // output file error + } + if (outPathEnd == 0) free ((void*) outFileName); + } + + // enforce executable specific constraints + i = __min (USHRT_MAX, wavReader.getSampleRate ()); + if ((wavReader.getNumChannels () > 3) && (i == 57600 || i == 51200 || i == 40000 || i == 38400 || i == 34150 || + i == 28800 || i == 25600 || i == 20000 || i == 19200 || i == 17075 || i == 14400 || i == 12800 || i == 9600)) + { + fprintf_s (stderr, " ERROR: exhale does not support %d-channel coding with %d Hz sampling rate.\n\n", wavReader.getNumChannels (), i); + + goto mainFinish; // encoder config error + } + else + { + const unsigned startLength = (frameLength * 25) >> 4; // encoder PCM look-ahead + const unsigned numChannels = wavReader.getNumChannels (); + const unsigned inFrameSize = frameLength * sizeof (int32_t); + const unsigned inSampDepth = wavReader.getBitDepth (); + const int64_t expectLength = wavReader.getDataBytesLeft () / int64_t (numChannels * inSampDepth >> 3); + + // allocate dynamic frame memory buffers + inPcmData = (int32_t*) malloc (inFrameSize * numChannels); // max frame in size + outAuData = (uint8_t*) malloc ((6144 >> 3) * numChannels); // max frame AU size + if ((inPcmData == nullptr) || (outAuData == nullptr)) + { + fprintf_s (stderr, " ERROR while trying to allocate dynamic memory! Not enough free RAM available!\n\n"); + i = 2048; // return value + + goto mainFinish; // memory alloc error + } + + if (wavReader.read (inPcmData, frameLength) != frameLength) // full first frame + { + fprintf_s (stderr, " ERROR while trying to encode input audio data! The audio stream is too short!\n\n"); + i = 1024; // return value + + goto mainFinish; // audio is too short + } + else // start coding loop, show progress + { + const unsigned sampleRate = wavReader.getSampleRate (); + const unsigned indepPeriod = (sampleRate < 48000 ? sampleRate / frameLength : 45 /*for 50-Hz video, use 50 for 60-Hz video*/); + const unsigned mod3Percent = unsigned ((expectLength * (3 + coreSbrFrameLengthIndex)) >> 17); + // open & prepare ExhaleEncoder object + uint32_t byteCount = 0, bw = 0, bwMax = 0, br; // for bytes read and bit-rate + uint32_t headerRes = 0; + ExhaleEncoder exhaleEnc (inPcmData, outAuData, sampleRate, numChannels, frameLength, indepPeriod, variableCoreBitRateMode + + (sampleRate > 24000 ? 0 : 1 - (variableCoreBitRateMode >> 2)) // compensate for low sampling rates +#if !RESTRICT_TO_AAC + , true /*noise filling*/, compatibleExtensionFlag > 0 +#endif + ); + BasicMP4Writer mp4Writer; // .m4a file + + // init encoder, generate UsacConfig() + memset (outAuData, 0, 108 * sizeof (uint8_t)); // max. allowed ASC + UC size + i = exhaleEnc.initEncoder (outAuData, &bw); // bw holds actual ASC + UC size + + if ((i |= mp4Writer.open (outFileHandle, sampleRate, numChannels, inSampDepth, frameLength, startLength, + indepPeriod, outAuData, bw, time (nullptr) & UINT_MAX, (char) variableCoreBitRateMode)) != 0) + { + fprintf_s (stderr, " ERROR while trying to initialize xHE-AAC encoder: error value %d was returned!\n\n", i); + i <<= 2; // return value + + goto mainFinish; // coder init error + } + + if (*argv[1] != '#') // user-def. mode + { + fprintf_s (stdout, " Encoding %d-kHz %d-channel %d-bit WAVE to low-complexity xHE-AAC at %d kbit/s\n\n", + sampleRate / 1000, numChannels, inSampDepth, __min (4, numChannels) * (24 + variableCoreBitRateMode * 8)); + } + if (!readStdin && (mod3Percent > 0)) + { +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) + SetConsoleTextAttribute (hConsole, EXHALE_TEXT_BLUE); + fprintf_s (stdout, " Progress: "); + SetConsoleTextAttribute (hConsole, csbi.wAttributes); // initial text color + fprintf_s (stdout, "-"); fflush (stdout); +#else + fprintf_s (stdout, " Progress: -"); fflush (stdout); +#endif + } +#if !IGNORE_WAV_LENGTH + if (!readStdin) // reserve space for MP4 file header. TODO: nasty, avoid this + { + if ((headerRes = (uint32_t) mp4Writer.initHeader (uint32_t (__min (UINT_MAX - startLength, expectLength)))) < 666) + { + fprintf_s (stderr, "\n ERROR while trying to write MPEG-4 bit-stream header: stopped after %d bytes!\n\n", headerRes); + i = 3; // return value + + goto mainFinish; // writeout error + } + } +#endif + i = 1; // for progress bar + + // initial frame, encode look-ahead AU + if ((bw = exhaleEnc.encodeLookahead ()) < 3) + { + fprintf_s (stderr, "\n ERROR while trying to create first xHE-AAC frame: error value %d was returned!\n\n", bw); + i = 2; // return value + + goto mainFinish; // coder-time error + } + if (bwMax < bw) bwMax = bw; + // write first AU, add frame to header + if (mp4Writer.addFrameAU (outAuData, byteCount, bw) != bw) goto mainFinish; + byteCount += bw; + + while (wavReader.read (inPcmData, frameLength) > 0) // read a new audio frame + { + // frame coding loop, encode next AU + if ((bw = exhaleEnc.encodeFrame ()) < 3) + { + fprintf_s (stderr, "\n ERROR while trying to create xHE-AAC frame: error value %d was returned!\n\n", bw); + i = 2; // return value + + goto mainFinish; + } + if (bwMax < bw) bwMax = bw; + // write new AU, add frame to header + if (mp4Writer.addFrameAU (outAuData, byteCount, bw) != bw) goto mainFinish; + byteCount += bw; + + if (!readStdin && (mod3Percent > 0) && !(mp4Writer.getFrameCount () % mod3Percent)) + { + if ((i++) < 34) // for short files + { + fprintf_s (stdout, "-"); fflush (stdout); + } + } + } // frame loop + + // end of coding loop, encode final AU + if ((bw = exhaleEnc.encodeFrame ()) < 3) + { + fprintf_s (stderr, "\n ERROR while trying to create xHE-AAC frame: error value %d was returned!\n\n", bw); + i = 2; // return value + + goto mainFinish; // coder-time error + } + if (bwMax < bw) bwMax = bw; + // write final AU, add frame to header + if (mp4Writer.addFrameAU (outAuData, byteCount, bw) != bw) goto mainFinish; + byteCount += bw; + + const int64_t actualLength = wavReader.getDataBytesRead () / int64_t (numChannels * inSampDepth >> 3); + + if (((actualLength + startLength) % frameLength) > 0) // flush trailing audio + { + memset (inPcmData, 0, inFrameSize * numChannels); + + // flush remaining audio into new AU + if ((bw = exhaleEnc.encodeFrame ()) < 3) + { + fprintf_s (stderr, "\n ERROR while trying to create last xHE-AAC frame: error value %d was returned!\n\n", bw); + i = 2; // return value + + goto mainFinish; + } + if (bwMax < bw) bwMax = bw; + // the flush AU, add frame to header + if (mp4Writer.addFrameAU (outAuData, byteCount, bw) != bw) goto mainFinish; + byteCount += bw; + } // trailing frame + +#if !IGNORE_WAV_LENGTH + if (readStdin) // reserve space for MP4 file header (is there an easier way?) +#endif + { + int64_t pos = _SEEK (outFileHandle, 0, 1 /*SEEK_CUR*/); + + if ((headerRes = (uint32_t) mp4Writer.initHeader (uint32_t (__min (UINT_MAX - startLength, actualLength)))) < 666) + { + fprintf_s (stderr, "\n ERROR while trying to write MPEG-4 bit-stream header: stopped after %d bytes!\n\n", headerRes); + i = 3; // return value + + goto mainFinish; // writeout error + } + // move AU data forward to make room for actual MP4 header at start of file + br = inFrameSize * numChannels; + while ((pos -= br) > 0) // move loop + { + _SEEK (outFileHandle, pos, 0 /*SEEK_SET*/); + _READ (outFileHandle, inPcmData, br); + _SEEK (outFileHandle, pos + headerRes, 0 /*SEEK_SET*/); + _WRITE(outFileHandle, inPcmData, br); + } + if ((br = (uint32_t) __max (0, pos + br)) > 0) // remainder of data to move + { + _SEEK (outFileHandle, 0, 0 /*SEEK_SET*/); + _READ (outFileHandle, inPcmData, br); + _SEEK (outFileHandle, headerRes, 0 /*SEEK_SET*/); + _WRITE(outFileHandle, inPcmData, br); + } + } + + // mean & max. bit-rate of encoded AUs + br = uint32_t (((actualLength >> 1) + 8 * (byteCount + 4 * (int64_t) mp4Writer.getFrameCount ()) * sampleRate) / actualLength); + bw = uint32_t (((frameLength >> 1) + 8 * (bwMax + 4u /* maximum AU size + stsz as a bit-rate */) * sampleRate) / frameLength); + bw = mp4Writer.finishFile (br, bw, uint32_t (__min (UINT_MAX - startLength, actualLength)), time (nullptr) & UINT_MAX); + + fprintf_s (stdout, " Done, actual average %.1f kbit/s\n\n", (float) br * 0.001f); + i = 0; // no errors + if (!readStdin && (actualLength != expectLength || bw != headerRes)) + { + fprintf_s (stderr, " WARNING: %ld sample frames read but %ld sample frames expected!\n", actualLength, expectLength); + if (bw != headerRes) fprintf_s (stderr, " The encoded MPEG-4 bit-stream is likely to be unreadable!\n"); + fprintf_s (stderr, "\n"); + } + } // end coding loop and stats print-out + } + +mainFinish: + + // free all dynamic memory + if (inPcmData != nullptr) + { + free ((void*) inPcmData); + inPcmData = nullptr; + } + if (outAuData != nullptr) + { + free ((void*) outAuData); + outAuData = nullptr; + } + // close input file + if (inFileHandle != -1) + { + if (_CLOSE (inFileHandle) != 0) + { + if (readStdin) // stdin + { + fprintf_s (stderr, " ERROR while trying to close stdin stream! Has it already been closed?\n\n"); + } + else // argc = 4, file + { + fprintf_s (stderr, " ERROR while trying to close input file %s! Does it still exist?\n\n", argv[2]); + } + } + inFileHandle = 0; + } + // close output file + if (outFileHandle != -1) + { + if (_CLOSE (outFileHandle) != 0) + { + fprintf_s (stderr, " ERROR while trying to close output file %s! Does it still exist?\n\n", argv[argc - 1]); + } + outFileHandle = 0; + } + + return (inFileHandle | outFileHandle | i); +} diff --git a/src/app/exhaleApp.ico b/src/app/exhaleApp.ico new file mode 100644 index 0000000..c420a62 Binary files /dev/null and b/src/app/exhaleApp.ico differ diff --git a/src/app/exhaleApp.rc b/src/app/exhaleApp.rc new file mode 100644 index 0000000..1ad287f --- /dev/null +++ b/src/app/exhaleApp.rc @@ -0,0 +1,35 @@ +/* exhaleApp.rc - resource file for exhale application binaries compiled under Windows + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "..\..\include\version.h" // for EXHALELIB_VERSION_... strings +#include "winres.h" + +0 ICON "exhaleApp.ico" +VS_VERSION_INFO VERSIONINFO +FILEVERSION 1,0,0 +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", "ecodis" + VALUE "FileDescription", "exhale - ecodis extended high-efficiency and low-complexity encoder" + VALUE "InternalName", "exhaleApp.exe" + VALUE "LegalCopyright", "© 2018-2020 C. R. Helmrich, ecodis" + VALUE "OriginalFilename", "exhale.exe" + VALUE "ProductName", "exhaleApp" + VALUE "ProductVersion", EXHALELIB_VERSION_MAJOR "." EXHALELIB_VERSION_MINOR EXHALELIB_VERSION_BUGFIX + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/src/app/exhaleAppPch.cpp b/src/app/exhaleAppPch.cpp new file mode 100644 index 0000000..2b9bd94 --- /dev/null +++ b/src/app/exhaleAppPch.cpp @@ -0,0 +1,27 @@ +/* exhaleAppPch.cpp - pre-compiled source file for source code of exhale application + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleAppPch.h" + +// ISO/IEC 23003-3 USAC Table 67 +static const unsigned supportedSamplingRates[26] = { + 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, // AAC + 57600, 51200, 40000, 38400, 34150, 28800, 25600, 20000, 19200, 17075, 14400, 12800, 9600 // USAC +}; + +// public sampling rate function +bool isSamplingRateSupported (const unsigned samplingRate) +{ + for (unsigned i = 0; i < 26; i++) + { + if (samplingRate == supportedSamplingRates[i]) return true; + } + return false; // not supported +} diff --git a/src/app/exhaleAppPch.h b/src/app/exhaleAppPch.h new file mode 100644 index 0000000..48f5a6a --- /dev/null +++ b/src/app/exhaleAppPch.h @@ -0,0 +1,48 @@ +/* exhaleAppPch.h - pre-compiled header file for source code of exhale application + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _EXHALE_APP_PCH_H_ +#define _EXHALE_APP_PCH_H_ + +#include // for .._MAX, .._MIN +#include // for (u)int8_t, (u)int16_t, (u)int32_t, (u)int64_t +#include // for abs, div, calloc, malloc, free, (__)max, (__)min, (s)rand +#include // for memcpy, memset +#include // for std::vector <> +#if defined (_WIN32) || defined (WIN32) || defined (_WIN64) || defined (WIN64) +# include + +# define _CLOSE _close +# define _READ _read +# define _SEEK _lseeki64 +# define _WRITE _write +#else // Linux, MacOS, Unix +# include + +# define _CLOSE ::close +# define _READ ::read +# define _SEEK ::lseek +# define _WRITE ::write +#endif + +#ifndef __max +# define __max(a, b) ((a) > (b) ? (a) : (b)) +#endif +#ifndef __min +# define __min(a, b) ((a) < (b) ? (a) : (b)) +#endif +#ifndef fprintf_s +# define fprintf_s fprintf +#endif + +// public sampling rate function +bool isSamplingRateSupported (const unsigned samplingRate); + +#endif // _EXHALE_APP_PCH_H_ diff --git a/src/app/exhaleApp_vs2012.vcxproj b/src/app/exhaleApp_vs2012.vcxproj new file mode 100644 index 0000000..40b0b08 --- /dev/null +++ b/src/app/exhaleApp_vs2012.vcxproj @@ -0,0 +1,181 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {EC0D1502-2018-1700-4865-6C6D72696368} + exhaleApp + exhaleApp + + + + Application + v110 + true + + + Application + v110 + true + + + Application + v110 + false + true + + + Application + v110 + false + true + + + + + + + + + + + + + + + + + + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)bin\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)bin\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + false + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)bin\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + false + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)bin\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + + $(SolutionDir)include + Disabled + Use + exhaleAppPch.h + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + Level3 + + + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + true + Console + + + + + $(SolutionDir)include + Disabled + Use + exhaleAppPch.h + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + Level3 + + + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + true + Console + + + + + $(SolutionDir)include + true + true + MaxSpeed + Use + exhaleAppPch.h + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + Level3 + + + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + true + false + true + Console + + + + + $(SolutionDir)include + true + true + MaxSpeed + Use + exhaleAppPch.h + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + Level3 + + + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + true + false + true + Console + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + + {EC0D1501-2018-1700-4865-6C6D72696368} + + + + \ No newline at end of file diff --git a/src/app/exhaleApp_vs2012.vcxproj.filters b/src/app/exhaleApp_vs2012.vcxproj.filters new file mode 100644 index 0000000..bab0bec --- /dev/null +++ b/src/app/exhaleApp_vs2012.vcxproj.filters @@ -0,0 +1,53 @@ + + + + + {EC0D1506-2018-1700-4865-6C6D72696368} + h;hpp + + + {EC0D1507-2018-1700-4865-6C6D72696368} + cpp;c;asm;asmx + + + {EC0D1508-2018-1700-4865-6C6D72696368} + rc;ico + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Resource Files + + + \ No newline at end of file diff --git a/src/app/exhaleApp_vs2012.vcxproj.user b/src/app/exhaleApp_vs2012.vcxproj.user new file mode 100644 index 0000000..fc19bc1 --- /dev/null +++ b/src/app/exhaleApp_vs2012.vcxproj.user @@ -0,0 +1,7 @@ + + + + # C:\ha2010.wav debug.m4a > ..\..\debug.txt + WindowsLocalDebugger + + \ No newline at end of file diff --git a/src/app/makefile b/src/app/makefile new file mode 100644 index 0000000..1594217 --- /dev/null +++ b/src/app/makefile @@ -0,0 +1,50 @@ +## makefile - application make-file for compiling exhale on Linux and MacOS platforms + # written by C. R. Helmrich, last modified 2019 - see License.txt for legal notices + # + # The copyright in this software is being made available under a Modified BSD License + # and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + # party rights, including patent rights. No such rights are granted under this License. + # + # Copyright (c) 2018-2019 Christian R. Helmrich, project ecodis. All rights reserved. + ## + +# define as console application +CONFIG = CONSOLE + +# source and output directories +DIR_BIN = ../../bin +DIR_OBJ = ../../build +DIR_INC = ../../include +DIR_LIB = ../../lib +DIR_SRC = ../../src/app + +# build with large file support +DEFS = -DMSYS_LINUX -DMSYS_UNIX_LARGEFILE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 + +# name of product / binary file +PRD_NAME = Exhale + +# name of temporary object file +OBJS = \ + $(DIR_OBJ)/basicMP4Writer.o \ + $(DIR_OBJ)/basicWavReader.o \ + $(DIR_OBJ)/exhaleApp.o \ + $(DIR_OBJ)/exhaleAppPch.o \ + +# define libraries to link with +LIBS = -ldl +DYN_LIBS = +STAT_LIBS = -lpthread + +DYN_DEBUG_LIBS = -lExhaleDynd +DYN_DEBUG_PREREQS = $(DIR_LIB)/libExhaleDynd.a +STAT_DEBUG_LIBS = -lExhaled +STAT_DEBUG_PREREQS = $(DIR_LIB)/libExhaled.a + +DYN_RELEASE_LIBS = -lExhale +DYN_RELEASE_PREREQS = $(DIR_LIB)/libExhale.a +STAT_RELEASE_LIBS = -lExhale +STAT_RELEASE_PREREQS = $(DIR_LIB)/libExhale.a + +# include common makefile.base +include ../makefile.base diff --git a/src/lib/bitAllocation.cpp b/src/lib/bitAllocation.cpp new file mode 100644 index 0000000..6aa8bcf --- /dev/null +++ b/src/lib/bitAllocation.cpp @@ -0,0 +1,347 @@ +/* bitAllocation.cpp - source file for class needed for psychoacoustic bit-allocation + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "bitAllocation.h" + +// static helper functions +static inline uint32_t jndModel (const uint32_t val, const uint32_t mean, + const unsigned expTimes512, const unsigned mulTimes512) +{ + const double exp = (double) expTimes512 / 512.0; // exponent + const double mul = (double) mulTimes512 / 512.0; // a factor + const double res = pow (mul * (double) val, exp) * pow ((double) mean, 1.0 - exp); + + return uint32_t (__min ((double) UINT_MAX, res + 0.5)); +} + +static void jndPowerLawAndPeakSmoothing (uint32_t* const stepSizes, const unsigned nStepSizes, + const uint32_t avgStepSize, const uint8_t sfm, const uint8_t tfm) +{ + const unsigned expTimes512 = 512u - sfm; // 1.0 - sfm / 2.0 + const unsigned mulTimes512 = __min (expTimes512, 512u - tfm); + uint32_t stepSizeM3 = 0, stepSizeM2 = 0, stepSizeM1 = 99 + BA_EPS; // hearing threshold around DC + unsigned b; + + for (b = 0; b < __min (2, nStepSizes); b++) + { + stepSizeM3 = stepSizeM2; + stepSizeM2 = stepSizeM1; + stepSizeM1 = stepSizes[b] = jndModel (stepSizes[b], avgStepSize, expTimes512, mulTimes512); + } + stepSizes[0] = __min (stepSizeM1, stepSizes[0]); // `- becomes -- + for (/*b*/; b < nStepSizes; b++) + { + const uint32_t stepSizeB = jndModel (stepSizes[b], avgStepSize, expTimes512, mulTimes512); + + if ((stepSizeM3 <= stepSizeM2) && (stepSizeM3 <= stepSizeM1) && (stepSizeB <= stepSizeM2) && (stepSizeB <= stepSizeM1)) + { + const uint32_t maxM3M0 = __max (stepSizeM3, stepSizeB); // smoothen local spectral peak of _´`- shape + + stepSizes[b - 2] = __min (maxM3M0, stepSizes[b - 2]); // _-`- + stepSizes[b - 1] = __min (maxM3M0, stepSizes[b - 1]); // _--- + } + stepSizeM3 = stepSizeM2; + stepSizeM2 = stepSizeM1; + stepSizeM1 = (stepSizes[b] = stepSizeB); // modified step-size may be smoothened in next loop iteration + } +} + +// constructor +BitAllocator::BitAllocator () +{ + for (unsigned ch = 0; ch < USAC_MAX_NUM_CHANNELS; ch++) + { + m_avgStepSize[ch] = 0; + m_avgSpecFlat[ch] = 0; + m_avgTempFlat[ch] = 0; + } +} + +// public functions +void BitAllocator::getChAverageSpecFlat (uint8_t meanSpecFlatInCh[USAC_MAX_NUM_CHANNELS], const unsigned nChannels) +{ + if ((meanSpecFlatInCh == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS)) + { + return; + } + memcpy (meanSpecFlatInCh, m_avgSpecFlat, nChannels * sizeof (uint8_t)); +} + +void BitAllocator::getChAverageTempFlat (uint8_t meanTempFlatInCh[USAC_MAX_NUM_CHANNELS], const unsigned nChannels) +{ + if ((meanTempFlatInCh == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS)) + { + return; + } + memcpy (meanTempFlatInCh, m_avgTempFlat, nChannels * sizeof (uint8_t)); +} + +uint8_t BitAllocator::getScaleFac (const uint32_t sfbStepSize, const int32_t* const sfbSignal, const uint8_t sfbWidth, + const uint32_t sfbRmsValue) +{ + uint8_t sf; + uint32_t u; +#if !RESTRICT_TO_AAC + uint64_t meanSpecLoudness = 0; + double d; +#endif + + if ((sfbSignal == nullptr) || (sfbWidth == 0) || (sfbRmsValue < 46)) + { + return 0; // use lowest scale factor + } +#if RESTRICT_TO_AAC + u = 0; + for (sf = 0; sf < sfbWidth; sf++) + { + u += uint32_t (0.5 + sqrt (abs ((double) sfbSignal[sf]))); + } + u = uint32_t ((u * 16384ui64 + (sfbWidth >> 1)) / sfbWidth); + u = uint32_t (0.5 + sqrt ((double) u) * 128.0); + + if (u < 42567) return 0; + + u = uint32_t ((sfbStepSize * 42567ui64 + (u >> 1)) / u); + sf = (u > 1 ? uint8_t (0.5 + 17.7169498394 * log10 ((double) u)) : 4); +#else + for (sf = 0; sf < sfbWidth; sf++) // simple, low-complexity derivation method for USAC's arithmetic coder + { + const int64_t temp = ((int64_t) sfbSignal[sf] + 8) >> 4; // avoid overflow + + meanSpecLoudness += temp * temp; + } + meanSpecLoudness = uint64_t (0.5 + pow (256.0 * (double) meanSpecLoudness / sfbWidth, 0.25)); + + u = uint32_t (0.5 + pow ((double) sfbRmsValue, 0.75) * 256.0); // u = 2^8 * (sfbRmsValue^0.75) + u = uint32_t ((meanSpecLoudness * sfbStepSize * 665 + (u >> 1)) / u); // u = sqrt(6.75) * m*thr/u + d = (u > 1 ? log10 ((double) u) : 0.25); + + u = uint32_t (0.5 + pow ((double) sfbRmsValue, 0.25) * 16384.0); // u = 2^14 * (sfbRmsValue^0.25) + u = uint32_t (((uint64_t) sfbStepSize * 42567 + (u >> 1)) / u); // u = sqrt(6.75) * thr/u + d += (u > 1 ? log10 ((double) u) : 0.25); + + sf = uint8_t (0.5 + 8.8584749197 * d); // sf = (8/3) * log2(u1*u2) = (8/3) * (log2(u1)+log2(u2)) +#endif + + return __min (SCHAR_MAX, sf); +} + +unsigned BitAllocator::initSfbStepSizes (const SfbGroupData* const groupData[USAC_MAX_NUM_CHANNELS], const uint8_t numSwbShort, + const uint32_t specAnaStats[USAC_MAX_NUM_CHANNELS], + const uint32_t tempAnaStats[USAC_MAX_NUM_CHANNELS], + const unsigned nChannels, const unsigned samplingRate, uint32_t* const sfbStepSizes, + const unsigned lfeChannelIndex /*= USAC_MAX_NUM_CHANNELS*/, const bool tnsDisabled /*= false*/) +{ + // equal-loudness weighting based on data from: K. Kurakata, T. Mizunami, and K. Matsushita, "Percentiles + // of Normal Hearing-Threshold Distribution Under Free-Field Listening Conditions in Numerical Form," Ac. + // Sci. Tech, vol. 26, no. 5, pp. 447-449, Jan. 2005, https://www.researchgate.net/publication/239433096. + const unsigned HF/*idx*/= ((123456 - samplingRate) >> 11) + (samplingRate <= 34150 ? 2 : 0); // start SFB + const unsigned LF/*idx*/= 9; + const unsigned MF/*idx*/= (samplingRate < 28800 ? HF : __min (HF, 30u)); + const unsigned msShift = (samplingRate + 36736) >> 15; // TODO: 768 smp + const unsigned msOffset = 1 << (msShift - 1); + uint32_t nMeans = 0, sumMeans = 0; + + if ((groupData == nullptr) || (specAnaStats == nullptr) || (tempAnaStats == nullptr) || (sfbStepSizes == nullptr) || + (numSwbShort < MIN_NUM_SWB_SHORT) || (numSwbShort > MAX_NUM_SWB_SHORT) || (nChannels > USAC_MAX_NUM_CHANNELS) || + (samplingRate < 7350) || (samplingRate > 96000) || (lfeChannelIndex > USAC_MAX_NUM_CHANNELS)) + { + return 1; // invalid arguments error + } + + for (unsigned ch = 0; ch < nChannels; ch++) + { + const SfbGroupData& grpData = *groupData[ch]; + const uint32_t maxSfbInCh = grpData.sfbsPerGroup; + const uint32_t nBandsInCh = grpData.numWindowGroups * maxSfbInCh; + const uint32_t* rms = grpData.sfbRmsValues; + uint32_t* stepSizes = &sfbStepSizes[ch * numSwbShort * NUM_WINDOW_GROUPS]; +// --- apply INTRA-channel simultaneous masking, equal-loudness weighting, and thresholding to SFB RMS data + uint32_t maskingSlope = LF, b, elw = 58254; // 8/9 + uint32_t rmsEqualLoud = 0; + uint32_t sumStepSizes = 0; + + m_avgStepSize[ch] = 0; + + b = ((specAnaStats[ch] >> 16) & UCHAR_MAX); // start with squared spec. flatness from spectral analysis + b = __max (b * b, (tempAnaStats[ch] >> 24) * (tempAnaStats[ch] >> 24)); // ..and from temporal analysis + m_avgSpecFlat[ch] = uint8_t ((b + (1 << 7)) >> 8); // normalized maximum + + b = ((tempAnaStats[ch] >> 16) & UCHAR_MAX); // now derive squared temp. flatness from temporal analysis + b = __max (b * b, (specAnaStats[ch] >> 24) * (specAnaStats[ch] >> 24)); // ..and from spectral analysis + m_avgTempFlat[ch] = uint8_t ((b + (1 << 7)) >> 8); // normalized maximum + + if ((nBandsInCh == 0) || (grpData.numWindowGroups > NUM_WINDOW_GROUPS)) + { + continue; + } + if ((ch == lfeChannelIndex) || (grpData.numWindowGroups != 1)) // LFE, SHORT windows: no masking or ELW + { + for (unsigned gr = 0; gr < grpData.numWindowGroups; gr++) + { + const uint32_t* gRms = &rms[numSwbShort * gr]; + uint32_t* gStepSizes = &stepSizes[numSwbShort * gr]; + + for (b = numSwbShort - 1; b >= maxSfbInCh; b--) + { + gStepSizes[b] = 0; + } + for (/*b*/; b > 0; b--) + { + gStepSizes[b] = __max (gRms[b], BA_EPS); + sumStepSizes += unsigned (0.5 + sqrt ((double) gStepSizes[b])); + } + gStepSizes[0] = __max (gRms[0], maskingSlope + BA_EPS); + sumStepSizes += unsigned (0.5 + sqrt ((double) gStepSizes[0])); + } // for gr + + if (ch != lfeChannelIndex) + { +// --- SHORT windows: apply perceptual just noticeable difference (JND) model and local band-peak smoothing + nMeans++; + m_avgStepSize[ch] = __min (USHRT_MAX, uint32_t ((sumStepSizes + (nBandsInCh >> 1)) / nBandsInCh)); + sumMeans += m_avgStepSize[ch]; + m_avgStepSize[ch] *= m_avgStepSize[ch]; + + for (unsigned gr = 0; gr < grpData.numWindowGroups; gr++) // separate peak smoothing for each group + { + jndPowerLawAndPeakSmoothing (&stepSizes[numSwbShort * gr], maxSfbInCh, m_avgStepSize[ch], m_avgSpecFlat[ch], 0); + } + } + continue; + } + + stepSizes[0] = __max (rms[0], maskingSlope + BA_EPS); + for (b = 1; b < __min (LF, maxSfbInCh); b++) // apply steeper low-frequency simultaneous masking slopes + { + maskingSlope = (stepSizes[b - 1] + (msOffset << (9u - b))) >> (msShift + 9u - b); + stepSizes[b] = __max (rms[b], maskingSlope + BA_EPS); + } + for (/*b*/; b < __min (MF, maxSfbInCh); b++) // apply typical mid-frequency simultaneous masking slopes + { + maskingSlope = (stepSizes[b - 1] + msOffset) >> msShift; + stepSizes[b] = __max (rms[b], maskingSlope + BA_EPS); + } + if ((samplingRate >= 28800) && (samplingRate <= 64000)) + { + for (/*b*/; b < __min (HF, maxSfbInCh); b++) // compensate high-frequency slopes for linear SFB width + { + maskingSlope = ((uint64_t) stepSizes[b - 1] * (9u + b - MF) + (msOffset << 3u)) >> (msShift + 3u); + stepSizes[b] = __max (rms[b], maskingSlope + BA_EPS); + } + for (/*b = HF region*/; b < maxSfbInCh; b++) // apply extra high-frequency equal-loudness attenuation + { + for (unsigned d = b - HF; d > 0; d--) + { + elw = (elw * 52430 - SHRT_MIN) >> 16; // elw *= 4/5 + } + rmsEqualLoud = uint32_t (((uint64_t) rms[b] * elw - SHRT_MIN) >> 16); // equal loudness weighting + maskingSlope = ((uint64_t) stepSizes[b - 1] * (9u + b - MF) + (msOffset << 3u)) >> (msShift + 3u); + stepSizes[b] = __max (rmsEqualLoud, maskingSlope + BA_EPS); + } + } + else // no equal-loudness weighting for low or high rates + { + for (/*b = MF region*/; b < maxSfbInCh; b++) // compensate high-frequency slopes for linear SFB width + { + maskingSlope = ((uint64_t) stepSizes[b - 1] * (9u + b - MF) + (msOffset << 3u)) >> (msShift + 3u); + stepSizes[b] = __max (rms[b], maskingSlope + BA_EPS); + } + } + for (b -= 1; b > __min (MF, maxSfbInCh); b--) // complete simultaneous masking by reversing the pattern + { + sumStepSizes += unsigned (0.5 + sqrt ((double) stepSizes[b])); + maskingSlope = ((uint64_t) stepSizes[b] * (8u + b - MF) + (msOffset << 3u)) >> (msShift + 3u); + stepSizes[b - 1] = __max (stepSizes[b - 1], maskingSlope); + } + for (/*b*/; b > __min (LF, maxSfbInCh); b--) // typical reversed mid-freq. simultaneous masking slopes + { + sumStepSizes += unsigned (0.5 + sqrt ((double) stepSizes[b])); + maskingSlope = (stepSizes[b] + msOffset) >> msShift; + stepSizes[b - 1] = __max (stepSizes[b - 1], maskingSlope); + } + for (/*b = min (9, maxSfbInCh)*/; b > 0; b--) // steeper reversed low-freq. simultaneous masking slopes + { + sumStepSizes += unsigned (0.5 + sqrt ((double) stepSizes[b])); + maskingSlope = (stepSizes[b] + (msOffset << (10u - b))) >> (msShift + 10u - b); + stepSizes[b - 1] = __max (stepSizes[b - 1], maskingSlope); + } + sumStepSizes += unsigned (0.5 + sqrt ((double) stepSizes[0])); + +// --- LONG window: apply perceptual JND model and local band-peak smoothing, undo equal-loudness weighting + nMeans++; + m_avgStepSize[ch] = __min (USHRT_MAX, uint32_t ((sumStepSizes + (nBandsInCh >> 1)) / nBandsInCh)); + sumMeans += m_avgStepSize[ch]; + m_avgStepSize[ch] *= m_avgStepSize[ch]; + + jndPowerLawAndPeakSmoothing (stepSizes, maxSfbInCh, m_avgStepSize[ch], m_avgSpecFlat[ch], tnsDisabled ? m_avgTempFlat[ch] : 0); + + if ((samplingRate >= 28800) && (samplingRate <= 64000)) + { + elw = 36; // 36/32 = 9/8 + for (b = HF; b < grpData.sfbsPerGroup; b++) // undo additional high-freq. equal-loudness attenuation + { + for (unsigned d = b - HF; d > 0; d--) + { + elw = (16u + elw * 40) >> 5; // inverse elw *= 5/4. NOTE: this may overflow for 64 kHz, that's OK + } + if (elw == 138 || elw >= 1024) elw--; + rmsEqualLoud = uint32_t (__min (UINT_MAX, (16u + (uint64_t) stepSizes[b] * elw) >> 5)); + stepSizes[b] = rmsEqualLoud; + } + } + } // for ch + + if ((nMeans < 2) || (sumMeans <= nMeans * BA_EPS)) // in case of one channel or low-RMS input, we're done + { + return 0; // no error + } + + sumMeans = (sumMeans + (nMeans >> 1)) / nMeans; + sumMeans *= sumMeans; // since we've averaged square-roots +#if BA_INTER_CHAN_SIM_MASK + if (nMeans > 3) + { + // TODO: cross-channel simultaneous masking for 4.0 - 7.1 + } +#endif + + for (unsigned ch = 0; ch < nChannels; ch++) + { + const SfbGroupData& grpData = *groupData[ch]; + const uint32_t maxSfbInCh = grpData.sfbsPerGroup; + const uint32_t nBandsInCh = grpData.numWindowGroups * maxSfbInCh; + const uint32_t chStepSize = m_avgStepSize[ch]; + uint32_t* stepSizes = &sfbStepSizes[ch * numSwbShort * NUM_WINDOW_GROUPS]; +// --- apply INTER-channel simultaneous masking and JND modeling to calculated INTRA-channel step-size data + uint64_t mAvgStepSize; // modified and averaged step-size + + if ((nBandsInCh == 0) || (grpData.numWindowGroups > NUM_WINDOW_GROUPS) || (ch == lfeChannelIndex)) + { + continue; + } + mAvgStepSize = jndModel (chStepSize, sumMeans, 7 << 6 /*7/8*/, 512); + + for (unsigned gr = 0; gr < grpData.numWindowGroups; gr++) + { + uint32_t* gStepSizes = &stepSizes[numSwbShort * gr]; + + for (unsigned b = 0; b < maxSfbInCh; b++) + { + gStepSizes[b] = uint32_t (__min (UINT_MAX, (mAvgStepSize * gStepSizes[b] + (chStepSize >> 1)) / chStepSize)); + } + } // for gr + + m_avgStepSize[ch] = (uint32_t) mAvgStepSize; + } // for ch + + return 0; // no error +} diff --git a/src/lib/bitAllocation.h b/src/lib/bitAllocation.h new file mode 100644 index 0000000..6e197ff --- /dev/null +++ b/src/lib/bitAllocation.h @@ -0,0 +1,48 @@ +/* bitAllocation.h - header file for class needed for psychoacoustic bit-allocation + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _BIT_ALLOCATION_H_ +#define _BIT_ALLOCATION_H_ + +#include "exhaleLibPch.h" + +// constants, experimental macros +#define BA_EPS 1 +#define BA_INTER_CHAN_SIM_MASK 0 // cross-channel simultaneous masking for surround + +// class for audio bit-allocation +class BitAllocator +{ +private: + + // member variables + uint32_t m_avgStepSize[USAC_MAX_NUM_CHANNELS]; + uint8_t m_avgSpecFlat[USAC_MAX_NUM_CHANNELS]; + uint8_t m_avgTempFlat[USAC_MAX_NUM_CHANNELS]; + +public: + + // constructor + BitAllocator (); + // destructor + ~BitAllocator () { } + // public functions + void getChAverageSpecFlat (uint8_t meanSpecFlatInCh[USAC_MAX_NUM_CHANNELS], const unsigned nChannels); + void getChAverageTempFlat (uint8_t meanTempFlatInCh[USAC_MAX_NUM_CHANNELS], const unsigned nChannels); + uint8_t getScaleFac (const uint32_t sfbStepSize, const int32_t* const sfbSignal, const uint8_t sfbWidth, + const uint32_t sfbRmsValue); + unsigned initSfbStepSizes (const SfbGroupData* const groupData[USAC_MAX_NUM_CHANNELS], const uint8_t numSwbShort, + const uint32_t specAnaStats[USAC_MAX_NUM_CHANNELS], + const uint32_t tempAnaStats[USAC_MAX_NUM_CHANNELS], + const unsigned nChannels, const unsigned samplingRate, uint32_t* const sfbStepSizes, + const unsigned lfeChannelIndex = USAC_MAX_NUM_CHANNELS, const bool tnsDisabled = false); +}; // BitAllocator + +#endif // _BIT_ALLOCATION_H_ diff --git a/src/lib/bitStreamWriter.cpp b/src/lib/bitStreamWriter.cpp new file mode 100644 index 0000000..bcfc191 --- /dev/null +++ b/src/lib/bitStreamWriter.cpp @@ -0,0 +1,559 @@ +/* bitStreamWriter.cpp - source file for class with basic bit-stream writing capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "bitStreamWriter.h" + +// private helper functions +void BitStreamWriter::writeByteAlignment () // write '0' bits until stream is byte-aligned +{ + if (m_auBitStream.heldBitCount > 0) + { + m_auBitStream.stream.push_back (m_auBitStream.heldBitChunk); + m_auBitStream.heldBitChunk = 0; + m_auBitStream.heldBitCount = 0; + } +} + +unsigned BitStreamWriter::writeChannelWiseIcsInfo (const IcsInfo& icsInfo) // ics_info() +{ +#if RESTRICT_TO_AAC + m_auBitStream.write ((unsigned) icsInfo.windowSequence, 2); +#else + m_auBitStream.write (unsigned (icsInfo.windowSequence == STOP_START ? LONG_START : icsInfo.windowSequence), 2); +#endif + m_auBitStream.write ((unsigned) icsInfo.windowShape, 1); + if (icsInfo.windowSequence == EIGHT_SHORT) + { + m_auBitStream.write (icsInfo.maxSfb, 4); + m_auBitStream.write (icsInfo.windowGrouping, 7); // scale_factor_grouping + + return 14; + } + m_auBitStream.write (icsInfo.maxSfb, 6); + + return 9; +} + +unsigned BitStreamWriter::writeChannelWiseTnsData (const TnsData& tnsData, const bool eightShorts) +{ + const unsigned numWindows = (eightShorts ? 8 : 1); + const unsigned offsetBits = (eightShorts ? 1 : 2); + unsigned bitCount = 0, i; + + for (unsigned w = 0; w < numWindows; w++) + { + bitCount += offsetBits; + if (w != tnsData.filteredWindow) + { + m_auBitStream.write (0/*n_filt[w] = 0*/, offsetBits); + } + else + { + m_auBitStream.write (tnsData.numFilters, offsetBits); + if (tnsData.numFilters > 0) + { + m_auBitStream.write (tnsData.coeffResLow ? 0 : 1, 1); // coef_res[w] + bitCount++; + for (unsigned f = 0; f < tnsData.numFilters; f++) + { + const unsigned order = tnsData.filterOrder[f]; + + m_auBitStream.write (tnsData.filterLength[f], 2 + offsetBits * 2); + m_auBitStream.write (order, 2 + offsetBits); + bitCount += 4 + offsetBits * 3; + if (order > 0) + { + const int8_t* coeff = tnsData.coeff[f]; + unsigned coefBits = (tnsData.coeffResLow ? 3 : 4); + char coefMaxValue = (tnsData.coeffResLow ? 2 : 4); + bool dontCompress = false; + + m_auBitStream.write (tnsData.filterDownward[f] ? 1 : 0, 1); + for (i = 0; i < order; i++) // get coef_compress, then write coef + { + dontCompress |= ((coeff[i] < -coefMaxValue) || (coeff[i] >= coefMaxValue)); + } + m_auBitStream.write (dontCompress ? 0 : 1, 1); + coefMaxValue <<= 1; + if (dontCompress) coefMaxValue <<= 1; else coefBits--; + for (i = 0; i < order; i++) + { + m_auBitStream.write (unsigned (coeff[i] < 0 ? coefMaxValue + coeff[i] : coeff[i]), coefBits); + } + bitCount += 2 + order * coefBits; + } + } + } // if (n_filt[w]) + } + } // for w + + return bitCount; +} + +unsigned BitStreamWriter::writeFDChannelStream (const CoreCoderData& elData, EntropyCoder& entrCoder, const unsigned ch, + const int32_t* const mdctSignal, const uint8_t* const mdctQuantMag, +#if !RESTRICT_TO_AAC + const bool timeWarping, const bool noiseFilling, +#endif + const bool indepFlag /*= false*/) +{ + const IcsInfo& icsInfo = elData.icsInfoCurr[ch]; + const TnsData& tnsData = elData.tnsData[ch]; + const SfbGroupData& grp = elData.groupingData[ch]; + const unsigned maxSfb = grp.sfbsPerGroup; + const bool eightShorts = icsInfo.windowSequence == EIGHT_SHORT; + uint8_t* const sf = (uint8_t* const) grp.scaleFactors; + uint8_t sfIdxPred = CLIP_UCHAR (sf[0] > SCHAR_MAX ? 0 : sf[0] + (eightShorts ? 68 : 80)); + unsigned bitCount = 8, g, b, i; + + m_auBitStream.write (sfIdxPred, 8); // adjusted global_gain +#if !RESTRICT_TO_AAC + if (noiseFilling) + { + m_auBitStream.write (elData.specFillData[ch], 8); // noise level | offset + bitCount += 8; + } +#endif + if (!elData.commonWindow) + { + bitCount += writeChannelWiseIcsInfo (icsInfo); // ics_info + } +#if !RESTRICT_TO_AAC + if (timeWarping) // && (!common_tw) + { + m_auBitStream.write (0, 1); // enforce tw_data_present = 0 + bitCount++; + } +#endif + sfIdxPred = sf[0]; // scale factors + for (g = 0; g < grp.numWindowGroups; g++) + { + uint8_t* const gSf = &sf[m_numSwbShort * g]; + + for (b = 0; b < maxSfb; b++) + { + uint8_t sfIdx = gSf[b]; + + if ((g + 1 < grp.numWindowGroups) && (b + 1 == maxSfb) && ((unsigned) sfIdx + INDEX_OFFSET < sf[m_numSwbShort * (g + 1)])) + { + // ugly, avoidable if each gr. had its own global_gain + gSf[b] = sfIdx = sf[m_numSwbShort * (g + 1)] - INDEX_OFFSET; + } + if ((g > 0) || (b > 0)) + { + int sfIdxDpcm = (int) sfIdx - sfIdxPred; + unsigned sfBits; + + if (sfIdxDpcm > INDEX_OFFSET) // just as sanity checks + { + sfIdxDpcm = INDEX_OFFSET; + sfIdxPred += INDEX_OFFSET; + } + else if (sfIdxDpcm < -INDEX_OFFSET) // highly unlikely + { + sfIdxDpcm = -INDEX_OFFSET; + sfIdxPred -= INDEX_OFFSET; + } + else // scale factor range OK + { + sfIdxPred = sfIdx; + } + sfBits = entrCoder.indexGetBitCount (sfIdxDpcm); + m_auBitStream.write (entrCoder.indexGetHuffCode (sfIdxDpcm), sfBits); + bitCount += sfBits; + } + } + } // for g + + if (!elData.commonTnsData && (tnsData.numFilters > 0)) + { + bitCount += writeChannelWiseTnsData (tnsData, eightShorts); + } + + bitCount += (indepFlag ? 1 : 2); // arith_reset_flag, fac_data_present bits + + if (maxSfb == 0) // zeroed spectrum + { + entrCoder.initWindowCoding (!eightShorts /*reset*/, eightShorts); + + if (!indepFlag) m_auBitStream.write (1, 1); // force reset + } + else // not zeroed, nasty since SFB ungrouping may be needed + { + const uint16_t* grpOff = grp.sfbOffsets; + uint8_t grpLen = grp.windowGroupLength[0]; + uint8_t grpWin = 0; + uint8_t swbSize[MAX_NUM_SWB_SHORT]; + const uint8_t* winMag = (grpLen > 1 ? m_uCharBuffer : mdctQuantMag); + const uint16_t lg = (grpLen > 1 ? grpOff[maxSfb] / grpLen : grpOff[maxSfb]); + + if (eightShorts || (grpLen > 1)) // ungroup the SFB widths + { + for (b = 0, i = oneTwentyEightOver[grpLen]; b < maxSfb; b++) + { + swbSize[b] = ((grpOff[b+1] - grpOff[b]) * i) >> 7; // sfbWidth/grpLen + } + } + g = 0; + for (int w = 0; w < (eightShorts ? 8 : 1); w++, grpWin++) // window loop + { + if (grpWin >= grpLen) // next g + { + grpOff += m_numSwbShort; + grpLen = grp.windowGroupLength[++g]; + grpWin = 0; + winMag = (grpLen > 1 ? m_uCharBuffer : &mdctQuantMag[grpOff[0]]); + } + if (eightShorts && (grpLen > 1)) + { + for (b = i = 0; b < maxSfb; b++) // ungroup magnitudes + { + memcpy (&m_uCharBuffer[i], &mdctQuantMag[grpOff[b] + grpWin * swbSize[b]], swbSize[b] * sizeof (uint8_t)); + i += swbSize[b]; + } + } + entrCoder.initWindowCoding (indepFlag && (w == 0), eightShorts); + + if (!indepFlag && (w == 0)) // optimize arith_reset_flag + { + if ((b = entrCoder.arithGetResetBit (winMag, 0, lg)) != 0) + { + entrCoder.arithResetMemory (); + entrCoder.arithSetCodState (USHRT_MAX << 16); + entrCoder.arithSetCtxState (0); + } + m_auBitStream.write (b, 1); // write adapted reset bit + } + bitCount += entrCoder.arithCodeSigMagn (winMag, 0, lg, true, &m_auBitStream); + + if (eightShorts && (grpLen > 1)) + { + for (b = i = 0; b < maxSfb; b++) // ungroup coef signs + { + const int32_t* const swbSig = &mdctSignal[grpOff[b] + grpWin * swbSize[b]]; + + for (unsigned j = 0; j < swbSize[b]; j++, i++) + { + if (winMag[i] != 0) + { + m_auBitStream.write (swbSig[j] < 0 ? 0 : 1, 1); // - = 0, + = 1 + bitCount++; + } + } + } + } + else // not grouped long window + { + const int32_t* const winSig = &mdctSignal[grpOff[0]]; + + for (i = 0; i < lg; i++) + { + if (winMag[i] != 0) + { + m_auBitStream.write (winSig[i] < 0 ? 0 : 1, 1); // -1 = 0, +1 = 1 + bitCount++; + } + } + } + } // for w + } // if (maxSfb == 0) + + m_auBitStream.write (0, 1); // fac_data_present, no fac_data + + return bitCount; +} + +unsigned BitStreamWriter::writeStereoCoreToolInfo (const CoreCoderData& elData, +#if !RESTRICT_TO_AAC + const bool timeWarping, +#endif + const bool indepFlag /*= false*/) +{ + const IcsInfo& icsInfo0 = elData.icsInfoCurr[0]; + const IcsInfo& icsInfo1 = elData.icsInfoCurr[1]; + const TnsData& tnsData0 = elData.tnsData[0]; + const TnsData& tnsData1 = elData.tnsData[1]; + unsigned bitCount = 2, g, b; + + m_auBitStream.write (elData.tnsActive ? 1 : 0, 1); // tns_active + m_auBitStream.write (elData.commonWindow ? 1 : 0, 1); + if (elData.commonWindow) + { + const unsigned maxSfbSte = __max (icsInfo0.maxSfb, icsInfo1.maxSfb); + const unsigned sfb1Bits = icsInfo1.windowSequence == EIGHT_SHORT ? 4 : 6; + + bitCount += writeChannelWiseIcsInfo (icsInfo0); // ics_info() + m_auBitStream.write (elData.commonMaxSfb ? 1 : 0, 1); + if (!elData.commonMaxSfb) + { + m_auBitStream.write (icsInfo1.maxSfb, sfb1Bits); // max_sfb1 + bitCount += sfb1Bits; + } + m_auBitStream.write (__min (3, elData.stereoMode), 2); // ms_mask_present + bitCount += 3; + if (elData.stereoMode == 1) // write SFB-wise ms_used[][] flag + { + for (g = 0; g < elData.groupingData[0].numWindowGroups; g++) + { + const char* const gMsUsed = &elData.stereoData[m_numSwbShort * g]; + + for (b = 0; b < maxSfbSte; b++) + { + m_auBitStream.write (gMsUsed[b] > 0 ? 1 : 0, 1); + } + } + bitCount += maxSfbSte * g; + } +#if !RESTRICT_TO_AAC + else if (elData.stereoMode >= 3) // SFB-wise cplx_pred_data() + { + m_auBitStream.write (elData.stereoMode - 3, 1); // _pred_all + if (elData.stereoMode == 3) + { + for (g = 0; g < elData.groupingData[0].numWindowGroups; g++) + { + const char* const gCplxPredUsed = &elData.stereoData[m_numSwbShort * g]; + + for (b = 0; b < maxSfbSte; b += SFB_PER_PRED_BAND) + { + m_auBitStream.write (gCplxPredUsed[b] > 0 ? 1 : 0, 1); + } + } + bitCount += ((maxSfbSte + 1) / SFB_PER_PRED_BAND) * g; + } + // pred_dir and complex_coef. TODO: rest of cplx_pred_data() + m_auBitStream.write (elData.stereoConfig & 3, 2); + bitCount += 3; + } +#endif + } // common_window +#if !RESTRICT_TO_AAC + if (timeWarping) + { + m_auBitStream.write (0, 1); // common_tw not needed in xHE-AAC + bitCount++; + } // tw_mdct +#endif + if (elData.tnsActive) + { + if (elData.commonWindow) + { + m_auBitStream.write (elData.commonTnsData ? 1 : 0, 1); + bitCount++; + } + m_auBitStream.write (elData.tnsOnLeftRight ? 1 : 0, 1); + bitCount++; + if (elData.commonTnsData) + { + bitCount += writeChannelWiseTnsData (tnsData0, icsInfo0.windowSequence == EIGHT_SHORT); + } + else // tns_present_both and tns_data_present[1] + { + const bool tnsPresentBoth = (tnsData0.numFilters > 0) && (tnsData1.numFilters > 0); + + m_auBitStream.write (tnsPresentBoth ? 1 : 0, 1); + bitCount++; + if (!tnsPresentBoth) + { + m_auBitStream.write (tnsData1.numFilters > 0 ? 1 : 0, 1); + bitCount++; + } + } + } // tns_active + + return bitCount; +} + +// public functions +unsigned BitStreamWriter::createAudioConfig (const char samplingFrequencyIndex, const bool shortFrameLength, + const uint8_t chConfigurationIndex, const uint8_t numElements, + const ELEM_TYPE* const elementType, const bool configExtensionPresent, +#if !RESTRICT_TO_AAC + const bool* const tw_mdct /*N/A*/, const bool* const noiseFilling, +#endif + unsigned char* const audioConfig) +{ + unsigned bitCount = 37; + + if ((elementType == nullptr) || (audioConfig == nullptr) || (chConfigurationIndex >= USAC_MAX_NUM_ELCONFIGS) || +#if !RESTRICT_TO_AAC + (noiseFilling == nullptr) || (tw_mdct == nullptr) || +#endif + (numElements == 0) || (numElements > USAC_MAX_NUM_ELEMENTS) || (samplingFrequencyIndex < 0) || (samplingFrequencyIndex >= 0x1F)) + { + return 0; // invalid arguments error + } + + m_auBitStream.reset (); +// --- AudioSpecificConfig(): https://wiki.multimedia.cx/index.php/MPEG-4_Audio/ + m_auBitStream.write (0x7CA, 11); // audio object type (AOT) 32 (esc) + 10 = 42 + if (samplingFrequencyIndex < AAC_NUM_SAMPLE_RATES) + { + m_auBitStream.write (samplingFrequencyIndex, 4); + } + else + { + m_auBitStream.write (0xF, 4); // esc + m_auBitStream.write (toSamplingRate (samplingFrequencyIndex), 24); + bitCount += 24; + } + // for multichannel audio, refer to channel mapping of AotSpecificConfig below + m_auBitStream.write (chConfigurationIndex > 2 ? 0 : chConfigurationIndex, 4); + +// --- AotSpecificConfig(): UsacConfig() + m_auBitStream.write (samplingFrequencyIndex, 5); // usacSamplingFrequencyIndex + m_auBitStream.write (shortFrameLength ? 0 : 1, 3); // coreSbrFrameLengthIndex + m_auBitStream.write (chConfigurationIndex, 5); // channelConfigurationIndex + m_auBitStream.write (numElements - 1, 4); // numElements in UsacDecoderConfig + + for (unsigned el = 0; el < numElements; el++) // el element loop + { + m_auBitStream.write ((unsigned) elementType[el], 2); // usacElementType[el] + bitCount += 2; + if (elementType[el] < ID_USAC_LFE) // SCE, CPE: UsacCoreConfig + { +#if RESTRICT_TO_AAC + m_auBitStream.write (0, 2); // time warping and noise filling not allowed +#else + m_auBitStream.write ((tw_mdct[el] ? 2 : 0) | (noiseFilling[el] ? 1 : 0), 2); +#endif + bitCount += 2; + } + } // for el + + m_auBitStream.write (configExtensionPresent ? 1 : 0, 1); // usacConfigExten... + if (configExtensionPresent) // 23003-4: loudnessInfo + { + m_auBitStream.write (0, 2); // numConfigExtensions + m_auBitStream.write (ID_EXT_LOUDNESS_INFO, 4); + m_auBitStream.write (8, 4); // usacConfigExtLength + + m_auBitStream.write (1, 12);// loudnessInfoCount=1 + m_auBitStream.write (1, 14); // peakLevelPresent=1 + m_auBitStream.write (0, 12); // bsSamplePeakLevel + m_auBitStream.write (1, 5); // measurementCount=1 + + m_auBitStream.write (1, 4); // methodDefinition=1 + m_auBitStream.write (0, 8); // methodValue storage + m_auBitStream.write (0, 4); // measurementSystem=0 + m_auBitStream.write (3, 2); // reliability=3, good + + m_auBitStream.write (0, 1); // ...SetExtPresent=0 + bitCount += 72; + } + + bitCount += (8 - m_auBitStream.heldBitCount) & 7; + writeByteAlignment (); // flush bytes + + memcpy (audioConfig, &m_auBitStream.stream.front (), __min (16, bitCount >> 3)); + + return (bitCount >> 3); // byte count +} + +unsigned BitStreamWriter::createAudioFrame (CoreCoderData** const elementData, EntropyCoder* const entropyCoder, + int32_t** const mdctSignals, uint8_t** const mdctQuantMag, + const bool usacIndependencyFlag, const uint8_t numElements, + const uint8_t numSwbShort, uint8_t* const tempBuffer, +#if !RESTRICT_TO_AAC + const bool* const tw_mdct /*N/A*/, const bool* const noiseFilling, +#endif + unsigned char* const accessUnit, const unsigned nSamplesInFrame /*= 1024*/) +{ + unsigned bitCount = 1, ci = 0; + + if ((elementData == nullptr) || (entropyCoder == nullptr) || (tempBuffer == nullptr) || + (mdctSignals == nullptr) || (mdctQuantMag == nullptr) || (accessUnit == nullptr) || (nSamplesInFrame > 2048) || +#if !RESTRICT_TO_AAC + (noiseFilling == nullptr) || (tw_mdct == nullptr) || +#endif + (numElements == 0) || (numElements > USAC_MAX_NUM_ELEMENTS) || (numSwbShort < MIN_NUM_SWB_SHORT) || (numSwbShort > MAX_NUM_SWB_SHORT)) + { + return 0; // invalid arguments error + } + + m_auBitStream.reset (); + m_frameLength = nSamplesInFrame; + m_numSwbShort = numSwbShort; + m_uCharBuffer = tempBuffer; + m_auBitStream.write (usacIndependencyFlag ? 1 : 0, 1); + + for (unsigned el = 0; el < numElements; el++) // el element loop + { + const CoreCoderData* const elData = elementData[el]; + + if (elData == nullptr) + { + return 0; // internal memory error + } + switch (elData->elementType) // write out UsacCoreCoderData() + { + case ID_USAC_SCE: // UsacSingleChannelElement() + { + m_auBitStream.write (CORE_MODE_FD, 1); + m_auBitStream.write (elData->tnsActive ? 1 : 0, 1); // tns_data_present + bitCount += 2; + bitCount += writeFDChannelStream (*elData, entropyCoder[ci], 0, + mdctSignals[ci], mdctQuantMag[ci], +#if !RESTRICT_TO_AAC + tw_mdct[el], noiseFilling[el], +#endif + usacIndependencyFlag); + ci++; + break; + } + case ID_USAC_CPE: // UsacChannelPairElement() + { + m_auBitStream.write (CORE_MODE_FD, 1); // L + m_auBitStream.write (CORE_MODE_FD, 1); // R + bitCount += 2; + bitCount += writeStereoCoreToolInfo (*elData, +#if !RESTRICT_TO_AAC + tw_mdct[el], +#endif + usacIndependencyFlag); + bitCount += writeFDChannelStream (*elData, entropyCoder[ci], 0, // L + mdctSignals[ci], mdctQuantMag[ci], +#if !RESTRICT_TO_AAC + tw_mdct[el], noiseFilling[el], +#endif + usacIndependencyFlag); + ci++; + bitCount += writeFDChannelStream (*elData, entropyCoder[ci], 1, // R + mdctSignals[ci], mdctQuantMag[ci], +#if !RESTRICT_TO_AAC + tw_mdct[el], noiseFilling[el], +#endif + usacIndependencyFlag); + ci++; + break; + } + case ID_USAC_LFE: // UsacLfeElement() + { + bitCount += writeFDChannelStream (*elData, entropyCoder[ci], 0, + mdctSignals[ci], mdctQuantMag[ci], +#if !RESTRICT_TO_AAC + false, false, +#endif + usacIndependencyFlag); + ci++; + break; + } + default: break; + } + } // for el + + bitCount += (8 - m_auBitStream.heldBitCount) & 7; + writeByteAlignment (); // flush bytes + + memcpy (accessUnit, &m_auBitStream.stream.front (), __min (768 * ci, bitCount >> 3)); + + return (bitCount >> 3); // byte count +} diff --git a/src/lib/bitStreamWriter.h b/src/lib/bitStreamWriter.h new file mode 100644 index 0000000..b34f1ce --- /dev/null +++ b/src/lib/bitStreamWriter.h @@ -0,0 +1,74 @@ +/* bitStreamWriter.h - header file for class with basic bit-stream writing capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _BIT_STREAM_WRITER_H_ +#define _BIT_STREAM_WRITER_H_ + +#include "exhaleLibPch.h" +#include "entropyCoding.h" + +// constants, experimental macros +#define CORE_MODE_FD 0 +#define ID_EXT_LOUDNESS_INFO 2 +#define ID_EXT_ELE_FILL 0 +#define SFB_PER_PRED_BAND 2 + +// output bit-stream writer class +class BitStreamWriter +{ +private: + + // member variables + OutputStream m_auBitStream; // access unit bit-stream to write + uint32_t m_frameLength; // number of samples in full frame + uint8_t m_numSwbShort; // max. SFB count in short windows + uint8_t* m_uCharBuffer; // temporary buffer for ungrouping + + // helper functions + void writeByteAlignment (); // write 0s for byte alignment + unsigned writeChannelWiseIcsInfo (const IcsInfo& icsInfo); // ics_info() + unsigned writeChannelWiseTnsData (const TnsData& tnsData, const bool eightShorts); + unsigned writeFDChannelStream (const CoreCoderData& elData, EntropyCoder& entrCoder, const unsigned ch, + const int32_t* const mdctSignal, const uint8_t* const mdctQuantMag, +#if !RESTRICT_TO_AAC + const bool timeWarping, const bool noiseFilling, +#endif + const bool indepFlag = false); + unsigned writeStereoCoreToolInfo (const CoreCoderData& elData, +#if !RESTRICT_TO_AAC + const bool timeWarping, +#endif + const bool indepFlag = false); + +public: + + // constructor + BitStreamWriter () { m_auBitStream.reset (); m_frameLength = 0; m_numSwbShort = 0; m_uCharBuffer = nullptr; } + // destructor + ~BitStreamWriter() { m_auBitStream.reset (); } + // public functions + unsigned createAudioConfig (const char samplingFrequencyIndex, const bool shortFrameLength, + const uint8_t chConfigurationIndex, const uint8_t numElements, + const ELEM_TYPE* const elementType, const bool configExtensionPresent, +#if !RESTRICT_TO_AAC + const bool* const tw_mdct /*N/A*/, const bool* const noiseFilling, +#endif + unsigned char* const audioConfig); + unsigned createAudioFrame (CoreCoderData** const elementData, EntropyCoder* const entropyCoder, + int32_t** const mdctSignals, uint8_t** const mdctQuantMag, + const bool usacIndependencyFlag, const uint8_t numElements, + const uint8_t numSwbShort, uint8_t* const tempBuffer, +#if !RESTRICT_TO_AAC + const bool* const tw_mdct /*N/A*/, const bool* const noiseFilling, +#endif + unsigned char* const audioFrame, const unsigned nSamplesInFrame = 1024); +}; // BitStreamWriter + +#endif // _BIT_STREAM_WRITER_H_ diff --git a/src/lib/entropyCoding.cpp b/src/lib/entropyCoding.cpp new file mode 100644 index 0000000..6c5f462 --- /dev/null +++ b/src/lib/entropyCoding.cpp @@ -0,0 +1,605 @@ +/* entropyCoding.cpp - source file for class with lossless entropy coding capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "entropyCoding.h" + +// ISO/IEC 14496-3, Annex 4.A.1 +static const uint32_t huffScf[INDEX_SIZE] = { // upper 3 bytes: value, lower byte: length + 0x03FFE812, 0x03FFE612, 0x03FFE712, 0x03FFE512, 0x07FFF513, 0x07FFF113, 0x07FFED13, 0x07FFF613, + 0x07FFEE13, 0x07FFEF13, 0x07FFF013, 0x07FFFC13, 0x07FFFD13, 0x07FFFF13, 0x07FFFE13, 0x07FFF713, + 0x07FFF813, 0x07FFFB13, 0x07FFF913, 0x03FFE412, 0x07FFFA13, 0x03FFE312, 0x01FFEF11, 0x01FFF011, + 0x00FFF510, 0x01FFEE11, 0x00FFF210, 0x00FFF310, 0x00FFF410, 0x00FFF110, 0x007FF60F, 0x007FF70F, + 0x003FF90E, 0x003FF50E, 0x003FF70E, 0x003FF30E, 0x003FF60E, 0x003FF20E, 0x001FF70D, 0x001FF50D, + 0x000FF90C, 0x000FF70C, 0x000FF60C, 0x0007F90B, 0x000FF40C, 0x0007F80B, 0x0003F90A, 0x0003F70A, + 0x0003F50A, 0x0001F809, 0x0001F709, 0x0000FA08, 0x0000F808, 0x0000F608, 0x00007907, 0x00003A06, + 0x00003806, 0x00001A05, 0x00000B04, 0x00000403, 0x00000001, 0x00000A04, 0x00000C04, 0x00001B05, 0x00003906, + 0x00003B06, 0x00007807, 0x00007A07, 0x0000F708, 0x0000F908, 0x0001F609, 0x0001F909, 0x0003F40A, + 0x0003F60A, 0x0003F80A, 0x0007F50B, 0x0007F40B, 0x0007F60B, 0x0007F70B, 0x000FF50C, 0x000FF80C, + 0x001FF40D, 0x001FF60D, 0x001FF80D, 0x003FF80E, 0x003FF40E, 0x00FFF010, 0x007FF40F, 0x00FFF610, + 0x007FF50F, 0x03FFE212, 0x07FFD913, 0x07FFDA13, 0x07FFDB13, 0x07FFDC13, 0x07FFDD13, 0x07FFDE13, + 0x07FFD813, 0x07FFD213, 0x07FFD313, 0x07FFD413, 0x07FFD513, 0x07FFD613, 0x07FFF213, 0x07FFDF13, + 0x07FFE713, 0x07FFE813, 0x07FFE913, 0x07FFEA13, 0x07FFEB13, 0x07FFE613, 0x07FFE013, 0x07FFE113, + 0x07FFE213, 0x07FFE313, 0x07FFE413, 0x07FFE513, 0x07FFD713, 0x07FFEC13, 0x07FFF413, 0x07FFF313 +}; + +// ISO/IEC 23003-3, Annex C.1 +static const uint8_t arithLookupM[ARITH_SIZE] = { // arith_lookup_m + 0x01, 0x34, 0x0D, 0x13, 0x12, 0x25, 0x00, 0x3A, 0x05, 0x00, 0x21, 0x13, 0x1F, 0x1A, 0x1D, 0x36, + 0x24, 0x2B, 0x1B, 0x33, 0x37, 0x29, 0x1D, 0x33, 0x37, 0x33, 0x37, 0x33, 0x37, 0x33, 0x2C, 0x00, + 0x21, 0x13, 0x25, 0x2A, 0x00, 0x21, 0x24, 0x12, 0x2C, 0x1E, 0x37, 0x24, 0x1F, 0x35, 0x37, 0x24, + 0x35, 0x37, 0x35, 0x37, 0x38, 0x2D, 0x21, 0x29, 0x1E, 0x21, 0x13, 0x2D, 0x36, 0x38, 0x29, 0x36, + 0x37, 0x24, 0x36, 0x38, 0x37, 0x38, 0x00, 0x20, 0x23, 0x20, 0x23, 0x36, 0x38, 0x24, 0x3B, 0x24, + 0x26, 0x29, 0x1F, 0x30, 0x2D, 0x0D, 0x12, 0x3F, 0x2D, 0x21, 0x1C, 0x2A, 0x00, 0x21, 0x12, 0x1E, + 0x36, 0x38, 0x36, 0x37, 0x3F, 0x1E, 0x0D, 0x1F, 0x2A, 0x1E, 0x21, 0x24, 0x12, 0x2A, 0x3C, 0x21, + 0x24, 0x1F, 0x3C, 0x21, 0x29, 0x36, 0x38, 0x36, 0x37, 0x38, 0x21, 0x1E, 0x00, 0x3B, 0x25, 0x1E, + 0x20, 0x10, 0x1F, 0x3C, 0x20, 0x23, 0x29, 0x08, 0x23, 0x12, 0x08, 0x23, 0x21, 0x38, 0x00, 0x20, + 0x13, 0x20, 0x3B, 0x1C, 0x20, 0x3B, 0x29, 0x20, 0x23, 0x24, 0x21, 0x24, 0x21, 0x24, 0x3B, 0x13, + 0x23, 0x26, 0x23, 0x13, 0x21, 0x24, 0x26, 0x29, 0x12, 0x22, 0x2B, 0x02, 0x1E, 0x0D, 0x1F, 0x2D, + 0x00, 0x0D, 0x12, 0x00, 0x3C, 0x21, 0x29, 0x3C, 0x21, 0x2A, 0x3C, 0x3B, 0x22, 0x1E, 0x20, 0x10, + 0x1F, 0x3C, 0x0D, 0x29, 0x3C, 0x21, 0x24, 0x08, 0x23, 0x20, 0x38, 0x39, 0x3C, 0x20, 0x13, 0x3C, + 0x00, 0x0D, 0x13, 0x1F, 0x3C, 0x09, 0x26, 0x1F, 0x08, 0x09, 0x26, 0x12, 0x08, 0x23, 0x29, 0x20, + 0x23, 0x21, 0x24, 0x20, 0x13, 0x20, 0x3B, 0x16, 0x20, 0x3B, 0x29, 0x20, 0x3B, 0x29, 0x20, 0x3B, + 0x13, 0x21, 0x24, 0x29, 0x0B, 0x13, 0x09, 0x3B, 0x13, 0x09, 0x3B, 0x13, 0x21, 0x3B, 0x13, 0x0D, + 0x26, 0x29, 0x26, 0x29, 0x3D, 0x12, 0x22, 0x28, 0x2E, 0x04, 0x08, 0x13, 0x3C, 0x3B, 0x3C, 0x20, + 0x10, 0x3C, 0x21, 0x07, 0x08, 0x10, 0x00, 0x08, 0x0D, 0x29, 0x08, 0x0D, 0x29, 0x08, 0x09, 0x13, + 0x20, 0x23, 0x39, 0x08, 0x09, 0x13, 0x08, 0x09, 0x16, 0x08, 0x09, 0x10, 0x12, 0x20, 0x3B, 0x3D, + 0x09, 0x26, 0x20, 0x3B, 0x24, 0x39, 0x09, 0x26, 0x20, 0x0D, 0x13, 0x00, 0x09, 0x13, 0x20, 0x0D, + 0x26, 0x12, 0x20, 0x3B, 0x13, 0x21, 0x26, 0x0B, 0x12, 0x09, 0x3B, 0x16, 0x09, 0x3B, 0x3D, 0x09, + 0x26, 0x0D, 0x13, 0x26, 0x3D, 0x1C, 0x12, 0x1F, 0x28, 0x2E, 0x07, 0x0B, 0x08, 0x09, 0x00, 0x39, + 0x0B, 0x08, 0x26, 0x08, 0x09, 0x13, 0x20, 0x0B, 0x39, 0x10, 0x39, 0x0D, 0x13, 0x20, 0x10, 0x12, + 0x09, 0x13, 0x20, 0x3B, 0x13, 0x09, 0x26, 0x0B, 0x09, 0x3B, 0x1C, 0x09, 0x3B, 0x13, 0x20, 0x3B, + 0x13, 0x09, 0x26, 0x0B, 0x16, 0x0D, 0x13, 0x09, 0x13, 0x09, 0x13, 0x26, 0x3D, 0x1C, 0x1F, 0x28, + 0x2E, 0x07, 0x10, 0x39, 0x0B, 0x39, 0x39, 0x13, 0x39, 0x0B, 0x39, 0x0B, 0x39, 0x26, 0x39, 0x10, + 0x20, 0x3B, 0x16, 0x20, 0x10, 0x09, 0x26, 0x0B, 0x13, 0x09, 0x13, 0x26, 0x1C, 0x0B, 0x3D, 0x1C, + 0x1F, 0x28, 0x2B, 0x07, 0x0C, 0x39, 0x0B, 0x39, 0x0B, 0x0C, 0x0B, 0x26, 0x0B, 0x26, 0x3D, 0x0D, + 0x1C, 0x14, 0x28, 0x2B, 0x39, 0x0B, 0x0C, 0x0E, 0x3D, 0x1C, 0x0D, 0x12, 0x22, 0x2B, 0x07, 0x0C, + 0x0E, 0x3D, 0x1C, 0x10, 0x1F, 0x2B, 0x0C, 0x0E, 0x19, 0x14, 0x10, 0x1F, 0x28, 0x0C, 0x0E, 0x19, + 0x14, 0x26, 0x22, 0x2B, 0x0C, 0x0E, 0x19, 0x14, 0x26, 0x28, 0x0E, 0x19, 0x14, 0x26, 0x28, 0x0E, + 0x19, 0x14, 0x28, 0x0E, 0x19, 0x14, 0x22, 0x28, 0x2B, 0x0E, 0x14, 0x2B, 0x31, 0x00, 0x3A, 0x3A, + 0x05, 0x05, 0x1B, 0x1D, 0x33, 0x06, 0x35, 0x35, 0x20, 0x21, 0x37, 0x21, 0x24, 0x05, 0x1B, 0x2C, + 0x2C, 0x2C, 0x06, 0x34, 0x1E, 0x34, 0x00, 0x08, 0x36, 0x09, 0x21, 0x26, 0x1C, 0x2C, 0x00, 0x02, + 0x02, 0x02, 0x3F, 0x04, 0x04, 0x04, 0x34, 0x39, 0x20, 0x0A, 0x0C, 0x39, 0x0B, 0x0F, 0x07, 0x07, + 0x07, 0x07, 0x34, 0x39, 0x39, 0x0A, 0x0C, 0x39, 0x0C, 0x0F, 0x07, 0x07, 0x07, 0x00, 0x39, 0x39, + 0x0C, 0x0F, 0x07, 0x07, 0x39, 0x0C, 0x0F, 0x07, 0x39, 0x0C, 0x0F, 0x39, 0x39, 0x0C, 0x0F, 0x39, + 0x0C, 0x39, 0x0C, 0x0F, 0x00, 0x11, 0x27, 0x17, 0x2F, 0x27, 0x00, 0x27, 0x17, 0x00, 0x11, 0x17, + 0x00, 0x11, 0x17, 0x11, 0x00, 0x27, 0x15, 0x11, 0x17, 0x01, 0x15, 0x11, 0x15, 0x11, 0x15, 0x15, + 0x17, 0x00, 0x27, 0x01, 0x27, 0x27, 0x15, 0x00, 0x27, 0x11, 0x27, 0x15, 0x15, 0x15, 0x27, 0x15, + 0x15, 0x15, 0x15, 0x17, 0x2F, 0x11, 0x17, 0x27, 0x27, 0x27, 0x11, 0x27, 0x15, 0x27, 0x27, 0x15, + 0x15, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, + 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, + 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x27, 0x17, 0x2F, 0x17, 0x2F, 0x2B, 0x00, 0x27, 0x00, 0x00, 0x11, + 0x15, 0x00, 0x11, 0x11, 0x27, 0x27, 0x15, 0x17, 0x15, 0x17, 0x15, 0x17, 0x27, 0x17, 0x27, 0x17, + 0x27, 0x17, 0x27, 0x17, 0x27, 0x17, 0x27, 0x17, 0x27, 0x17, 0x27, 0x17, 0x27, 0x17, 0x27, 0x17, + 0x27, 0x15, 0x27, 0x27, 0x15, 0x27 +}; + +// ISO/IEC 23003-3, Annex C.2 +static const uint32_t arithHashM[ARITH_SIZE] = { // arith_hash_m + 0x00000104, 0x0000030A, 0x00000510, 0x00000716, 0x00000A1F, 0x00000F2E, 0x00011100, 0x00111103, + 0x00111306, 0x00111436, 0x00111623, 0x00111929, 0x00111F2E, 0x0011221B, 0x00112435, 0x00112621, + 0x00112D12, 0x00113130, 0x0011331D, 0x00113535, 0x00113938, 0x0011411B, 0x00114433, 0x00114635, + 0x00114F29, 0x00116635, 0x00116F24, 0x00117433, 0x0011FF0F, 0x00121102, 0x0012132D, 0x00121436, + 0x00121623, 0x00121912, 0x0012213F, 0x0012232D, 0x00122436, 0x00122638, 0x00122A29, 0x00122F2B, + 0x0012322D, 0x00123436, 0x00123738, 0x00123B29, 0x0012411D, 0x00124536, 0x00124938, 0x00124F12, + 0x00125535, 0x00125F29, 0x00126535, 0x0012B837, 0x0013112A, 0x0013131E, 0x0013163B, 0x0013212D, + 0x0013233C, 0x00132623, 0x00132F2E, 0x0013321E, 0x00133521, 0x00133824, 0x0013411E, 0x00134336, + 0x00134838, 0x00135135, 0x00135537, 0x00135F12, 0x00137637, 0x0013FF29, 0x00140024, 0x00142321, + 0x00143136, 0x00143321, 0x00143F25, 0x00144321, 0x00148638, 0x0014FF29, 0x00154323, 0x0015FF12, + 0x0016F20C, 0x0018A529, 0x00210031, 0x0021122C, 0x00211408, 0x00211713, 0x00211F2E, 0x0021222A, + 0x00212408, 0x00212710, 0x00212F2E, 0x0021331E, 0x00213436, 0x00213824, 0x0021412D, 0x0021431E, + 0x00214536, 0x00214F1F, 0x00216637, 0x00220004, 0x0022122A, 0x00221420, 0x00221829, 0x00221F2E, + 0x0022222D, 0x00222408, 0x00222623, 0x00222929, 0x00222F2B, 0x0022321E, 0x00223408, 0x00223724, + 0x00223A29, 0x0022411E, 0x00224436, 0x00224823, 0x00225134, 0x00225621, 0x00225F12, 0x00226336, + 0x00227637, 0x0022FF29, 0x0023112D, 0x0023133C, 0x00231420, 0x00231916, 0x0023212D, 0x0023233C, + 0x00232509, 0x00232929, 0x0023312D, 0x00233308, 0x00233509, 0x00233724, 0x0023413C, 0x00234421, + 0x00234A13, 0x0023513C, 0x00235421, 0x00235F1F, 0x00236421, 0x0023FF29, 0x00240024, 0x0024153B, + 0x00242108, 0x00242409, 0x00242726, 0x00243108, 0x00243409, 0x00243610, 0x00244136, 0x00244321, + 0x00244523, 0x00244F1F, 0x00245423, 0x0024610A, 0x00246423, 0x0024FF29, 0x00252510, 0x00253121, + 0x0025343B, 0x00254121, 0x00254510, 0x00254F25, 0x00255221, 0x0025FF12, 0x00266513, 0x0027F529, + 0x0029F101, 0x002CF224, 0x00310030, 0x0031122A, 0x00311420, 0x00311816, 0x0031212C, 0x0031231E, + 0x00312408, 0x00312710, 0x0031312A, 0x0031321E, 0x00313408, 0x00313623, 0x0031411E, 0x0031433C, + 0x00320007, 0x0032122D, 0x00321420, 0x00321816, 0x0032212D, 0x0032233C, 0x00322509, 0x00322916, + 0x0032312D, 0x00323420, 0x00323710, 0x00323F2B, 0x00324308, 0x00324623, 0x00324F25, 0x00325421, + 0x00325F1F, 0x00326421, 0x0032FF29, 0x00331107, 0x00331308, 0x0033150D, 0x0033211E, 0x00332308, + 0x00332420, 0x00332610, 0x00332929, 0x0033311E, 0x00333308, 0x0033363B, 0x00333A29, 0x0033413C, + 0x00334320, 0x0033463B, 0x00334A29, 0x0033510A, 0x00335320, 0x00335824, 0x0033610A, 0x00336321, + 0x00336F12, 0x00337623, 0x00341139, 0x0034153B, 0x00342108, 0x00342409, 0x00342610, 0x00343108, + 0x00343409, 0x00343610, 0x00344108, 0x0034440D, 0x00344610, 0x0034510A, 0x00345309, 0x0034553B, + 0x0034610A, 0x00346309, 0x0034F824, 0x00350029, 0x00352510, 0x00353120, 0x0035330D, 0x00353510, + 0x00354120, 0x0035430D, 0x00354510, 0x00354F28, 0x0035530D, 0x00355510, 0x00355F1F, 0x00356410, + 0x00359626, 0x0035FF12, 0x00366426, 0x0036FF12, 0x0037F426, 0x0039D712, 0x003BF612, 0x003DF81F, + 0x00410004, 0x00411207, 0x0041150D, 0x0041212A, 0x00412420, 0x0041311E, 0x00413308, 0x00413509, + 0x00413F2B, 0x00414208, 0x00420007, 0x0042123C, 0x00421409, 0x00422107, 0x0042223C, 0x00422409, + 0x00422610, 0x0042313C, 0x00423409, 0x0042363B, 0x0042413C, 0x00424320, 0x0042463B, 0x00425108, + 0x00425409, 0x0042FF29, 0x00431107, 0x00431320, 0x0043153B, 0x0043213C, 0x00432320, 0x00432610, + 0x0043313C, 0x00433320, 0x0043353B, 0x00433813, 0x00434108, 0x00434409, 0x00434610, 0x00435108, + 0x0043553B, 0x00435F25, 0x00436309, 0x0043753B, 0x0043FF29, 0x00441239, 0x0044143B, 0x00442139, + 0x00442309, 0x0044253B, 0x00443108, 0x00443220, 0x0044353B, 0x0044410A, 0x00444309, 0x0044453B, + 0x00444813, 0x0044510A, 0x00445309, 0x00445510, 0x00445F25, 0x0044630D, 0x00450026, 0x00452713, + 0x00453120, 0x0045330D, 0x00453510, 0x00454120, 0x0045430D, 0x00454510, 0x00455120, 0x0045530D, + 0x00456209, 0x00456410, 0x0045FF12, 0x00466513, 0x0047FF22, 0x0048FF25, 0x0049F43D, 0x004BFB25, + 0x004EF825, 0x004FFF18, 0x00511339, 0x00512107, 0x00513409, 0x00520007, 0x00521107, 0x00521320, + 0x00522107, 0x00522409, 0x0052313C, 0x00523320, 0x0052353B, 0x00524108, 0x00524320, 0x00531139, + 0x00531309, 0x00532139, 0x00532309, 0x0053253B, 0x00533108, 0x0053340D, 0x00533713, 0x00534108, + 0x0053453B, 0x00534F2B, 0x00535309, 0x00535610, 0x00535F25, 0x0053643B, 0x00541139, 0x00542139, + 0x00542309, 0x00542613, 0x00543139, 0x00543309, 0x00543510, 0x00543F2B, 0x00544309, 0x00544510, + 0x00544F28, 0x0054530D, 0x0054FF12, 0x00553613, 0x00553F2B, 0x00554410, 0x0055510A, 0x0055543B, + 0x00555F25, 0x0055633B, 0x0055FF12, 0x00566513, 0x00577413, 0x0059FF28, 0x005CC33D, 0x005EFB28, + 0x005FFF18, 0x00611339, 0x00612107, 0x00613320, 0x0061A724, 0x00621107, 0x0062140B, 0x00622107, + 0x00622320, 0x00623139, 0x00623320, 0x00631139, 0x0063130C, 0x00632139, 0x00632309, 0x00633139, + 0x00633309, 0x00633626, 0x00633F2B, 0x00634309, 0x00634F2B, 0x0063543B, 0x0063FF12, 0x0064343B, + 0x00643F2B, 0x0064443B, 0x00645209, 0x00665513, 0x0066610A, 0x00666526, 0x0067A616, 0x0069843D, + 0x006CF612, 0x006EF326, 0x006FFF18, 0x0071130C, 0x00721107, 0x00722239, 0x0072291C, 0x0072340B, + 0x00731139, 0x00732239, 0x0073630B, 0x0073FF12, 0x0074430B, 0x00755426, 0x00776F28, 0x00777410, + 0x0078843D, 0x007CF416, 0x007EF326, 0x007FFF18, 0x00822239, 0x00831139, 0x0083430B, 0x0084530B, + 0x0087561C, 0x00887F25, 0x00888426, 0x008AF61C, 0x008F0018, 0x008FFF18, 0x00911107, 0x0093230B, + 0x0094530B, 0x0097743D, 0x00998C25, 0x00999616, 0x009EF825, 0x009FFF18, 0x00A3430B, 0x00A4530B, + 0x00A7743D, 0x00AA9F2B, 0x00AAA616, 0x00ABD61F, 0x00AFFF18, 0x00B3330B, 0x00B44426, 0x00B7643D, + 0x00BB971F, 0x00BBB53D, 0x00BEF512, 0x00BFFF18, 0x00C22139, 0x00C5330E, 0x00C7633D, 0x00CCAF2E, + 0x00CCC616, 0x00CFFF18, 0x00D4440E, 0x00D6420E, 0x00DDCF2E, 0x00DDD516, 0x00DFFF18, 0x00E4330E, + 0x00E6841C, 0x00EEE61C, 0x00EFFF18, 0x00F3320E, 0x00F55319, 0x00F8F41C, 0x00FAFF2E, 0x00FF002E, + 0x00FFF10C, 0x00FFF33D, 0x00FFF722, 0x00FFFF18, 0x01000232, 0x0111113E, 0x01112103, 0x0111311A, + 0x0112111A, 0x01122130, 0x01123130, 0x0112411D, 0x01131102, 0x01132102, 0x01133102, 0x01141108, + 0x01142136, 0x01143136, 0x01144135, 0x0115223B, 0x01211103, 0x0121211A, 0x01213130, 0x01221130, + 0x01222130, 0x01223102, 0x01231104, 0x01232104, 0x01233104, 0x01241139, 0x01241220, 0x01242220, + 0x01251109, 0x0125223B, 0x0125810A, 0x01283212, 0x0131111A, 0x01312130, 0x0131222C, 0x0131322A, + 0x0132122A, 0x0132222D, 0x0132322D, 0x01331207, 0x01332234, 0x01333234, 0x01341139, 0x01343134, + 0x01344134, 0x01348134, 0x0135220B, 0x0136110B, 0x01365224, 0x01411102, 0x01412104, 0x01431239, + 0x01432239, 0x0143320A, 0x01435134, 0x01443107, 0x01444134, 0x01446134, 0x0145220E, 0x01455134, + 0x0147110E, 0x01511102, 0x01521239, 0x01531239, 0x01532239, 0x01533107, 0x0155220E, 0x01555134, + 0x0157110E, 0x01611107, 0x01621239, 0x01631239, 0x01661139, 0x01666134, 0x01711107, 0x01721239, + 0x01745107, 0x0177110C, 0x01811107, 0x01821107, 0x0185110C, 0x0188210C, 0x01911107, 0x01933139, + 0x01A11107, 0x01A31139, 0x01F5220E, 0x02000001, 0x02000127, 0x02000427, 0x02000727, 0x02000E2F, + 0x02110000, 0x02111200, 0x02111411, 0x02111827, 0x02111F2F, 0x02112411, 0x02112715, 0x02113200, + 0x02113411, 0x02113715, 0x02114200, 0x02121200, 0x02121301, 0x02121F2F, 0x02122200, 0x02122615, + 0x02122F2F, 0x02123311, 0x02123F2F, 0x02124411, 0x02131211, 0x02132311, 0x02133211, 0x02184415, + 0x02211200, 0x02211311, 0x02211F2F, 0x02212311, 0x02212F2F, 0x02213211, 0x02221201, 0x02221311, + 0x02221F2F, 0x02222311, 0x02222F2F, 0x02223211, 0x02223F2F, 0x02231211, 0x02232211, 0x02232F2F, + 0x02233211, 0x02233F2F, 0x02287515, 0x022DAB17, 0x02311211, 0x02311527, 0x02312211, 0x02321211, + 0x02322211, 0x02322F2F, 0x02323311, 0x02323F2F, 0x02331211, 0x02332211, 0x02332F2F, 0x02333F2F, + 0x0237FF17, 0x02385615, 0x023D9517, 0x02410027, 0x02487827, 0x024E3117, 0x024FFF2F, 0x02598627, + 0x025DFF2F, 0x025FFF2F, 0x02687827, 0x026DFA17, 0x026FFF2F, 0x02796427, 0x027E4217, 0x027FFF2F, + 0x02888727, 0x028EFF2F, 0x028FFF2F, 0x02984327, 0x029F112F, 0x029FFF2F, 0x02A76527, 0x02AEF717, + 0x02AFFF2F, 0x02B7C827, 0x02BEF917, 0x02BFFF2F, 0x02C66527, 0x02CD5517, 0x02CFFF2F, 0x02D63227, + 0x02DDD527, 0x02DFFF2B, 0x02E84717, 0x02EEE327, 0x02EFFF2F, 0x02F54527, 0x02FCF817, 0x02FFEF2B, + 0x02FFFA2F, 0x02FFFE2F, 0x03000127, 0x03000201, 0x03111200, 0x03122115, 0x03123200, 0x03133211, + 0x03211200, 0x03213127, 0x03221200, 0x03345215, 0x04000F17, 0x04122F17, 0x043F6515, 0x043FFF17, + 0x044F5527, 0x044FFF17, 0x045F0017, 0x045FFF17, 0x046F6517, 0x04710027, 0x047F4427, 0x04810027, + 0x048EFA15, 0x048FFF2F, 0x049F4427, 0x049FFF2F, 0x04AEA727, 0x04AFFF2F, 0x04BE9C15, 0x04BFFF2F, + 0x04CE5427, 0x04CFFF2F, 0x04DE3527, 0x04DFFF17, 0x04EE4627, 0x04EFFF17, 0x04FEF327, 0x04FFFF2F, + 0x06000F27, 0x069FFF17, 0x06FFFF17, 0x08110017, 0x08EFFF15, 0xFFFFFF00 +}; + +// ISO/IEC 23003-3, Annex C.3 +static const uint16_t arithCumFreqM[64][ARITH_ESCAPE + 1] = { // arith_cf_m + { 708, 706, 579, 569, 568, 567, 479, 469, 297, 138, 97, 91, 72, 52, 38, 34, 0}, + { 7619, 6917, 6519, 6412, 5514, 5003, 4683, 4563, 3907, 3297, 3125, 3060, 2904, 2718, 2631, 2590, 0}, + { 7263, 4888, 4810, 4803, 1889, 415, 335, 327, 195, 72, 52, 49, 36, 20, 15, 14, 0}, + { 3626, 2197, 2188, 2187, 582, 57, 47, 46, 30, 12, 9, 8, 6, 4, 3, 2, 0}, + { 7806, 5541, 5451, 5441, 2720, 834, 691, 674, 487, 243, 179, 167, 139, 98, 77, 70, 0}, + { 6684, 4101, 4058, 4055, 1748, 426, 368, 364, 322, 257, 235, 232, 228, 222, 217, 215, 0}, + { 9162, 5964, 5831, 5819, 3269, 866, 658, 638, 535, 348, 258, 244, 234, 214, 195, 186, 0}, + {10638, 8491, 8365, 8351, 4418, 2067, 1859, 1834, 1190, 601, 495, 478, 356, 217, 174, 164, 0}, + {13389,10514,10032, 9961, 7166, 3488, 2655, 2524, 2015, 1140, 760, 672, 585, 426, 325, 283, 0}, + {14861,12788,12115,11952, 9987, 6657, 5323, 4984, 4324, 3001, 2205, 1943, 1764, 1394, 1115, 978, 0}, + {12876,10004, 9661, 9610, 7107, 3435, 2711, 2595, 2257, 1508, 1059, 952, 893, 753, 609, 538, 0}, + {15125,13591,13049,12874,11192, 8543, 7406, 7023, 6291, 4922, 4104, 3769, 3465, 2890, 2486, 2275, 0}, + {14574,13106,12731,12638,10453, 7947, 7233, 7037, 6031, 4618, 4081, 3906, 3465, 2802, 2476, 2349, 0}, + {15070,13179,12517,12351,10742, 7657, 6200, 5825, 5264, 3998, 3014, 2662, 2510, 2153, 1799, 1564, 0}, + {15542,14466,14007,13844,12489,10409, 9481, 9132, 8305, 6940, 6193, 5867, 5458, 4743, 4291, 4047, 0}, + {15165,14384,14084,13934,12911,11485,10844,10513,10002, 8993, 8380, 8051, 7711, 7036, 6514, 6233, 0}, + {15642,14279,13625,13393,12348, 9971, 8405, 7858, 7335, 6119, 4918, 4376, 4185, 3719, 3231, 2860, 0}, + {13408,13407,11471,11218,11217,11216, 9473, 9216, 6480, 3689, 2857, 2690, 2256, 1732, 1405, 1302, 0}, + {16098,15584,15191,14931,14514,13578,12703,12103,11830,11172,10475, 9867, 9695, 9281, 8825, 8389, 0}, + {15844,14873,14277,13996,13230,11535,10205, 9543, 9107, 8086, 7085, 6419, 6214, 5713, 5195, 4731, 0}, + {16131,15720,15443,15276,14848,13971,13314,12910,12591,11874,11225,10788,10573,10077, 9585, 9209, 0}, + {16331,16330,12283,11435,11434,11433, 8725, 8049, 6065, 4138, 3187, 2842, 2529, 2171, 1907, 1745, 0}, + {16011,15292,14782,14528,14008,12767,11556,10921,10591, 9759, 8813, 8043, 7855, 7383, 6863, 6282, 0}, + {16380,16379,15159,14610,14609,14608,12859,12111,11046, 9536, 8348, 7713, 7216, 6533, 5964, 5546, 0}, + {16367,16333,16294,16253,16222,16143,16048,15947,15915,15832,15731,15619,15589,15512,15416,15310, 0}, + {15967,15319,14937,14753,14010,12638,11787,11360,10805, 9706, 8934, 8515, 8166, 7456, 6911, 6575, 0}, + { 4906, 3005, 2985, 2984, 875, 102, 83, 81, 47, 17, 12, 11, 8, 5, 4, 3, 0}, + { 7217, 4346, 4269, 4264, 1924, 428, 340, 332, 280, 203, 179, 175, 171, 164, 159, 157, 0}, + {16010,15415,15032,14805,14228,13043,12168,11634,11265,10419, 9645, 9110, 8892, 8378, 7850, 7437, 0}, + { 8573, 5218, 5046, 5032, 2787, 771, 555, 533, 443, 286, 218, 205, 197, 181, 168, 162, 0}, + {11474, 8095, 7822, 7796, 4632, 1443, 1046, 1004, 748, 351, 218, 194, 167, 121, 93, 83, 0}, + {16152,15764,15463,15264,14925,14189,13536,13070,12846,12314,11763,11277,11131,10777,10383,10011, 0}, + {14187,11654,11043,10919, 8498, 4885, 3778, 3552, 2947, 1835, 1283, 1134, 998, 749, 585, 514, 0}, + {14162,11527,10759,10557, 8601, 5417, 4105, 3753, 3286, 2353, 1708, 1473, 1370, 1148, 959, 840, 0}, + {16205,15902,15669,15498,15213,14601,14068,13674,13463,12970,12471,12061,11916,11564,11183,10841, 0}, + {15043,12972,12092,11792,10265, 7446, 5934, 5379, 4883, 3825, 3036, 2647, 2507, 2185, 1901, 1699, 0}, + {15320,13694,12782,12352,11191, 8936, 7433, 6671, 6255, 5366, 4622, 4158, 4020, 3712, 3420, 3198, 0}, + {16255,16020,15768,15600,15416,14963,14440,14006,13875,13534,13137,12697,12602,12364,12084,11781, 0}, + {15627,14503,13906,13622,12557,10527, 9269, 8661, 8117, 6933, 5994, 5474, 5222, 4664, 4166, 3841, 0}, + {16366,16365,14547,14160,14159,14158,11969,11473, 8735, 6147, 4911, 4530, 3865, 3180, 2710, 2473, 0}, + {16257,16038,15871,15754,15536,15071,14673,14390,14230,13842,13452,13136,13021,12745,12434,12154, 0}, + {15855,14971,14338,13939,13239,11782,10585, 9805, 9444, 8623, 7846, 7254, 7079, 6673, 6262, 5923, 0}, + { 9492, 6318, 6197, 6189, 3004, 652, 489, 477, 333, 143, 96, 90, 78, 60, 50, 47, 0}, + {16313,16191,16063,15968,15851,15590,15303,15082,14968,14704,14427,14177,14095,13899,13674,13457, 0}, + { 8485, 5473, 5389, 5383, 2411, 494, 386, 377, 278, 150, 117, 112, 103, 89, 81, 78, 0}, + {10497, 7154, 6959, 6943, 3788, 1004, 734, 709, 517, 238, 152, 138, 120, 90, 72, 66, 0}, + {16317,16226,16127,16040,15955,15762,15547,15345,15277,15111,14922,14723,14671,14546,14396,14239, 0}, + {16382,16381,15858,15540,15539,15538,14704,14168,13768,13092,12452,11925,11683,11268,10841,10460, 0}, + { 5974, 3798, 3758, 3755, 1275, 205, 166, 162, 95, 35, 26, 24, 18, 11, 8, 7, 0}, + { 3532, 2258, 2246, 2244, 731, 135, 118, 115, 87, 45, 36, 34, 29, 21, 17, 16, 0}, + { 7466, 4882, 4821, 4811, 2476, 886, 788, 771, 688, 531, 469, 457, 437, 400, 369, 361, 0}, + { 9580, 5772, 5291, 5216, 3444, 1496, 1025, 928, 806, 578, 433, 384, 366, 331, 296, 273, 0}, + {10692, 7730, 7543, 7521, 4679, 1746, 1391, 1346, 1128, 692, 495, 458, 424, 353, 291, 268, 0}, + {11040, 7132, 6549, 6452, 4377, 1875, 1253, 1130, 958, 631, 431, 370, 346, 296, 253, 227, 0}, + {12687, 9332, 8701, 8585, 6266, 3093, 2182, 2004, 1683, 1072, 712, 608, 559, 458, 373, 323, 0}, + {13429, 9853, 8860, 8584, 6806, 4039, 2862, 2478, 2239, 1764, 1409, 1224, 1178, 1077, 979, 903, 0}, + {14685,12163,11061,10668, 9101, 6345, 4871, 4263, 3908, 3200, 2668, 2368, 2285, 2106, 1942, 1819, 0}, + {13295,11302,10999,10945, 7947, 5036, 4490, 4385, 3391, 2185, 1836, 1757, 1424, 998, 833, 785, 0}, + { 4992, 2993, 2972, 2970, 1269, 575, 552, 549, 530, 505, 497, 495, 493, 489, 486, 485, 0}, + {15419,13862,13104,12819,11429, 8753, 7220, 6651, 6020, 4667, 3663, 3220, 2995, 2511, 2107, 1871, 0}, + {12468, 9263, 8912, 8873, 5758, 2193, 1625, 1556, 1187, 589, 371, 330, 283, 200, 149, 131, 0}, + {15870,15076,14615,14369,13586,12034,10990,10423, 9953, 8908, 8031, 7488, 7233, 6648, 6101, 5712, 0}, + { 1693, 978, 976, 975, 194, 18, 16, 15, 11, 7, 6, 5, 4, 3, 2, 1, 0}, + { 7992, 5218, 5147, 5143, 2152, 366, 282, 276, 173, 59, 38, 35, 27, 16, 11, 10, 0} +}; + +// ISO/IEC 23003-3, Annex C.4 +static const uint16_t arithCumFreqR[3][4] = { // arith_cf_r + {12571, 10569, 3696, 0}, + {12661, 5700, 3751, 0}, + {10827, 6884, 2929, 0} +}; + +// static helper functions +static inline unsigned arithGetPkIndex (const unsigned ctx) // cumul. frequency table index pki = arith_get_pk(c) +{ + int iMax = ARITH_SIZE - 1; + int iMin = -1; + int i = iMin; + uint32_t j, k; + + while (iMax > iMin + 1) + { + i = iMin + ((iMax - iMin) >> 1); + j = arithHashM[i]; + k = j >> 8; + + if (ctx < k) iMax = i; + else if (ctx > k) iMin = i; + else return j & UCHAR_MAX; + } + + return arithLookupM[iMax]; // pki +} + +static inline unsigned writeSymbol (OutputStream* const stream, const bool leadingBitIs1, const uint16_t trailingBits) +{ + stream->write (leadingBitIs1 ? 1 : 0, 1); + stream->write (leadingBitIs1 ? 0 : (1u << trailingBits) - 1, (uint8_t) trailingBits); + + return trailingBits + 1; // count +} + +// private helper functions +unsigned EntropyCoder::arithCodeSymbol (const uint16_t symbol, const uint16_t* table, OutputStream* const stream /*= nullptr*/) +{ + const unsigned range = m_acHigh + 1 - m_acLow; + uint16_t high = m_acHigh; + uint16_t low = m_acLow; + unsigned bitCount = 0; + + if (symbol > 0) + { + high = low + ((range * table[symbol - 1]) >> 14) - 1; + } + low += (range * table[symbol]) >> 14; // NOTE: the spec incorrectly reads "[symbol-1]" here + + if (stream != nullptr) // write-out + { + while (true) + { + if (high <= SHRT_MAX) + { + bitCount += writeSymbol (stream, false, m_acBits); + m_acBits = 0; + } + else if (low > SHRT_MAX) + { + bitCount += writeSymbol (stream, true, m_acBits); + m_acBits = 0; + + high += SHRT_MIN; + low += SHRT_MIN; + } + else if ((low > (SHRT_MAX >> 1)) && (high < ((-3 * SHRT_MIN) >> 1))) + { + m_acBits++; + + high += SHRT_MIN >> 1; + low += SHRT_MIN >> 1; + } + else break; + + high <<= 1; high |= 1; + low <<= 1; + } + } + else // stream == nullptr, counting + { + while (true) + { + if (high <= SHRT_MAX) + { + bitCount += m_acBits + 1; + m_acBits = 0; + } + else if (low > SHRT_MAX) + { + bitCount += m_acBits + 1; + m_acBits = 0; + + high += SHRT_MIN; + low += SHRT_MIN; + } + else if ((low > (SHRT_MAX >> 1)) && (high < ((-3 * SHRT_MIN) >> 1))) + { + m_acBits++; + + high += SHRT_MIN >> 1; + low += SHRT_MIN >> 1; + } + else break; + + high <<= 1; high |= 1; + low <<= 1; + } + } + m_acHigh = high; + m_acLow = low; + + return bitCount; +} + +unsigned EntropyCoder::arithGetContext (const unsigned ctx, const unsigned idx) // c = arith_get_context(c, i, N) +{ + unsigned c = (ctx & 0xFFFF) >> 4; // NOTE: the "& 0xFFFF" was part of some USAC corrigendum + + c = (c | ((unsigned) m_qcPrev[idx + 1] << 12)) & 0xFFF0; // add top-left previous neighbor + + if (idx > 0) // lower neighbor(s) + { + c |= (unsigned) m_qcCurr[idx - 1]; + + if ((idx > 3) && (m_qcCurr[idx - 3] + m_qcCurr[idx - 2] + m_qcCurr[idx - 1] < 5)) + { + return c | 0x10000; + } + } + return c; // updated context ctx +} + +unsigned EntropyCoder::arithMapContext (const bool arithResetFlag) // c = arith_map_context(N, arith_reset_flag) +{ + if (arithResetFlag) + { + memset (m_qcPrev, 0, m_maxTupleLength * sizeof (uint8_t)); + } + else if (m_shortTrafoCurr == m_shortTrafoPrev) + { + memcpy (m_qcPrev, m_qcCurr, m_acSize * sizeof (uint8_t)); + } + else if (m_shortTrafoCurr && !m_shortTrafoPrev) + { + for (int i = m_acSize - 1; i >= 0; i--) + { + m_qcPrev[i] = m_qcCurr[i << 3]; + } + } + else // (!m_shortTrafoCurr && m_shortTrafoPrev) + { + for (int i = m_acSize - 1; i >= 0; i--) + { + m_qcPrev[i] = m_qcCurr[i >> 3]; + } + } + m_qcPrev[m_acSize] = 0; // for encoder speed-up + + return (unsigned) m_qcPrev[0] << 12; // initial context ctx with top-left previous neighbor +} + +#if EC_TRELLIS_OPT_CODING +void EntropyCoder::arithSetContext (const unsigned newCtxState, const uint16_t sigEnd) +{ + m_csCurr = newCtxState; + m_acBits = (m_csCurr >> 17) & 31; + for (uint16_t s = 1; s < 4; s++) + { + if (sigEnd >= s) m_qcCurr[sigEnd - s] = (m_csCurr >> (18 + 4 * s)) & 0xF; + } +} +#endif + +// constructor +EntropyCoder::EntropyCoder () +{ + // initialize all helper buffers + m_qcCurr = nullptr; + m_qcPrev = nullptr; + + // initialize encoding variables + m_acBits = 0; + m_acHigh = USHRT_MAX; + m_acLow = 0; + m_acSize = 0; + m_csCurr = 0; + m_maxTupleLength = 0; + m_shortTrafoCurr = false; + m_shortTrafoPrev = false; +} + +// destructor +EntropyCoder::~EntropyCoder () +{ + // free allocated helper buffers + MFREE (m_qcCurr); + MFREE (m_qcPrev); +} + +// public functions +unsigned EntropyCoder::arithCodeSigMagn (const uint8_t* const magn, const uint16_t sigOffset, const uint16_t sigLength, + const bool arithFinish /*= false*/, OutputStream* const stream /*= nullptr*/) +{ + const uint8_t* a = &magn[sigOffset ]; + const uint8_t* b = &magn[sigOffset + 1]; + unsigned c = m_csCurr & 0x1FFFF; + unsigned bitCount = 0; + uint16_t r[7]; + uint16_t sigEnd = (sigOffset >> 1) + (sigLength >> 1); + + if (arithFinish && (sigLength > 0)) // try to save bits via signalling of ARITH_STOP symbol + { + int i = sigLength - 2; + + while ((i >= 0) && ((a[i] | b[i]) == 0)) i -= 2; + i = (sigOffset + i + 2) >> 1; + + if (i + 28 < (int) sigEnd) sigEnd = (uint16_t) i; + } + + for (uint16_t s = sigOffset >> 1; s < sigEnd; s++) + { + uint32_t lev = 0; + uint16_t a1 = *a; + uint16_t b1 = *b; + + a += 2; b += 2; + + // arith_get_context, cf Scl. 7.4 + c = arithGetContext (c, s); + // arith_update_context, Scl. 7.4 + m_qcCurr[s] = __min (0xF, a1 + b1 + 1); + + // MSB encoding as in Scl. B.25.3 + while ((a1 > 3) || (b1 > 3)) + { + // write escaped codeword value + bitCount += arithCodeSymbol (ARITH_ESCAPE, arithCumFreqM[arithGetPkIndex (c | (lev << 17))], stream); + // store LSBs in r, right-shift + r[lev++] = (a1 & 1) | ((b1 & 1) << 1); + a1 >>= 1; b1 >>= 1; + } + // write the m MSB codeword value + bitCount += arithCodeSymbol (a1 | (b1 << 2), arithCumFreqM[arithGetPkIndex (c | (lev << 17))], stream); + + // LSB encoding, Table 38, B.25.3 + while (lev--) + { + const uint16_t rLev = r[lev]; + + bitCount += arithCodeSymbol (rLev, arithCumFreqR[a1 == 0 ? 1 : (b1 == 0 ? 0 : 2)], stream); + a1 = (a1 << 1) | (rLev & 1); + b1 = (b1 << 1) | ((rLev >> 1) & 1); + } + } // for s + + if (arithFinish) // flush last bits + { + // NOTE: the spec incorrectly reads "m_acBits" below (bits_to_follow++ missing in B.25.3) + if (sigLength > 0) + { + if (sigEnd < (sigOffset >> 1) + (sigLength >> 1)) // write ARITH_STOP flag to save bits + { + c = arithGetContext (c, sigEnd); + bitCount += arithCodeSymbol (ARITH_ESCAPE, arithCumFreqM[arithGetPkIndex (c)], stream); + bitCount += arithCodeSymbol (0 /*m=STOP*/, arithCumFreqM[arithGetPkIndex (c | (1 << 17))], stream); + } + bitCount += writeSymbol (stream, m_acLow > (SHRT_MAX >> 1), m_acBits + 1); + } + m_csCurr = m_acBits = 0; + } + else + { + m_csCurr = 0; + + for (uint16_t s = 1; s < 4; s++) + { + if (sigEnd >= s) m_csCurr |= __min (255u >> (2 * s), m_qcCurr[sigEnd - s]) << (18 + 4 * s); + } + } + m_csCurr |= ((unsigned) m_acBits << 17) | c; + + return bitCount; +} + +unsigned EntropyCoder::arithGetResetBit (const uint8_t* const magn, const uint16_t sigOffset, const uint16_t sigLength) +{ + const uint16_t sigEnd = (sigOffset >> 1) + (sigLength >> 1); + const uint8_t* a = &magn[sigOffset ]; + const uint8_t* b = &magn[sigOffset + 1]; + unsigned qcDiff = 0; + + for (uint16_t s = sigOffset >> 1; s < sigEnd; s++) + { + const int qcCurrS = __min (0xF, (int)*a + (int)*b); + const int qcDiffS = qcCurrS - m_qcPrev[s]; + + qcDiff += qcDiffS * qcDiffS; + a += 2; b += 2; + } + + return (qcDiff * 2u > sigLength * 7u ? 1 : 0); // use reset if difference exceeds threshold +} + +unsigned EntropyCoder::indexGetBitCount (const int scaleFactorDelta) const +{ + return huffScf[CLIP_PM (scaleFactorDelta, INDEX_OFFSET) + INDEX_OFFSET] & UCHAR_MAX; +} + +unsigned EntropyCoder::indexGetHuffCode (const int scaleFactorDelta) const +{ + return huffScf[CLIP_PM (scaleFactorDelta, INDEX_OFFSET) + INDEX_OFFSET] >> 8; +} + +unsigned EntropyCoder::initCodingMemory (const unsigned maxTransfLength) +{ + const unsigned max2TupleLength = maxTransfLength >> 1; // tuple buffer size, maxWinLength/4 + + if ((maxTransfLength < 128) || (maxTransfLength > 8192) || (maxTransfLength & 7)) + { + return 1; // invalid arguments error + } + + m_maxTupleLength = max2TupleLength; + MFREE (m_qcCurr); + MFREE (m_qcPrev); + + if ((m_qcCurr = (uint8_t*) malloc (max2TupleLength * sizeof (uint8_t))) == nullptr || + (m_qcPrev = (uint8_t*) malloc ((max2TupleLength + 1) * sizeof (uint8_t))) == nullptr) + { + return 2; // memory allocation error + } + + memset (m_qcCurr, 0, max2TupleLength * sizeof (uint8_t)); + + return 0; // no error +} + +unsigned EntropyCoder::initWindowCoding (const bool forceArithReset, const bool shortWin /*= false*/) +{ + // arith_first_symbol() in Scl. B.25.3 + m_acBits = 0; + m_acHigh = USHRT_MAX; + m_acLow = 0; + m_acSize = (shortWin ? m_maxTupleLength >> 3 : m_maxTupleLength); + + m_shortTrafoPrev = m_shortTrafoCurr; + m_shortTrafoCurr = shortWin; + + m_csCurr = arithMapContext (forceArithReset); // m_qcPrev + memset (m_qcCurr, 1, m_acSize * sizeof (uint8_t)); // reset m_qcCurr, see also arith_finish + + return 0; // no error +} diff --git a/src/lib/entropyCoding.h b/src/lib/entropyCoding.h new file mode 100644 index 0000000..5b2e989 --- /dev/null +++ b/src/lib/entropyCoding.h @@ -0,0 +1,79 @@ +/* entropyCoding.h - header file for class with lossless entropy coding capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _ENTROPY_CODING_H_ +#define _ENTROPY_CODING_H_ + +#include "exhaleLibPch.h" + +// constants, experimental macro +#define ARITH_ESCAPE 16 +#define ARITH_SIZE 742 +#define INDEX_OFFSET 60 +#define INDEX_SIZE 121 +#define EC_TRELLIS_OPT_CODING 1 + +// lossless entropy coding class +class EntropyCoder +{ +private: + + // member variables + uint8_t* m_qcCurr; // curr. window's quantized context q[1] + uint8_t* m_qcPrev; // prev. window's quantized context q[0] + + uint16_t m_acBits; // bits_to_follow in arith_encode, 0..31 + uint16_t m_acHigh; // high in arith_encode as in Annex B.25 + uint16_t m_acLow; // low in arith_encode, as in Annex B.25 + uint16_t m_acSize; // context window size (N/4 in Scl. 7.4) + uint32_t m_csCurr; // context state, see initWindowCoding() + unsigned m_maxTupleLength; // maximum half-transform length (<4096) + bool m_shortTrafoCurr; // used to derive N in Scl. 7.4 and B.25 + bool m_shortTrafoPrev; // used to derive previous_N in Scl. 7.4 + + // helper functions + unsigned arithCodeSymbol (const uint16_t symbol, const uint16_t* table, OutputStream* const stream = nullptr); + unsigned arithGetContext (const unsigned ctx, const unsigned idx); + unsigned arithMapContext (const bool arithResetFlag); +#if EC_TRELLIS_OPT_CODING + void arithSetContext (const unsigned newCtxState, const uint16_t sigEnd); +#endif + +public: + + // constructor + EntropyCoder (); + // destructor + ~EntropyCoder (); + // public functions + unsigned arithCodeSigMagn (const uint8_t* const magn, const uint16_t sigOffset, const uint16_t sigLength, + const bool arithFinish = false, OutputStream* const stream = nullptr); + unsigned arithGetCodState () const { return ((unsigned) m_acHigh << 16) | (unsigned) m_acLow; } + unsigned arithGetCtxState () const { return m_csCurr; } + unsigned arithGetResetBit (const uint8_t* const magn, const uint16_t sigOffset, const uint16_t sigLength); + char* arithGetTuplePtr () const { return (char*) m_qcCurr; } + void arithResetMemory () { memset (m_qcPrev, 0, (m_maxTupleLength + 1) * sizeof (uint8_t)); m_acBits = 0; } + void arithSetCodState (const unsigned newCodState) { m_acHigh = newCodState >> 16; m_acLow = newCodState & USHRT_MAX; } +#if EC_TRELLIS_OPT_CODING + void arithSetCtxState (const unsigned newCtxState, const uint16_t sigOffset = 0) { arithSetContext (newCtxState, sigOffset >> 1); } +#else + void arithSetCtxState (const unsigned newCtxState) { m_csCurr = newCtxState; } +#endif + unsigned indexGetBitCount (const int scaleFactorDelta) const; + unsigned indexGetHuffCode (const int scaleFactorDelta) const; + + unsigned initCodingMemory (const unsigned maxTransfLength); + unsigned initWindowCoding (const bool forceArithReset, const bool shortWin = false); + + bool getIsShortWindow () const { return m_shortTrafoCurr; } + void setIsShortWindow (const bool shortWin) { m_shortTrafoCurr = shortWin; } +}; // EntropyCoder + +#endif // _ENTROPY_CODING_H_ diff --git a/src/lib/exhaleEnc.cpp b/src/lib/exhaleEnc.cpp new file mode 100644 index 0000000..20b864f --- /dev/null +++ b/src/lib/exhaleEnc.cpp @@ -0,0 +1,1590 @@ +/* exhaleEnc.cpp - source file for class providing Extended HE-AAC encoding capability + * written by C. R. Helmrich, last modified 2019 - see License.txt for legal notices + * + * The copyright in this software is being made available under a Modified BSD License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2019 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "exhaleEnc.h" + +// static helper functions +static double modifiedBesselFunctionOfFirstKind (const double x) +{ + const double xOver2 = x * 0.5; + double d = 1.0, sum = 1.0; + int i = 0; + + do + { + const double x2di = xOver2 / double (++i); + + d *= (x2di * x2di); + sum += d; + } + while (d > sum * 1.2e-38); // FLT_MIN + + return sum; +} + +static int32_t* initWindowHalfCoeffs (const USAC_WSHP windowShape, const unsigned frameLength) +{ + int32_t* windowBuf = nullptr; + unsigned u; + + if ((windowBuf = (int32_t*) malloc (frameLength * sizeof (int32_t))) == nullptr) + { + return nullptr; // allocation error + } + + if (windowShape == WINDOW_SINE) + { + const double dNorm = 3.141592653589793 / (2.0 * frameLength); + // MLT sine window half + for (u = 0; u < frameLength; u++) + { + windowBuf[u] = int32_t (sin (dNorm * (u + 0.5)) * WIN_SCALE + 0.5); + } + } + else // if windowShape == WINDOW_KBD + { + const double alpha = 3.141592653589793 * (frameLength > 256 ? 4.0 : 6.0); + const double dBeta = 1.0 / modifiedBesselFunctionOfFirstKind (alpha /*sqrt (1.0)*/); + const double dNorm = 4.0 / (2.0 * frameLength); + const double iScal = double (1u << 30); + const double dScal = 1.0 / iScal; + double d, sum = 0.0; + // create Kaiser-Bessel window half + for (u = 0; u < frameLength; u++) + { + const double du1 = dNorm * u - 1.0; + + d = dBeta * modifiedBesselFunctionOfFirstKind (alpha * sqrt (1.0 - du1 * du1)); + sum += d; + windowBuf[u] = int32_t (d * iScal + 0.5); + } + d = 1.0 / sum; // normalized to sum + sum = 0.0; + // KBD window half + for (u = 0; u < frameLength; u++) + { + sum += dScal * windowBuf[u]; + windowBuf[u] = int32_t (sqrt (d * sum /*cumulative sum*/) * WIN_SCALE + 0.5); + } + } + return windowBuf; +} + +static uint32_t quantizeSfbWithMinSnr (const unsigned* const coeffMagn, const uint16_t* const sfbOffset, const unsigned b, + const unsigned char groupLength, unsigned char* const quantMagn, char* const arithTuples, + const bool nonZeroSnr = false) +{ + const unsigned short sfbStart = sfbOffset[b]; + const unsigned short sfbWidth = sfbOffset[b + 1] - sfbStart; + const unsigned* const sfbMagn = &coeffMagn[sfbStart]; + uint32_t maxIndex = 0, maxLevel = sfbMagn[0]; + + for (unsigned short s = sfbWidth - 1; s > 0; s--) + { + if (maxLevel < sfbMagn[s]) // find largest-level magn. in SFB + { + maxLevel = sfbMagn[s]; + maxIndex = s; + } + } + if (quantMagn != nullptr) // update quantized sample magnitudes + { + memset (&quantMagn[sfbStart], 0, sfbWidth * sizeof (unsigned char)); + + if (nonZeroSnr) quantMagn[sfbStart + maxIndex] = 1; // magn. 1 + } + + if (arithTuples != nullptr) // update entropy coding two-tuples + { + const unsigned short swbStart = ((sfbStart - sfbOffset[0]) * oneTwentyEightOver[groupLength]) >> 7; + + memset (&arithTuples[swbStart >> 1], 1, ((sfbWidth * oneTwentyEightOver[groupLength]) >> 8) * sizeof (char)); + + if (nonZeroSnr && (groupLength == 1)) // max. two-tuple is 1+1 + { + arithTuples[(swbStart + maxIndex) >> 1] = 2; + } + } + + return maxLevel; +} + +// inline helper functions +static inline unsigned char brModeAndFsToMaxSfbLong (const unsigned bitRateMode, const unsigned samplingRate) +{ + // max. for fs of 44 kHz: band 47 (19.3 kHz), 48 kHz: 45 (19.5 kHz), 64 kHz: 39 (22.0 kHz) + return __max (39, (0x20A000 + (samplingRate >> 1)) / samplingRate) - 9 + bitRateMode - (samplingRate < 48000 ? bitRateMode >> 3 : 0); +} + +static inline unsigned char brModeAndFsToMaxSfbShort(const unsigned bitRateMode, const unsigned samplingRate) +{ + // max. for fs of 44 kHz: band 13 (19.3 kHz), 48 kHz: 13 (21.0 kHz), 64 kHz: 11 (23.0 kHz) + return (samplingRate > 51200 ? 11 : 13) - 2 + (bitRateMode >> 2); +} + +static inline uint32_t getComplexRmsValue (const uint32_t rmsValue, const unsigned sfbGroup, const unsigned sfbIndex, + const unsigned char numSwb, const TnsData& tnsData) +{ + // compensate for missing MDST coefficients in RMS calculation of SFBs where TNS is active + return ((tnsData.numFilters > 0) && (sfbGroup == tnsData.filteredWindow) && (rmsValue <= UINT_MAX / 3) && + (tnsData.filterLength[0] + sfbIndex >= numSwb) ? (rmsValue * 3u) >> 1 : rmsValue); +} + +// ISO/IEC 23003-3, Table 75 +static inline unsigned toFrameLength (const USAC_CCFL coreCoderFrameLength) +{ + return (unsigned) coreCoderFrameLength; +} + +// ISO/IEC 23003-3, Table 73 +static const unsigned char numberOfChannels[USAC_MAX_NUM_ELCONFIGS] = {0, 1, 2, 3, 4, 5, 6, 8, 2, 3, 4, 7, 8}; + +static inline unsigned toNumChannels (const USAC_CCI chConfigurationIndex) +{ + return numberOfChannels[__max (0, (char) chConfigurationIndex)]; +} + +// ISO/IEC 23003-3, Table 68 +static const unsigned char elementCountConfig[USAC_MAX_NUM_ELCONFIGS] = {0, 1, 1, 2, 3, 3, 4, 5, 2, 2, 2, 5, 5}; + +static const ELEM_TYPE elementTypeConfig[USAC_MAX_NUM_ELCONFIGS][USAC_MAX_NUM_ELEMENTS] = { + {ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_UNDEF + {ID_USAC_SCE, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_1_CH + {ID_USAC_CPE, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_2_CH + {ID_USAC_SCE, ID_USAC_CPE, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_3_CH + {ID_USAC_SCE, ID_USAC_CPE, ID_USAC_SCE, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_4_CH + {ID_USAC_SCE, ID_USAC_CPE, ID_USAC_CPE, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_5_CH + {ID_USAC_SCE, ID_USAC_CPE, ID_USAC_CPE, ID_USAC_LFE, ID_EL_UNDEF}, // CCI_6_CH + {ID_USAC_SCE, ID_USAC_CPE, ID_USAC_CPE, ID_USAC_CPE, ID_USAC_LFE}, // CCI_8_CH + {ID_USAC_SCE, ID_USAC_SCE, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_2_CHM + {ID_USAC_CPE, ID_USAC_SCE, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_3_CHR + {ID_USAC_CPE, ID_USAC_CPE, ID_EL_UNDEF, ID_EL_UNDEF, ID_EL_UNDEF}, // CCI_4_CHR + {ID_USAC_SCE, ID_USAC_CPE, ID_USAC_CPE, ID_USAC_SCE, ID_USAC_LFE}, // CCI_7_CH + {ID_USAC_SCE, ID_USAC_CPE, ID_USAC_CPE, ID_USAC_CPE, ID_USAC_LFE} // CCI_8_CHM +}; + +// ISO/IEC 14496-3, Table 4.140 +static const unsigned short sfbOffsetL0[42] = { // 88.2 and 96 kHz + 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, 108, + 120, 132, 144, 156, 172, 188, 212, 240, 276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024 +}; +// ISO/IEC 14496-3, Table 4.141 +static const unsigned short sfbOffsetS0[13] = { + 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 +}; + +// ISO/IEC 14496-3, Table 4.138 +static const unsigned short sfbOffsetL1[48] = { // 64 kHz + 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 100, 112, 124, 140, 156, + 172, 192, 216, 240, 268, 304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824, 864, 904, 944, 984, 1024 +}; +// ISO/IEC 14496-3, Table 4.139 +static const unsigned short sfbOffsetS1[13] = { + 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 +}; + +// ISO/IEC 14496-3, Table 4.131 +static const unsigned short sfbOffsetL2[52] = { // 32, 44.1, and 48 kHz + 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, + 264, 292, 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800, 832, 864, 896, 928, 960/*!*/, 992/*!*/, 1024 +}; +// ISO/IEC 14496-3, Table 4.130 +static const unsigned short sfbOffsetS2[15] = { + 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128 +}; + +// ISO/IEC 14496-3, Table 4.136 +static const unsigned short sfbOffsetL3[48] = { // 22.05 and 24 kHz + 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 136, 148, + 160, 172, 188, 204, 220, 240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704, 768, 832, 896, 960, 1024 +}; +// ISO/IEC 14496-3, Table 4.137 +static const unsigned short sfbOffsetS3[16] = { + 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128 +}; + +// ISO/IEC 14496-3, Table 4.134 +static const unsigned short sfbOffsetL4[44] = { // 11.025, 12, and 16 kHz + 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124, 136, 148, 160, 172, 184, 196, 212, + 228, 244, 260, 280, 300, 320, 344, 368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024 +}; +// ISO/IEC 14496-3, Table 4.135 +static const unsigned short sfbOffsetS4[16] = { + 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128 +}; + +// ISO/IEC 14496-3, Table 4.132 +static const unsigned short sfbOffsetL5[41] = { // 8 kHz + 0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172, 188, 204, 220, 236, 252, 268, + 288, 308, 328, 348, 372, 396, 420, 448, 476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024 +}; +// ISO/IEC 14496-3, Table 4.133 +static const unsigned short sfbOffsetS5[16] = { + 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128 +}; + +// long-window SFB offset tables +static const unsigned short* swbOffsetsL[USAC_NUM_FREQ_TABLES] = { + sfbOffsetL0, sfbOffsetL1, sfbOffsetL2, sfbOffsetL3, sfbOffsetL4, sfbOffsetL5 +}; +static const unsigned char numSwbOffsetL[USAC_NUM_FREQ_TABLES] = {42, 48, 52, 48, 44, 41}; + +// short-window SFB offset tables +static const unsigned short* swbOffsetsS[USAC_NUM_FREQ_TABLES] = { + sfbOffsetS0, sfbOffsetS1, sfbOffsetS2, sfbOffsetS3, sfbOffsetS4, sfbOffsetS5 +}; +static const unsigned char numSwbOffsetS[USAC_NUM_FREQ_TABLES] = {13, 13, 15, 16, 16, 16}; + +// ISO/IEC 23003-3, Table 79 +static const unsigned char freqIdxToSwbTableIdxAAC[USAC_NUM_SAMPLE_RATES + 2] = { + /*96000*/ 0, 0, 1, 2, 2, 2,/*24000*/ 3, 3, 4, 4, 4, 5, 5, // AAC + 255, 255, 1, 2, 2, 2, 2, 2,/*25600*/ 3, 3, 3, 4, 4, 4, 4 // USAC +}; +#if !RESTRICT_TO_AAC +static const unsigned char freqIdxToSwbTableIdx768[USAC_NUM_SAMPLE_RATES + 2] = { + /*96000*/ 0, 0, 0, 1, 1, 2,/*24000*/ 2, 2, 3, 4, 4, 4, 4, // AAC + 255, 255, 0, 1, 2, 2, 2, 2,/*25600*/ 2, 3, 3, 3, 3, 4, 4 // USAC +}; +#endif // !RESTRICT_TO_AAC + +// ISO/IEC 23003-3, Table 131 +static const unsigned char tnsScaleFactorBandLimit[2 /*long/short*/][USAC_NUM_FREQ_TABLES] = { // TNS_MAX_BANDS +#if RESTRICT_TO_AAC + {31, 34, 51 /*to be corrected to 42 (44.1) and 40 (48 kHz)!*/, 46, 42, 39}, {9, 10, 14, 14, 14, 14} +#else + {31, 34, 51 /*to be corrected to 42 (44.1) and 40 (48 kHz)!*/, 47, 43, 40}, {9, 10, 14, 15, 15, 15} +#endif +}; + +// scale_factor_grouping map +// defines 4 groups based on the transient location: 1133, 1115, 2114, 3113, 4112, 5111, 3311, 1331 +static const unsigned char scaleFactorGrouping[8] = {0x1B, 0x0F, 0x47, 0x63, 0x71, 0x78, 0x6C, 0x36}; + +static const unsigned char windowGroupingTable[8][NUM_WINDOW_GROUPS] = { // for window_group_length + {1, 1, 3, 3}, {1, 1, 1, 5}, {2, 1, 1, 4}, {3, 1, 1, 3}, {4, 1, 1, 2}, {5, 1, 1, 1}, {3, 3, 1, 1}, {1, 3, 3, 1} +}; + +// window_sequence equalizer +static const USAC_WSEQ windowSequenceSynch[5][5] = { // first: chan. index 0, second: chan. index 1 + {ONLY_LONG, LONG_START, EIGHT_SHORT, LONG_STOP, STOP_START }, // left: ONLY_LONG +#if RESTRICT_TO_AAC + {LONG_START, LONG_START, EIGHT_SHORT, EIGHT_SHORT, STOP_START }, // Left: LONG_START +#else + {LONG_START, LONG_START, EIGHT_SHORT, STOP_START, STOP_START }, // Left: LONG_START +#endif + {EIGHT_SHORT, EIGHT_SHORT, EIGHT_SHORT, EIGHT_SHORT, EIGHT_SHORT}, // Left: EIGHT_SHORT +#if RESTRICT_TO_AAC + {LONG_STOP, EIGHT_SHORT, EIGHT_SHORT, LONG_STOP, STOP_START }, // Left: LONG_STOP +#else + {LONG_STOP, STOP_START, EIGHT_SHORT, LONG_STOP, STOP_START }, // Left: LONG_STOP +#endif + {STOP_START, STOP_START, EIGHT_SHORT, STOP_START, STOP_START } // Left: STOP_START +}; + +// private helper functions +unsigned ExhaleEncoder::applyTnsToWinGroup (TnsData& tnsData, SfbGroupData& grpData, const bool eightShorts, const unsigned char maxSfb, + const unsigned channelIndex) +{ + const unsigned short filtOrder = tnsData.filterOrder[0]; + const uint16_t* grpSO = &grpData.sfbOffsets[m_numSwbShort * tnsData.filteredWindow]; + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + unsigned errorValue = 0; // no error + + if ((maxSfb > (eightShorts ? 15 : 51)) || (channelIndex >= USAC_MAX_NUM_CHANNELS)) + { + return 1; // invalid arguments error + } + + if (filtOrder > 0) // determine TNS filter length in SFBs and apply TNS analysis filtering + { + unsigned char numSwbFrame = (eightShorts ? numSwbOffsetS[m_swbTableIdx] : numSwbOffsetL[m_swbTableIdx]) - 1; + unsigned char tnsMaxBands = tnsScaleFactorBandLimit[eightShorts ? 1 : 0][m_swbTableIdx]; + unsigned char tnsStartSfb = 1; // set this to 2 in case of 4 < MAX_PREDICTION_ORDER <= 8 + + if (!eightShorts) + { + const unsigned samplingRate = toSamplingRate (m_frequencyIdx); // refine TNS_MAX_BANDS + const unsigned tnsStartOffs = (m_specAnaCurr[channelIndex] & 31) << SA_BW_SHIFT; + + if ((samplingRate >= 46009) && (samplingRate < 55426)) // ~48kHz + { + numSwbFrame = 49; + tnsMaxBands = 40; + } + else + if ((samplingRate >= 37566) && (samplingRate < 46009)) // ~44kHz + { + numSwbFrame = 49; + tnsMaxBands = 42; + } + while (grpSO[tnsStartSfb] < tnsStartOffs) tnsStartSfb++; // start band for TNS filter + } + tnsMaxBands = __min (tnsMaxBands, maxSfb); + + if ((tnsData.filterLength[0] = __max (0, numSwbFrame - (int) tnsStartSfb)) > 0) + { + int32_t* const mdctSignal = m_mdctSignals[channelIndex]; + const short offs = grpSO[tnsStartSfb]; + unsigned short s = grpSO[tnsMaxBands] - offs; + short filterC[MAX_PREDICTION_ORDER] = {0, 0, 0, 0}; + int32_t* predSig = &mdctSignal[grpSO[tnsMaxBands]]; // end of spectrum to be predicted + + errorValue |= m_linPredictor.quantTnsToLpCoeffs (tnsData.coeff[0], filtOrder, tnsData.coeffResLow, tnsData.coeffParCor, filterC); + + // back up the leading MDCT samples + memcpy (m_tempIntBuf, &mdctSignal[offs - MAX_PREDICTION_ORDER], MAX_PREDICTION_ORDER * sizeof (int32_t)); + // TNS compliance: set them to zero + memset (&mdctSignal[offs - MAX_PREDICTION_ORDER], 0, MAX_PREDICTION_ORDER * sizeof (int32_t)); + + if (filtOrder >= 4) // max. order 4 + { + for (predSig--; s > 0; s--) + { + const int64_t predSample = *(predSig - 1) * (int64_t) filterC[0] + *(predSig - 2) * (int64_t) filterC[1] + + *(predSig - 3) * (int64_t) filterC[2] + *(predSig - 4) * (int64_t) filterC[3]; + *(predSig--) += int32_t ((predSample + (1 << (LP_DEPTH - 2))) >> (LP_DEPTH - 1)); + } + } + else if (filtOrder == 3) // order 3 + { + for (predSig--; s > 0; s--) + { + const int64_t predSample = *(predSig - 1) * (int64_t) filterC[0] + *(predSig - 2) * (int64_t) filterC[1] + + *(predSig - 3) * (int64_t) filterC[2]; + *(predSig--) += int32_t ((predSample + (1 << (LP_DEPTH - 2))) >> (LP_DEPTH - 1)); + } + } + else // save 1-2 MACs, order 2 or 1 + { + for (predSig--; s > 0; s--) + { + const int64_t predSample = *(predSig - 1) * (int64_t) filterC[0] + *(predSig - 2) * (int64_t) filterC[1]; + + *(predSig--) += int32_t ((predSample + (1 << (LP_DEPTH - 2))) >> (LP_DEPTH - 1)); + } + } + // restore the leading MDCT samples + memcpy (&mdctSignal[offs - MAX_PREDICTION_ORDER], m_tempIntBuf, MAX_PREDICTION_ORDER * sizeof (int32_t)); + + // recalculate SFB RMS in TNS range + errorValue |= m_specAnalyzer.getMeanAbsValues (mdctSignal, nullptr, nSamplesInFrame, 0, &grpSO[tnsStartSfb], __max (0, tnsMaxBands - (int) tnsStartSfb), + &grpData.sfbRmsValues[tnsStartSfb + m_numSwbShort * tnsData.filteredWindow]); + } + else tnsData.filterOrder[0] = tnsData.numFilters = 0; // disable zero-length TNS filters + } // if order > 0 + + return errorValue; +} + +unsigned ExhaleEncoder::eightShortGrouping (SfbGroupData& grpData, uint16_t* const grpOffsets, int32_t* const mdctSignal) +{ + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned nSamplesInShort = nSamplesInFrame >> 3; + unsigned grpStartLine = nSamplesInFrame; + + if ((grpOffsets == nullptr) || (mdctSignal == nullptr)) + { + return 1; // invalid arguments error + } + + for (short gr = grpData.numWindowGroups - 1; gr >= 0; gr--) // grouping, 14496-3 Fig. 4.24 + { + const unsigned grpLength = grpData.windowGroupLength[gr]; + uint16_t* grpOffset = &grpOffsets[m_numSwbShort * gr]; + int32_t* const grpMdctSig = &mdctSignal[grpStartLine -= nSamplesInShort * grpLength]; + + for (unsigned short b = 0; b < m_numSwbShort; b++) + { + const unsigned swbOffset = grpOffsets[b]; + const unsigned numCoeffs = __min (grpOffsets[b + 1], nSamplesInShort) - swbOffset; + + // adjust scale factor band offsets + grpOffset[b] = uint16_t (grpStartLine + swbOffset * grpLength); + // interleave spectral coefficients + for (unsigned short w = 0; w < grpLength; w++) + { + memcpy (&m_tempIntBuf[grpOffset[b] + w * numCoeffs], &grpMdctSig[swbOffset + w * nSamplesInShort], numCoeffs * sizeof (int32_t)); + } + } + grpOffset[m_numSwbShort] = uint16_t (grpStartLine + nSamplesInShort * grpLength); + } // for gr + + memcpy (mdctSignal, m_tempIntBuf, nSamplesInFrame * sizeof (int32_t)); + + return 0; // no error +} + +unsigned ExhaleEncoder::getOptParCorCoeffs (const int32_t* const mdctSignal, const SfbGroupData& grpData, const unsigned char maxSfb, + const unsigned channelIndex, TnsData& tnsData, const unsigned char firstGroupIndexToTest /*= 0*/) +{ + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned tnsStartSfb = 1; // set this to 2 in case of 4 < MAX_PREDICTION_ORDER <= 8 + unsigned bestOrder = MAX_PREDICTION_ORDER, predGainCurr, predGainPrev, temp = 0; + int16_t parCorBuffer[MAX_PREDICTION_ORDER]; + + tnsData.filterOrder[0] = tnsData.filteredWindow = tnsData.numFilters = 0; // zero TNS data + tnsData.filterDownward[0] = false; // enforce direction = 0 for now, detection difficult + + if ((mdctSignal == nullptr) || (tnsData.coeffParCor == nullptr) || (maxSfb <= tnsStartSfb) || (channelIndex >= USAC_MAX_NUM_CHANNELS)) + { + return 0; // invalid arguments error + } + + if (grpData.numWindowGroups == 1) // LONG window: use ParCor coeffs from spectral analyzer + { + tnsData.filterOrder[0] = (unsigned char) m_specAnalyzer.getLinPredCoeffs (tnsData.coeffParCor, channelIndex); + +#if EE_OPT_TNS_SPEC_RANGE + if (tnsData.filterOrder[0] > 0) // try to reduce TNS start band as long as SNR increases + { + const unsigned short filtOrder = tnsData.filterOrder[0]; + unsigned short b = __min (m_specAnaCurr[channelIndex] & 31, (nSamplesInFrame - filtOrder) >> SA_BW_SHIFT); + short filterC[MAX_PREDICTION_ORDER] = {0, 0, 0, 0}; + int32_t* predSig = &m_mdctSignals[channelIndex][b << SA_BW_SHIFT]; // TNS start offset + + m_linPredictor.parCorToLpCoeffs (tnsData.coeffParCor, filtOrder, filterC); + + for (b = (b > 0 ? b - 1 : 0), predSig--; b > 0; b--) // b is in spectr. analysis units + { + uint64_t sumAbsOrg = 0, sumAbsTns = 0; + + if (filtOrder >= 4) // max. order 4 + { + for (unsigned short s = 1 << SA_BW_SHIFT; s > 0; s--) // generate the TNS residual + { + const int64_t predSample = *(predSig - 1) * (int64_t) filterC[0] + *(predSig - 2) * (int64_t) filterC[1] + + *(predSig - 3) * (int64_t) filterC[2] + *(predSig - 4) * (int64_t) filterC[3]; + const int64_t mdctSample = *(predSig--); + const int64_t resiSample = mdctSample + ((predSample + (1 << 8)) >> 9); + + sumAbsOrg += abs (mdctSample); sumAbsTns += abs (resiSample); + } + } + else if (filtOrder == 3) // order 3 + { + for (unsigned short s = 1 << SA_BW_SHIFT; s > 0; s--) // generate the TNS residual + { + const int64_t predSample = *(predSig - 1) * (int64_t) filterC[0] + *(predSig - 2) * (int64_t) filterC[1] + + *(predSig - 3) * (int64_t) filterC[2]; + const int64_t mdctSample = *(predSig--); + const int64_t resiSample = mdctSample + ((predSample + (1 << 8)) >> 9); + + sumAbsOrg += abs (mdctSample); sumAbsTns += abs (resiSample); + } + } + else // save 1-2 MACs, order 2 or 1 + { + for (unsigned short s = 1 << SA_BW_SHIFT; s > 0; s--) // generate the TNS residual + { + const int64_t predSample = *(predSig - 1) * (int64_t) filterC[0] + *(predSig - 2) * (int64_t) filterC[1]; + const int64_t mdctSample = *(predSig--); + const int64_t resiSample = mdctSample + ((predSample + (1 << 8)) >> 9); + + sumAbsOrg += abs (mdctSample); sumAbsTns += abs (resiSample); + } + } + if (sumAbsOrg * 9 <= sumAbsTns * 8) break; // band SNR was reduced by more than 1 dB + } + m_specAnaCurr[channelIndex] = (m_specAnaCurr[channelIndex] & (UINT_MAX - 31)) | (b + 1); + } // if order > 0 +#endif // EE_OPT_TNS_SPEC_RANGE + return (m_specAnaCurr[channelIndex] >> 24) & UCHAR_MAX; // spectral analyzer's pred gain + } + // SHORT window: find short group with maximum pred gain, then determine best filter order + for (unsigned char gr = firstGroupIndexToTest; gr < grpData.numWindowGroups; gr++) + { + if (grpData.windowGroupLength[gr] == 1) + { + const uint16_t* grpSO = &grpData.sfbOffsets[m_numSwbShort * gr]; + + predGainCurr = m_linPredictor.calcParCorCoeffs (&mdctSignal[grpSO[tnsStartSfb]], grpSO[maxSfb] - grpSO[tnsStartSfb], bestOrder, parCorBuffer); + + if (temp < predGainCurr) // current pred gain set is "better" than best pred gain set + { + temp = predGainCurr; + tnsData.filteredWindow = gr; // changed later + memcpy (tnsData.coeffParCor, parCorBuffer, bestOrder * sizeof (int16_t)); + } + } + } // for gr + + predGainCurr = (temp >> 24) & UCHAR_MAX; + predGainPrev = (temp >> 16) & UCHAR_MAX; + while ((bestOrder > 1) && (predGainPrev >= predGainCurr)) // get lowest-order gain maximum + { + bestOrder--; + predGainCurr = predGainPrev; + predGainPrev = (temp >> (8 * bestOrder - 16)) & UCHAR_MAX; + } + tnsData.filterOrder[0] = ((bestOrder == 1) && (tnsData.coeffParCor[0] == 0) ? 0 : bestOrder); + + return predGainCurr; // maximum pred gain of all filter orders and length-1 window groups +} + +unsigned ExhaleEncoder::psychBitAllocation () // perceptual bit-allocation via scale factors +{ + const unsigned nChannels = toNumChannels (m_channelConf); + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned samplingRate = toSamplingRate (m_frequencyIdx); + const unsigned lfeChannelIndex = (m_channelConf >= CCI_6_CH ? __max (5, nChannels - 1) : USAC_MAX_NUM_CHANNELS); + const uint32_t maxSfbLong = (samplingRate < 37566 ? 51 /*32 kHz*/ : brModeAndFsToMaxSfbLong (m_bitRateMode, samplingRate)); +#if EC_TRELLIS_OPT_CODING + const uint64_t scaleSr = (samplingRate < 27713 ? 37 - m_bitRateMode : 39 - (m_bitRateMode > 2 ? 1 : 0)); +#else + const uint64_t scaleSr = (samplingRate < 27713 ? 36 - m_bitRateMode : 37); +#endif + const uint64_t scaleBr = (m_bitRateMode == 0 ? 32 : scaleSr - eightTimesSqrt256Minus[256 - m_bitRateMode] - ((m_bitRateMode - 1) >> 1)); + uint32_t* sfbStepSizes = (uint32_t*) m_tempIntBuf; + unsigned char meanSpecFlat[USAC_MAX_NUM_CHANNELS]; +//unsigned char meanTempFlat[USAC_MAX_NUM_CHANNELS]; + unsigned ci = 0, s; // running index + unsigned errorValue = 0; // no error + + // psychoacoustic processing of SFB RMS values yielding masking thresholds in m_tempIntBuf + errorValue |= m_bitAllocator.initSfbStepSizes (m_scaleFacData, m_numSwbShort, m_specAnaCurr, m_tempAnaCurr, + nChannels, samplingRate, sfbStepSizes, lfeChannelIndex); + + // get means of spectral and temporal flatness for every channel + m_bitAllocator.getChAverageSpecFlat (meanSpecFlat, nChannels); +//m_bitAllocator.getChAverageTempFlat (meanTempFlat, nChannels); + + for (unsigned el = 0; el < m_numElements; el++) // element loop + { + CoreCoderData& coreConfig = *m_elementData[el]; + const unsigned nrChannels = (coreConfig.elementType & 1) + 1; // for UsacCoreCoderData() + + if (coreConfig.elementType >= ID_USAC_LFE) // LFE/EXT elements + { + SfbGroupData& grpData = coreConfig.groupingData[0]; + uint32_t* stepSizes = &sfbStepSizes[ci * m_numSwbShort * NUM_WINDOW_GROUPS]; + const uint16_t* off = grpData.sfbOffsets; + const uint32_t* rms = grpData.sfbRmsValues; + unsigned char* scaleFactors = grpData.scaleFactors; + + for (unsigned short b = 0; b < grpData.sfbsPerGroup; b++) + { + const unsigned char sfbWidth = off[b + 1] - off[b]; + const unsigned highPassAtten = 4 + b * 2; // LF SNR increase, my M.Sc. thesis, p. 54 + const uint64_t scale = scaleBr * __min (32, highPassAtten); // rate ctrl. #1 + + // scale step-sizes according to VBR mode, then derive scale factors from step-sizes + stepSizes[b] = uint32_t (__max (BA_EPS, ((1u << 9) + stepSizes[b] * scale) >> 10)); + + scaleFactors[b] = m_bitAllocator.getScaleFac (stepSizes[b], &m_mdctSignals[ci][off[b]], sfbWidth, rms[b]); + } + ci++; + } + else // SCE or CPE: bandwidth-to-max_sfb mapping, short-window grouping for each channel + { + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + SfbGroupData& grpData = coreConfig.groupingData[ch]; + const bool eightShorts = (coreConfig.icsInfoCurr[ch].windowSequence == EIGHT_SHORT); + const unsigned char mSfmFac = eightTimesSqrt256Minus[meanSpecFlat[ci]]; + uint32_t* stepSizes = &sfbStepSizes[ci * m_numSwbShort * NUM_WINDOW_GROUPS]; + unsigned char numSwbFrame = (eightShorts ? numSwbOffsetS[m_swbTableIdx] : numSwbOffsetL[m_swbTableIdx]) - 1; + + if (!eightShorts && (samplingRate >= 37566) && (samplingRate < 55426)) // fix numSwb + { + numSwbFrame = 49; + } + memset (grpData.scaleFactors, 0, (MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS) * sizeof (unsigned char)); + + for (unsigned short gr = 0; gr < grpData.numWindowGroups; gr++) + { + const uint16_t* grpOff = &grpData.sfbOffsets[m_numSwbShort * gr]; + const uint32_t* grpRms = &grpData.sfbRmsValues[m_numSwbShort * gr]; + const uint32_t* refRms = &coreConfig.groupingData[1 - ch].sfbRmsValues[m_numSwbShort * gr]; + unsigned char* grpScaleFactors = &grpData.scaleFactors[m_numSwbShort * gr]; + uint32_t* grpStepSizes = &stepSizes[m_numSwbShort * gr]; + uint32_t b, grpRmsMin = INT_MAX; // min. RMS value, used for overcoding reduction + + // undercoding reduction for case where large number of coefs is quantized to zero + s = (eightShorts ? (nSamplesInFrame * grpData.windowGroupLength[gr]) >> 1 : nSamplesInFrame << 2); + for (b = 0; b < grpData.sfbsPerGroup; b++) + { + const uint32_t rmsComp = getComplexRmsValue (grpRms[b], gr, b, numSwbFrame, coreConfig.tnsData[ch]); + const uint32_t rmsRef9 = (!coreConfig.commonWindow ? rmsComp : + getComplexRmsValue (refRms[b], gr, b, numSwbFrame, coreConfig.tnsData[1 - ch]) >> 9); + + if (rmsComp < grpRmsMin) grpRmsMin = rmsComp; + if (rmsComp >= rmsRef9 && (rmsComp < (grpStepSizes[b] >> 1))) // zero-quantized + { + s -= ((grpOff[b + 1] - grpOff[b]) * 3 * __min (2 * SA_EPS, rmsComp) + SA_EPS) >> 11; // / (2 * SA_EPS) + } + } + if ((samplingRate >= 27713) && (b < maxSfbLong) && !eightShorts) // uncoded coefs + { + const uint32_t rmsComp = getComplexRmsValue (grpRms[b], gr, b, numSwbFrame, coreConfig.tnsData[ch]); + const uint32_t rmsRef9 = (!coreConfig.commonWindow ? rmsComp : + getComplexRmsValue (refRms[b], gr, b, numSwbFrame, coreConfig.tnsData[1 - ch]) >> 9); + + if (rmsComp >= rmsRef9) // check only first SFB above max_sfb for simplification + { + s -= ((grpOff[maxSfbLong] - grpOff[b]) * 3 * __min (2 * SA_EPS, rmsComp) + SA_EPS) >> 11; // / (2 * SA_EPS) + } + } + s = (eightShorts ? s / ((nSamplesInFrame * grpData.windowGroupLength[gr]) >> 8) : s / (nSamplesInFrame >> 5)); + + for (b = 0; b < grpData.sfbsPerGroup; b++) + { + const unsigned char sfbWidth = grpOff[b + 1] - grpOff[b]; + const unsigned highPassAtten = (b <= 5 ? (eightShorts ? 1 : 4) + b * 2 : 9 + b + ((b + 5) >> 4)); // LF SNR increase + const uint64_t rateFac = mSfmFac * s * __min (32, highPassAtten * grpData.numWindowGroups); // rate control #1 + const uint64_t sScaled = ((1u << 23) + __max (grpRmsMin, grpStepSizes[b]) * scaleBr * rateFac) >> 24; + + // scale step-sizes according to VBR mode & derive scale factors from step-sizes + grpStepSizes[b] = uint32_t (__max (BA_EPS, __min (UINT_MAX, sScaled))); + + grpScaleFactors[b] = m_bitAllocator.getScaleFac (grpStepSizes[b], &m_mdctSignals[ci][grpOff[b]], sfbWidth, grpRms[b]); + } + } // for gr + +#if !RESTRICT_TO_AAC + if (grpData.sfbsPerGroup > 0 && m_noiseFilling[el] && !eightShorts) // HF noise-fill + { + numSwbFrame = __min (numSwbFrame, maxSfbLong); // bit-rate dependent max bandwidth + + if (grpData.sfbsPerGroup < numSwbFrame) + { + memset (&grpData.scaleFactors[grpData.sfbsPerGroup], 0, (numSwbFrame - grpData.sfbsPerGroup) * sizeof (unsigned char)); + grpData.sfbsPerGroup = coreConfig.icsInfoCurr[ch].maxSfb = numSwbFrame; + } + if (ch > 0) coreConfig.commonMaxSfb = (coreConfig.icsInfoCurr[0].maxSfb == coreConfig.icsInfoCurr[1].maxSfb); + } +#endif + ci++; + } // for ch + + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + SfbGroupData& grpData = coreConfig.groupingData[ch]; + TnsData& tnsData = coreConfig.tnsData[ch]; + + if (tnsData.numFilters > 0) // convert TNS group index to window index for write-out + { + s = 0; + for (unsigned short gr = 0; gr < grpData.numWindowGroups; gr++) + { + if (gr == tnsData.filteredWindow) + { + tnsData.filteredWindow = (unsigned char) s; + break; + } + s += grpData.windowGroupLength[gr]; + } + } + } // for ch + } + } // for el + + return errorValue; +} + +unsigned ExhaleEncoder::quantizationCoding () // apply MDCT quantization and entropy coding +{ + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned samplingRate = toSamplingRate (m_frequencyIdx); + const unsigned* const coeffMagn = m_sfbQuantizer.getCoeffMagnPtr (); + unsigned ci = 0, s; // running index + unsigned errorValue = (coeffMagn == nullptr ? 1 : 0); + + for (unsigned el = 0; el < m_numElements; el++) // element loop + { + CoreCoderData& coreConfig = *m_elementData[el]; + const unsigned nrChannels = (coreConfig.elementType & 1) + 1; // for UsacCoreCoderData() + + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + EntropyCoder& entrCoder = m_entropyCoder[ci]; + SfbGroupData& grpData = coreConfig.groupingData[ch]; + const bool shortWinCurr = (coreConfig.icsInfoCurr[ch].windowSequence == EIGHT_SHORT); + const bool shortWinPrev = (coreConfig.icsInfoPrev[ch].windowSequence == EIGHT_SHORT); + char* const arithTuples = entrCoder.arithGetTuplePtr (); + unsigned char sfIdxPred = UCHAR_MAX; + + if ((errorValue > 0) || (arithTuples == nullptr)) + { + return 0; // an internal error + } + + // back up entropy coder memory for use by bit-stream writer + memcpy (m_tempIntBuf, arithTuples, (nSamplesInFrame >> 1) * sizeof (char)); + errorValue |= (entrCoder.getIsShortWindow () != shortWinPrev ? 1 : 0); // sanity check + + memset (m_mdctQuantMag[ci], 0, nSamplesInFrame * sizeof (unsigned char)); // zero out + + for (unsigned short gr = 0; gr < grpData.numWindowGroups; gr++) + { + const unsigned char grpLength = grpData.windowGroupLength[gr]; + const uint16_t* grpOff = &grpData.sfbOffsets[m_numSwbShort * gr]; + uint32_t* const grpRms = &grpData.sfbRmsValues[m_numSwbShort * gr]; // coding stats + unsigned char* grpScaleFactors = &grpData.scaleFactors[m_numSwbShort * gr]; + uint32_t estimBitCount = 0; + unsigned lastSfb = 0, lastSOff = 0; + + errorValue |= entrCoder.initWindowCoding (m_indepFlag && (gr == 0), shortWinCurr); + s = 0; + + for (unsigned short b = 0; b < grpData.sfbsPerGroup; b++) + { + // partial SFB ungrouping for entropy coding setup below + const unsigned short swbSize = ((grpOff[b + 1] - grpOff[b]) * oneTwentyEightOver[grpLength]) >> 7; // sfbWidth / grpLength + unsigned char* const swbMagn = &m_mdctQuantMag[ci][grpOff[b + 1] - swbSize]; + + grpScaleFactors[b] = m_sfbQuantizer.quantizeSpecSfb (entrCoder, m_mdctSignals[ci], grpLength, grpOff, grpRms, + b, grpScaleFactors[b], sfIdxPred, m_mdctQuantMag[ci]); + if ((b > 0) && (grpScaleFactors[b] < UCHAR_MAX) && (sfIdxPred == UCHAR_MAX)) + { + // back-propagate first nonzero-SFB scale factor index + memset (grpScaleFactors, grpScaleFactors[b], b * sizeof (unsigned char)); + } + sfIdxPred = grpScaleFactors[b]; + + // correct previous scale factor if the delta exceeds 60 + if ((b > 0) && (grpScaleFactors[b] > grpScaleFactors[b - 1] + INDEX_OFFSET)) + { + const unsigned short sfbM1Start = grpOff[b - 1]; + const unsigned short sfbM1Width = grpOff[b] - sfbM1Start; + const unsigned short swbM1Size = (sfbM1Width * oneTwentyEightOver[grpLength]) >> 7; // sfbM1Width / grpLength + + grpScaleFactors[b - 1] = grpScaleFactors[b] - INDEX_OFFSET; // reset SFB to zero + memset (&m_mdctQuantMag[ci][sfbM1Start], 0, sfbM1Width * sizeof (unsigned char)); + + // correct SFB statistics with some bit count estimate + grpRms[b - 1] = 1 + (sfbM1Width >> 3) + entrCoder.indexGetBitCount (b > 1 ? (int) grpScaleFactors[b - 1] - grpScaleFactors[b - 2] : 0); + // correct entropy coding 2-tuples for the next window + memset (&arithTuples[lastSOff], 1, (swbM1Size >> 1) * sizeof (char)); + } + + if (b > 0) + { + if ((grpRms[b - 1] >> 16) > 0) lastSfb = b - 1; + estimBitCount += grpRms[b - 1] & USHRT_MAX; + } + // set up entropy coding 2-tuples for next SFB or window + lastSOff = s; + for (unsigned short c = 0; c < swbSize; c += 2) + { + arithTuples[s++] = __min (0xF, swbMagn[c] + swbMagn[c + 1] + 1); // 23003-3, 7.4 + } + } // for b + + if (grpData.sfbsPerGroup > 0) // rate control #2 to enforce a constrained VBR (CVBR) + { + const unsigned char maxSfbLong = (samplingRate < 37566 ? 51 /*32 kHz*/ : brModeAndFsToMaxSfbLong (m_bitRateMode, samplingRate)); + const unsigned char maxSfbShort = (samplingRate < 37566 ? 14 /*32 kHz*/ : brModeAndFsToMaxSfbShort(m_bitRateMode, samplingRate)); + const unsigned short peakIndex = (shortWinCurr ? 0 : (m_specAnaCurr[ci] >> 5) & 2047); +#if RESTRICT_TO_AAC + const unsigned sfmBasedSfbStart = (shortWinCurr ? maxSfbShort : maxSfbLong) - 6 + (m_bitRateMode >> 1) + ((m_specAnaCurr[ci] >> 21) & 7); +#else + const unsigned highFreqMinStart = (m_noiseFilling[el] ? 6 : 6 - (m_bitRateMode >> 1)); + const unsigned sfmBasedSfbStart = (shortWinCurr ? maxSfbShort : maxSfbLong) - highFreqMinStart + ((m_specAnaCurr[ci] >> 21) & 7); +#endif + const unsigned targetBitCountX2 = ((48000 + 16000 * m_bitRateMode) * nSamplesInFrame) / (samplingRate * grpData.numWindowGroups); + unsigned b = grpData.sfbsPerGroup - 1; + + if ((grpRms[b] >> 16) > 0) lastSfb = b; + estimBitCount += grpRms[b] & USHRT_MAX; + + if (grpLength == 1) // finalize bit count estimate, RDOC + { + estimBitCount += ((entrCoder.arithGetCtxState () >> 17) & 31) + 2; // m_acBits+2 +#if EC_TRELLIS_OPT_CODING + estimBitCount = m_sfbQuantizer.quantizeSpecRDOC (entrCoder, grpScaleFactors, m_bitRateMode, // __min (estimBitCount, targetBitCountX2), + grpOff, grpRms, grpData.sfbsPerGroup, m_mdctQuantMag[ci]); +#endif + } + b = lastSfb; + while ((b >= sfmBasedSfbStart) && (grpOff[b] > peakIndex) && ((grpRms[b] >> 16) <= 1) /*coarse quantization*/ && + ((estimBitCount * 2 > targetBitCountX2) || (grpLength > 1 /*no accurate bit count estimate available*/))) + { + b--; // search first coarsely quantized high-freq. SFB + } + lastSOff = b; + + for (b++; b <= lastSfb; b++) + { + if ((grpRms[b] >> 16) > 0) // re-quantize nonzero band + { +#if RESTRICT_TO_AAC + uint32_t maxVal = 1; +#else + uint32_t maxVal = (shortWinCurr || !m_noiseFilling[el] ? 1 : (m_specAnaCurr[ci] >> 23) & 1); // 1 or 0 +#endif + estimBitCount -= grpRms[b] & USHRT_MAX; + grpRms[b] = (maxVal << 16) + maxVal; // bit estimate + maxVal = quantizeSfbWithMinSnr (coeffMagn, grpOff, b, grpLength, m_mdctQuantMag[ci], arithTuples, maxVal > 0); + + grpScaleFactors[b] = __min (SCHAR_MAX, m_sfbQuantizer.getScaleFacOffset ((double) maxVal)); + + // correct SFB statistics with estimate of bit count + grpRms[b] += 3 + entrCoder.indexGetBitCount ((int) grpScaleFactors[b] - grpScaleFactors[b - 1]); + estimBitCount += grpRms[b] & USHRT_MAX; + } + else // re-repeat scale factor for zero quantized band + { + grpScaleFactors[b] = grpScaleFactors[b - 1]; + } + } + + if (estimBitCount > targetBitCountX2) // too many bits!! + { + for (b = lastSOff; b > 0; b--) + { + if ((grpRms[b] >> 16) > 0) // emergency re-quantizer + { +#if RESTRICT_TO_AAC + uint32_t maxVal = 1; +#else + uint32_t maxVal = (shortWinCurr || !m_noiseFilling[el] ? 1 : (m_specAnaCurr[ci] >> 23) & 1); // 1 or 0 +#endif + estimBitCount -= grpRms[b] & USHRT_MAX; + grpRms[b] = (maxVal << 16) + maxVal; // bit estim. + maxVal = quantizeSfbWithMinSnr (coeffMagn, grpOff, b, grpLength, m_mdctQuantMag[ci], arithTuples, maxVal > 0); + + grpScaleFactors[b] = __min (SCHAR_MAX, m_sfbQuantizer.getScaleFacOffset ((double) maxVal)); + + // correct SFB statistics with estimated bit count + grpRms[b] += 3 + entrCoder.indexGetBitCount ((int) grpScaleFactors[b] - grpScaleFactors[b - 1]); + estimBitCount += grpRms[b] & USHRT_MAX; + } + if (estimBitCount <= targetBitCountX2) break; + } + + for (b++; b <= lastSfb; b++) // re-repeat scale factor + { + if ((grpRms[b] >> 16) == 0) // a zero quantized band + { + grpScaleFactors[b] = grpScaleFactors[b - 1]; + } + } + } // if (estimBitCount > targetBitCountX2) + + for (b = lastSfb + 1; b < grpData.sfbsPerGroup; b++) + { + if ((grpRms[b] >> 16) == 0) // HF zero quantized bands + { + grpScaleFactors[b] = grpScaleFactors[b - 1]; + } + } + + if ((grpScaleFactors[0] == UCHAR_MAX) && +#if !RESTRICT_TO_AAC + !m_noiseFilling[el] && +#endif + (lastSfb == 0)) // ensure all scale factors are set + { + memset (grpScaleFactors, (gr == 1 ? grpData.scaleFactors[grpData.sfbsPerGroup - 1] : 0), grpData.sfbsPerGroup * sizeof (unsigned char)); + } + } + } // for gr + + // restore entropy coder memory for use by bit-stream writer + memcpy (arithTuples, m_tempIntBuf, (nSamplesInFrame >> 1) * sizeof (char)); + entrCoder.setIsShortWindow (shortWinPrev); +#if !RESTRICT_TO_AAC + // obtain channel-wise noise_level and noise_offset for USAC + coreConfig.specFillData[ch] = (!m_noiseFilling[el] ? 0 : m_specGapFiller.getSpecGapFillParams (m_sfbQuantizer, m_mdctQuantMag[ci], + m_numSwbShort, grpData, nSamplesInFrame)); + // NOTE: gap-filling SFB bit count might be inaccurate now since scale factors changed + if (coreConfig.specFillData[ch] == 1) errorValue |= 1; +#endif + ci++; + } + } // for el + + return (errorValue > 0 ? 0 : m_outStream.createAudioFrame (m_elementData, m_entropyCoder, m_mdctSignals, m_mdctQuantMag, m_indepFlag, + m_numElements, m_numSwbShort, (unsigned char* const) m_tempIntBuf, +#if !RESTRICT_TO_AAC + m_timeWarping, m_noiseFilling, +#endif + m_outAuData, nSamplesInFrame)); // returns AU size +} + +unsigned ExhaleEncoder::spectralProcessing () // complete ics_info(), calc TNS and SFB data +{ + const unsigned nChannels = toNumChannels (m_channelConf); + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned nSamplesInShort = nSamplesInFrame >> 3; + const unsigned samplingRate = toSamplingRate (m_frequencyIdx); + const unsigned lfeChannelIndex = (m_channelConf >= CCI_6_CH ? __max (5, nChannels - 1) : USAC_MAX_NUM_CHANNELS); + unsigned ci = 0, s; // running index + unsigned errorValue = 0; // no error + + // get spectral channel statistics for last frame, used for frequency bandwidth detection + m_specAnalyzer.getSpecAnalysisStats (m_specAnaPrev, nChannels); + m_specAnalyzer.getSpectralBandwidth (m_bandwidPrev, nChannels); + + // spectral analysis for current MCLT signal (windowed time-samples of the current frame) + errorValue |= m_specAnalyzer.spectralAnalysis (m_mdctSignals, m_mdstSignals, nChannels, nSamplesInFrame, samplingRate, lfeChannelIndex); + + // get spectral channel statistics for this frame, used for perceptual model, BW detector + m_specAnalyzer.getSpecAnalysisStats (m_specAnaCurr, nChannels); + m_specAnalyzer.getSpectralBandwidth (m_bandwidCurr, nChannels); + + for (unsigned el = 0; el < m_numElements; el++) // element loop + { + CoreCoderData& coreConfig = *m_elementData[el]; + const unsigned nrChannels = (coreConfig.elementType & 1) + 1; // for UsacCoreCoderData() + + coreConfig.commonMaxSfb = false; + coreConfig.commonTnsData = false; + coreConfig.tnsActive = false; + coreConfig.tnsOnLeftRight = true; // enforce tns_on_lr = 1 for now, detection difficult + memset (coreConfig.tnsData, 0, nrChannels * sizeof (TnsData)); + + if (coreConfig.elementType >= ID_USAC_LFE) // LFE/EXT elements + { + SfbGroupData& grpData = coreConfig.groupingData[0]; + uint16_t* grpSO = grpData.sfbOffsets; + IcsInfo& icsCurr = coreConfig.icsInfoCurr[0]; + + memcpy (grpSO, swbOffsetsL[m_swbTableIdx], numSwbOffsetL[m_swbTableIdx] * sizeof (uint16_t)); + + icsCurr.maxSfb = MAX_NUM_SWB_LFE; + while (grpSO[icsCurr.maxSfb] > LFE_MAX) icsCurr.maxSfb--; // limit coefficients in LFE + ci++; + } + else // SCE or CPE: bandwidth-to-max_sfb mapping, short-window grouping for each channel + { + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + SfbGroupData& grpData = coreConfig.groupingData[ch]; + uint16_t* grpSO = grpData.sfbOffsets; + IcsInfo& icsCurr = coreConfig.icsInfoCurr[ch]; + TnsData& tnsData = coreConfig.tnsData[ch]; + + memset (grpSO, 0, (1 + MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS) * sizeof (uint16_t)); + + if (icsCurr.windowSequence != EIGHT_SHORT) + { + memcpy (grpSO, swbOffsetsL[m_swbTableIdx], numSwbOffsetL[m_swbTableIdx] * sizeof (uint16_t)); + + icsCurr.maxSfb = 0; + while (grpSO[icsCurr.maxSfb] < nSamplesInFrame) icsCurr.maxSfb++; // num_swb_long + grpSO[icsCurr.maxSfb] = (uint16_t) nSamplesInFrame; + grpData.sfbsPerGroup = icsCurr.maxSfb; // initialization, changed to max_sfb later + + if (samplingRate > 32000) // set max_sfb based on VBR mode and bandwidth detection + { + icsCurr.maxSfb = __min (icsCurr.maxSfb, brModeAndFsToMaxSfbLong (m_bitRateMode, samplingRate)); + } + while (grpSO[icsCurr.maxSfb] > __max (m_bandwidCurr[ci], m_bandwidPrev[ci])) icsCurr.maxSfb--; // BW detector + } + else // icsCurr.windowSequence == EIGHT_SHORT + { + memcpy (grpSO, swbOffsetsS[m_swbTableIdx], numSwbOffsetS[m_swbTableIdx] * sizeof (uint16_t)); + + icsCurr.maxSfb = 0; + while (grpSO[icsCurr.maxSfb] < nSamplesInShort) icsCurr.maxSfb++; // num_swb_short + grpSO[icsCurr.maxSfb] = (uint16_t) nSamplesInShort; + grpData.sfbsPerGroup = m_numSwbShort = icsCurr.maxSfb; // changed to max_sfb later + + if (samplingRate > 32000) // set max_sfb based on VBR mode and zero-ness detection + { + icsCurr.maxSfb = __min (icsCurr.maxSfb, brModeAndFsToMaxSfbShort (m_bitRateMode, samplingRate)); + } +#if SA_OPT_WINDOW_GROUPING + if (ch > 0 && coreConfig.commonWindow) // resynchronize the scale_factor_grouping + { + if (icsCurr.windowGrouping != coreConfig.icsInfoCurr[0].windowGrouping) + { + icsCurr.windowGrouping = coreConfig.icsInfoCurr[0].windowGrouping; + } + } + else // first element channel or not common_window, optimize scale_factor_grouping + { + if ((s = m_specAnalyzer.optimizeGrouping (ci, grpSO[icsCurr.maxSfb] << 3, icsCurr.windowGrouping)) < 8) + { + icsCurr.windowGrouping = (unsigned char) s; + } + } + memcpy (grpData.windowGroupLength, windowGroupingTable[icsCurr.windowGrouping], NUM_WINDOW_GROUPS * sizeof (unsigned char)); +#endif + while (grpSO[icsCurr.maxSfb] > __max (m_bandwidCurr[ci], m_bandwidPrev[ci])) icsCurr.maxSfb--; // not a bug!! + + errorValue |= eightShortGrouping (grpData, grpSO, m_mdctSignals[ci]); + } // if EIGHT_SHORT + + // compute and quantize optimal TNS coefficients, then find optimal TNS filter order + s /*linear pred gain*/ = getOptParCorCoeffs (m_mdctSignals[ci], grpData, icsCurr.maxSfb, ci, tnsData, + ch > 0 && coreConfig.commonWindow ? coreConfig.tnsData[0].filteredWindow : 0); + tnsData.filterOrder[0] = m_linPredictor.calcOptTnsCoeffs (tnsData.coeffParCor, tnsData.coeff[0], &tnsData.coeffResLow, + tnsData.filterOrder[0], s, (m_specAnaCurr[ci] >> 16) & UCHAR_MAX); + tnsData.numFilters = (tnsData.filterOrder[0] > 0 ? 1 : 0); + ci++; + } // for ch + + if (coreConfig.commonWindow) // synchronization of all StereoCoreToolInfo() components + { + unsigned char& maxSfb0 = coreConfig.icsInfoCurr[0].maxSfb; + unsigned char& maxSfb1 = coreConfig.icsInfoCurr[1].maxSfb; + const unsigned char maxSfbSte = __max (maxSfb0, maxSfb1); // max_sfb_ste in Table 24 + + if ((maxSfb0 > 0) && (maxSfb1 > 0) && (maxSfbSte - __min (maxSfb0, maxSfb1) <= 1)) + { + uint32_t& sa0 = m_specAnaCurr[ci-2]; + uint32_t& sa1 = m_specAnaCurr[ci-1]; + const int specFlat[2] = {int (sa0 >> 16) & UCHAR_MAX, int (sa1 >> 16) & UCHAR_MAX}; + const int tnsStart[2] = {int (sa0 & 31), int (sa1 & 31)}; // long TNS start offset + + if ((coreConfig.tnsData[0].filteredWindow == coreConfig.tnsData[1].filteredWindow) && + (abs (specFlat[0] - specFlat[1]) <= (UCHAR_MAX >> 3)) && + (abs (tnsStart[0] - tnsStart[1]) <= (UCHAR_MAX >> 5))) // TNS synchronization + { + const unsigned short maxTnsOrder = __max (coreConfig.tnsData[0].filterOrder[0], coreConfig.tnsData[1].filterOrder[0]); + TnsData& tnsData0 = coreConfig.tnsData[0]; + TnsData& tnsData1 = coreConfig.tnsData[1]; + + if (m_linPredictor.similarParCorCoeffs (tnsData0.coeffParCor, tnsData1.coeffParCor, maxTnsOrder, LP_DEPTH)) + { + coreConfig.commonTnsData = true; // synch tns_data + for (s = 0; s < maxTnsOrder; s++) + { + tnsData0.coeffParCor[s] = (tnsData0.coeffParCor[s] + tnsData1.coeffParCor[s] + 1) >> 1; + } + tnsData0.coeffResLow = false; // reoptimize coeffs + tnsData0.filterOrder[0] = m_linPredictor.calcOptTnsCoeffs (tnsData0.coeffParCor, tnsData0.coeff[0], &tnsData0.coeffResLow, + maxTnsOrder, UCHAR_MAX /*maximum pred gain*/, 0, LP_DEPTH); + tnsData0.numFilters = (tnsData0.filterOrder[0] > 0 ? 1 : 0); + memcpy (&tnsData1, &tnsData0, sizeof (TnsData)); + } + else if ((maxTnsOrder > 0) && (tnsData0.coeffResLow == tnsData1.coeffResLow) && (tnsData0.filterOrder[0] == tnsData1.filterOrder[0])) + { + const int32_t* coeff0 = (int32_t*) tnsData0.coeff[0]; // fast comparison code, + const int32_t* coeff1 = (int32_t*) tnsData1.coeff[0]; // might not be portable + + coreConfig.commonTnsData = (*coeff0 == *coeff1); // first four coeffs the same + } + if (coreConfig.commonTnsData) // synch TNS start SFB + { + const uint32_t avgTnsStart = (tnsStart[0] + tnsStart[1]) >> 1; // mean offset + + sa0 = (sa0 & (UINT_MAX - 31)) | avgTnsStart; // is used by applyTnsToWinGroup + sa1 = (sa1 & (UINT_MAX - 31)) | avgTnsStart; + } + } + maxSfb0 = maxSfb1 = maxSfbSte; + } + coreConfig.commonMaxSfb = (maxSfb0 == maxSfb1); // synch + coreConfig.stereoConfig = coreConfig.stereoMode = 0; + } // if coreConfig.commonWindow + } + + ci -= nrChannels; // zero frequency coefficients above num_swb for all channels, windows + + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + SfbGroupData& grpData = coreConfig.groupingData[ch]; + const uint16_t* grpSO = grpData.sfbOffsets; + const IcsInfo& icsCurr = coreConfig.icsInfoCurr[ch]; + const bool eightShorts = (icsCurr.windowSequence == EIGHT_SHORT); + unsigned grpEndLine = 0; + + if (eightShorts) // map grouping table idx to scale_factor_grouping idx for bit-stream + { + coreConfig.icsInfoCurr[ch].windowGrouping = scaleFactorGrouping[icsCurr.windowGrouping]; + } + + for (unsigned short gr = 0; gr < grpData.numWindowGroups; gr++) + { + const unsigned grpSOStart = grpSO[grpData.sfbsPerGroup + m_numSwbShort * gr]; + + grpEndLine += (eightShorts ? nSamplesInShort : nSamplesInFrame) * grpData.windowGroupLength[gr]; + memset (&m_mdctSignals[ci][grpSOStart], 0, (grpEndLine - grpSOStart) * sizeof (int32_t)); + memset (&m_mdstSignals[ci][grpSOStart], 0, (grpEndLine - grpSOStart) * sizeof (int32_t)); + } + memset (grpData.sfbRmsValues, 0, (MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS) * sizeof (uint32_t)); + + if (icsCurr.maxSfb > 0) + { + // use MCLTs for LONG but only MDCTs for SHORT windows (since MDSTs are not grouped) + errorValue |= m_specAnalyzer.getMeanAbsValues (m_mdctSignals[ci], eightShorts ? nullptr : m_mdstSignals[ci], nSamplesInFrame, + ci, grpSO, grpData.sfbsPerGroup * grpData.numWindowGroups, grpData.sfbRmsValues); + errorValue |= applyTnsToWinGroup (coreConfig.tnsData[ch], grpData, eightShorts, icsCurr.maxSfb, ci); + coreConfig.tnsActive |= (coreConfig.tnsData[ch].numFilters > 0); // tns_data_present + } + + grpData.sfbsPerGroup = icsCurr.maxSfb; // change num_swb to max_sfb for coding process + ci++; + } + } // for el + + return errorValue; +} + +unsigned ExhaleEncoder::temporalProcessing () // determine time-domain aspects of ics_info() +{ + const unsigned nChannels = toNumChannels (m_channelConf); + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned nSamplesTempAna = (nSamplesInFrame * 25) >> 4; // pre-delay for look-ahead + const unsigned lfeChannelIndex = (m_channelConf >= CCI_6_CH ? __max (5, nChannels - 1) : USAC_MAX_NUM_CHANNELS); + unsigned ci = 0; // running ch index + unsigned errorValue = 0; // no error + + // get temporal channel statistics for this frame, used for spectral grouping/quantization + m_tempAnalyzer.getTempAnalysisStats (m_tempAnaCurr, nChannels); + m_tempAnalyzer.getTransientLocation (m_tranLocCurr, nChannels); + + // temporal analysis for look-ahead signal (central nSamplesInFrame samples of next frame) + errorValue |= m_tempAnalyzer.temporalAnalysis (m_timeSignals, nChannels, nSamplesInFrame, nSamplesTempAna, lfeChannelIndex); + + // get temporal channel statistics for next frame, used for window length/overlap decision + m_tempAnalyzer.getTempAnalysisStats (m_tempAnaNext, nChannels); + m_tempAnalyzer.getTransientLocation (m_tranLocNext, nChannels); + + m_indepFlag = (((m_frameCount++) % m_indepPeriod) == 0); // configure usacIndependencyFlag + + for (unsigned el = 0; el < m_numElements; el++) // element loop + { + CoreCoderData& coreConfig = *m_elementData[el]; + const unsigned nrChannels = (coreConfig.elementType & 1) + 1; // for UsacCoreCoderData() + + coreConfig.commonWindow = false; + coreConfig.icsInfoPrev[0] = coreConfig.icsInfoCurr[0]; + coreConfig.icsInfoPrev[1] = coreConfig.icsInfoCurr[1]; + + if (coreConfig.elementType >= ID_USAC_LFE) // LFE/EXT elements + { + IcsInfo& icsCurr = coreConfig.icsInfoCurr[0]; + + icsCurr.windowGrouping = 0; + icsCurr.windowSequence = ONLY_LONG; +#if RESTRICT_TO_AAC + icsCurr.windowShape = WINDOW_SINE; +#else + icsCurr.windowShape = WINDOW_KBD; +#endif + ci++; + } + else // SCE or CPE: short-window, low-overlap, and sine-shape detection for each channel + { + unsigned tsCurr[2]; // save temporal stationarity values + unsigned tsNext[2]; // for common_window decision in CPE + + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + const IcsInfo& icsPrev = coreConfig.icsInfoPrev[ch]; + IcsInfo& icsCurr = coreConfig.icsInfoCurr[ch]; + const USAC_WSEQ wsPrev = icsPrev.windowSequence; + USAC_WSEQ& wsCurr = icsCurr.windowSequence; + // get temporal signal statistics, then determine overlap config. for the next frame + const unsigned sfCurr = (m_tempAnaCurr[ci] >> 24) & UCHAR_MAX; + const unsigned tfCurr = (m_tempAnaCurr[ci] >> 16) & UCHAR_MAX; + const unsigned sfNext = (m_tempAnaNext[ci] >> 24) & UCHAR_MAX; + const unsigned tfNext = (m_tempAnaNext[ci] >> 16) & UCHAR_MAX; + + tsCurr[ch] = (m_tempAnaCurr[ci] /*R*/) & UCHAR_MAX; + tsNext[ch] = (m_tempAnaNext[ci] >> 8) & UCHAR_MAX; + + const bool lowOlapNext = (m_tranLocNext[ci] >= 0) || (sfNext < 68 && tfNext >= 204) || (tsCurr[ch] >= 153) || (tsNext[ch] >= 153); + const bool sineWinCurr = (sfCurr >= 170) && (sfNext >= 170) && (sfCurr < 221) && (sfNext < 221) && (tsCurr[ch] < 20) && + (tfCurr >= 153) && (tfNext >= 153) && (tfCurr < 184) && (tfNext < 184) && (tsNext[ch] < 20); + // set window_sequence + if ((wsPrev == ONLY_LONG) || (wsPrev == LONG_STOP)) // 1st window half - max overlap + { + wsCurr = (lowOlapNext ? LONG_START : ONLY_LONG); + } + else // LONG_START_SEQUENCE, STOP_START_SEQUENCE, EIGHT_SHORT_SEQUENCE - min overlap + { + wsCurr = (m_tranLocCurr[ci] >= 0) ? EIGHT_SHORT : +#if RESTRICT_TO_AAC + (lowOlapNext ? EIGHT_SHORT : LONG_STOP); +#else + (lowOlapNext ? STOP_START : LONG_STOP); +#endif + } + + // set window_shape + if ((wsCurr == ONLY_LONG) || (wsCurr == LONG_STOP)) // 2nd window half - max overlap + { + icsCurr.windowShape = (sineWinCurr ? WINDOW_SINE : WINDOW_KBD); + } + else // LONG_START_SEQUENCE, STOP_START_SEQUENCE, EIGHT_SHORT_SEQUENCE - min overlap + { + icsCurr.windowShape = (m_tranLocCurr[ci] >= 0) ? WINDOW_KBD : + (sineWinCurr ? WINDOW_SINE : WINDOW_KBD); + } + + // set scale_factor_grouping + icsCurr.windowGrouping = (wsCurr == EIGHT_SHORT ? (m_tranLocCurr[ci] * 8) / (int16_t) nSamplesInFrame : 0); + ci++; + } // for ch + + if (nrChannels > 1) // common_window element detection for use in StereoCoreToolInfo() + { + IcsInfo& icsInfo0 = coreConfig.icsInfoCurr[0]; + IcsInfo& icsInfo1 = coreConfig.icsInfoCurr[1]; + USAC_WSEQ& winSeq0 = icsInfo0.windowSequence; + USAC_WSEQ& winSeq1 = icsInfo1.windowSequence; + + if (winSeq0 != winSeq1) // try to synch window_sequences + { + const USAC_WSEQ initialWs0 = (USAC_WSEQ) winSeq0; + const USAC_WSEQ initialWs1 = (USAC_WSEQ) winSeq1; + + winSeq0 = winSeq1 = windowSequenceSynch[initialWs0][initialWs1]; // equalization + if ((winSeq0 != initialWs0) && (winSeq0 == EIGHT_SHORT)) + { +#if !RESTRICT_TO_AAC + if ((tsCurr[0] * 7 < tsCurr[1] * 2) && (tsNext[0] * 7 < tsNext[1] * 2)) + { + winSeq0 = STOP_START; // don't synchronize to EIGHT_SHORT but keep low overlap + } + else +#endif + icsInfo0.windowGrouping = icsInfo1.windowGrouping; + } + if ((winSeq1 != initialWs1) && (winSeq1 == EIGHT_SHORT)) + { +#if !RESTRICT_TO_AAC + if ((tsCurr[1] * 7 < tsCurr[0] * 2) && (tsNext[1] * 7 < tsNext[0] * 2)) + { + winSeq1 = STOP_START; // don't synchronize to EIGHT_SHORT but keep low overlap + } + else +#endif + icsInfo1.windowGrouping = icsInfo0.windowGrouping; + } + } + else if (winSeq0 == EIGHT_SHORT) // resynchronize scale_factor_grouping if necessary + { + const int16_t tranLocSynch = __min (m_tranLocCurr[ci - 2], m_tranLocCurr[ci - 1]); + + icsInfo0.windowGrouping = icsInfo1.windowGrouping = (tranLocSynch * 8) / (int16_t) nSamplesInFrame; + } + + if ((icsInfo0.windowShape != WINDOW_SINE) || (icsInfo1.windowShape != WINDOW_SINE)) + { + icsInfo0.windowShape = WINDOW_KBD; // always synchronize window_shapes in order to + icsInfo1.windowShape = WINDOW_KBD; // encourage synch in next frame; KBD dominates + } + coreConfig.commonWindow = (winSeq0 == winSeq1); // synch + } // if nrChannels > 1 + } + + ci -= nrChannels; // modulated complex lapped transform (MCLT) for all channels, windows + + for (unsigned ch = 0; ch < nrChannels; ch++) // channel loop + { + const IcsInfo& icsPrev = coreConfig.icsInfoPrev[ch]; + const IcsInfo& icsCurr = coreConfig.icsInfoCurr[ch]; + const USAC_WSEQ wsCurr = icsCurr.windowSequence; + const bool eightShorts = (wsCurr == EIGHT_SHORT); + SfbGroupData& grpData = coreConfig.groupingData[ch]; + + grpData.numWindowGroups = (eightShorts ? NUM_WINDOW_GROUPS : 1); // fill groupingData + memcpy (grpData.windowGroupLength, windowGroupingTable[icsCurr.windowGrouping], NUM_WINDOW_GROUPS * sizeof (unsigned char)); + + errorValue |= m_transform.applyMCLT (m_timeSignals[ci], eightShorts, icsPrev.windowShape != WINDOW_SINE, icsCurr.windowShape != WINDOW_SINE, + wsCurr > LONG_START /*lOL*/, (wsCurr % 3) != ONLY_LONG /*lOR*/, m_mdctSignals[ci], m_mdstSignals[ci]); + m_scaleFacData[ci] = &grpData; + ci++; + } + } // for el + + return errorValue; +} + +// constructor +ExhaleEncoder::ExhaleEncoder (int32_t* const inputPcmData, unsigned char* const outputAuData, + const unsigned sampleRate /*= 44100*/, const unsigned numChannels /*= 2*/, + const unsigned frameLength /*= 1024*/, const unsigned indepPeriod /*= 45*/, + const unsigned varBitRateMode /*= 3*/ +#if !RESTRICT_TO_AAC + , const bool useNoiseFilling /*= true*/, const bool useEcodisExt /*= false*/ +#endif + ) +{ + // adopt basic coding parameters + m_bitRateMode = __min (9, varBitRateMode); + m_channelConf = (numChannels >= 7 ? CCI_UNDEF : (USAC_CCI) numChannels); // see 23003-3, Tables 73 & 161 + if (m_channelConf == CCI_CONF) + { + m_channelConf = CCI_2_CHM; // passing numChannels = 0 to ExhaleEncoder is interpreted as 2-ch dual-mono + } + m_numElements = elementCountConfig[m_channelConf % USAC_MAX_NUM_ELCONFIGS]; // used in UsacDecoderConfig + m_frameCount = 0; + m_frameLength = (USAC_CCFL) frameLength; // coreCoderFrameLength, signaled using coreSbrFrameLengthIndex + m_frequencyIdx = toSamplingFrequencyIndex (sampleRate); // I/O sample rate as usacSamplingFrequencyIndex + m_indepFlag = true; // usacIndependencyFlag in UsacFrame(), will be set per frame, true in first frame + m_indepPeriod = (indepPeriod == 0 ? UINT_MAX : indepPeriod); // RAP, signaled using usacIndependencyFlag +#if !RESTRICT_TO_AAC + m_nonMpegExt = useEcodisExt; +#endif + m_numSwbShort = MAX_NUM_SWB_SHORT; + m_outAuData = outputAuData; + m_pcm24Data = inputPcmData; + m_tempIntBuf = nullptr; + + // initialize all helper structs + for (unsigned el = 0; el < USAC_MAX_NUM_ELEMENTS; el++) + { + const ELEM_TYPE et = elementTypeConfig[m_channelConf % USAC_MAX_NUM_ELCONFIGS][el]; // usacElementType + + m_elementData[el] = nullptr; +#if !RESTRICT_TO_AAC + m_noiseFilling[el] = (useNoiseFilling && (et < ID_USAC_LFE)); + m_timeWarping[el] = (false /* N/A */ && (et < ID_USAC_LFE)); +#endif + } + // initialize all signal buffers + for (unsigned ch = 0; ch < USAC_MAX_NUM_CHANNELS; ch++) + { + m_bandwidCurr[ch] = 0; + m_bandwidPrev[ch] = 0; + m_mdctQuantMag[ch] = nullptr; + m_mdctSignals[ch] = nullptr; + m_mdstSignals[ch] = nullptr; + m_scaleFacData[ch] = nullptr; + m_specAnaCurr[ch] = 0; + m_specAnaPrev[ch] = 0; + m_tempAnaCurr[ch] = 0; + m_tempAnaNext[ch] = 0; + m_timeSignals[ch] = nullptr; + m_tranLocCurr[ch] = -1; + m_tranLocNext[ch] = -1; + } + // initialize all window buffers + for (unsigned ws = WINDOW_SINE; ws <= WINDOW_KBD; ws++) + { + m_timeWindowL[ws] = nullptr; + m_timeWindowS[ws] = nullptr; + } +} + +// destructor +ExhaleEncoder::~ExhaleEncoder () +{ + // free allocated helper structs + for (unsigned el = 0; el < USAC_MAX_NUM_ELEMENTS; el++) + { + MFREE (m_elementData[el]); + } + // free allocated signal buffers + for (unsigned ch = 0; ch < USAC_MAX_NUM_CHANNELS; ch++) + { + MFREE (m_mdctQuantMag[ch]); + MFREE (m_mdctSignals[ch]); + MFREE (m_mdstSignals[ch]); + MFREE (m_timeSignals[ch]); + } + // free allocated window buffers + for (unsigned ws = WINDOW_SINE; ws <= WINDOW_KBD; ws++) + { + MFREE (m_timeWindowL[ws]); + MFREE (m_timeWindowS[ws]); + } + // execute sub-class destructors +} + +// public functions +unsigned ExhaleEncoder::encodeLookahead () +{ + const unsigned nChannels = toNumChannels (m_channelConf); + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned nSamplesTempAna = (nSamplesInFrame * 25) >> 4; // pre-delay for look-ahead + const int32_t* chSig = m_pcm24Data; + unsigned ch, s; + + // copy nSamplesInFrame external channel-interleaved samples into internal channel buffers + for (s = 0; s < nSamplesInFrame; s++) // sample loop + { + for (ch = 0; ch < nChannels; ch++) // channel loop + { + m_timeSignals[ch][nSamplesTempAna + s] = *(chSig++); + } + } + + // generate first nSamplesTempAna deinterleaved samples (previous frame data) by LP filter + for (ch = 0; ch < nChannels; ch++) + { + short filterC[MAX_PREDICTION_ORDER] = {0, 0, 0, 0}; + short parCorC[MAX_PREDICTION_ORDER] = {0, 0, 0, 0}; + int32_t* predSig = &m_timeSignals[ch][nSamplesTempAna]; // end of signal to be predicted + + m_linPredictor.calcParCorCoeffs (predSig, uint16_t (nSamplesInFrame >> 1), MAX_PREDICTION_ORDER, parCorC); + m_linPredictor.parCorToLpCoeffs (parCorC, MAX_PREDICTION_ORDER, filterC); + + for (s = nSamplesTempAna; s > 0; s--) // generate prediction signal without limit cycles + { + const int64_t predSample = *(predSig + 0) * (int64_t) filterC[0] + *(predSig + 1) * (int64_t) filterC[1] + + *(predSig + 2) * (int64_t) filterC[2] + *(predSig + 3) * (int64_t) filterC[3]; + *(--predSig) = int32_t ((predSample > 0 ? -predSample + (1 << 9) - 1 : -predSample) >> 9); + } + } + + // set initial temporal channel statistic to something meaningful before first coded frame + m_tempAnalyzer.temporalAnalysis (m_timeSignals, nChannels, nSamplesInFrame, nSamplesTempAna - nSamplesInFrame); + + if (temporalProcessing ()) // time domain: window length, overlap, grouping, and transform + { + return 2; // internal error in temporal processing + } + if (spectralProcessing ()) // MCLT domain: (common_)max_sfb, grouping 2, TNS, and SFB data + { + return 2; // internal error in spectral processing + } + if (psychBitAllocation ()) // SFB domain: psychoacoustic model and scale factor estimation + { + return 1; // internal error in bit-allocation code + } + + return quantizationCoding (); // max(3, coded bytes) +} + +unsigned ExhaleEncoder::encodeFrame () +{ + const unsigned nChannels = toNumChannels (m_channelConf); + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned nSamplesTempAna = (nSamplesInFrame * 25) >> 4; // pre-delay for look-ahead + const int32_t* chSig = m_pcm24Data; + unsigned ch, s; + + // move internal channel buffers nSamplesInFrame to the past to make room for next samples + for (ch = 0; ch < nChannels; ch++) + { + memcpy (&m_timeSignals[ch][0], &m_timeSignals[ch][nSamplesInFrame], nSamplesInFrame * sizeof (int32_t)); + memcpy (&m_timeSignals[ch][nSamplesInFrame], &m_timeSignals[ch][2 * nSamplesInFrame], (nSamplesTempAna - nSamplesInFrame) * sizeof (int32_t)); + } + + // copy nSamplesInFrame external channel-interleaved samples into internal channel buffers + for (s = 0; s < nSamplesInFrame; s++) // sample loop + { + for (ch = 0; ch < nChannels; ch++) // channel loop + { + m_timeSignals[ch][nSamplesTempAna + s] = *(chSig++); + } + } + + if (temporalProcessing ()) // time domain: window length, overlap, grouping, and transform + { + return 2; // internal error in temporal processing + } + if (spectralProcessing ()) // MCLT domain: (common_)max_sfb, grouping 2, TNS, and SFB data + { + return 2; // internal error in spectral processing + } + if (psychBitAllocation ()) // SFB domain: psychoacoustic model and scale factor estimation + { + return 1; // internal error in bit-allocation code + } + + return quantizationCoding (); // max(3, coded bytes) +} + +unsigned ExhaleEncoder::initEncoder (unsigned char* const audioConfigBuffer, uint32_t* const audioConfigBytes /*= nullptr*/) +{ + const unsigned nChannels = toNumChannels (m_channelConf); + const unsigned nSamplesInFrame = toFrameLength (m_frameLength); + const unsigned specSigBufSize = nSamplesInFrame * sizeof (int32_t); + const unsigned timeSigBufSize = ((nSamplesInFrame * 41) >> 4) * sizeof (int32_t); // core-codec delay*4 + const unsigned char chConf = m_channelConf; + unsigned errorValue = 0; // no error + + // check user's input parameters +#if RESTRICT_TO_AAC + if ((m_channelConf <= CCI_CONF) || (m_channelConf > CCI_8_CH)) +#else + if ((m_channelConf <= CCI_CONF) || (m_channelConf > CCI_8_CHS)) +#endif + { + errorValue |= 128; + } +#if RESTRICT_TO_AAC + if (m_frameLength != CCFL_1024) +#else + if ((m_frameLength != CCFL_768) && (m_frameLength != CCFL_1024)) +#endif + { + errorValue |= 64; + } + if (m_frequencyIdx < 0) + { + errorValue |= 32; + } + if ((m_outAuData == nullptr) || (m_pcm24Data == nullptr)) + { + errorValue |= 16; + } + if (errorValue > 0) return errorValue; + + // allocate all helper structs + for (unsigned el = 0; el < m_numElements; el++) // element loop + { + if ((m_elementData[el] = (CoreCoderData*) malloc (sizeof (CoreCoderData))) == nullptr) + { + errorValue |= 8; + } + else + { + memset (m_elementData[el], 0, sizeof (CoreCoderData)); + m_elementData[el]->elementType = elementTypeConfig[chConf][el]; // usacElementType[el] + } + } + // allocate all signal buffers + for (unsigned ch = 0; ch < nChannels; ch++) + { + if ((m_entropyCoder[ch].initCodingMemory (nSamplesInFrame) > 0) || + (m_mdctQuantMag[ch] = (unsigned char*) malloc (nSamplesInFrame * sizeof (unsigned char))) == nullptr || + (m_mdctSignals[ch] = (int32_t*) malloc (specSigBufSize)) == nullptr || + (m_mdstSignals[ch] = (int32_t*) malloc (specSigBufSize)) == nullptr || + (m_timeSignals[ch] = (int32_t*) malloc (timeSigBufSize)) == nullptr) + { + errorValue |= 4; + } + } + // allocate all window buffers + for (unsigned ws = WINDOW_SINE; ws <= WINDOW_KBD; ws++) + { + if ((m_timeWindowL[ws] = initWindowHalfCoeffs ((USAC_WSHP) ws, nSamplesInFrame)) == nullptr || + (m_timeWindowS[ws] = initWindowHalfCoeffs ((USAC_WSHP) ws, nSamplesInFrame >> 3)) == nullptr) + { + errorValue |= 2; + } + } + if (errorValue > 0) return errorValue; + + // initialize coder class memory + errorValue = (unsigned) m_frequencyIdx; // for temporary storage +#if RESTRICT_TO_AAC + m_swbTableIdx = freqIdxToSwbTableIdxAAC[errorValue]; +#else + m_swbTableIdx = (m_frameLength == CCFL_768 ? freqIdxToSwbTableIdx768[errorValue] : freqIdxToSwbTableIdxAAC[errorValue]); +#endif + m_tempIntBuf = m_timeSignals[0]; + errorValue = 0; +#if EC_TRELLIS_OPT_CODING + if (m_sfbQuantizer.initQuantMemory (nSamplesInFrame, numSwbOffsetL[m_swbTableIdx] - 1, m_bitRateMode) > 0 || +#else + if (m_sfbQuantizer.initQuantMemory (nSamplesInFrame) > 0 || +#endif + m_specAnalyzer.initLinPredictor (&m_linPredictor) > 0 || + m_transform.initConstants (m_tempIntBuf, m_timeWindowL, m_timeWindowS, nSamplesInFrame) > 0) + { + errorValue |= 1; + } + + if ((errorValue == 0) && (audioConfigBuffer != nullptr)) // save UsacConfig() for writeout + { + errorValue = m_outStream.createAudioConfig (m_frequencyIdx, m_frameLength != CCFL_1024, chConf, m_numElements, + elementTypeConfig[chConf], false /*usacConfigExtensionPresent=0*/, +#if !RESTRICT_TO_AAC + m_timeWarping, m_noiseFilling, +#endif + audioConfigBuffer); + if (audioConfigBytes) *audioConfigBytes = errorValue; // length of UsacConfig() in bytes + errorValue = (errorValue == 0 ? 1 : 0); + } + + return errorValue; +} diff --git a/src/lib/exhaleEnc.h b/src/lib/exhaleEnc.h new file mode 100644 index 0000000..f729292 --- /dev/null +++ b/src/lib/exhaleEnc.h @@ -0,0 +1,143 @@ +/* exhaleEnc.h - header file for class providing Extended HE-AAC encoding capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _EXHALE_ENC_H_ +#define _EXHALE_ENC_H_ + +#include "exhaleLibPch.h" +#include "bitAllocation.h" +#include "bitStreamWriter.h" +#include "entropyCoding.h" +#include "lappedTransform.h" +#include "linearPrediction.h" +#include "quantization.h" +#include "specAnalysis.h" +#include "specGapFilling.h" +#include "tempAnalysis.h" + +// constant and experimental macro +#define WIN_SCALE double (1 << 23) +#define EE_OPT_TNS_SPEC_RANGE 1 + +// channelConfigurationIndex setup +typedef enum USAC_CCI : char +{ + CCI_UNDEF = -1, + CCI_CONF = 0, // channel-to-speaker mapping defined in UsacChannelConfig() (not to be used here!) + CCI_1_CH = 1, // 1.0: front-center + CCI_2_CH = 2, // 2.0: front-left, front-right + CCI_3_CH = 3, // 3.0: front-center, front-left, front-right + CCI_4_CH = 4, // 4.0: front-center, front-left, front-right, back-center + CCI_5_CH = 5, // 5.0: front-center, front-left, front-right, back-left, back-right + CCI_6_CH = 6, // 5.1: front-center, front-left, front-right, back-left, back-right, LFE + CCI_8_CH = 7, // 7.1: front-center, front-left, front-right, side-left, side-right, back-left, back-right, LFE + CCI_2_CHM = 8, // 2.0, dual-mono: channel1, channel2 + CCI_3_CHR = 9, // 3.0, R-rotated: front-left, front-right, back-center + CCI_4_CHR = 10, // 4.0, R-rotated: front-left, front-right, back-left, back-right + CCI_7_CH = 11, // 6.1: front-center, front-left, front-right, back-left, back-right, back-center, LFE + CCI_8_CHS = 12 // 7.1, surround: front-center, front-L, front-R, surround-L, surround-R, back-L, back-R, LFE +} USAC_CCI; + +// coreCoderFrameLength definition +typedef enum USAC_CCFL : short +{ + CCFL_UNDEF = -1, +#if !RESTRICT_TO_AAC + CCFL_768 = 768, // LD +#endif + CCFL_1024 = 1024 // LC +} USAC_CCFL; + +// overall xHE-AAC encoding class +class ExhaleEncoder +{ +private: + + // member variables + uint16_t m_bandwidCurr[USAC_MAX_NUM_CHANNELS]; + uint16_t m_bandwidPrev[USAC_MAX_NUM_CHANNELS]; + BitAllocator m_bitAllocator; // for scale factor init + uint8_t m_bitRateMode; + USAC_CCI m_channelConf; + CoreCoderData* m_elementData[USAC_MAX_NUM_ELEMENTS]; + EntropyCoder m_entropyCoder[USAC_MAX_NUM_CHANNELS]; + uint32_t m_frameCount; + USAC_CCFL m_frameLength; + char m_frequencyIdx; + bool m_indepFlag; // usacIndependencyFlag bit + uint32_t m_indepPeriod; + LinearPredictor m_linPredictor; // for pre-roll est, TNS + uint8_t* m_mdctQuantMag[USAC_MAX_NUM_CHANNELS]; + int32_t* m_mdctSignals[USAC_MAX_NUM_CHANNELS]; + int32_t* m_mdstSignals[USAC_MAX_NUM_CHANNELS]; +#if !RESTRICT_TO_AAC + bool m_noiseFilling[USAC_MAX_NUM_ELEMENTS]; + bool m_nonMpegExt; +#endif + uint8_t m_numElements; + uint8_t m_numSwbShort; + uint8_t* m_outAuData; + BitStreamWriter m_outStream; // for access unit creation + int32_t* m_pcm24Data; + SfbGroupData* m_scaleFacData[USAC_MAX_NUM_CHANNELS]; + SfbQuantizer m_sfbQuantizer; // powerlaw quantization + SpecAnalyzer m_specAnalyzer; // for spectral analysis + uint32_t m_specAnaCurr[USAC_MAX_NUM_CHANNELS]; + uint32_t m_specAnaPrev[USAC_MAX_NUM_CHANNELS]; +#if !RESTRICT_TO_AAC + SpecGapFiller m_specGapFiller;// for noise/gap filling +#endif + uint8_t m_swbTableIdx; + TempAnalyzer m_tempAnalyzer; // for temporal analysis + uint32_t m_tempAnaCurr[USAC_MAX_NUM_CHANNELS]; + uint32_t m_tempAnaNext[USAC_MAX_NUM_CHANNELS]; + int32_t* m_tempIntBuf; // temporary int32 buffer + int32_t* m_timeSignals[USAC_MAX_NUM_CHANNELS]; +#if !RESTRICT_TO_AAC + bool m_timeWarping[USAC_MAX_NUM_ELEMENTS]; +#endif + int32_t* m_timeWindowL[2]; // long window halves + int32_t* m_timeWindowS[2]; // short window halves + int16_t m_tranLocCurr[USAC_MAX_NUM_CHANNELS]; + int16_t m_tranLocNext[USAC_MAX_NUM_CHANNELS]; + LappedTransform m_transform; // time-frequency transform + + // helper functions + unsigned applyTnsToWinGroup (TnsData& tnsData, SfbGroupData& grpData, const bool eightShorts, const uint8_t maxSfb, + const unsigned channelIndex); + unsigned eightShortGrouping (SfbGroupData& grpData, uint16_t* const grpOffsets, int32_t* const mdctSignal); + unsigned getOptParCorCoeffs (const int32_t* const mdctSignal, const SfbGroupData& grpData, const uint8_t maxSfb, + const unsigned channelIndex, TnsData& tnsData, const uint8_t firstGroupIndexToTest = 0); + unsigned psychBitAllocation (); + unsigned quantizationCoding (); + unsigned spectralProcessing (); + unsigned temporalProcessing (); + +public: + + // constructor + ExhaleEncoder (int32_t* const inputPcmData, unsigned char* const outputAuData, + const unsigned sampleRate = 44100, const unsigned numChannels = 2, + const unsigned frameLength = 1024, const unsigned indepPeriod = 45, + const unsigned varBitRateMode = 3 +#if !RESTRICT_TO_AAC + , const bool useNoiseFilling = true, const bool useEcodisExt = false +#endif + ); + // destructor + ~ExhaleEncoder (); + // public functions + unsigned encodeLookahead (); + unsigned encodeFrame (); + unsigned initEncoder (unsigned char* const audioConfigBuffer, uint32_t* const audioConfigBytes = nullptr); + +}; // ExhaleEncoder + +#endif // _EXHALE_ENC_H_ diff --git a/src/lib/exhaleLibPch.cpp b/src/lib/exhaleLibPch.cpp new file mode 100644 index 0000000..8c4e100 --- /dev/null +++ b/src/lib/exhaleLibPch.cpp @@ -0,0 +1,85 @@ +/* exhaleLibPch.cpp - pre-compiled source file for classes of exhaleLib coding library + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" + +// public bit-stream functions +void OutputStream::reset () // clear writer states and byte buffer +{ + heldBitChunk = 0; + heldBitCount = 0; + stream.clear (); +} + +void OutputStream::write (const uint32_t bitChunk, const uint8_t bitCount) +{ + if (bitCount > 32) return; // only a maximum of 32 bits is writable at once + + const uint8_t totalBitCount = bitCount + heldBitCount; + const uint8_t totalByteCount = totalBitCount >> 3; // to be written + const uint8_t newHeldBitCount = totalBitCount & 7; // not yet written + const uint8_t newHeldBitChunk = (bitChunk << (8 - newHeldBitCount)) & UCHAR_MAX; + + if (totalByteCount == 0) // not enough bits to write, only update held bits + { + heldBitChunk |= newHeldBitChunk; + } + else // write bits + { + const uint32_t writtenChunk = (heldBitChunk << uint32_t ((bitCount - newHeldBitCount) & ~7)) | (bitChunk >> newHeldBitCount); + switch (totalByteCount) + { + case 4: stream.push_back (writtenChunk >> 24); + case 3: stream.push_back (writtenChunk >> 16); + case 2: stream.push_back (writtenChunk >> 8); + case 1: stream.push_back (writtenChunk); + } + heldBitChunk = newHeldBitChunk; + } + heldBitCount = newHeldBitCount; +} + +// ISO/IEC 23003-3, Table 67 +static const unsigned allowedSamplingRates[USAC_NUM_SAMPLE_RATES] = { + 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, // AAC + 57600, 51200, 40000, 38400, 34150, 28800, 25600, 20000, 19200, 17075, 14400, 12800, 9600 // USAC +}; + +// public sampling rate functions +char toSamplingFrequencyIndex (const unsigned samplingRate) +{ + for (char i = 0; i < AAC_NUM_SAMPLE_RATES; i++) + { + if (samplingRate == allowedSamplingRates[(int) i]) // AAC rate + { + return i; + } +#if !RESTRICT_TO_AAC + if (samplingRate == allowedSamplingRates[i + AAC_NUM_SAMPLE_RATES]) + { + return i + AAC_NUM_SAMPLE_RATES + 2; // skip reserved entry + } +#endif + } + return -1; // no index found +} + +unsigned toSamplingRate (const char samplingFrequencyIndex) +{ +#if RESTRICT_TO_AAC + if ((samplingFrequencyIndex < 0) || (samplingFrequencyIndex >= AAC_NUM_SAMPLE_RATES)) +#else + if ((samplingFrequencyIndex < 0) || (samplingFrequencyIndex >= USAC_NUM_SAMPLE_RATES + 2)) +#endif + { + return 0; // invalid index + } + return allowedSamplingRates[samplingFrequencyIndex > AAC_NUM_SAMPLE_RATES ? samplingFrequencyIndex - 2 : samplingFrequencyIndex]; +} diff --git a/src/lib/exhaleLibPch.h b/src/lib/exhaleLibPch.h new file mode 100644 index 0000000..8b0e594 --- /dev/null +++ b/src/lib/exhaleLibPch.h @@ -0,0 +1,176 @@ +/* exhaleLibPch.h - pre-compiled header file for classes of exhaleLib coding library + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _EXHALE_LIB_PCH_H_ +#define _EXHALE_LIB_PCH_H_ + +#include // for .._MAX, .._MIN +#include // for pow, sin, sqrt +#include // for (u)int8_t, (u)int16_t, (u)int32_t, (u)int64_t +#include // for abs, div, calloc, malloc, free, (__)max, (__)min, (s)rand +#include // for memcpy, memset +#include // for std::vector <> + +// constants, experimental macros +#define AAC_NUM_SAMPLE_RATES 13 +#define MAX_PREDICTION_ORDER 4 +#define MAX_NUM_SWB_LFE 6 +#define MAX_NUM_SWB_SHORT 15 +#define MIN_NUM_SWB_SHORT 12 +#define NUM_WINDOW_GROUPS 4 // must be between 4 and 8 +#define USAC_MAX_NUM_CHANNELS 8 +#define USAC_MAX_NUM_ELCONFIGS 13 +#define USAC_MAX_NUM_ELEMENTS 5 +#define USAC_NUM_FREQ_TABLES 6 +#define USAC_NUM_SAMPLE_RATES (2 * AAC_NUM_SAMPLE_RATES) + +#define RESTRICT_TO_AAC 0 // allow only AAC tool-set + +#if RESTRICT_TO_AAC +# define LFE_MAX 12 +#else +# define LFE_MAX 24 +#endif + +#ifndef __max +# define __max(a, b) ((a) > (b) ? (a) : (b)) +#endif +#ifndef __min +# define __min(a, b) ((a) < (b) ? (a) : (b)) +#endif +#ifndef CLIP_PM +# define CLIP_PM(x, clip) (__max (-clip, __min (+clip, x))) +#endif +#ifndef CLIP_UCHAR +# define CLIP_UCHAR(x) (__max (0, __min (UCHAR_MAX, x))) +#endif + +#ifndef MFREE +# define MFREE(x) if (x != nullptr) { free ((void*) x); x = nullptr; } +#endif + +// usacElementType[el] definition +typedef enum ELEM_TYPE : int8_t +{ + ID_EL_UNDEF = -1, + ID_USAC_SCE = 0, // single-channel element (CCI_1_CH) + ID_USAC_CPE = 1, // channel-pair element (CCI_2_CH) + ID_USAC_LFE = 2, // low-frequency effects element (CCI_1_CH) with ONLY_LONG_SEQUENCE, no TNS + ID_USAC_EXT = 3 // extension element (not to be used here!) +} ELEM_TYPE; + +// window_sequence defines for ICS +typedef enum USAC_WSEQ : uint8_t +{ + ONLY_LONG = 0, // one symmetric long window .´`. + LONG_START = 1, // asymmet. long-start window .´|_ + EIGHT_SHORT = 2, // 8 symmetric short windows _MM_ + LONG_STOP = 3, // asymmet. long-stop window _|`. + STOP_START = 4 // symmet. stop-start window _||_ +} USAC_WSEQ; + +// window_shape definition for ICS +typedef enum USAC_WSHP : uint8_t +{ + WINDOW_SINE = 0, // half-sine window = sin(pi*((0:L-1)'+0.5)/L) + WINDOW_KBD = 1 // Kaiser-Bessel derived (KBD) window by Dolby +} USAC_WSHP; + +// ics_info(): channel data struct +struct IcsInfo +{ + uint8_t maxSfb; // max_sfb(1) + uint8_t windowGrouping; // scale_factor_grouping (index) + USAC_WSEQ windowSequence; // window_sequence + USAC_WSHP windowShape; // window_shape +}; + +// tns_data(): channel data struct +struct TnsData +{ + int8_t coeff[3][MAX_PREDICTION_ORDER]; + int16_t coeffParCor[MAX_PREDICTION_ORDER]; + bool coeffResLow; // means coef_res[w]=0 + uint8_t filteredWindow; // filtered window w + bool filterDownward[3]; // direction[f]=1 + uint8_t filterLength[3]; // filter length[f] + uint8_t filterOrder[3]; // filter order[f] + uint8_t numFilters; // n_filt for window w +}; + +// scale factor group. data struct +struct SfbGroupData +{ + uint16_t numWindowGroups; // 1 | NUM_WINDOW_GROUPS, num_window_groups + uint16_t sfbOffsets[1+MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS]; + uint32_t sfbRmsValues[MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS]; + uint8_t scaleFactors[MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS]; // sf[] + uint8_t sfbsPerGroup; // max_sfb(1) duplicate needed by BitAllocator + uint8_t windowGroupLength[NUM_WINDOW_GROUPS]; // window_group_length +}; + +// UsacCoreCoderData() data struct +struct CoreCoderData +{ + bool commonMaxSfb; // common_max_sfb in StereoCoreToolInfo() + bool commonTnsData; // common_tns in StereoCoreToolInfo() + bool commonWindow; // common_window in StereoCoreToolInfo() + ELEM_TYPE elementType; // usacElementType in UsacDecoderConfig() + SfbGroupData groupingData[2]; // window grouping and SFB offset data + IcsInfo icsInfoCurr[2]; // current ics_info() for each channel + IcsInfo icsInfoPrev[2]; // previous ics_info() for each channel +#if !RESTRICT_TO_AAC + uint8_t specFillData[2]; // noise filling data for each channel +#endif + uint8_t stereoConfig; // cplx_pred_data() config: pred_dir etc. + char stereoData[MAX_NUM_SWB_SHORT * NUM_WINDOW_GROUPS]; + uint8_t stereoMode; // ms_mask_present in StereoCoreToolInfo() + bool tnsActive; // tns_active flag in StereoCoreToolInfo() + TnsData tnsData[2]; // current tns_data() for each channel + bool tnsOnLeftRight; // tns_on_lr in StereoCoreToolInfo() +}; + +// bit-stream encoding data struct +struct OutputStream +{ + uint8_t heldBitChunk; // bits not yet flushed to buffer + uint8_t heldBitCount; // number of bits not yet flushed + std::vector stream; // FIFO bit-stream buffer + // constructor + OutputStream () { reset (); } + // destructor + ~OutputStream() { stream.clear (); } + // public functions + void reset (); // clear writer states and byte buffer + void write (const uint32_t bitChunk, const uint8_t bitCount); +}; // OutputStream + +// fast calculation of sqrt (256 - x): (4 + eightTimesSqrt256Minus[x]) >> 3, for 0 <= x <= 255 +const uint8_t eightTimesSqrt256Minus[256] = { + 128, 128, 127, 127, 127, 127, 126, 126, 126, 126, 125, 125, 125, 125, 124, 124, 124, 124, 123, 123, 123, 123, 122, 122, 122, 122, + 121, 121, 121, 121, 120, 120, 120, 119, 119, 119, 119, 118, 118, 118, 118, 117, 117, 117, 116, 116, 116, 116, 115, 115, 115, 115, + 114, 114, 114, 113, 113, 113, 113, 112, 112, 112, 111, 111, 111, 111, 110, 110, 110, 109, 109, 109, 109, 108, 108, 108, 107, 107, + 107, 106, 106, 106, 106, 105, 105, 105, 104, 104, 104, 103, 103, 103, 102, 102, 102, 102, 101, 101, 101, 100, 100, 100, 99, 99, + 99, 98, 98, 98, 97, 97, 97, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91, 91, 90, + 90, 89, 89, 89, 88, 88, 88, 87, 87, 87, 86, 86, 85, 85, 85, 84, 84, 84, 83, 83, 82, 82, 82, 81, 81, 80, + 80, 80, 79, 79, 78, 78, 78, 77, 77, 76, 76, 75, 75, 75, 74, 74, 73, 73, 72, 72, 72, 71, 71, 70, 70, 69, + 69, 68, 68, 67, 67, 66, 66, 65, 65, 64, 64, 63, 63, 62, 62, 61, 61, 60, 60, 59, 59, 58, 58, 57, 57, 56, + 55, 55, 54, 54, 53, 52, 52, 51, 51, 50, 49, 49, 48, 47, 47, 46, 45, 45, 44, 43, 42, 42, 41, 40, 39, 38, + 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 25, 24, 23, 21, 20, 18, 16, 14, 11, 8 +}; + +// fast calculation of x / den: (x * oneTwentyEightOver[den]) >> 7, accurate for 0 <= x <= 162 +const uint8_t oneTwentyEightOver[14] = {0, 128, 64, 43, 32, 26, 22, 19, 16, 15, 13, 12, 11, 10}; + +// public sampling rate functions +char toSamplingFrequencyIndex (const unsigned samplingRate); +unsigned toSamplingRate (const char samplingFrequencyIndex); + +#endif // _EXHALE_LIB_PCH_H_ diff --git a/src/lib/exhaleLib_vs2012.vcxproj b/src/lib/exhaleLib_vs2012.vcxproj new file mode 100644 index 0000000..a0178a2 --- /dev/null +++ b/src/lib/exhaleLib_vs2012.vcxproj @@ -0,0 +1,188 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {EC0D1501-2018-1700-4865-6C6D72696368} + exhaleLib + exhaleLib + + + + StaticLibrary + v110 + true + + + StaticLibrary + v110 + true + + + StaticLibrary + v110 + false + true + + + StaticLibrary + v110 + false + true + + + + + + + + + + + + + + + + + + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + false + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + false + $(SolutionDir)build\$(PlatformToolset)\$(Platform)\$(Configuration)\ + $(SolutionDir)lib\$(PlatformToolset)\$(Platform)\$(Configuration)\ + + + + $(SolutionDir)include + Disabled + Use + exhaleLibPch.h + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + true + Level3 + + + + true + Windows + + + + + $(SolutionDir)include + Disabled + Use + exhaleLibPch.h + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + true + Level3 + + + + true + Windows + + + + + $(SolutionDir)include + true + true + MaxSpeed + Use + exhaleLibPch.h + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + true + Level3 + + + + true + false + true + Windows + + + + + $(SolutionDir)include + true + true + MaxSpeed + Use + exhaleLibPch.h + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + true + Level3 + + + + true + false + true + Windows + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + + + + \ No newline at end of file diff --git a/src/lib/exhaleLib_vs2012.vcxproj.filters b/src/lib/exhaleLib_vs2012.vcxproj.filters new file mode 100644 index 0000000..54637f7 --- /dev/null +++ b/src/lib/exhaleLib_vs2012.vcxproj.filters @@ -0,0 +1,93 @@ + + + + + {EC0D1503-2018-1700-4865-6C6D72696368} + h;hpp + + + {EC0D1504-2018-1700-4865-6C6D72696368} + cpp;c;asm;asmx + + + {EC0D1505-2018-1700-4865-6C6D72696368} + rc;ico + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/src/lib/lappedTransform.cpp b/src/lib/lappedTransform.cpp new file mode 100644 index 0000000..9afe48e --- /dev/null +++ b/src/lib/lappedTransform.cpp @@ -0,0 +1,431 @@ +/* lappedTransform.cpp - source file for class providing time-frequency transformation + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "lappedTransform.h" +#ifdef _MSC_VER +# include // _BitScanReverse + +# pragma intrinsic (_BitScanReverse) +#endif + +// static helper functions +static short* createPermutTable (const short tableSize) +{ + const short lOver2 = tableSize >> 1; + short* permutTable = nullptr; + short i = 0; + + if ((permutTable = (short*) malloc (tableSize * sizeof (short))) == nullptr) + { + return nullptr; // allocation error + } + + permutTable[0] = 0; + for (short s = 1; s < tableSize; s++) + { + short l = lOver2; + + while (i >= l) + { + i -= l; + l >>= 1; + } + permutTable[s] = (i += l); + } + + return permutTable; +} + +static inline int shortIntLog2 (uint16_t s) +{ +#ifdef _MSC_VER + unsigned long l; + + _BitScanReverse (&l, s); + + return (int) l; +#else + // fast base-2 integer logarithm by Todd Lehman (Stack Overflow), July 2014 + int i = 0; +# define S(k) if (s >= (1u << k)) { i += k; s >>= k; } + S (8); S (4); S (2); S (1); +# undef S + return i; +#endif +} + +// private helper functions +void LappedTransform::applyHalfSizeFFT (int32_t* const iR/*eal*/, int32_t* const iI/*mag*/, const bool shortTransform) // works in-place +{ + // int32 FFT version based on http://paulbourke.net/miscellaneous/dft, 1993 + const int l = (shortTransform ? m_transfLengthS : m_transfLengthL) >> 1; + const short* p = (shortTransform ? m_fftPermutS : m_fftPermutL); // look-up + int l2 = 1, l3 = m_transfLengthL >> 1; + + if (iR == nullptr) + { + return; // null-pointer input error + } + + // sort input with permutation look-up table + if (iI != nullptr) + { + for (int i = l - 1; i >= 0; i--) + { + const int j = p[i]; + + if (j > i) // swap input data at i and j + { + const int32_t iRTmp = iR[i]; // use re- + const int32_t iITmp = iI[i]; // gisters + + iR[i] = iR[j]; + iI[i] = iI[j]; + iR[j] = iRTmp; + iI[j] = iITmp; + } + } + } + else // real-valued input, no imaginary part + { + for (int i = l - 1; i >= 0; i--) + { + const int j = p[i]; + + if (j > i) // swap real input at i and j + { + const int32_t iRTmp = iR[i]; + + iR[i] = iR[j]; + iR[j] = iRTmp; + } + iI[i] = 0; // zero imaginary input data + } + } + + // get length-l Fast Fourier Transform (FFT) + for (int k = shortIntLog2 ((uint16_t) l) - 1; k >= 0; k--) + { + const int l1 = l2; + l2 <<= 1; + l3 >>= 1; + + for (int j = l1 - 1; j >= 0; j--) + { + const int jTl3 = j * l3; + const int64_t cosjl3 = m_fftHalfCos[jTl3]; // cos/sin + const int64_t sinjl3 = m_fftHalfSin[jTl3]; // look-up + + for (int i = j; i < l; i += l2) + { + const int iPl1 = i + l1; + const int32_t rotR = int32_t ((cosjl3 * iR[iPl1] + sinjl3 * iI[iPl1] + LUT_OFFSET) >> LUT_SHIFT); // clockwise + const int32_t rotI = int32_t ((cosjl3 * iI[iPl1] - sinjl3 * iR[iPl1] + LUT_OFFSET) >> LUT_SHIFT); // rotation + + iR[iPl1] = iR[i] + rotR; iR[i] -= rotR; + iI[iPl1] = iI[i] + rotI; iI[i] -= rotI; + } + } + } +} + +void LappedTransform::windowAndFoldInL (const int32_t* inputL, const bool shortTransform, const bool kbdWindowL, const bool lowOverlapL, + const bool mdstKernel, int32_t* const output) +{ + const unsigned ws = (kbdWindowL ? 1 : 0); // shape + const int32_t* wl = (lowOverlapL ? m_timeWindowS[ws] : m_timeWindowL[ws]); + const int Mo2 = (shortTransform ? m_transfLengthS : m_transfLengthL) >> 1; + const int Mm1 = Mo2 * 2 - 1; + const int Mo2m1 = Mo2 - 1; + const int Mo2mO = (lowOverlapL ? Mo2 - (m_transfLengthS >> 1) : 0); + const int Mm1mO = Mm1 - Mo2mO; // overlap offset + int n; + + if (mdstKernel) // time-reversal and TDA sign flip + { + for (n = Mo2m1; n >= Mo2mO; n--) // windowed pt. + { + const int64_t i64 = (int64_t) inputL[Mm1 - n] * wl[Mm1mO - n] + (int64_t) inputL[n] * wl[n - Mo2mO]; + + output[Mo2m1 - n] = int32_t ((i64 + WIN_OFFSET) >> WIN_SHIFT); + } + for (/*Mo2mO-1*/; n >= 0; n--) // unwindowed pt. + { + output[Mo2m1 - n] = (inputL[Mm1 - n] + 2) >> 2; + } + } + else // MDCT kernel, no time-reversal or sign flip + { + for (n = Mo2m1; n >= Mo2mO; n--) // windowed pt. + { + const int64_t i64 = (int64_t) inputL[Mm1 - n] * wl[Mm1mO - n] - (int64_t) inputL[n] * wl[n - Mo2mO]; + + output[Mo2 + n] = int32_t ((i64 + WIN_OFFSET) >> WIN_SHIFT); + } + for (/*Mo2mO-1*/; n >= 0; n--) // unwindowed pt. + { + output[Mo2 + n] = (inputL[Mm1 - n] + 2) >> 2; + } + } +} + +void LappedTransform::windowAndFoldInR (const int32_t* inputR, const bool shortTransform, const bool kbdWindowR, const bool lowOverlapR, + const bool mdstKernel, int32_t* const output) +{ + const unsigned ws = (kbdWindowR ? 1 : 0); // shape + const int32_t* wr = (lowOverlapR ? m_timeWindowS[ws] : m_timeWindowL[ws]); + const int Mo2 = (shortTransform ? m_transfLengthS : m_transfLengthL) >> 1; + const int Mm1 = Mo2 * 2 - 1; + const int Mo2m1 = Mo2 - 1; + const int Mo2mO = (lowOverlapR ? Mo2 - (m_transfLengthS >> 1) : 0); + const int Mm1mO = Mm1 - Mo2mO; // overlap offset + int n; + + if (mdstKernel) // time-reversal and TDA sign flip + { + for (n = Mo2m1; n >= Mo2mO; n--) // windowed pt. + { + const int64_t i64 = (int64_t) inputR[n] * wr[Mm1mO - n] - (int64_t) inputR[Mm1 - n] * wr[n - Mo2mO]; + + output[Mo2 + n] = int32_t ((i64 + WIN_OFFSET) >> WIN_SHIFT); + } + for (/*Mo2mO-1*/; n >= 0; n--) // unwindowed pt. + { + output[Mo2 + n] = (inputR[n] + 2) >> 2; + } + } + else // MDCT kernel, no time-reversal or sign flip + { + for (n = Mo2m1; n >= Mo2mO; n--) // windowed pt. + { + const int64_t i64 = (int64_t) inputR[n] * wr[Mm1mO - n] + (int64_t) inputR[Mm1 - n] * wr[n - Mo2mO]; + + output[Mo2m1 - n] = int32_t ((i64 + WIN_OFFSET) >> WIN_SHIFT); + } + for (/*Mo2mO-1*/; n >= 0; n--) // unwindowed pt. + { + output[Mo2m1 - n] = (inputR[n] + 2) >> 2; + } + } +} + +// constructor +LappedTransform::LappedTransform () +{ + // initialize all helper buffers + m_dctRotCosL = nullptr; + m_dctRotCosS = nullptr; + m_dctRotSinL = nullptr; + m_dctRotSinS = nullptr; + m_fftHalfCos = nullptr; + m_fftHalfSin = nullptr; + m_fftPermutL = nullptr; + m_fftPermutS = nullptr; + m_tempIntBuf = nullptr; + + // initialize all window buffers + for (short s = 0; s < 2; s++) + { + m_timeWindowL[s] = nullptr; + m_timeWindowS[s] = nullptr; + } + m_transfLengthL = 0; + m_transfLengthS = 0; +} + +// destructor +LappedTransform::~LappedTransform () +{ + // free allocated helper buffers + MFREE (m_dctRotCosL); + MFREE (m_dctRotCosS); + MFREE (m_dctRotSinL); + MFREE (m_dctRotSinS); + MFREE (m_fftHalfCos); + MFREE (m_fftHalfSin); + MFREE (m_fftPermutL); + MFREE (m_fftPermutS); + m_tempIntBuf = nullptr; +} + +// public functions +unsigned LappedTransform::applyNegDCT4 (int32_t* const signal, const bool shortTransform) // works in-place +{ + // int32 negative-DCT-IV version based on http://www.ee.columbia.edu/~marios/mdct/mdct_giraffe.html, 2003 + // NOTE: amplifies short-transform results (8 times shorter than long-transform results) by a factor of 8 + const int lm1 = (shortTransform ? m_transfLengthS : m_transfLengthL) - 1; + const int lm1o2 = lm1 >> 1; + const int32_t* rotatCos = (shortTransform ? m_dctRotCosS : m_dctRotCosL); + const int32_t* rotatSin = (shortTransform ? m_dctRotSinS : m_dctRotSinL); + const int64_t rotOffset = (shortTransform ? LUT_OFFSET>>3 : LUT_OFFSET); + const int64_t rotShift = (shortTransform ? LUT_SHIFT - 3 : LUT_SHIFT); + int32_t* const tempReal = m_tempIntBuf; + int32_t* const tempImag = &m_tempIntBuf[lm1o2 + 1]; + int i, i2; + + if (signal == nullptr) + { + return 1; // null-pointer input error + } + + // resort, separate, pre-twiddle signal + for (i = lm1o2, i2 = lm1 - 1; i >= 0; i--, i2 -= 2) + { + const int64_t c = rotatCos[i]; + const int64_t s = rotatSin[i]; + const int64_t e = signal[i2/*even*/]; + const int64_t o = signal[lm1 - i2]; + + tempReal[i] = int32_t ((rotOffset + e * c - o * s) >> rotShift); + tempImag[i] = int32_t ((rotOffset + o * c + e * s) >> rotShift); + } + + applyHalfSizeFFT (tempReal, tempImag, shortTransform); + + // post-twiddle, combine, resort output + for (i = lm1o2, i2 = lm1 - 1; i >= 0; i--, i2 -= 2) + { + const int64_t c = rotatCos[i]; + const int64_t s = rotatSin[i]; + const int64_t e = tempReal[i]; + const int64_t o = tempImag[i]; + + signal[i2/*even*/] = int32_t ((LUT_OFFSET + o * s - e * c) >> LUT_SHIFT); + signal[lm1 - i2] = int32_t ((LUT_OFFSET + e * s + o * c) >> LUT_SHIFT); + } + + return 0; // no error +} + +unsigned LappedTransform::applyMCLT (const int32_t* timeSig, const bool eightTransforms, bool kbdWindowL, const bool kbdWindowR, + const bool lowOverlapL, const bool lowOverlapR, int32_t* const outMdct, int32_t* const outMdst) +{ + if ((timeSig == nullptr) || (outMdct == nullptr) || (outMdst == nullptr)) + { + return 1; // invalid arguments error + } + + if (eightTransforms) // short windows + { + const int32_t* tSigS = &timeSig[(m_transfLengthL - m_transfLengthS) >> 1]; + int32_t* outMdctS = outMdct; + int32_t* outMdstS = outMdst; + + for (unsigned w = 0; w < 8; w++) + { + windowAndFoldInL (tSigS /*window half 1*/, true, kbdWindowL, lowOverlapL, false, outMdctS); + windowAndFoldInR (&tSigS[m_transfLengthS], true, kbdWindowR, lowOverlapR, false, outMdctS); + windowAndFoldInL (tSigS /*window half 1*/, true, kbdWindowL, lowOverlapL, true, outMdstS); + windowAndFoldInR (&tSigS[m_transfLengthS], true, kbdWindowR, lowOverlapR, true, outMdstS); + // MDCT via DCT-IV + applyNegDCT4 (outMdctS, true); + // MDST via DCT-IV + applyNegDCT4 (outMdstS, true); +#if 1 // not needed here + for (int i = m_transfLengthS - 2; i >= 0; i -= 2) + { + outMdstS[i] *= -1; // DCT to DST + } +#endif + kbdWindowL = kbdWindowR; // only first window uses last frame's shape + tSigS += m_transfLengthS; + outMdctS += m_transfLengthS; + outMdstS += m_transfLengthS; + } + } + else // 1 long window + { + windowAndFoldInL (timeSig /*window half 1*/, false, kbdWindowL, lowOverlapL, false, outMdct); + windowAndFoldInR (&timeSig[m_transfLengthL], false, kbdWindowR, lowOverlapR, false, outMdct); + windowAndFoldInL (timeSig /*window half 1*/, false, kbdWindowL, lowOverlapL, true, outMdst); + windowAndFoldInR (&timeSig[m_transfLengthL], false, kbdWindowR, lowOverlapR, true, outMdst); + // MDCT using DCT-IV + applyNegDCT4 (outMdct, false); + // MDST using DCT-IV + applyNegDCT4 (outMdst, false); +#if 1 // not needed here + for (int i = m_transfLengthL - 2; i >= 0; i -= 2) + { + outMdst[i] *= -1; // DCT to DST + } +#endif + } + + return 0; // no error +} + +unsigned LappedTransform::initConstants (int32_t* const tempIntBuf, int32_t* const timeWindowL[2], int32_t* const timeWindowS[2], + const unsigned maxTransfLength) +{ + const short halfLength = short (maxTransfLength >> 1); + const short sixtLength = short (maxTransfLength >> 4); + const double dNormL = 3.141592653589793 / (2.0 * halfLength); + const double dNormS = 3.141592653589793 / (2.0 * sixtLength); + const double dNormL4 = dNormL * 4.0; + short s; + + if ((tempIntBuf == nullptr) || (timeWindowL == nullptr) || (timeWindowS == nullptr) || + (maxTransfLength < 128) || (maxTransfLength > 8192) || (maxTransfLength & (maxTransfLength - 1))) + { + return 1; // invalid arguments error + } + + m_transfLengthL = 2 * halfLength; + m_transfLengthS = 2 * sixtLength; + + if ((m_dctRotCosL = (int32_t*) malloc (halfLength * sizeof (int32_t))) == nullptr || + (m_dctRotCosS = (int32_t*) malloc (sixtLength * sizeof (int32_t))) == nullptr || + (m_dctRotSinL = (int32_t*) malloc (halfLength * sizeof (int32_t))) == nullptr || + (m_dctRotSinS = (int32_t*) malloc (sixtLength * sizeof (int32_t))) == nullptr || + (m_fftHalfCos = (int32_t*) malloc ((halfLength >> 1) * sizeof (int32_t))) == nullptr || + (m_fftHalfSin = (int32_t*) malloc ((halfLength >> 1) * sizeof (int32_t))) == nullptr || + (m_fftPermutL = createPermutTable (halfLength)) == nullptr || + (m_fftPermutS = createPermutTable (sixtLength)) == nullptr) + { + return 2; // memory allocation error + } + + // obtain cosine and sine coefficients + for (s = 0; s < halfLength; s++) + { + m_dctRotCosL[s] = int32_t (cos (dNormL * (s + 0.125)) * (INT_MAX + 1.0) + 0.5); + m_dctRotSinL[s] = int32_t (sin (dNormL * (s + 0.125)) * INT_MIN - 0.5); + } + for (s = 0; s < sixtLength; s++) + { + m_dctRotCosS[s] = int32_t (cos (dNormS * (s + 0.125)) * (INT_MAX + 1.0) + 0.5); + m_dctRotSinS[s] = int32_t (sin (dNormS * (s + 0.125)) * INT_MIN - 0.5); + } + + for (s = 0; s < m_transfLengthS; s++) + { + m_fftHalfSin[s] = int32_t (sin (dNormL4 * s) * INT_MIN - 0.5); + m_fftHalfCos[m_transfLengthS + s] = -m_fftHalfSin[s]; + } + // complete missing entries by copying + m_fftHalfSin[s] = INT_MIN; + m_fftHalfCos[0] = INT_MIN; + for (s = 1; s < m_transfLengthS; s++) + { + m_fftHalfSin[m_transfLengthS + s] = m_fftHalfSin[m_transfLengthS - s]; + m_fftHalfCos[m_transfLengthS - s] = m_fftHalfSin[s]; + } + + // adopt helper/window buffer pointers + m_tempIntBuf = tempIntBuf; + for (s = 0; s < 2; s++) + { + m_timeWindowL[s] = timeWindowL[s]; + m_timeWindowS[s] = timeWindowS[s]; + } + + return 0; // no error +} diff --git a/src/lib/lappedTransform.h b/src/lib/lappedTransform.h new file mode 100644 index 0000000..188f081 --- /dev/null +++ b/src/lib/lappedTransform.h @@ -0,0 +1,63 @@ +/* lappedTransform.h - header file for class providing time-frequency transformation + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _LAPPED_TRANSFORM_H_ +#define _LAPPED_TRANSFORM_H_ + +#include "exhaleLibPch.h" + +// constants, experimental macros +#define LUT_OFFSET (1 << 30) +#define LUT_SHIFT 31 +#define WIN_OFFSET (1 << 24) +#define WIN_SHIFT 25 + +// time-frequency transform class +class LappedTransform +{ +private: + + // member variables + int32_t* m_dctRotCosL; + int32_t* m_dctRotCosS; + int32_t* m_dctRotSinL; + int32_t* m_dctRotSinS; + int32_t* m_fftHalfCos; + int32_t* m_fftHalfSin; + short* m_fftPermutL; + short* m_fftPermutS; + int32_t* m_tempIntBuf; // pointer to temporary helper buffer + int32_t* m_timeWindowL[2]; // pointer to two long window halves + int32_t* m_timeWindowS[2]; // pointer to two short window halves + short m_transfLengthL; + short m_transfLengthS; + + // helper functions + void applyHalfSizeFFT (int32_t* const iR/*eal*/, int32_t* const iI/*mag*/, const bool shortTransform); + void windowAndFoldInL (const int32_t* inputL, const bool shortTransform, const bool kbdWindowL, const bool lowOverlapL, + const bool mdstKernel, int32_t* const output); + void windowAndFoldInR (const int32_t* inputR, const bool shortTransform, const bool kbdWindowR, const bool lowOverlapR, + const bool mdstKernel, int32_t* const output); + +public: + + // constructor + LappedTransform (); + // destructor + ~LappedTransform (); + // public functions + unsigned applyNegDCT4 (int32_t* const signal, const bool shortTransform); + unsigned applyMCLT (const int32_t* timeSig, const bool eightTransforms, bool kbdWindowL, const bool kbdWindowR, + const bool lowOverlapL, const bool lowOverlapR, int32_t* const outMdct, int32_t* const outMdst); + unsigned initConstants (int32_t* const tempIntBuf, int32_t* const timeWindowL[2], int32_t* const timeWindowS[2], + const unsigned maxTransfLength); +}; // LappedTransform + +#endif // _LAPPED_TRANSFORM_H_ diff --git a/src/lib/linearPrediction.cpp b/src/lib/linearPrediction.cpp new file mode 100644 index 0000000..c526df4 --- /dev/null +++ b/src/lib/linearPrediction.cpp @@ -0,0 +1,421 @@ +/* linearPrediction.cpp - source file for class providing linear prediction capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "linearPrediction.h" + +// reconstructed 3-bit TNS coefficients +static const short tnsQuantCoeff3[9 /*2^3+1*/] = { // = round (2^11 * sin (x * pi / (x < 0 ? 9 : 7))) + -2017, -1774, -1316, -700, 0, 889, 1601, 1997, 1997 +}; + +// reconstructed 4-bit TNS coefficients +static const short tnsQuantCoeff4[17/*2^4+1*/] = { // = round (2^11 * sin (x * pi / (x < 0 ? 17 : 15))) + -2039, -1970, -1833, -1634, -1380, -1078, -740, -376, 0, 426, 833, 1204, 1522, 1774, 1948, 2037, 2037 +}; + +static const short* tnsQuantCoeff[2/*coefRes*/] = {tnsQuantCoeff3, tnsQuantCoeff4}; + +// ISO/IEC 14496-3, Sec. 4.6.9.3, 3-bit +static const char tnsQuantIndex3[SCHAR_MAX + 1] = { // = round (asin (x / 64) * (x < 0 ? 9 : 7) / pi) + -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3 +}; + +// ISO/IEC 14496-3, Sec. 4.6.9.3, 4-bit +static const char tnsQuantIndex4[SCHAR_MAX + 1] = { // = round (asin (x / 64) * (x < 0 ? 17 : 15) / pi) + -8, -7, -7, -7, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, + -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7 +}; + +static const char* tnsQuantIndex[2/*coefRes*/] = {tnsQuantIndex3, tnsQuantIndex4}; + +// static helper functions +static int quantizeParCorCoeffs (const short* const parCorCoeffs, const uint16_t nCoeffs, const short bitDepth, int8_t* const quantCoeffs, + const bool lowRes) +{ + const short bitShift = bitDepth - 7; + const unsigned tabIdx = (lowRes ? 0 : 1); + const char tabOffset = 4 << tabIdx; + const short* coeffTab = tnsQuantCoeff[tabIdx]; + const char* indexTab = tnsQuantIndex[tabIdx]; + int dist0, dist1, distTotal = 0; + + for (uint16_t s = 0; s < nCoeffs; s++) + { + const short coeff = (bitShift < 0 ? parCorCoeffs[s] << -bitShift : parCorCoeffs[s] >> bitShift); + const char coeff1 = indexTab[coeff + 1 + (SCHAR_MAX >> 1)]; + const char coeff0 = (coeff1 <= -tabOffset ? coeff1 : coeff1 - 1); + + dist0 = (int) coeffTab[coeff0 + tabOffset] - parCorCoeffs[s]; + dist0 *= dist0; + dist1 = (int) coeffTab[coeff1 + tabOffset] - parCorCoeffs[s]; + dist1 *= dist1; + if (dist0 < dist1) // use down-rounded coeff + { + quantCoeffs[s] = coeff0; + distTotal += dist0; + } + else // dist0 >= dist1, use up-rounded coeff + { + quantCoeffs[s] = ((dist0 == dist1) && (abs (coeff0) < abs (coeff1)) ? coeff0 : coeff1); + distTotal += dist1; + } + } // for s + + return distTotal; // total quantization error +} + +// constructor +LinearPredictor::LinearPredictor () +{ + // initialize member variables + memset (m_tempBuf, 0, 2 * MAX_PREDICTION_ORDER * sizeof (int64_t)); +} + +// public functions +uint32_t LinearPredictor::calcParCorCoeffs (const int32_t* const anaSignal, const uint16_t nAnaSamples, const uint16_t nCoeffs, + short* const parCorCoeffs) // returns 256 - 256 / prediction gain per filter order, or 0 +{ + // int64 version of algorithm in Figure 1 of J. LeRoux and C. Gueguen, "A Fixed Point Computation + // of Partial Correlation Coefficients," IEEE Trans. ASSP, vol. 27, no. 3, pp. 257-259, June 1977. + int64_t* const acf = m_tempBuf; // correlation + uint32_t pg[MAX_PREDICTION_ORDER] = {0, 0, 0, 0}; + int64_t pgDen, pgOff; // for prediction gains + short s = nAnaSamples - 1; + + if ((anaSignal == nullptr) || (parCorCoeffs == nullptr) || (nCoeffs == 0) || (nCoeffs > MAX_PREDICTION_ORDER) || (nAnaSamples <= nCoeffs)) + { + return 0; + } + + if (nCoeffs >= 2) // high predictor order, 2-4 + { + int64_t* const EN = &m_tempBuf[0]; + int64_t* const EP = &m_tempBuf[MAX_PREDICTION_ORDER]; + int64_t sampleHO = anaSignal[s]; + + // calculate autocorrelation function values + acf[0] = sampleHO * sampleHO; + sampleHO = anaSignal[--s]; + acf[0] += sampleHO * sampleHO; + acf[1] = sampleHO * anaSignal[s + 1]; + sampleHO = anaSignal[--s]; + acf[0] += sampleHO * sampleHO; + acf[1] += sampleHO * anaSignal[s + 1]; + acf[2] = sampleHO * anaSignal[s + 2]; + + if (nCoeffs == 2) + { + for (s--; s >= 0; s--) + { + const int64_t sample = anaSignal[s]; + + acf[0] += sample * sample; + acf[1] += sample * anaSignal[s + 1]; + acf[2] += sample * anaSignal[s + 2]; + } + } + else // order 3-4 + { + sampleHO = anaSignal[--s]; + acf[0] += sampleHO * sampleHO; + acf[1] += sampleHO * anaSignal[s + 1]; + acf[2] += sampleHO * anaSignal[s + 2]; + acf[3] = sampleHO * anaSignal[s + 3]; + + if (nCoeffs == 3) + { + for (s--; s >= 0; s--) + { + const int64_t sample = anaSignal[s]; + + acf[0] += sample * sample; + acf[1] += sample * anaSignal[s + 1]; + acf[2] += sample * anaSignal[s + 2]; + acf[3] += sample * anaSignal[s + 3]; + } + } + else // order 4 + { + acf[4] = 0; + for (s--; s >= 0; s--) + { + const int64_t sample = anaSignal[s]; + + acf[0] += sample * sample; + acf[1] += sample * anaSignal[s + 1]; + acf[2] += sample * anaSignal[s + 2]; + acf[3] += sample * anaSignal[s + 3]; + acf[4] += sample * anaSignal[s + 4]; + } + } + } + + // reduce correlation value range to <32 bit + acf[0] = (acf[0] - INT_MIN/*eps*/) >> 31; + + EP[3] = (acf[4] - (INT_MIN >> 1)) >> 31; + EN[3] = (acf[3] - (INT_MIN >> 1)) >> 31; + EP[2] = EN[3]; + EN[2] = (acf[2] - (INT_MIN >> 1)) >> 31; + EP[1] = EN[2]; + EN[1] = (acf[1] - (INT_MIN >> 1)) >> 31; + EP[0] = EN[1]; // finish EP buffer creation + EN[0] = acf[0]; // finish EN buffer creation + + pgOff = acf[0]; + pgDen = pgOff << 1; + + for (s = 0; s < (short) nCoeffs; s++) + { + uint16_t p; + // ParCor coefficient Ks & prediction gain + int64_t Ks = (EP[s] * -512) / (EN[0] + LP_EPS); + + Ks = CLIP_PM (Ks, 511); // enforce |Ks|<1 + parCorCoeffs[s] = (short) Ks; + + for (p = s; p < nCoeffs; p++) + { + sampleHO = EN[p - s]; // use register? + EN[p - s] = (EN[p - s] << 9) + EP[p] * Ks; + EP[p] = (EP[p] << 9) + sampleHO * Ks; + } + if (s > 0 && EN[0] < 0) // EN wrap-around + { + pg[s] = pg[s - 1]; // "invent" some gain + } + else + { + sampleHO = (1 << (s * 9)) >> 1;// offset + pg[s] = (pgOff <= LP_EPS ? 0 : (1 << 8) - uint32_t ((((EN[0] + sampleHO) >> (s * 9)) + pgOff) / pgDen)); + } + } // for s + } + else // nCoeffs == 1, minimum predictor order + { + int64_t sampleMO = anaSignal[s]; + + acf[0] = sampleMO * sampleMO; + acf[1] = 0; + for (s--; s >= 0; s--) + { + const int64_t sample = anaSignal[s]; + + acf[0] += sample * sample; + acf[1] += sample * anaSignal[s + 1]; + } + + // reduce correlation value range to <32 bit + acf[0] = (acf[0] - INT_MIN/*eps*/) >> 31; + acf[1] = (acf[1] - (INT_MIN >> 1)) >> 31; + + pgOff = acf[0]; + pgDen = pgOff << 1; + + // 1st-order coefficient K & prediction gain + sampleMO = (acf[1] * -512) / (acf[0] + LP_EPS); + + sampleMO = CLIP_PM (sampleMO, 511); // |K|<1 + parCorCoeffs[0] = (short) sampleMO; + + sampleMO = (acf[0] << 9) + acf[1] * sampleMO; + pg[0] = (pgOff <= LP_EPS ? 0 : (1 << 8) - uint32_t ((sampleMO + pgOff) / pgDen)); + } + + return (CLIP_UCHAR (pg[3]) << 24) | (CLIP_UCHAR (pg[2]) << 16) | (CLIP_UCHAR (pg[1]) << 8) | CLIP_UCHAR (pg[0]); +} + +uint8_t LinearPredictor::calcOptTnsCoeffs (short* const parCorCoeffs, int8_t* const quantCoeffs, bool* const lowCoeffRes, + const uint16_t maxOrder, const uint8_t predGain, const uint8_t tonality /*= 0*/, + const uint16_t parCorCoeffBitDepth /*= 10*/) // returns optimized filter order for TNS +{ + const short bitShift = LP_DEPTH - (short) parCorCoeffBitDepth; + short shortBuf[MAX_PREDICTION_ORDER]; + uint16_t s, order = __min (maxOrder, MAX_PREDICTION_ORDER); + int d, i; + + if ((parCorCoeffs == nullptr) || (quantCoeffs == nullptr) || (maxOrder == 0) || (maxOrder > MAX_PREDICTION_ORDER) || (parCorCoeffBitDepth < 2) || (bitShift < 0)) + { + if (quantCoeffs) memset (quantCoeffs, 0, order * sizeof (char)); + + return 0; // invalid input arguments error + } + + // determine direct-form filter damping factor + parCorCoeffs[0] <<= bitShift; + i = abs (parCorCoeffs[0]); + for (s = 1; s < order; s++) + { + parCorCoeffs[s] <<= bitShift; // scale coeff + i = __max (i, abs (parCorCoeffs[s])); + } + for (/*s*/; s < MAX_PREDICTION_ORDER; s++) + { + parCorCoeffs[s] = 0; // similarParCorCoeffs + } + + if (predGain < 41 + (tonality >> 3)) // 1.5 dB + { + memset (quantCoeffs, 0, order * sizeof (char)); + + return 0; // LPC prediction gain is too low + } + + d = (7 << (LP_DEPTH - 1)) >> 3; + + if (i > d) // apply direct-form filter damping + { + i = ((i >> 1) + d * (1 << LP_SHIFT)) / i; + d = i; + if (parCorToLpCoeffs (parCorCoeffs, order, shortBuf, LP_DEPTH) > 0) + { + return 0; // coefficient conversion error + } + for (s = 0; s < order; s++) + { + shortBuf[s] = short ((LP_OFFSET + d * shortBuf[s]) >> LP_SHIFT); + d = (LP_OFFSET + d * i) >> LP_SHIFT; + } + // verify order and go back to ParCor domain + if ((s > 0) && (shortBuf[s - 1] == 0)) + { + order--; + } + if (lpToParCorCoeffs (shortBuf, order, parCorCoeffs, LP_DEPTH) > 0) + { + return 0; // coefficient conversion error + } + } + + // high-res quantizer, obtain coeff distortion + d = quantizeParCorCoeffs (parCorCoeffs, order, LP_DEPTH, quantCoeffs, false); + + if ((lowCoeffRes != nullptr) && (quantizeParCorCoeffs (parCorCoeffs, order, LP_DEPTH, (int8_t* const) m_tempBuf, true) < d)) + { + // low-res quantizer yields lower distortion + *lowCoeffRes = true; + memcpy (quantCoeffs, m_tempBuf, order * sizeof (char)); + } + + for (; order > 0; order--) // return opt order + { + if (quantCoeffs[order - 1] != 0) return (uint8_t) order; + } + return 0; +} + +unsigned LinearPredictor::lpToParCorCoeffs (/*mod!*/short* const lpCoeffs, const uint16_t nCoeffs, short* const parCorCoeffs, + const uint16_t parCorCoeffBitDepth /*= 10*/) +{ + int* const intBuf = (int* const) m_tempBuf; + const int shift = parCorCoeffBitDepth - 1; + const int offset = 1 << (shift - 1); + + if ((lpCoeffs == nullptr) || (parCorCoeffs == nullptr) || (nCoeffs == 0) || (nCoeffs > MAX_PREDICTION_ORDER) || (parCorCoeffBitDepth < 2)) + { + return 1; // error + } + + for (uint16_t p, s = nCoeffs - 1; s > 0; s--) + { + const int i = (parCorCoeffs[s] = lpCoeffs[s]); + const int d = (1 << shift) - ((offset + i * i) >> shift); + const int o = d >> 1; + + if (d <= 0) return s; // invalid coefficient + + for (p = 0; p < s; p++) + { + intBuf[p] = lpCoeffs[s - 1 - p]; + } + for (p = 0; p < s; p++) + { + lpCoeffs[p] = short ((o + ((int) lpCoeffs[p] << shift) - intBuf[p] * i) / d); + } + } + parCorCoeffs[0] = lpCoeffs[0]; + + return 0; // no error +} + +unsigned LinearPredictor::parCorToLpCoeffs (const short* const parCorCoeffs, const uint16_t nCoeffs, short* const lpCoeffs, + const uint16_t parCorCoeffBitDepth /*= 10*/) +{ + int* const intBuf = (int* const) m_tempBuf; + const int shift = parCorCoeffBitDepth - 1; + const int offset = 1 << (shift - 1); + + if ((parCorCoeffs == nullptr) || (lpCoeffs == nullptr) || (nCoeffs == 0) || (nCoeffs > MAX_PREDICTION_ORDER) || (parCorCoeffBitDepth < 2)) + { + return 1; // error + } + + lpCoeffs[0] = parCorCoeffs[0]; + for (uint16_t p, s = 1; s < nCoeffs; s++) + { + const int i = (lpCoeffs[s] = parCorCoeffs[s]); + + if (abs (i) > (1 << shift)) return s; // > 1 + + for (p = 0; p < s; p++) + { + intBuf[p] = lpCoeffs[s - 1 - p]; + } + for (p = 0; p < s; p++) + { + lpCoeffs[p] += short ((offset + intBuf[p] * i) >> shift); + } + } + return 0; // no error +} + +unsigned LinearPredictor::quantTnsToLpCoeffs (const int8_t* const quantTnsCoeffs, const uint16_t nCoeffs, const bool lowCoeffRes, + short* const parCorCoeffs, short* const lpCoeffs) +{ + const unsigned tabIdx = (lowCoeffRes ? 0 : 1); + const char tabOffset = 4 << tabIdx; + const short* coeffTab = tnsQuantCoeff[tabIdx]; + + if ((quantTnsCoeffs == nullptr) || (parCorCoeffs == nullptr) || (lpCoeffs == nullptr) || (nCoeffs == 0) || (nCoeffs > MAX_PREDICTION_ORDER)) + { + return 1; // error + } + + for (uint16_t s = 0; s < nCoeffs; s++) + { + parCorCoeffs[s] = coeffTab[CLIP_PM (quantTnsCoeffs[s], tabOffset) + tabOffset]; + } + + return parCorToLpCoeffs (parCorCoeffs, nCoeffs, lpCoeffs, LP_DEPTH); +} + +bool LinearPredictor::similarParCorCoeffs (const short* const parCorCoeffs1, const short* const parCorCoeffs2, const uint16_t nCoeffs, + const uint16_t parCorCoeffBitDepth /*= 10*/) +{ + unsigned sumAbsDiff = 0; + + if ((parCorCoeffs1 == nullptr) || (parCorCoeffs2 == nullptr) || (nCoeffs == 0) || (nCoeffs > MAX_PREDICTION_ORDER) || (parCorCoeffBitDepth < 2)) + { + return false; // error + } + + for (uint16_t s = 0; s < nCoeffs; s++) + { + sumAbsDiff += abs (parCorCoeffs1[s] - parCorCoeffs2[s]); + } + + return (sumAbsDiff < ((unsigned) nCoeffs << (parCorCoeffBitDepth >> 1))); +} diff --git a/src/lib/linearPrediction.h b/src/lib/linearPrediction.h new file mode 100644 index 0000000..de8f608 --- /dev/null +++ b/src/lib/linearPrediction.h @@ -0,0 +1,52 @@ +/* linearPrediction.h - header file for class providing linear prediction capability + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _LINEAR_PREDICTION_H_ +#define _LINEAR_PREDICTION_H_ + +#include "exhaleLibPch.h" + +// constants, experimental macros +#define LP_EPS 1 +#define LP_SHIFT 15 +#define LP_DEPTH (1 + LP_SHIFT - MAX_PREDICTION_ORDER) +#define LP_OFFSET (1 << (LP_SHIFT - 1)) + +// linear predictive filter class +class LinearPredictor +{ +private: + + // temporary buffer + int64_t m_tempBuf[2 * MAX_PREDICTION_ORDER]; + +public: + + // constructor + LinearPredictor (); + // destructor + ~LinearPredictor () { } + // public functions + uint32_t calcParCorCoeffs (const int32_t* const anaSignal, const uint16_t nAnaSamples, const uint16_t nCoeffs, + short* const parCorCoeffs); // returns 256 - 256 / prediction gain per filter order, or 0 + uint8_t calcOptTnsCoeffs (short* const parCorCoeffs, int8_t* const quantCoeffs, bool* const lowCoeffRes, + const uint16_t maxOrder, const uint8_t predGain, const uint8_t tonality = 0, + const uint16_t parCorCoeffBitDepth = 10); // returns optimized filter order for TNS + unsigned lpToParCorCoeffs (short* const lpCoeffs, const uint16_t nCoeffs, short* const parCorCoeffs, + const uint16_t parCorCoeffBitDepth = 10); + unsigned parCorToLpCoeffs (const short* const parCorCoeffs, const uint16_t nCoeffs, short* const lpCoeffs, + const uint16_t parCorCoeffBitDepth = 10); + unsigned quantTnsToLpCoeffs(const int8_t* const quantCoeffs, const uint16_t nCoeffs, const bool lowCoeffRes, + short* const parCorCoeffs, short* const lpCoeffs); + bool similarParCorCoeffs (const short* const parCorCoeffs1, const short* const parCorCoeffs2, const uint16_t nCoeffs, + const uint16_t parCorCoeffBitDepth = 10); +}; // LinearPredictor + +#endif // _LINEAR_PREDICTION_H_ diff --git a/src/lib/makefile b/src/lib/makefile new file mode 100644 index 0000000..3a19f24 --- /dev/null +++ b/src/lib/makefile @@ -0,0 +1,52 @@ +## makefile - code library make-file for compiling exhale on Linux and MacOS platforms + # written by C. R. Helmrich, last modified 2019 - see License.txt for legal notices + # + # The copyright in this software is being made available under a Modified BSD License + # and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + # party rights, including patent rights. No such rights are granted under this License. + # + # Copyright (c) 2018-2019 Christian R. Helmrich, project ecodis. All rights reserved. + ## + +# define as source code library +CONFIG = LIBRARY + +# source and output directories +DIR_BIN = ../../bin +DIR_OBJ = ../../build +DIR_INC = ../../include +DIR_LIB = ../../lib +DIR_SRC = ../../src/lib + +# build with large file support +DEFS = -DMSYS_LINUX -DMSYS_UNIX_LARGEFILE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 + +# name of product / binary file +PRD_NAME = Exhale + +# name of temporary object file +OBJS = \ + $(DIR_OBJ)/bitAllocation.o \ + $(DIR_OBJ)/bitStreamWriter.o \ + $(DIR_OBJ)/entropyCoding.o \ + $(DIR_OBJ)/exhaleEnc.o \ + $(DIR_OBJ)/exhaleLibPch.o \ + $(DIR_OBJ)/lappedTransform.o \ + $(DIR_OBJ)/linearPrediction.o \ + $(DIR_OBJ)/quantization.o \ + $(DIR_OBJ)/specAnalysis.o \ + $(DIR_OBJ)/specGapFilling.o \ + $(DIR_OBJ)/tempAnalysis.o \ + +# define libraries to link with +LIBS = -lpthread +DYN_LIBS = -ldl +STAT_LIBS = + +DYN_DEBUG_LIBS = +DYN_RELEASE_LIBS = +STAT_DEBUG_LIBS = +STAT_RELEASE_LIBS = + +# include common makefile.base +include ../makefile.base diff --git a/src/lib/quantization.cpp b/src/lib/quantization.cpp new file mode 100644 index 0000000..b90b3ca --- /dev/null +++ b/src/lib/quantization.cpp @@ -0,0 +1,788 @@ +/* quantization.cpp - source file for class with nonuniform quantization functionality + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "quantization.h" + +// static helper function +static inline short getBitCount (EntropyCoder& entrCoder, const int sfIndex, const int sfIndexPred, + const unsigned char groupLength, const unsigned char* coeffQuant, + const uint16_t coeffOffset, const uint16_t numCoeffs) +{ + unsigned bitCount = (sfIndex != UCHAR_MAX && sfIndexPred == UCHAR_MAX ? 8 : entrCoder.indexGetBitCount (sfIndex - sfIndexPred)); + + if (groupLength == 1) // include arithmetic coding in bit count + { + bitCount += entrCoder.arithCodeSigMagn (coeffQuant, coeffOffset, numCoeffs); + } + + return (short) __min (SHRT_MAX, bitCount); // exclude sign bits +} + +// private helper functions +double SfbQuantizer::getQuantDist (const unsigned* const coeffMagn, const unsigned char scaleFactor, + const unsigned char* coeffQuant, const uint16_t numCoeffs) +{ + const double stepSizeDiv = m_lutSfNorm[scaleFactor]; + double dDist = 0.0; + + for (int i = numCoeffs - 1; i >= 0; i--) + { + const double d = m_lutXExp43[coeffQuant[i]] - coeffMagn[i] * stepSizeDiv; + + dDist += d * d; // TODO: do this in fixed-point and with SIMD + } + + // consider quantization step-size in calculation of distortion + return dDist * m_lut2ExpX4[scaleFactor] * m_lut2ExpX4[scaleFactor]; +} + +unsigned char SfbQuantizer::quantizeMagn (const unsigned* const coeffMagn, const unsigned char scaleFactor, + unsigned char* const coeffQuant, const uint16_t numCoeffs, + short* const sigMaxQ /*= NULL*/, short* const sigNumQ /*= NULL*/) +{ + const double stepSizeDiv = m_lutSfNorm[scaleFactor]; + double dNum = 0.0, dDen = 0.0; + short maxQ = 0, numQ = 0; + + for (int i = numCoeffs - 1; i >= 0; i--) + { + const double normalizedMagn = (double) coeffMagn[i] * stepSizeDiv; +#if SFB_QUANT_FAST_POW + short q; + + if (normalizedMagn < 28.5) // fast approximate pow (d, 0.75) + { + // based on code from: N. N. Schraudolph, "A Fast, Compact Approximation of the Expo- + // nential Function," Neural Comput., vol. 11, pp. 853-862, 1998 and M. Ankerl, 2007, + // https://martin.ankerl.com/2007/10/04/optimized-pow-approximation-for-java-and-c-c/ + union { double d; int32_t i[2]; } u = { normalizedMagn }; + + u.i[1] = int32_t (0.75 * (u.i[1] - 1072632447) + 1072632447.0); + u.i[0] = 0; + q = short (u.d + (u.d < 1.0 ? 0.3822484 : 0.2734375)); + } + else + { + q = short (SFB_QUANT_OFFSET + pow (normalizedMagn, 0.75)); + } +#else + short q = short (SFB_QUANT_OFFSET + pow (normalizedMagn, 0.75)); +#endif + + if (q > 0) + { + if (q >= SCHAR_MAX) + { + if (maxQ < q) + { + maxQ = q; // find maximum quantized magnitude in vector + } + q = SCHAR_MAX; + } + else + { + const double diffRoundD = normalizedMagn - m_lutXExp43[q]; + const double diffRoundU = normalizedMagn - m_lutXExp43[q + 1]; + + if (diffRoundU * diffRoundU < diffRoundD * diffRoundD) + { + q++; // round-up gives lower distortion than round-down + } + } + if (maxQ < q) + { + maxQ = q; + } + numQ++; + dNum += m_lutXExp43[q] * normalizedMagn; + dDen += m_lutXExp43[q] * m_lutXExp43[q]; + } +#if SFB_QUANT_PERCEPT_OPT + else // q == 0, assume perceptual transparency for code below + { + dNum += normalizedMagn * normalizedMagn; + dDen += normalizedMagn * normalizedMagn; + } +#endif + coeffQuant[i] = (unsigned char) q; + } + + if (sigMaxQ) *sigMaxQ = maxQ; // max. quantized value magnitude + if (sigNumQ) *sigNumQ = numQ; // nonzero coeff. count (L0 norm) + + // compute least-squares optimal gain multiplied onto step-size + numQ = scaleFactor + short (SF_QUANT_OFFSET + FOUR_LOG102 * log10 (dNum <= 0.0 ? 1.0 : dNum / dDen) - (dNum < dDen ? 1.0 : 0.0)); + + return (unsigned char) __max (0, numQ); // optimal scale factor +} + +// constructor +SfbQuantizer::SfbQuantizer () +{ + // initialize all helper buffers + m_coeffMagn = nullptr; + m_lut2ExpX4 = nullptr; + m_lutSfNorm = nullptr; + m_lutXExp43 = nullptr; + + m_maxSfIndex = 0; +#if EC_TRELLIS_OPT_CODING + m_numCStates = 0; + + for (unsigned b = 0; b < 52; b++) + { + m_quantDist[b] = nullptr; + m_quantInSf[b] = nullptr; + m_quantRate[b] = nullptr; + } +#endif +} + +// destructor +SfbQuantizer::~SfbQuantizer () +{ + // free allocated helper buffers + MFREE (m_coeffMagn); + MFREE (m_lut2ExpX4); + MFREE (m_lutSfNorm); + MFREE (m_lutXExp43); +#if EC_TRELLIS_OPT_CODING + + for (unsigned b = 0; b < 52; b++) + { + MFREE (m_quantDist[b]); + MFREE (m_quantInSf[b]); + MFREE (m_quantRate[b]); + } +#endif +} + +// public functions +unsigned SfbQuantizer::initQuantMemory (const unsigned maxTransfLength, +#if EC_TRELLIS_OPT_CODING + const unsigned char numSwb, const unsigned char bitRateMode, +#endif + const unsigned char maxScaleFacIndex /*= SCHAR_MAX*/) +{ + const unsigned numScaleFactors = (unsigned) maxScaleFacIndex + 1; +#if EC_TRELLIS_OPT_CODING + const unsigned char numIStates = 8 - __min (5, (bitRateMode + 2) >> 2); // states per SFB + const unsigned char numDStates = numIStates * numIStates; // interdependent states per SFB +#endif + unsigned x; + + if ((maxTransfLength < 128) || (maxTransfLength > 8192) || (maxTransfLength & 7) || (maxScaleFacIndex == 0) || (maxScaleFacIndex > SCHAR_MAX)) + { + return 1; // invalid arguments error + } + + m_maxSfIndex = maxScaleFacIndex; + + if ((m_coeffMagn = (unsigned*) malloc (maxTransfLength * sizeof (unsigned))) == nullptr || + (m_lut2ExpX4 = (double* ) malloc (numScaleFactors * sizeof (double ))) == nullptr || + (m_lutSfNorm = (double* ) malloc (numScaleFactors * sizeof (double ))) == nullptr || + (m_lutXExp43 = (double* ) malloc ((SCHAR_MAX + 1) * sizeof (double ))) == nullptr) + { + return 2; // memory allocation error + } +#if EC_TRELLIS_OPT_CODING + m_numCStates = numIStates; + + for (x = 0; x < __min (52u, numSwb); x++) + { + if ((m_quantDist[x] = (double* ) malloc (numIStates * sizeof (double ))) == nullptr || + (m_quantInSf[x] = (uint8_t* ) malloc (numIStates * sizeof (uint8_t ))) == nullptr || + (m_quantRate[x] = (uint16_t*) malloc (numDStates * sizeof (uint16_t))) == nullptr) + { + return 2; + } + } +#endif + memset (m_coeffTemp, 0, sizeof (m_coeffTemp)); + + // calculate scale factor gain 2^(x/4) + for (x = 0; x < numScaleFactors; x++) + { + m_lut2ExpX4[x] = pow (2.0, (double) x / 4.0); + m_lutSfNorm[x] = 1.0 / m_lut2ExpX4[x]; + } + // calculate dequantized coeff x^(4/3) + for (x = 0; x < (SCHAR_MAX + 1); x++) + { + m_lutXExp43[x] = pow ((double) x, 4.0 / 3.0); + } + + return 0; // no error +} + +uint8_t SfbQuantizer::quantizeSpecSfb (EntropyCoder& entropyCoder, const int32_t* const inputCoeffs, const unsigned char grpLength, + const uint16_t* const grpOffsets, uint32_t* const grpStats, // quant./coding statistics + const unsigned sfb, const unsigned char sfIndex, const unsigned char sfIndexPred /*= UCHAR_MAX*/, + unsigned char* const quantCoeffs /*= nullptr*/) // returns the RD optimized scale factor index +{ + unsigned char sfBest = sfIndex; + + if ((inputCoeffs == nullptr) || (grpOffsets == nullptr) || (sfb >= 52) || (sfIndex > m_maxSfIndex)) + { + return UCHAR_MAX; // invalid input error + } + +#if EC_TRELLIS_OPT_CODING + if (grpLength == 1) // references for RDOC + { + m_quantDist[sfb][1] = -1.0; + m_quantInSf[sfb][1] = sfIndex; + m_quantRate[sfb][1] = 0; // for sgn bits + m_quantRate[sfb][0] = entropyCoder.arithGetCtxState () & USHRT_MAX; // ref start context + } +#endif + if ((sfIndex == 0) || (sfIndexPred <= m_maxSfIndex && sfIndex + INDEX_OFFSET < sfIndexPred)) + { + const uint16_t grpStart = grpOffsets[0]; + const uint16_t sfbStart = grpOffsets[sfb]; + const uint16_t sfbWidth = grpOffsets[sfb + 1] - sfbStart; + uint32_t* const coeffMagn = &m_coeffMagn[sfbStart]; + + for (int i = sfbWidth - 1; i >= 0; i--) // back up magnitudes. TODO: use SIMD for speed? + { + coeffMagn[i] = abs (inputCoeffs[sfbStart + i]); + } + + if (quantCoeffs) + { + memset (&quantCoeffs[sfbStart], 0, sfbWidth * sizeof (unsigned char)); // zero output + if (grpStats) // approximate bit count + { + grpStats[sfb] = getBitCount (entropyCoder, 0, 0, grpLength, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + } + } + return sfIndexPred - (sfIndex == 0 ? 0 : INDEX_OFFSET); // save delta bits if applicable + } + else // nonzero sf, optimized quantization + { + const uint16_t grpStart = grpOffsets[0]; + const uint16_t sfbStart = grpOffsets[sfb]; + const uint16_t sfbWidth = grpOffsets[sfb + 1] - sfbStart; + const uint16_t cpyWidth = sfbWidth * sizeof (unsigned char); + uint32_t* const coeffMagn = &m_coeffMagn[sfbStart]; + unsigned codStart = 0, ctxStart = 0; + unsigned codFinal = 0, ctxFinal = 0; + double distBest = 0, distCurr = 0; + short maxQBest = 0, maxQCurr = 0; + short numQBest = 0, numQCurr = 0; +#if EC_TRELLIS_OPT_CODING + bool rdOptimQuant = (grpLength != 1); +#else + bool rdOptimQuant = true; +#endif + unsigned char* ptrBest = &m_coeffTemp[0]; + unsigned char* ptrCurr = &m_coeffTemp[100]; + unsigned char sfCurr = sfIndex; + + for (int i = sfbWidth - 1; i >= 0; i--) // back up magnitudes. TODO: use SIMD for speed? + { + coeffMagn[i] = abs (inputCoeffs[sfbStart + i]); + } + +// --- determine default quantization result using range limited scale factor as a reference + sfBest = quantizeMagn (coeffMagn, sfCurr, ptrBest, sfbWidth, &maxQBest, &numQBest); + + if (maxQBest > SCHAR_MAX) // limit SNR via scale factor index + { + for (unsigned char c = 0; (c < 2) && (maxQBest > SCHAR_MAX); c++) // rarely done twice + { + sfCurr += getScaleFacOffset (pow ((double) maxQBest, 4.0 / 3.0) / m_lutXExp43[SCHAR_MAX]) + c; + sfBest = quantizeMagn (coeffMagn, sfCurr, ptrBest, sfbWidth, &maxQBest, &numQBest); + } + rdOptimQuant = false; + } + else if ((sfBest < sfCurr) && (sfBest != sfIndexPred)) // re-optimize above quantization + { + sfBest = quantizeMagn (coeffMagn, --sfCurr, ptrBest, sfbWidth, &maxQBest, &numQBest); + + rdOptimQuant &= (maxQBest <= SCHAR_MAX); + } + +#if EC_TRELLIS_OPT_CODING + if (grpLength == 1) // ref masking level + { + m_quantInSf[sfb][1] = __min (sfCurr, m_maxSfIndex); + } +#endif + if (maxQBest == 0) // SFB was quantized to zero - zero output + { + if (quantCoeffs) + { + memset (&quantCoeffs[sfbStart], 0, cpyWidth); + if (grpStats) // estimated bit count + { + grpStats[sfb] = getBitCount (entropyCoder, 0, 0, grpLength, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + } + } + return sfIndexPred; // repeat scale factor, save delta bits + } + +// --- check whether optimized quantization and coding results in lower rate-distortion cost + distBest = getQuantDist (coeffMagn, sfBest, ptrBest, sfbWidth); + +#if EC_TRELLIS_OPT_CODING + if (grpLength == 1) // ref band-wise NMR + { + const double refSfbNmrDiv = m_lutSfNorm[m_quantInSf[sfb][1]]; + + m_quantDist[sfb][1] = distBest * refSfbNmrDiv * refSfbNmrDiv; + m_quantRate[sfb][1] = numQBest; // sgn + } +#endif + if (quantCoeffs) + { + memcpy (&quantCoeffs[sfbStart], ptrBest, cpyWidth); + + codStart = entropyCoder.arithGetCodState (); // start state + ctxStart = entropyCoder.arithGetCtxState (); + numQBest += getBitCount (entropyCoder, sfBest, sfIndexPred, grpLength, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + codFinal = entropyCoder.arithGetCodState (); // final state + ctxFinal = entropyCoder.arithGetCtxState (); + } + rdOptimQuant &= (distBest > 0.0); + + if ((sfBest < sfCurr) && (sfBest != sfIndexPred) && rdOptimQuant) // R/D re-optimization + { + sfCurr = quantizeMagn (coeffMagn, sfCurr - 1, ptrCurr, sfbWidth, &maxQCurr, &numQCurr); + + if (maxQCurr <= maxQBest) + { + distCurr = getQuantDist (coeffMagn, sfCurr, ptrCurr, sfbWidth); + if (quantCoeffs) + { + memcpy (&quantCoeffs[sfbStart], ptrCurr, cpyWidth); + + entropyCoder.arithSetCodState (codStart);// reset state + entropyCoder.arithSetCtxState (ctxStart); + numQCurr += getBitCount (entropyCoder, sfCurr, sfIndexPred, grpLength, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + } + + // rate-distortion decision with empirical rate threshold + if ((numQCurr <= numQBest + (distCurr >= distBest ? -1 : short (0.5 + distBest / __max (1.0, distCurr))))) + { + unsigned char* ptrTemp = ptrBest; + + ptrBest = ptrCurr; + ptrCurr = ptrTemp; + distBest = distCurr; + maxQBest = maxQCurr; + numQBest = numQCurr; + sfBest = sfCurr; + } + else if (quantCoeffs) // discard result, recover best try + { + memcpy (&quantCoeffs[sfbStart], ptrBest, cpyWidth); + + entropyCoder.arithSetCodState (codFinal); // set state + entropyCoder.arithSetCtxState (ctxFinal); + } + } // if (maxQCurr <= maxQBest) + } + else sfCurr = sfBest; + + rdOptimQuant &= (distBest > 0.0); + + if ((sfCurr != sfIndexPred) && (sfBest != sfIndexPred) && rdOptimQuant && (sfIndexPred > 0) && (sfIndexPred < m_maxSfIndex)) + { + unsigned char sf; + + // try quantization with repeated scale factor to save bits + for (sf = (sfCurr = sfIndexPred + 1); (sf >= sfIndexPred) && (sfCurr > sfIndexPred); sf--) + { + sfCurr = quantizeMagn (coeffMagn, sf, ptrCurr, sfbWidth, &maxQCurr, &numQCurr); + } + if ((sfCurr <= sfIndexPred) && (maxQCurr == maxQBest)) + { + bool calcRate = (quantCoeffs != nullptr); + double distTemp; + + codFinal = entropyCoder.arithGetCodState (); // new state + ctxFinal = entropyCoder.arithGetCtxState (); + + distCurr = getQuantDist (coeffMagn, sfIndexPred, ptrCurr, sfbWidth); + + if (sfCurr < sfIndexPred) // repeated index isn't optimal + { + distTemp = getQuantDist (coeffMagn, sfIndexPred, ptrBest, sfbWidth); + + if (distTemp < distCurr) // best gives lower distortion + { +#if SFB_QUANT_MORE_TESTS + ptrCurr = ptrBest; +#endif + distCurr = distTemp; + maxQCurr = maxQBest; + numQCurr = numQBest; + sfCurr = __min (sfBest, sfIndexPred); + calcRate = false; // (num)qBest are already complete + } + } +#if SFB_QUANT_MORE_TESTS + if (quantCoeffs && (sf >= sfIndexPred)) // a missing test + { + const short maxQTemp = maxQCurr; + const short numQTemp = numQCurr; + + sf = quantizeMagn (coeffMagn, sf, &quantCoeffs[sfbStart], sfbWidth, &maxQCurr, &numQCurr); + distTemp = getQuantDist (coeffMagn, sfIndexPred, &quantCoeffs[sfbStart], sfbWidth); + + if (distTemp < distCurr) // also gives lower distortion + { +# if 1 + ptrCurr = &quantCoeffs[sfbStart]; +# endif + distCurr = distTemp; + entropyCoder.arithSetCodState (codStart);// set state + entropyCoder.arithSetCtxState (ctxStart); + numQCurr += getBitCount (entropyCoder, sfIndexPred, sfIndexPred, grpLength, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + sfCurr = __min (sf, sfIndexPred); + calcRate = false; + } + else // distortion is not lower - restore maxQ and numQ + { + maxQCurr = maxQTemp; + numQCurr = numQTemp; + if (!calcRate) memcpy (&quantCoeffs[sfbStart], ptrCurr, cpyWidth); + } + } +#endif + if (calcRate) + { + memcpy (&quantCoeffs[sfbStart], ptrCurr, cpyWidth); + + entropyCoder.arithSetCodState (codStart);// reset state + entropyCoder.arithSetCtxState (ctxStart); + numQCurr += getBitCount (entropyCoder, sfIndexPred, sfIndexPred, grpLength, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + } + + // rate-distortion decision with empirical rate threshold + if ((numQCurr <= numQBest + (distCurr >= distBest ? -1 : short (0.5 + distBest / __max (1.0, distCurr))))) + { +#if SFB_QUANT_MORE_TESTS + if ((sfCurr < sfIndexPred) && (distCurr >= distBest) && (numQCurr + 1 + sfIndexPred - sfCurr < numQBest) && + (getQuantDist (coeffMagn, sfCurr, ptrCurr, sfbWidth) < distCurr)) + { + numQCurr += 1 + sfIndexPred - sfCurr; // 14496, 4.A.1 + sfBest = sfCurr; + } + else +#endif + sfBest = sfIndexPred; + maxQBest = maxQCurr; + numQBest = numQCurr; + } + else if (quantCoeffs) // discard result, recover best try + { + memcpy (&quantCoeffs[sfbStart], ptrBest, cpyWidth); + + entropyCoder.arithSetCodState (codFinal); // set state + entropyCoder.arithSetCtxState (ctxFinal); + } + } // if ((sfCurr <= sfIndexPred) && (maxQCurr >= maxQBest)) + } + + if (grpStats) + { + grpStats[sfb] = ((uint32_t) maxQBest << 16) | numQBest; // max magnitude and bit count + } + } // if (sfIndex == 0) + + return __min (sfBest, m_maxSfIndex); +} + +#if EC_TRELLIS_OPT_CODING +# define EC_TRAIN 0 + +unsigned SfbQuantizer::quantizeSpecRDOC (EntropyCoder& entropyCoder, unsigned char* const optimalSf, const unsigned targetBitCount, + const uint16_t* const grpOffsets, uint32_t* const grpStats, // quant./coding statistics + const unsigned numSfb, unsigned char* const quantCoeffs) // returns RD optimization bit count +{ + // numSfb: number of trellis stages. Based on: A. Aggarwal, S. L. Regunathan, and K. Rose, + // "Trellis-Based Optimization of MPEG-4 Advanced Audio Coding," in Proc. IEEE Workshop on + // Speech Coding, pp. 142-144, Sep. 2000. Modified for arithmetic instead of Huffman coder + const uint32_t codStart = USHRT_MAX << 16; + const uint32_t ctxStart = m_quantRate[0][0]; // start context before quantizeSfb() + const uint32_t codFinal = entropyCoder.arithGetCodState (); + const uint32_t ctxFinal = entropyCoder.arithGetCtxState (); // after quantizeSfb() + const uint16_t grpStart = grpOffsets[0]; + unsigned char* const inScaleFac = &m_coeffTemp[716]; + uint32_t prevCodState[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + uint32_t prevCtxState[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + unsigned char prevScaleFac[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + double prevVtrbCost[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + uint32_t tempCodState[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + uint32_t tempCtxState[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + unsigned char tempScaleFac[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + double tempVtrbCost[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + unsigned tempBitCount, sfb, is; + int ds; +#if EC_TRAIN + double refGrpDist = 0.0, tempGrpDist; +#else + const double lambda = (108.0 + targetBitCount * targetBitCount) / 1024.0; // Lagrange par. +#endif + + if ((optimalSf == nullptr) || (grpOffsets == nullptr) || (numSfb == 0) || (numSfb > 52) || (targetBitCount == 0) || (targetBitCount > SHRT_MAX)) + { + return 0; // invalid input error + } + + for (sfb = 0; sfb < numSfb; sfb++) // SFB-wise scale factor, weighted distortion, and rate + { + const unsigned char refSf = m_quantInSf[sfb][1]; + const uint16_t refNumQ = m_quantRate[sfb][1]; + const double refQuantDist = m_quantDist[sfb][1]; + const double refQuantNorm = m_lutSfNorm[refSf] * m_lutSfNorm[refSf]; + const uint16_t sfbStart = grpOffsets[sfb]; + const uint16_t sfbWidth = grpOffsets[sfb + 1] - sfbStart; + uint32_t* const coeffMagn = &m_coeffMagn[sfbStart]; + unsigned char* const tempMagn = &m_coeffTemp[sfbStart]; + bool maxSnrReached = false; + + if (refQuantDist < 0.0) memset (tempMagn, 0, sfbWidth * sizeof (unsigned char)); +#if EC_TRAIN + else refGrpDist += refQuantDist; +#endif + if (grpStats) + { + grpStats[sfb] = (grpStats[sfb] & (USHRT_MAX << 16)) | refNumQ; // keep magn, sign bits + } + + for (is = 0; is < m_numCStates; is++) // populate the trellis + { + unsigned char* const mag = (is != 1 || quantCoeffs == nullptr ? &m_coeffTemp[grpStart] : &quantCoeffs[grpStart]); + double* const currDist = &m_quantDist[sfb][is]; + uint16_t* currRate = &m_quantRate[sfb][is * m_numCStates]; + unsigned char sfBest = optimalSf[sfb]; // optimal refSf + short maxQCurr = 0, numQCurr = 0; // for sign bits counting + + if (refQuantDist < 0.0) // -1.0 means SFB is zero-quantized + { + *currDist = -1.0; + m_quantInSf[sfb][is] = refSf; + } + else if (is != 1) // quantization & distortion not computed + { + const unsigned char sfCurr = __max (0, __min (m_maxSfIndex, refSf + 1 - (int) is)); + + *currDist = -1.0; + if ((sfCurr == 0) || maxSnrReached) + { + maxSnrReached = true; + } + else // sfCurr > 0 && sfCurr <= m_maxSfIndex, re-quantize + { + sfBest = quantizeMagn (coeffMagn, sfCurr, tempMagn, sfbWidth, &maxQCurr, &numQCurr); + + if (maxQCurr > SCHAR_MAX) + { + maxSnrReached = true; numQCurr = 0; + } + else + { + *currDist = getQuantDist (coeffMagn, sfBest, tempMagn, sfbWidth) * refQuantNorm; + } + } + if (*currDist < 0.0) memset (tempMagn, 0, sfbWidth * sizeof (unsigned char)); + m_quantInSf[sfb][is] = sfCurr; // store initial scale fac + } + else // is == 1, quant. & dist. computed with quantizeSfb() + { + numQCurr = refNumQ; + } + + if (sfb == 0) // first SFB, having sfbStart - grpStart == 0 + { + entropyCoder.arithSetCodState (codStart); // group start + entropyCoder.arithSetCtxState (ctxStart, 0); + tempBitCount = (maxSnrReached ? USHRT_MAX : numQCurr + getBitCount (entropyCoder, sfBest, UCHAR_MAX, 1, mag, 0, sfbWidth)); + + for (ds = m_numCStates - 1; ds >= 0; ds--) + { + currRate[ds] = (uint16_t) tempBitCount; + } + tempCodState[is] = entropyCoder.arithGetCodState (); + tempCtxState[is] = entropyCoder.arithGetCtxState (); + } + else // sfb > 0, rate depends on decisions in preceding SFB + { + for (ds = m_numCStates - 1; ds >= 0; ds--) + { + const uint16_t prevRate = m_quantRate[sfb - 1][ds * m_numCStates]; + + entropyCoder.arithSetCodState (prevCodState[ds]); + entropyCoder.arithSetCtxState (prevCtxState[ds], sfbStart - grpStart); + tempBitCount = (maxSnrReached || (prevRate == USHRT_MAX) ? USHRT_MAX : numQCurr + getBitCount (entropyCoder, + (numQCurr == 0 ? prevScaleFac[ds] : sfBest), prevScaleFac[ds], 1, mag, sfbStart - grpStart, sfbWidth)); + currRate[ds] = (uint16_t) tempBitCount; + + if ((sfb + 1 == numSfb) && (tempBitCount != USHRT_MAX)) + { + currRate[ds] += ((entropyCoder.arithGetCtxState () >> 17) & 31) + 2; // m_acBits+2 + } + if (ds == 1) // statistically best place to save states + { + tempCodState[is] = entropyCoder.arithGetCodState (); + tempCtxState[is] = entropyCoder.arithGetCtxState (); + } + } + } + tempScaleFac[is] = sfBest; // optimized factor for next SFB + } // for is + + memcpy (prevCodState, tempCodState, m_numCStates * sizeof (uint32_t)); + memcpy (prevCtxState, tempCtxState, m_numCStates * sizeof (uint32_t)); + memcpy (prevScaleFac, tempScaleFac, m_numCStates * sizeof (unsigned char)); + } // for sfb + + entropyCoder.arithSetCodState (codFinal); // back to last state + entropyCoder.arithSetCtxState (ctxFinal, grpOffsets[numSfb] - grpStart); + +#if EC_TRAIN + tempBitCount = targetBitCount + 1; // Viterbi search for minimum distortion at target rate + for (double lambda = 0.015625; (lambda <= 0.375) && (tempBitCount > targetBitCount); lambda += 0.0078125) +#endif + { + double* const prevCost = prevVtrbCost; + unsigned char* const prevPath = m_coeffTemp; // for backtrack + double costMinIs = (double) UINT_MAX; +#if EC_TRAIN + double tempGrpDist = 0.0; +#endif + unsigned pathMinIs = 1; + + for (is = 0; is < m_numCStates; is++) // initial minimum path + { + const uint16_t currRate = m_quantRate[0][is * m_numCStates]; + + prevCost[is] = (currRate >= USHRT_MAX ? (double) UINT_MAX : lambda * currRate + __max (0.0, m_quantDist[0][is])); + prevPath[is] = 0; + } + + for (sfb = 1; sfb < numSfb; sfb++) // search for minimum path + { + double* const currCost = tempVtrbCost; + unsigned char* const currPath = &prevPath[sfb * m_numCStates]; + + for (is = 0; is < m_numCStates; is++) // SFB's minimum path + { + uint16_t* currRate = &m_quantRate[sfb][is * m_numCStates]; + double costMinDs = (double) UINT_MAX; + unsigned char pathMinDs = 1; + + for (ds = m_numCStates - 1; ds >= 0; ds--) // transitions + { + const double costCurr = (currRate[ds] >= USHRT_MAX ? (double) UINT_MAX : prevCost[ds] + lambda * currRate[ds]); + + if (costMinDs > costCurr) + { + costMinDs = costCurr; + pathMinDs = (unsigned char) ds; + } + } + if (costMinDs < UINT_MAX) costMinDs += __max (0.0, m_quantDist[sfb][is]); + + currCost[is] = costMinDs; + currPath[is] = pathMinDs; + } // for is + + memcpy (prevCost, currCost, m_numCStates * sizeof (double)); // TODO: avoid memcpy, use pointer swapping instead for speed + } // for sfb + + for (sfb--, is = 0; is < m_numCStates; is++) // group minimum + { + if (costMinIs > prevCost[is]) + { + costMinIs = prevCost[is]; + pathMinIs = is; + } + } + + for (tempBitCount = 0; sfb > 0; sfb--) // min-cost group rate + { + const unsigned char* currPath = &prevPath[sfb * m_numCStates]; + const unsigned char pathMinDs = currPath[pathMinIs]; + + inScaleFac[sfb] = (m_quantDist[sfb][pathMinIs] < 0.0 ? UCHAR_MAX : m_quantInSf[sfb][pathMinIs]); + tempBitCount += m_quantRate[sfb][pathMinDs + pathMinIs * m_numCStates]; +#if EC_TRAIN + tempGrpDist += __max (0.0, m_quantDist[sfb][pathMinIs]); +#endif + pathMinIs = pathMinDs; + } + inScaleFac[0] = (m_quantDist[0][pathMinIs] < 0.0 ? UCHAR_MAX : m_quantInSf[0][pathMinIs]); + tempBitCount += m_quantRate[0][pathMinIs * m_numCStates]; +#if EC_TRAIN + tempGrpDist += __max (0.0, m_quantDist[0][pathMinIs]); +#endif + } // Viterbi search + +#if EC_TRAIN + if ((quantCoeffs != nullptr) && (tempGrpDist <= refGrpDist || tempBitCount <= targetBitCount)) +#else + if (quantCoeffs != nullptr) +#endif + { + unsigned char sfIndexPred = UCHAR_MAX; + + if (grpStats) + { + entropyCoder.arithSetCodState (codStart);// set group start + entropyCoder.arithSetCtxState (ctxStart, 0); + + tempBitCount = 0; + } + for (sfb = 0; sfb < numSfb; sfb++) // re-quantize spectrum with R/D optimized parameters + { + const uint16_t sfbStart = grpOffsets[sfb]; + const uint16_t sfbWidth = grpOffsets[sfb + 1] - sfbStart; + + if (inScaleFac[sfb] == UCHAR_MAX) // forced zero-quantized + { + optimalSf[sfb] = sfIndexPred; + memset (&quantCoeffs[sfbStart], 0, sfbWidth * sizeof (unsigned char)); + } + else if (inScaleFac[sfb] != m_quantInSf[sfb][1]) // speedup + { + short maxQBest = 0, numQBest = 0; + + optimalSf[sfb] = quantizeMagn (&m_coeffMagn[sfbStart], inScaleFac[sfb], &quantCoeffs[sfbStart], sfbWidth, &maxQBest, &numQBest); + if (maxQBest == 0) optimalSf[sfb] = sfIndexPred; // empty + if (grpStats) + { + grpStats[sfb] = ((uint32_t) maxQBest << 16) | numQBest; // max magn. and sign bits + } + } + + if (grpStats) // complete statistics with per-SFB bit count + { + grpStats[sfb] += getBitCount (entropyCoder, optimalSf[sfb], sfIndexPred, 1, &quantCoeffs[grpStart], sfbStart - grpStart, sfbWidth); + tempBitCount += grpStats[sfb] & USHRT_MAX; + } + + if ((sfb > 0) && (optimalSf[sfb] < UCHAR_MAX) && (sfIndexPred == UCHAR_MAX)) + { + memset (optimalSf, optimalSf[sfb], sfb * sizeof (unsigned char)); // back-propagate + } + sfIndexPred = optimalSf[sfb]; + } // for sfb + + return tempBitCount + (grpStats ? ((entropyCoder.arithGetCtxState () >> 17) & 31) /*m_acBits*/ + 2 : 0); + } + + return targetBitCount; +} +#endif // EC_TRELLIS_OPT_CODING diff --git a/src/lib/quantization.h b/src/lib/quantization.h new file mode 100644 index 0000000..594900e --- /dev/null +++ b/src/lib/quantization.h @@ -0,0 +1,85 @@ +/* quantization.h - header file for class with nonuniform quantization functionality + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _QUANTIZATION_H_ +#define _QUANTIZATION_H_ + +#include "exhaleLibPch.h" +#include "entropyCoding.h" + +// constants, experimental macros +#define FOUR_LOG102 13.28771238 // 4 / log10 (2) +#define SF_QUANT_OFFSET 0.4783662 // for scale fac +#define SFB_QUANT_FAST_POW 1 // faster pow () +#define SFB_QUANT_MORE_TESTS 1 // longer search +#define SFB_QUANT_PERCEPT_OPT 1 // psych. quant. +#if SFB_QUANT_FAST_POW +#define SFB_QUANT_OFFSET 0.496094 // 13 - 29^(3/4) +#else +#define SFB_QUANT_OFFSET 0.405396 // 1 - 0.5^(3/4) +#endif + +// class for xHE-AAC quantization +class SfbQuantizer +{ +private: + + // member variables + unsigned* m_coeffMagn; // temp memory +#if EC_TRELLIS_OPT_CODING + uint8_t m_coeffTemp[1024]; // TODO? +#else + uint8_t m_coeffTemp[200]; // 40 * 5 - NOTE: increase this when maximum grpLength > 5 +#endif + double* m_lut2ExpX4; // for 2^(X/4) + double* m_lutSfNorm; // 1 / 2^(X/4) + double* m_lutXExp43; // for X^(4/3) + uint8_t m_maxSfIndex; // 1,..., 127 +#if EC_TRELLIS_OPT_CODING + uint8_t m_numCStates; // states/SFB + // trellis memory, max. 8 KB @ num_swb=51 + double* m_quantDist[52]; // quantizing distortion + uint8_t* m_quantInSf[52]; // initial scale factors + uint16_t* m_quantRate[52]; // MDCT and SF bit count +#endif + + // helper functions + double getQuantDist (const unsigned* const coeffMagn, const uint8_t scaleFactor, + const uint8_t* const coeffQuant, const uint16_t numCoeffs); + uint8_t quantizeMagn (const unsigned* const coeffMagn, const uint8_t scaleFactor, + /*mod*/uint8_t* const coeffQuant, const uint16_t numCoeffs, + short* const sigMaxQ = nullptr, short* const sigNumQ = nullptr); +public: + + // constructor + SfbQuantizer (); + // destructor + ~SfbQuantizer (); + // public functions + unsigned* getCoeffMagnPtr () const { return m_coeffMagn; } + double* getSfNormTabPtr () const { return m_lutSfNorm; } + uint8_t getScaleFacOffset (const double absValue) const { return uint8_t (SF_QUANT_OFFSET + FOUR_LOG102 * log10 (__max (1.0, absValue))); } + unsigned initQuantMemory (const unsigned maxTransfLength, +#if EC_TRELLIS_OPT_CODING + const uint8_t numSwb, const uint8_t bitRateMode, +#endif + const uint8_t maxScaleFacIndex = SCHAR_MAX); + uint8_t quantizeSpecSfb (EntropyCoder& entropyCoder, const int32_t* const inputCoeffs, const uint8_t grpLength, + const uint16_t* const grpOffsets, uint32_t* const grpStats, // quant./coding statistics + const unsigned sfb, const uint8_t sfIndex, const uint8_t sfIndexPred = UCHAR_MAX, + uint8_t* const quantCoeffs = nullptr); // returns index of the RD optimized scale factor +#if EC_TRELLIS_OPT_CODING + unsigned quantizeSpecRDOC (EntropyCoder& entropyCoder, uint8_t* const optimalSf, const unsigned targetBitCount, + const uint16_t* const grpOffsets, uint32_t* const grpStats, // quant./coding statistics + const unsigned numSfb, uint8_t* const quantCoeffs); // returns RD optimization bit count +#endif +}; // SfbQuantizer + +#endif // _QUANTIZATION_H_ diff --git a/src/lib/specAnalysis.cpp b/src/lib/specAnalysis.cpp new file mode 100644 index 0000000..518acb0 --- /dev/null +++ b/src/lib/specAnalysis.cpp @@ -0,0 +1,342 @@ +/* specAnalysis.cpp - source file for class providing spectral analysis of MCLT signals + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "specAnalysis.h" + +// static helper function +static inline uint32_t packAvgSpecAnalysisStats (const uint64_t sumAvgBand, const uint64_t sumMaxBand, + const unsigned char predGain, + const uint16_t idxMaxSpec, const uint16_t idxLpStart) +{ + // temporal flatness, normalized for a value of 256 for a linear prediction gain of 1 (0 dB) + const unsigned flatTemp = predGain; + // spectral flatness, normalized for a value of 256 for steady low or mid-frequency sinusoid + const int32_t flatSpec = 256 - int (((sumAvgBand + SA_EPS) * 402) / (sumMaxBand + SA_EPS)); + + return (flatTemp << 24) | (CLIP_UCHAR (flatSpec) << 16) | (__min (2047, idxMaxSpec) << 5) | __min (31, idxLpStart); +} + +// constructor +SpecAnalyzer::SpecAnalyzer () +{ + for (unsigned ch = 0; ch < USAC_MAX_NUM_CHANNELS; ch++) + { + m_bandwidthOff[ch] = 0; + m_numAnaBands [ch] = 0; + m_specAnaStats[ch] = 0; + memset (m_parCorCoeffs[ch], 0, MAX_PREDICTION_ORDER * sizeof (short)); + } + m_tnsPredictor = nullptr; +} + +// public functions +unsigned SpecAnalyzer::getLinPredCoeffs (short parCorCoeffs[MAX_PREDICTION_ORDER], const unsigned channelIndex) // returns best filter order +{ + unsigned bestOrder = MAX_PREDICTION_ORDER, predGainCurr, predGainPrev; + + if ((parCorCoeffs == nullptr) || (channelIndex >= USAC_MAX_NUM_CHANNELS)) + { + return 0; // invalid arguments error + } + memcpy (parCorCoeffs, m_parCorCoeffs[channelIndex], MAX_PREDICTION_ORDER * sizeof (short)); + + predGainCurr = (m_tnsPredGains[channelIndex] >> 24) & UCHAR_MAX; + predGainPrev = (m_tnsPredGains[channelIndex] >> 16) & UCHAR_MAX; + while ((bestOrder > 1) && (predGainPrev >= predGainCurr)) // find lowest-order gain maximum + { + bestOrder--; + predGainCurr = predGainPrev; + predGainPrev = (m_tnsPredGains[channelIndex] >> (8 * bestOrder - 16)) & UCHAR_MAX; + } + return ((bestOrder == 1) && (m_parCorCoeffs[channelIndex][0] == 0) ? 0 : bestOrder); +} + +unsigned SpecAnalyzer::getMeanAbsValues (const int32_t* const mdctSignal, const int32_t* const mdstSignal, const unsigned nSamplesInFrame, + const unsigned channelIndex, const uint16_t* const bandStartOffsets, const unsigned nBands, + uint32_t* const meanBandValues) +{ + if ((mdctSignal == nullptr) || (bandStartOffsets == nullptr) || (meanBandValues == nullptr) || (channelIndex >= USAC_MAX_NUM_CHANNELS) || + (nSamplesInFrame > 2048) || (nSamplesInFrame < 2) || (nBands > nSamplesInFrame)) + { + return 1; // invalid arguments error + } + + if (mdstSignal != nullptr) // use complex-valued spectral data + { + for (unsigned b = 0; b < nBands; b++) + { + const unsigned bandOffset = __min (nSamplesInFrame, bandStartOffsets[b]); + const unsigned bandWidth = __min (nSamplesInFrame, bandStartOffsets[b + 1]) - bandOffset; + const unsigned anaBandIdx = bandOffset >> SA_BW_SHIFT; + + if ((anaBandIdx < m_numAnaBands[channelIndex]) && (bandOffset == (anaBandIdx << SA_BW_SHIFT)) && ((bandWidth & (SA_BW - 1)) == 0)) + { + const uint32_t* const anaAbsVal = &m_meanAbsValue[channelIndex][anaBandIdx]; + + // data available from previous call to spectralAnalysis + meanBandValues[b] = (bandWidth == SA_BW ? *anaAbsVal : uint32_t (((int64_t) anaAbsVal[0] + (int64_t) anaAbsVal[1] + 1) >> 1)); + } + else // no previous data available, compute mean magnitude + { + const int32_t* const bMdct = &mdctSignal[bandOffset]; + const int32_t* const bMdst = &mdstSignal[bandOffset]; + uint64_t sumAbsVal = 0; + + for (int s = bandWidth - 1; s >= 0; s--) + { +#if SA_EXACT_COMPLEX_ABS + const double complexSqr = (double) bMdct[s] * (double) bMdct[s] + (double) bMdst[s] * (double) bMdst[s]; + const unsigned absSample = unsigned (sqrt (complexSqr) + 0.5); +#else + const unsigned absReal = abs (bMdct[s]); // Richard Lyons, 1997; en.wikipedia.org/ + const unsigned absImag = abs (bMdst[s]); // wiki/Alpha_max_plus_beta_min_algorithm + const unsigned absSample = (absReal > absImag ? absReal + ((absImag * 3) >> 3) : absImag + ((absReal * 3) >> 3)); +#endif + sumAbsVal += absSample; + } + // average spectral sample magnitude across current band + meanBandValues[b] = uint32_t ((sumAbsVal + (bandWidth >> 1)) / bandWidth); + } + } // for b + } + else // no imaginary part available, real-valued spectral data + { + for (unsigned b = 0; b < nBands; b++) + { + const unsigned bandOffset = __min (nSamplesInFrame, bandStartOffsets[b]); + const unsigned bandWidth = __min (nSamplesInFrame, bandStartOffsets[b + 1]) - bandOffset; + const int32_t* const bMdct = &mdctSignal[bandOffset]; + uint64_t sumAbsVal = 0; + + for (int s = bandWidth - 1; s >= 0; s--) + { + const unsigned absSample = abs (bMdct[s]); + + sumAbsVal += absSample; + } + // average spectral sample magnitude across frequency band + meanBandValues[b] = uint32_t ((sumAbsVal + (bandWidth >> 1)) / bandWidth); + } // for b + } + m_numAnaBands[channelIndex] = 0; // mark spectral data as used + + return 0; // no error +} + +void SpecAnalyzer::getSpecAnalysisStats (uint32_t avgSpecAnaStats[USAC_MAX_NUM_CHANNELS], const unsigned nChannels) +{ + if ((avgSpecAnaStats == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS)) + { + return; + } + memcpy (avgSpecAnaStats, m_specAnaStats, nChannels * sizeof (uint32_t)); +} + +void SpecAnalyzer::getSpectralBandwidth (uint16_t bandwidthOffset[USAC_MAX_NUM_CHANNELS], const unsigned nChannels) +{ + if ((bandwidthOffset == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS)) + { + return; + } + memcpy (bandwidthOffset, m_bandwidthOff, nChannels * sizeof (uint16_t)); +} + +unsigned SpecAnalyzer::initLinPredictor (LinearPredictor* const linPredictor) +{ + if (linPredictor == nullptr) + { + return 1; // invalid arguments error + } + m_tnsPredictor = linPredictor; + + return 0; // no error +} + +#if SA_OPT_WINDOW_GROUPING +unsigned SpecAnalyzer::optimizeGrouping (const unsigned channelIndex, const unsigned prefBandwidth, const unsigned prefGroupingIndex) +{ + const uint32_t* meanAbsValCurr = m_meanAbsValue[channelIndex]; + const uint32_t numAnaBandsInCh = m_numAnaBands [channelIndex]; + unsigned grpIdxCurr = prefGroupingIndex, maxBands, numBands; + uint64_t energyCurrHF, energyPrefHF; + uint32_t energyCurrLF, energyPrefLF; + unsigned b; + + if ((prefBandwidth > 2048) || (grpIdxCurr == 0) || (grpIdxCurr >= 8) || (channelIndex >= USAC_MAX_NUM_CHANNELS) || (numAnaBandsInCh == 0)) + { + return 8; // invalid arguments error, or pypassing + } + + numBands = numAnaBandsInCh >> 3; + maxBands = numAnaBandsInCh << SA_BW_SHIFT; // available bandwidth, equal to nSamplesInFrame + maxBands = (numBands * __min (maxBands, prefBandwidth) + (maxBands >> 1)) / maxBands; + + if (maxBands * numBands == 0) return 8; // low/no BW + if (grpIdxCurr < 7) grpIdxCurr++; // after transient + + meanAbsValCurr += grpIdxCurr * numBands; + grpIdxCurr++; + energyPrefLF = meanAbsValCurr[0] >> 1; // - 6 dB + energyPrefHF = 0; + for (b = maxBands - 1; b > 0; b--) // avoid LF band + { + energyPrefHF += meanAbsValCurr[b]; + } + energyPrefHF >>= 1; // - 6 dB + + do // check whether HF or LF transient starts earlier than preferred grouping index suggests + { + meanAbsValCurr -= numBands; + grpIdxCurr--; + energyCurrLF = meanAbsValCurr[0]; + energyCurrHF = 0; + for (b = maxBands - 1; b > 0; b--) // prev. window + { + energyCurrHF += meanAbsValCurr[b]; + } + } + while ((grpIdxCurr > 1) && (energyCurrHF >= energyPrefHF) && (energyCurrLF >= energyPrefLF)); + + return __min (grpIdxCurr, prefGroupingIndex); // final optimized grouping index +} +#endif // SA_OPT_WINDOW_GROUPING + +unsigned SpecAnalyzer::spectralAnalysis (const int32_t* const mdctSignals[USAC_MAX_NUM_CHANNELS], + const int32_t* const mdstSignals[USAC_MAX_NUM_CHANNELS], + const unsigned nChannels, const unsigned nSamplesInFrame, const unsigned samplingRate, + const unsigned lfeChannelIndex /*= USAC_MAX_NUM_CHANNELS*/) // to skip an LFE channel +{ + const unsigned lpcStopBand16k = (samplingRate <= 32000 ? nSamplesInFrame : (32000 * nSamplesInFrame) / samplingRate) >> SA_BW_SHIFT; + const unsigned thresholdSlope = (48000 + SA_EPS * samplingRate) / 96000; + const unsigned thresholdStart = samplingRate >> 15; + + if ((mdctSignals == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS) || (lfeChannelIndex > USAC_MAX_NUM_CHANNELS) || + (nSamplesInFrame > 2048) || (nSamplesInFrame < 2) || (samplingRate < 7350) || (samplingRate > 96000)) + { + return 1; // invalid arguments error + } + + for (unsigned ch = 0; ch < nChannels; ch++) + { + const int32_t* const chMdct = mdctSignals[ch]; + const int32_t* const chMdst = (mdstSignals == nullptr ? nullptr : mdstSignals[ch]); +// --- get L1 norm and max value in each band + uint16_t idxMaxSpec = 0; + uint64_t sumAvgBand = 0; + uint64_t sumMaxBand = 0; + uint32_t valMaxSpec = 0; + int b; + + if (ch == lfeChannelIndex) // no analysis + { + m_bandwidthOff[ch] = LFE_MAX; + m_numAnaBands [ch] = 0; + m_specAnaStats[ch] = 0; // flat/stationary frame + continue; + } + + m_bandwidthOff[ch] = 0; + m_numAnaBands [ch] = nSamplesInFrame >> SA_BW_SHIFT; + + for (b = m_numAnaBands[ch] - 1; b >= 0; b--) + { + const uint16_t offs = b << SA_BW_SHIFT; // start offset of current analysis band + const int32_t* const bMdct = &chMdct[offs]; + const int32_t* const bMdst = (chMdst == nullptr ? nullptr : &chMdst[offs]); + uint16_t maxAbsIdx = 0; + uint32_t maxAbsVal = 0, tmp = UINT_MAX; + uint64_t sumAbsVal = 0; + + if (bMdst != nullptr) // complex-valued spectrum + { + for (int s = SA_BW - 1; s >= 0; s--) + { + // sum absolute values of complex signal, derive L1 norm, peak value, and peak index +#if SA_EXACT_COMPLEX_ABS + const double complexSqr = (double) bMdct[s] * (double) bMdct[s] + (double) bMdst[s] * (double) bMdst[s]; + const unsigned absSample = unsigned (sqrt (complexSqr) + 0.5); +#else + const unsigned absReal = abs (bMdct[s]); // Richard Lyons, 1997; en.wikipedia.org/ + const unsigned absImag = abs (bMdst[s]); // wiki/Alpha_max_plus_beta_min_algorithm + const unsigned absSample = (absReal > absImag ? absReal + ((absImag * 3) >> 3) : absImag + ((absReal * 3) >> 3)); +#endif + sumAbsVal += absSample; + if (offs + s > 0) // exclude DC from max/min + { + if (maxAbsVal < absSample) // maximum data + { + maxAbsVal = absSample; + maxAbsIdx = (uint16_t) s; + } + if (tmp/*min*/> absSample) // minimum data + { + tmp/*min*/= absSample; + } + } // b > 0 + } + } + else // real-valued spectrum, no imaginary part + { + for (int s = SA_BW - 1; s >= 0; s--) + { + // obtain absolute values of real signal, derive L1 norm, peak value, and peak index + const unsigned absSample = abs (bMdct[s]); + + sumAbsVal += absSample; + if (offs + s > 0) // exclude DC from max/min + { + if (maxAbsVal < absSample) // maximum data + { + maxAbsVal = absSample; + maxAbsIdx = (uint16_t) s; + } + if (tmp/*min*/> absSample) // minimum data + { + tmp/*min*/= absSample; + } + } + } + } + // bandwidth detection + if ((m_bandwidthOff[ch] == 0) && (maxAbsVal > __max (thresholdSlope * (thresholdStart + b), SA_EPS))) + { + m_bandwidthOff[ch] = __max (maxAbsIdx + 5/*guard*/, SA_BW) + offs; + m_bandwidthOff[ch] = __min (m_bandwidthOff[ch], nSamplesInFrame); + } + // save mean magnitude + tmp/*mean*/ = uint32_t ((sumAbsVal + (1 << (SA_BW_SHIFT - 1))) >> SA_BW_SHIFT); + m_meanAbsValue[ch][b] = tmp; + // spectral statistics + if (b > 0) + { + sumAvgBand += tmp; + sumMaxBand += maxAbsVal; + } + if (valMaxSpec < maxAbsVal) + { + valMaxSpec = maxAbsVal; + idxMaxSpec = maxAbsIdx + offs; + } + } // for b + +// --- spectral analysis statistics for frame + b = 1; + while (((unsigned) b + 1 < lpcStopBand16k) && ((uint64_t) m_meanAbsValue[ch][b] * (m_numAnaBands[ch] - 1) > sumAvgBand)) b++; + b = __min (m_bandwidthOff[ch], b << SA_BW_SHIFT); + + // obtain prediction gain across spectrum + m_tnsPredGains[ch] = m_tnsPredictor->calcParCorCoeffs (&chMdct[b], __min (m_bandwidthOff[ch], lpcStopBand16k << SA_BW_SHIFT) - b, + MAX_PREDICTION_ORDER, m_parCorCoeffs[ch]); + m_specAnaStats[ch] = packAvgSpecAnalysisStats (sumAvgBand, sumMaxBand, m_tnsPredGains[ch] >> 24, idxMaxSpec, (unsigned) b >> SA_BW_SHIFT); + } // for ch + + return 0; // no error +} diff --git a/src/lib/specAnalysis.h b/src/lib/specAnalysis.h new file mode 100644 index 0000000..a8d82b1 --- /dev/null +++ b/src/lib/specAnalysis.h @@ -0,0 +1,61 @@ +/* specAnalysis.h - header file for class providing spectral analysis of MCLT signals + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _SPEC_ANALYSIS_H_ +#define _SPEC_ANALYSIS_H_ + +#include "exhaleLibPch.h" +#include "linearPrediction.h" + +// constants, experimental macros +#define SA_BW_SHIFT 5 +#define SA_BW (1 << SA_BW_SHIFT) +#define SA_EPS 1024 +#define SA_EXACT_COMPLEX_ABS 0 +#define SA_OPT_WINDOW_GROUPING 1 + +// spectral signal analysis class +class SpecAnalyzer +{ +private: + + // member variables + uint16_t m_bandwidthOff[USAC_MAX_NUM_CHANNELS]; + uint32_t m_meanAbsValue[USAC_MAX_NUM_CHANNELS][1024 >> SA_BW_SHIFT]; + uint16_t m_numAnaBands [USAC_MAX_NUM_CHANNELS]; + short m_parCorCoeffs[USAC_MAX_NUM_CHANNELS][MAX_PREDICTION_ORDER]; + uint32_t m_specAnaStats[USAC_MAX_NUM_CHANNELS]; + uint32_t m_tnsPredGains[USAC_MAX_NUM_CHANNELS]; + LinearPredictor* m_tnsPredictor; + +public: + + // constructor + SpecAnalyzer (); + // destructor + ~SpecAnalyzer () { } + // public functions + unsigned getLinPredCoeffs (short parCorCoeffs[MAX_PREDICTION_ORDER], const unsigned channelIndex); // returns best filter order + unsigned getMeanAbsValues (const int32_t* const mdctSignal, const int32_t* const mdstSignal, const unsigned nSamplesInFrame, + const unsigned channelIndex, const uint16_t* const bandStartOffsets, const unsigned nBands, + uint32_t* const meanBandValues); + void getSpecAnalysisStats (uint32_t avgSpecAnaStats[USAC_MAX_NUM_CHANNELS], const unsigned nChannels); + void getSpectralBandwidth (uint16_t bandwidthOffset[USAC_MAX_NUM_CHANNELS], const unsigned nChannels); + unsigned initLinPredictor (LinearPredictor* const linPredictor); +#if SA_OPT_WINDOW_GROUPING + unsigned optimizeGrouping (const unsigned channelIndex, const unsigned preferredBandwidth, const unsigned preferredGrouping); +#endif + unsigned spectralAnalysis (const int32_t* const mdctSignals[USAC_MAX_NUM_CHANNELS], + const int32_t* const mdstSignals[USAC_MAX_NUM_CHANNELS], + const unsigned nChannels, const unsigned nSamplesInFrame, const unsigned samplingRate, + const unsigned lfeChannelIndex = USAC_MAX_NUM_CHANNELS); // to skip an LFE channel +}; // SpecAnalyzer + +#endif // _SPEC_ANALYSIS_H_ diff --git a/src/lib/specGapFilling.cpp b/src/lib/specGapFilling.cpp new file mode 100644 index 0000000..fc803b3 --- /dev/null +++ b/src/lib/specGapFilling.cpp @@ -0,0 +1,223 @@ +/* specGapFilling.cpp - source file for class with spectral gap filling coding methods + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "specGapFilling.h" + +// ISO/IEC 23003-3, Table 109 +static const uint16_t noiseFillingStartOffset[2 /*long/short*/][2 /*768/1024*/] = {{120, 160}, {15, 20}}; + +// constructor +SpecGapFiller::SpecGapFiller () +{ + m_1stGapFillSfb = 0; + memset (m_1stNonZeroSfb, 0, sizeof (m_1stNonZeroSfb)); +} + +// public functions +unsigned char SpecGapFiller::getSpecGapFillParams (const SfbQuantizer& sfbQuantizer, const unsigned char* const quantMagn, + const unsigned char numSwbShort, SfbGroupData& grpData /*modified*/, + const unsigned nSamplesInFrame /*= 1024*/) +{ + const unsigned* const coeffMagn = sfbQuantizer.getCoeffMagnPtr (); + const double* const sfNormFacs = sfbQuantizer.getSfNormTabPtr (); + const uint16_t sfbsPerGrp = grpData.sfbsPerGroup; + const uint16_t windowNfso = noiseFillingStartOffset[grpData.numWindowGroups == 1 ? 0 : 1][nSamplesInFrame >> 10]; + unsigned char scaleFactorLimit = 0; + uint16_t u = 0; + short diff = 0, s = 0; + double magnSum = 0.0; + + if ((coeffMagn == nullptr) || (sfNormFacs == nullptr) || (quantMagn == nullptr) || + (numSwbShort < MIN_NUM_SWB_SHORT) || (numSwbShort > MAX_NUM_SWB_SHORT) || (nSamplesInFrame > 1024)) + { + return 1; // invalid arguments error + } + +// --- determine noise_level as mean of all coeff magnitudes at zero-quantized coeff indices + m_1stGapFillSfb = 0; + memset (m_1stNonZeroSfb, -1, sizeof (m_1stNonZeroSfb)); + + for (uint16_t gr = 0; gr < grpData.numWindowGroups; gr++) + { + const uint16_t* grpOff = &grpData.sfbOffsets[numSwbShort * gr]; + const uint32_t* grpRms = &grpData.sfbRmsValues[numSwbShort * gr]; // quant./coding stats + const unsigned char* grpScFacs = &grpData.scaleFactors[numSwbShort * gr]; + const uint16_t grpLength = grpData.windowGroupLength[gr]; + const uint16_t grpNfso = grpOff[0] + grpLength * windowNfso; + const uint16_t sfbLimit = (grpData.numWindowGroups == 1 ? sfbsPerGrp - (grpOff[sfbsPerGrp] >= nSamplesInFrame ? 1 : 0) + : __min (sfbsPerGrp, numSwbShort - 1)); // no high frequencies + for (uint16_t b = 0; b < sfbLimit; b++) // find first gap-fill SFB and noise_level + { + const uint16_t sfbStart = grpOff[b]; + const uint16_t sfbWidth = grpOff[b + 1] - sfbStart; + const unsigned* const sfbMagn = &coeffMagn[sfbStart]; + const unsigned char* sfbQuant = &quantMagn[sfbStart]; + const unsigned char sFac = grpScFacs[b]; + + if (sfbStart < grpNfso) // SFBs below noiseFillingStartOffset + { + if ((grpRms[b] >> 16) > 0) // the SFB is non-zero quantized + { + if (m_1stNonZeroSfb[gr] < 0) m_1stNonZeroSfb[gr] = b; + if (scaleFactorLimit < sFac) scaleFactorLimit = sFac; + } + } + else // sfbStart >= grpNfso, so above noiseFillingStartOffset + { + if (m_1stNonZeroSfb[gr] < 0) m_1stNonZeroSfb[gr] = b; + if (m_1stGapFillSfb == 0) m_1stGapFillSfb = b; + + if ((grpRms[b] >> 16) > 0) // the SFB is non-zero quantized + { + unsigned sfbMagnSum = 0; // NOTE: may overflow, but unlikely, and 32 bit is faster + + if (scaleFactorLimit < sFac) scaleFactorLimit = sFac; +#if SGF_OPT_SHORT_WIN_CALC + if (grpLength > 1) // eight-short windows: SFB ungrouping + { + const uint32_t* sfbMagnPtr = sfbMagn; + const unsigned char* sfbQuantPtr = sfbQuant; + const int swbLength = (sfbWidth * oneTwentyEightOver[grpLength]) >> 7; // sfbWidth / grpLength + unsigned sfbMagnMin = USHRT_MAX; + uint16_t uMin = 0; + + for (uint16_t w = 0; w < grpLength; w++) + { + unsigned sfbMagnWin = 0; + uint16_t uWin = 0; + + for (int i = swbLength - 1; i >= 0; i--, sfbMagnPtr++, sfbQuantPtr++) + { + if ((*sfbQuantPtr == 0) && (i == 0 || i == swbLength - 1 || *(sfbQuantPtr-1) + *(sfbQuantPtr+1) < 2)) + { + sfbMagnWin += *sfbMagnPtr; + uWin++; + } + } + if (sfbMagnWin * (uint64_t) uMin < sfbMagnMin * (uint64_t) uWin) // new minimum + { + sfbMagnMin = sfbMagnWin; + uMin = uWin; + } + } // for w + + sfbMagnSum += sfbMagnMin * grpLength; // scaled minimum + u += uMin * grpLength; + } + else +#endif + for (int i = sfbWidth - 1; i >= 0; i--) + { + if ((sfbQuant[i] == 0) && (sfbQuant[i - 1] + sfbQuant[i + 1] < 2)) + { + sfbMagnSum += sfbMagn[i]; + u++; + } + } + magnSum += sfbMagnSum * sfNormFacs[grpScFacs[b]]; + } + } + } // for b + + // clip to non-negative value for get function and memset below + if (m_1stNonZeroSfb[gr] < 0) m_1stNonZeroSfb[gr] = 0; + } // for gr + + // determine quantized noise_level from normalized mean magnitude + if ((u < 4) || (magnSum * 359.0 < u * 16.0)) + { + if (sfbsPerGrp <= m_1stGapFillSfb) return 0; // silent, level 0 + + magnSum = 1.0; u = 4; // max. level + } + u = __min (7, uint16_t (14.47118288 + 9.965784285 * log10 (magnSum / (double) u))); + + magnSum = pow (2.0, (14 - u) / 3.0); // noiseVal^-1, 23003-3, 7.2 + +// --- calculate gap-fill scale factors for zero quantized SFBs, then determine noise_offset + u <<= 5; // left-shift for bit-stream + if (scaleFactorLimit < SGF_LIMIT) scaleFactorLimit = SGF_LIMIT; + + for (uint16_t gr = 0; gr < grpData.numWindowGroups; gr++) + { + const uint16_t* grpOff = &grpData.sfbOffsets[numSwbShort * gr]; + const uint32_t* grpRms = &grpData.sfbRmsValues[numSwbShort * gr]; // quant./coding stats + unsigned char* const grpScFacs = &grpData.scaleFactors[numSwbShort * gr]; + + for (uint16_t b = m_1stGapFillSfb; b < sfbsPerGrp; b++) // calculate scale factors + { + if ((grpRms[b] >> 16) == 0) // the SFB is all-zero quantized + { + if (grpScFacs[b] > 0) + { + const uint16_t sfbStart = grpOff[b]; + const int16_t sfbWidthM1 = grpOff[b + 1] - sfbStart - 1; + const unsigned* sfbMagn = &coeffMagn[sfbStart]; + unsigned sfbMagnMax = 0; + unsigned sfbMagnSum = 0; // NOTE: may overflow, but unlikely, and 32 bit is faster + + for (int i = sfbWidthM1; i >= 0; i--) + { + sfbMagnSum += sfbMagn[i]; + if (sfbMagnMax < sfbMagn[i]) sfbMagnMax = sfbMagn[i]; // sum up without maximum + } + grpScFacs[b] = sfbQuantizer.getScaleFacOffset (((sfbMagnSum - sfbMagnMax) * magnSum) / (double) sfbWidthM1); + + if (grpScFacs[b] > scaleFactorLimit) grpScFacs[b] = scaleFactorLimit; + } +#if SGF_SF_PEAK_SMOOTHING + // save delta-code bits by smoothing scale factor peaks in zero quantized SFB ranges + if ((b > m_1stGapFillSfb) && ((grpRms[b - 1] >> 16) == 0) && ((grpRms[b - 2] >> 16) == 0) && + (grpScFacs[b - 1] > grpScFacs[b]) && (grpScFacs[b - 1] > grpScFacs[b - 2])) + { + grpScFacs[b - 1] = (grpScFacs[b - 1] + __max (grpScFacs[b], grpScFacs[b - 2])) >> 1; + } +#endif + } + + if ((b > m_1stGapFillSfb) && (((grpRms[b - 1] >> 16) > 0) ^ ((grpRms[b - 2] >> 16) > 0))) + { + diff += (int) grpScFacs[b - 1] - (int) grpScFacs[b - 2]; // sum up transition deltas + s++; + } + } // for b + } // for gr + + if (s > 0) + { + diff = (diff + (s >> 1)*(diff < 0 ? -1 : 1)) / s; // mean delta + if (diff < -16) diff = -16; + else + if (diff >= 16) diff = 15; + } + s = __max (-diff, (short) scaleFactorLimit - SGF_LIMIT); // limit + + for (uint16_t gr = 0; gr < grpData.numWindowGroups; gr++) + { + const uint32_t* grpRms = &grpData.sfbRmsValues[numSwbShort * gr]; // quant./coding stats + unsigned char* const grpScFacs = &grpData.scaleFactors[numSwbShort * gr]; + + for (uint16_t b = m_1stGapFillSfb; b < sfbsPerGrp; b++) // account f. noise_offset + { + if ((grpRms[b] >> 16) == 0) // the SFB is all-zero quantized + { + grpScFacs[b] = (unsigned char) __max (s, grpScFacs[b] - diff); + + if (grpScFacs[b] > scaleFactorLimit) grpScFacs[b] = scaleFactorLimit; + } + } // for b + + // repeat first significant scale factor downwards to save bits + memset (grpScFacs, grpScFacs[m_1stNonZeroSfb[gr]], m_1stNonZeroSfb[gr] * sizeof (unsigned char)); + } // for gr + + return CLIP_UCHAR (u | (diff + 16)); // combined level and offset +} diff --git a/src/lib/specGapFilling.h b/src/lib/specGapFilling.h new file mode 100644 index 0000000..04d2d86 --- /dev/null +++ b/src/lib/specGapFilling.h @@ -0,0 +1,44 @@ +/* specGapFilling.h - header file for class with spectral gap filling coding methods + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _SPEC_GAP_FILLING_H_ +#define _SPEC_GAP_FILLING_H_ + +#include "exhaleLibPch.h" +#include "quantization.h" + +// constants, experimental macro +#define SGF_LIMIT 2*INDEX_OFFSET +#define SGF_OPT_SHORT_WIN_CALC 1 +#define SGF_SF_PEAK_SMOOTHING 1 + +// MDCT-domain gap filling class +class SpecGapFiller +{ +private: + + // member variables + uint16_t m_1stGapFillSfb; + int16_t m_1stNonZeroSfb[NUM_WINDOW_GROUPS]; + +public: + + // constructor + SpecGapFiller (); + // destructor + ~SpecGapFiller () { } + // public functions + uint16_t getFirstGapFillSfb () const { return m_1stGapFillSfb; } + uint8_t getSpecGapFillParams (const SfbQuantizer& sfbQuantizer, const uint8_t* const quantMagn, + const uint8_t numSwbShort, SfbGroupData& grpData /*modified*/, + const unsigned nSamplesInFrame = 1024); +}; // SpecGapFiller + +#endif // _SPEC_GAP_FILLING_H_ diff --git a/src/lib/tempAnalysis.cpp b/src/lib/tempAnalysis.cpp new file mode 100644 index 0000000..7097cd7 --- /dev/null +++ b/src/lib/tempAnalysis.cpp @@ -0,0 +1,270 @@ +/* tempAnalysis.cpp - source file for class providing temporal analysis of PCM signals + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#include "exhaleLibPch.h" +#include "tempAnalysis.h" + +// static helper functions +static unsigned updateAbsStats (const int32_t* const chSig, const int nSamples, unsigned* const maxAbsVal, int16_t* const maxAbsIdx) +{ + const int32_t* const chSigM1 = chSig - 1; // for first-order high-pass + unsigned sumAbs = 0; + + for (int s = nSamples - 1; s >= 0; s--) + { + // compute absolute values of high-pass signal, obtain L1 norm, peak value, and peak index + const unsigned absSample = abs (chSig[s] - chSigM1[s]); + + sumAbs += absSample; + if (*maxAbsVal < absSample) + { + *maxAbsVal = absSample; + *maxAbsIdx = (int16_t) s; + } + } + return sumAbs; +} + +static unsigned applyPitchPred (const int32_t* const chSig, const int nSamples, const int pitchLag, const int pitchSign = 1) +{ + const int32_t* const chSigM1 = chSig - 1; // for first-order high-pass + const int32_t* const plSig = chSig - pitchLag; // & pitch prediction + const int32_t* const plSigM1 = plSig - 1; + unsigned sumAbs = 0; + + for (int s = nSamples - 1; s >= 0; s--) + { + // compute absolute values of pitch-predicted high-pass signal, obtain L1 norm, peak value + sumAbs += abs (chSig[s] - chSigM1[s] - pitchSign * (plSig[s] - plSigM1[s])); + } + return sumAbs; +} + +static inline uint32_t packAvgTempAnalysisStats (const unsigned avgAbsHpL, const unsigned avgAbsHpR, const unsigned avgAbsHpP, + const unsigned avgAbsPpLR, const unsigned maxAbsHpLR) +{ + // spectral flatness, normalized for a value of 256 for noise-like, spectrally flat waveform + const unsigned flatSpec = 256 - int ((int64_t (avgAbsPpLR/*L+R sum*/ + TA_EPS) * 256) / (int64_t (avgAbsHpL + avgAbsHpR + TA_EPS))); + // temporal flatness, normalized for a value of 256 for steady low or mid-frequency sinusoid + const int32_t flatTemp = 256 - int ((int64_t (avgAbsHpL + avgAbsHpR + TA_EPS) * 402) / (int64_t (maxAbsHpLR/*L+R sum*/ + TA_EPS))); + // temporal stationarity, two sides, normalized for values of 256 for L1-stationary waveform + const int32_t statTmpL = 256 - int (((__min (avgAbsHpP, avgAbsHpL) + TA_EPS) * 256) / ((__max (avgAbsHpP, avgAbsHpL) + TA_EPS))); + const int32_t statTmpR = 256 - int (((__min (avgAbsHpL, avgAbsHpR) + TA_EPS) * 256) / ((__max (avgAbsHpL, avgAbsHpR) + TA_EPS))); + + return (CLIP_UCHAR (flatSpec) << 24) | (CLIP_UCHAR (flatTemp) << 16) | (CLIP_UCHAR (statTmpL) << 8) | CLIP_UCHAR (statTmpR); +} + +static inline int16_t getMaxAbsHpValueLocation (const unsigned maxAbsValL, const unsigned maxAbsValR, const unsigned maxAbsValP, + const int16_t maxAbsIdxL, const int16_t maxAbsIdxR) +{ + if ((maxAbsValP * 8 < maxAbsValL * 3) || (maxAbsValL * 8 < maxAbsValR * 3)) // has transient + { + return maxAbsValR > maxAbsValL ? maxAbsIdxR : maxAbsIdxL; + } + return -1; // no transient +} + +// constructor +TempAnalyzer::TempAnalyzer () +{ + for (unsigned ch = 0; ch < USAC_MAX_NUM_CHANNELS; ch++) + { + m_avgAbsHpPrev[ch] = 0; + m_maxAbsHpPrev[ch] = 0; + m_maxIdxHpPrev[ch] = 1; + m_pitchLagPrev[ch] = 0; + m_tempAnaStats[ch] = 0; + m_transientLoc[ch] = -1; + } +} + +// public functions +void TempAnalyzer::getTempAnalysisStats (uint32_t avgTempAnaStats[USAC_MAX_NUM_CHANNELS], const unsigned nChannels) +{ + if ((avgTempAnaStats == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS)) + { + return; + } + memcpy (avgTempAnaStats, m_tempAnaStats, nChannels * sizeof (uint32_t)); +} + +void TempAnalyzer::getTransientLocation (int16_t maxHighPassValueLocation[USAC_MAX_NUM_CHANNELS], const unsigned nChannels) +{ + if ((maxHighPassValueLocation == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS)) + { + return; + } + memcpy (maxHighPassValueLocation, m_transientLoc, nChannels * sizeof (int16_t)); +} + +unsigned TempAnalyzer::temporalAnalysis (const int32_t* const timeSignals[USAC_MAX_NUM_CHANNELS], const unsigned nChannels, + const int nSamplesInFrame, const unsigned lookaheadOffset, + const unsigned lfeChannelIndex /*= USAC_MAX_NUM_CHANNELS*/) // to skip an LFE channel +{ + const int halfFrameOffset = nSamplesInFrame >> 1; + + if ((timeSignals == nullptr) || (nChannels > USAC_MAX_NUM_CHANNELS) || (lfeChannelIndex > USAC_MAX_NUM_CHANNELS) || + (nSamplesInFrame > 2048) || (nSamplesInFrame < 2) || (lookaheadOffset > 2048) || (lookaheadOffset == 0)) + { + return 1; + } + + for (unsigned ch = 0; ch < nChannels; ch++) + { + const int32_t* const chSig = &timeSignals[ch][lookaheadOffset]; + const int32_t* const chSigM1 = chSig - 1; // for first-order high-pass +// --- get L1 norm and pitch lag of both sides + unsigned sumAbsValL = 0, sumAbsValR = 0; + unsigned maxAbsValL = 0, maxAbsValR = 0; + int16_t maxAbsIdxL = 0, maxAbsIdxR = 0; + int splitPtL = 0; + int splitPtC = halfFrameOffset; + int splitPtR = nSamplesInFrame; + unsigned uL0 = abs (chSig[splitPtL ] - chSigM1[splitPtL ]); + unsigned uL1 = abs (chSig[splitPtC - 1] - chSigM1[splitPtC - 1]); + unsigned uR0 = abs (chSig[splitPtC ] - chSigM1[splitPtC ]); + unsigned uR1 = abs (chSig[splitPtR - 1] - chSigM1[splitPtR - 1]); + unsigned u; // temporary value - register? + + if (ch == lfeChannelIndex) // no analysis + { + m_tempAnaStats[ch] = 0; // flat/stationary frame + m_transientLoc[ch] = -1; + continue; + } + + do // find last sample of left-side region + { + sumAbsValL += (u = uL1); + splitPtC--; + } + while ((splitPtC > /*start +*/1) && (uL1 = abs (chSig[splitPtC - 1] - chSigM1[splitPtC - 1])) < u); + + do // find first sample of left-side range + { + sumAbsValL += (u = uL0); + splitPtL++; + } + while ((splitPtL < splitPtC - 1) && (uL0 = abs (chSig[splitPtL] - chSigM1[splitPtL])) < u); + + sumAbsValL += updateAbsStats (&chSig[splitPtL], splitPtC - splitPtL, &maxAbsValL, &maxAbsIdxL); + maxAbsIdxL += splitPtL; // left-side stats + if ((maxAbsIdxL == 1) && (maxAbsValL <= u)) + { + maxAbsValL = u; + maxAbsIdxL--; + } + + splitPtC = halfFrameOffset; + + do // find last sample of right-side region + { + sumAbsValR += (u = uR1); + splitPtR--; + } + while ((splitPtR > splitPtC + 1) && (uR1 = abs (chSig[splitPtR - 1] - chSigM1[splitPtR - 1])) < u); + + do // find first sample of right-side range + { + sumAbsValR += (u = uR0); + splitPtC++; + } + while ((splitPtC < splitPtR - 1) && (uR0 = abs (chSig[splitPtC] - chSigM1[splitPtC])) < u); + + sumAbsValR += updateAbsStats (&chSig[splitPtC], splitPtR - splitPtC, &maxAbsValR, &maxAbsIdxR); + maxAbsIdxR += splitPtC; // right-side stats + if ((maxAbsIdxR == halfFrameOffset + 1) && (maxAbsValR <= u)) + { + maxAbsValR = u; + maxAbsIdxR--; + } + +// --- find best pitch lags minimizing L1 norms + if (sumAbsValL == 0 && sumAbsValR == 0) + { + m_tempAnaStats[ch] = 0; // flat/stationary frame + m_transientLoc[ch] = -1; + // re-init stats history for this channel + m_avgAbsHpPrev[ch] = 0; // sumAbsValR >> 9 + m_maxAbsHpPrev[ch] = 0; // maxAbsValR + m_maxIdxHpPrev[ch] = 1; // (unsigned) maxAbsIdxR + m_pitchLagPrev[ch] = 0; // (unsigned) pLagBestR + } + else // nonzero signal in the current frame + { + const int maxAbsIdxP = __max ((int) m_maxIdxHpPrev[ch] - nSamplesInFrame, 1 - (int) lookaheadOffset); + unsigned sumAbsHpL = sumAbsValL, sumAbsHpR = sumAbsValR; // after high-pass filter + unsigned sumAbsPpL = sumAbsValL, sumAbsPpR = sumAbsValR; // after pitch prediction + int pLag, pLagBestR = 0, pSgn; + + // test left-side pitch lag on this frame + pLag = __min (maxAbsIdxL - maxAbsIdxP, (int) lookaheadOffset - 1); + pSgn = (((chSig[maxAbsIdxL] - chSigM1[maxAbsIdxL] > 0) && (chSig[maxAbsIdxP] - chSigM1[maxAbsIdxP] < 0)) || + ((chSig[maxAbsIdxL] - chSigM1[maxAbsIdxL] < 0) && (chSig[maxAbsIdxP] - chSigM1[maxAbsIdxP] > 0)) ? -1 : 1); + if ((sumAbsValL = applyPitchPred (chSig, halfFrameOffset, pLag, pSgn)) < sumAbsPpL) + { + sumAbsPpL = sumAbsValL; // left side + } +#if TA_MORE_PITCH_TESTS + if ((sumAbsValR = applyPitchPred (chSig + halfFrameOffset, halfFrameOffset, pLag, pSgn)) < sumAbsPpR) + { + sumAbsPpR = sumAbsValR; // right side + pLagBestR = pLag; + } +#endif + // test right-side pitch lag on the frame + pLag = __min (maxAbsIdxR - maxAbsIdxL, (int) lookaheadOffset - 1); + pSgn = (((chSig[maxAbsIdxR] - chSigM1[maxAbsIdxR] > 0) && (chSig[maxAbsIdxL] - chSigM1[maxAbsIdxL] < 0)) || + ((chSig[maxAbsIdxR] - chSigM1[maxAbsIdxR] < 0) && (chSig[maxAbsIdxL] - chSigM1[maxAbsIdxL] > 0)) ? -1 : 1); +#if TA_MORE_PITCH_TESTS + if ((sumAbsValL = applyPitchPred (chSig, halfFrameOffset, pLag, pSgn)) < sumAbsPpL) + { + sumAbsPpL = sumAbsValL; // left side + } +#endif + if ((sumAbsValR = applyPitchPred (chSig + halfFrameOffset, halfFrameOffset, pLag, pSgn)) < sumAbsPpR) + { + sumAbsPpR = sumAbsValR; // right side + pLagBestR = pLag; + } + // try previous frame's lag on this frame + pLag = (m_pitchLagPrev[ch] > 0 ? (int) m_pitchLagPrev[ch] : __min (halfFrameOffset, (int) lookaheadOffset - 1)); + pSgn = (((chSig[maxAbsIdxL] - chSigM1[maxAbsIdxL] > 0) && (chSig[maxAbsIdxL-pLag] - chSigM1[maxAbsIdxL-pLag] < 0)) || + ((chSig[maxAbsIdxL] - chSigM1[maxAbsIdxL] < 0) && (chSig[maxAbsIdxL-pLag] - chSigM1[maxAbsIdxL-pLag] > 0)) ? -1 : 1); + if ((sumAbsValL = applyPitchPred (chSig, halfFrameOffset, pLag, pSgn)) < sumAbsPpL) + { + sumAbsPpL = sumAbsValL; // left side + } + if ((sumAbsValR = applyPitchPred (chSig + halfFrameOffset, halfFrameOffset, pLag, pSgn)) < sumAbsPpR) + { + sumAbsPpR = sumAbsValR; // right side + pLagBestR = pLag; + } + + // convert L1 norms into average values + sumAbsHpL = (sumAbsHpL + unsigned (halfFrameOffset >> 1)) / unsigned (halfFrameOffset); + sumAbsHpR = (sumAbsHpR + unsigned (halfFrameOffset >> 1)) / unsigned (halfFrameOffset); + sumAbsPpL = (sumAbsPpL + unsigned (halfFrameOffset >> 1)) / unsigned (halfFrameOffset); + sumAbsPpR = (sumAbsPpR + unsigned (halfFrameOffset >> 1)) / unsigned (halfFrameOffset); +// --- temporal analysis statistics for frame + m_tempAnaStats[ch] = packAvgTempAnalysisStats (sumAbsHpL, sumAbsHpR, m_avgAbsHpPrev[ch], + sumAbsPpL + sumAbsPpR, maxAbsValL + maxAbsValR); + m_transientLoc[ch] = getMaxAbsHpValueLocation (maxAbsValL, maxAbsValR, m_maxAbsHpPrev[ch], + maxAbsIdxL, maxAbsIdxR); + // update stats history for this channel + m_avgAbsHpPrev[ch] = sumAbsHpR; + m_maxAbsHpPrev[ch] = maxAbsValR; + m_maxIdxHpPrev[ch] = (unsigned) maxAbsIdxR; + m_pitchLagPrev[ch] = (unsigned) pLagBestR; + } // if sumAbsValL == 0 && sumAbsValR == 0 + } // for ch + + return 0; // no error +} diff --git a/src/lib/tempAnalysis.h b/src/lib/tempAnalysis.h new file mode 100644 index 0000000..b654390 --- /dev/null +++ b/src/lib/tempAnalysis.h @@ -0,0 +1,47 @@ +/* tempAnalysis.h - header file for class providing temporal analysis of PCM signals + * written by C. R. Helmrich, last modified in 2019 - see License.htm for legal notices + * + * The copyright in this software is being made available under a Modified BSD-Style License + * and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + * party rights, including patent rights. No such rights are granted under this License. + * + * Copyright (c) 2018-2020 Christian R. Helmrich, project ecodis. All rights reserved. + */ + +#ifndef _TEMP_ANALYSIS_H_ +#define _TEMP_ANALYSIS_H_ + +#include "exhaleLibPch.h" + +// constants, experimental macros +#define TA_EPS 4096 +#define TA_MORE_PITCH_TESTS 0 + +// temporal signal analysis class +class TempAnalyzer +{ +private: + + // member variables + unsigned m_avgAbsHpPrev[USAC_MAX_NUM_CHANNELS]; + unsigned m_maxAbsHpPrev[USAC_MAX_NUM_CHANNELS]; + unsigned m_maxIdxHpPrev[USAC_MAX_NUM_CHANNELS]; + unsigned m_pitchLagPrev[USAC_MAX_NUM_CHANNELS]; + uint32_t m_tempAnaStats[USAC_MAX_NUM_CHANNELS]; + int16_t m_transientLoc[USAC_MAX_NUM_CHANNELS]; + +public: + + // constructor + TempAnalyzer (); + // destructor + ~TempAnalyzer () { } + // public functions + void getTempAnalysisStats (uint32_t avgTempAnaStats[USAC_MAX_NUM_CHANNELS], const unsigned nChannels); + void getTransientLocation (int16_t maxHighPassValueLocation[USAC_MAX_NUM_CHANNELS], const unsigned nChannels); + unsigned temporalAnalysis (const int32_t* const timeSignals[USAC_MAX_NUM_CHANNELS], const unsigned nChannels, + const int nSamplesInFrame, const unsigned lookaheadOffset, + const unsigned lfeChannelIndex = USAC_MAX_NUM_CHANNELS); // to skip an LFE channel +}; // TempAnalyzer + +#endif // _TEMP_ANALYSIS_H_ diff --git a/src/makefile.base b/src/makefile.base new file mode 100644 index 0000000..4140004 --- /dev/null +++ b/src/makefile.base @@ -0,0 +1,305 @@ +## makefile.base - common make-file for compiling exhale on Linux and MacOS platforms + # written by C. R. Helmrich, last modified 2019 - see License.txt for legal notices + # + # The copyright in this software is being made available under a Modified BSD License + # and comes with ABSOLUTELY NO WARRANTY. This software may be subject to other third- + # party rights, including patent rights. No such rights are granted under this License. + # + # Copyright (c) 2018-2019 Christian R. Helmrich, project ecodis. All rights reserved. + ## + +######################################################### +# check CONFIG parameter +######################################################### + +ifneq ($(CONFIG), CONSOLE) + ifneq ($(CONFIG), LIBRARY) + CONFIG_ERR = TRUE + endif +endif + +######################################################### +# executables used +######################################################### + +AR = ar +ASM = nasm +CPP = g++ +LD = $(CPP) + +######################################################### +# output file names and version information +######################################################### + +ifeq ($(CONFIG), CONSOLE) + STAT_DEBUG_OUT = $(DIR_BIN)/$(PRD_NAME)d + STAT_RELEASE_OUT = $(DIR_BIN)/$(PRD_NAME) + DYN_DEBUG_OUT = $(DIR_BIN)/$(PRD_NAME)Dynd + DYN_RELEASE_OUT = $(DIR_BIN)/$(PRD_NAME)Dyn +else + ifeq ($(CONFIG), LIBRARY) + STAT_DEBUG_OUT = $(DIR_LIB)/lib$(PRD_NAME)d.a + STAT_RELEASE_OUT = $(DIR_LIB)/lib$(PRD_NAME).a + DYN_DEBUG_OUT = $(DIR_LIB)/lib$(PRD_NAME)Dynd.so + DYN_RELEASE_OUT = $(DIR_LIB)/lib$(PRD_NAME)Dyn.so + endif +endif + +######################################################### +# c compiler flags +######################################################### + +# default cpp flags for all configurations +#CPPFLAGS = -Wall -fPIC $(DEFS) -I$(CURDIR)/$(DIR_INC) +CPPFLAGS = -fPIC $(DEFS) -I$(CURDIR)/$(DIR_INC) -Wall -Wshadow -Wno-sign-compare -Werror -D_FILE_OFFSET_BITS=64 + +########## +# enforce 32-bit build : 1=yes, 0=no +########## +M32?= 0 +ifeq ($(M32),1) +CPPFLAGS+=-m32 +endif +########## + +# +# debug cpp flags +DEBUG_CPPFLAGS = -g -D_DEBUG +# +# release cpp +RELEASE_CPPFLAGS = -O3 -Wuninitialized + + +######################################################### +# linker flags +######################################################### + +# linker flags for all +ALL_LDFLAGS = -Wall + +########## +# enforce 32-bit build : 1=yes, 0=no +########## +ifeq ($(M32),1) +ALL_LDFLAGS+=-m32 +endif +########## + + +ifeq ($(CONFIG), LIBRARY) +# linker flags for library +# LDFLAGS = $(ALL_LDFLAGS) -shared -Wl,-Bsymbolic +LDFLAGS = $(ALL_LDFLAGS) -shared +# +# debug linker flags for library +DEBUG_LDFLAGS = -Wl,-soname,lib$(PRD_NAME)d.so +# +# release linker flags for library +RELEASE_LDFLAGS = -Wl,-soname,lib$(PRD_NAME).so +# +else +ifeq ($(CONFIG), CONSOLE) +# linker flags for console +LDFLAGS = $(ALL_LDFLAGS) +# +# debug linker flags for console +DEBUG_LDFLAGS = +# +# release linker flags for console +RELEASE_LDFLAGS = +# +endif +endif + + + +######################################################### +# objects that have to be created +######################################################### + +# the object types that have to be created +RELEASE_OBJS = $(OBJS:.o=.r.o) +DEBUG_OBJS = $(OBJS:.o=.d.o) + + +######################################################### +# rules +######################################################### + +# suffixes +.SUFFIXES: .asm .cpp .d.o .r.o + + +## specification of assembler rules +ASMFLAGS = -f elf $(DEFS) +DEBUG_ASMFLAGS = -g +RELEASE_ASMFLAGS = + +# creation of ASM debug objects +$(DIR_OBJ)/%.d.o: $(DIR_SRC)/%.asm + $(ASM) $(ASMFLAGS) $(DEBUG_ASMFLAGS) -o $@ $< + +# creation of ASM release objects +$(DIR_OBJ)/%.r.o: $(DIR_SRC)/%.asm + $(ASM) $(ASMFLAGS) $(RELEASE_ASMFLAGS) -o $@ $< + + +## specification of C and C++ rules +define COMPILE_AND_DEPEND_DEBUG + $(CPP) -c -MMD -MF $(DIR_OBJ)/$*.d.d -MT $(DIR_OBJ)/$*.d.o $(CPPFLAGS) $(DEBUG_CPPFLAGS) -o $@ $(CURDIR)/$< + @cp $(DIR_OBJ)/$*.d.d $(DIR_OBJ)/$*.d.p; \ + sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \ + -e '/^$$/ d' -e 's/$$/ :/' < $(DIR_OBJ)/$*.d.d >> $(DIR_OBJ)/$*.d.p; \ + rm -f $(DIR_OBJ)/$*.d.d +endef +define COMPILE_AND_DEPEND_RELEASE + $(CPP) -c -MMD -MF $(DIR_OBJ)/$*.r.d -MT $(DIR_OBJ)/$*.r.o $(CPPFLAGS) $(RELEASE_CPPFLAGS) -o $@ $(CURDIR)/$< + @cp $(DIR_OBJ)/$*.r.d $(DIR_OBJ)/$*.r.p; \ + sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \ + -e '/^$$/ d' -e 's/$$/ :/' < $(DIR_OBJ)/$*.r.d >> $(DIR_OBJ)/$*.r.p; \ + rm -f $(DIR_OBJ)/$*.r.d +endef + +# creation of C++ debug objects +$(DIR_OBJ)/%.d.o: $(DIR_SRC)/%.cpp + $(COMPILE_AND_DEPEND_DEBUG) + +# creation of C++ release objects +$(DIR_OBJ)/%.r.o: $(DIR_SRC)/%.cpp + $(COMPILE_AND_DEPEND_RELEASE) + +# creation of C debug objects +$(DIR_OBJ)/%.d.o: $(DIR_SRC)/%.c + $(COMPILE_AND_DEPEND_DEBUG) + +# creation of C release objects +$(DIR_OBJ)/%.r.o: $(DIR_SRC)/%.c + $(COMPILE_AND_DEPEND_RELEASE) + + +## config dependent directory setup +ifeq ($(CONFIG), CONSOLE) + CHECK_DIRS = $(DIR_OBJ) $(DIR_BIN) +else + ifeq ($(CONFIG), LIBRARY) + CHECK_DIRS = $(DIR_OBJ) $(DIR_LIB) + endif +endif + + +## specification of build targets +all: check_errors debug release + +debug: check_errors \ + $(CHECK_DIRS) \ + $(STAT_DEBUG_OUT) + +# $(DYN_DEBUG_OUT) \ + +release: check_errors \ + $(CHECK_DIRS) \ + $(STAT_RELEASE_OUT) + +# $(DYN_RELEASE_OUT) \ + + +## check for configuration errors +check_errors: + @if [ "$(CONFIG_ERR)" = "TRUE" ]; then\ + echo "ERROR: Wrong CONFIG parameter specified: $(CONFIG)";\ + false;\ + fi + + +## creation of output directories +$(DIR_BIN): + @if [ ! -d $(DIR_BIN) ]; then\ + mkdir $(DIR_BIN);\ + fi + +$(DIR_OBJ): + @if [ ! -d $(DIR_OBJ) ]; then\ + mkdir $(DIR_OBJ);\ + fi + +$(DIR_LIB): + @if [ ! -d $(DIR_LIB) ]; then\ + mkdir $(DIR_LIB);\ + fi + + +## creation of binary output files +ifeq ($(CONFIG), LIBRARY) +# +# create static debug out +$(STAT_DEBUG_OUT): $(DEBUG_OBJS) + $(AR) -crs $@ $(DEBUG_OBJS) +# +# +# create release debug out +$(STAT_RELEASE_OUT): $(RELEASE_OBJS) + $(AR) -crs $@ $(RELEASE_OBJS) +# +# +# create dynamic debug out +$(DYN_DEBUG_OUT): $(DYN_DEBUG_OUT) + ln -fs lib$(PRD_NAME)d.so $@ +# +# create dynamic debug out +$(DYN_DEBUG_OUT): $(DEBUG_OBJS) + $(LD) $(LDFLAGS) $(DEBUG_LDFLAGS) -o $@ $(DEBUG_OBJS) -L$(DIR_LIB) $(LIBS) $(DYN_LIBS) $(DYN_DEBUG_LIBS) +# +# +# create dynamic release out +$(DYN_RELEASE_OUT): $(DYN_RELEASE_OUT) + ln -fs lib$(PRD_NAME).so $@ +# +# create dynamic release out +$(DYN_RELEASE_OUT): $(RELEASE_OBJS) + $(LD) $(LDFLAGS) $(RELEASE_LDFLAGS) -o $@ $(RELEASE_OBJS) -L$(DIR_LIB) $(LIBS) $(DYN_LIBS) $(DYN_RELEASE_LIBS) +# +# +# +# +# +else +ifeq ($(CONFIG), CONSOLE) +# +# added linked libraries to target prerequisites - $(*_PREREQS) variables - to force relinking when libraries have been rebuilt +# +# create static debug out +$(STAT_DEBUG_OUT): $(DEBUG_OBJS) $(STAT_DEBUG_PREREQS) + $(LD) -o $@ $(LDFLAGS) $(DEBUG_LDFLAGS) $(DEBUG_OBJS) -L$(DIR_LIB) $(LIBS) $(STAT_LIBS) $(STAT_DEBUG_LIBS) +# +# +# create static release out +$(STAT_RELEASE_OUT): $(RELEASE_OBJS) $(STAT_RELEASE_PREREQS) + $(LD) -o $@ $(LDFLAGS) $(RELEASE_LDFLAGS) $(RELEASE_OBJS) -L$(DIR_LIB) $(LIBS) $(STAT_LIBS) $(STAT_RELEASE_LIBS) +# +# +# create dynamic debug out +$(DYN_DEBUG_OUT): $(DEBUG_OBJS) $(DYN_DEBUG_PREREQS) + $(LD) -o $@ $(LDFLAGS) $(DEBUG_LDFLAGS) $(DEBUG_OBJS) -L$(DIR_LIB) $(LIBS) $(DYN_LIBS) $(DYN_DEBUG_LIBS) +# +# +# create dynamic release out +$(DYN_RELEASE_OUT): $(RELEASE_OBJS) $(DYN_RELEASE_PREREQS) + $(LD) -o $@ $(LDFLAGS) $(RELEASE_LDFLAGS) $(RELEASE_OBJS) -L$(DIR_LIB) $(LIBS) $(DYN_LIBS) $(DYN_RELEASE_LIBS) +# +# +endif +endif + + +## clean: delete all created files +clean: + /bin/rm -rf $(DYN_DEBUG_OUT) + /bin/rm -rf $(DYN_RELEASE_OUT) + /bin/rm -rf $(STAT_DEBUG_OUT) + /bin/rm -rf $(STAT_RELEASE_OUT) + /bin/rm -rf $(DIR_OBJ) + + +## include needed dependency files +-include $(OBJS:.o=.d.p) +-include $(OBJS:.o=.r.p)