WallyHackenslacker/Aerofoil
1
0
Fork 0
mirror of https://github.com/elasota/Aerofoil.git synced 2025-09-23 06:53:43 +00:00
Code Issues Projects Releases Wiki Activity

Add MACE 6:1 decompression to fix some missing audio samples, parallelize deflate compression

Browse Source
This commit is contained in:
elasota
2020-06-07 17:17:32 -04:00
parent 4c3ccbd7fa
commit b37b0a4f8a
7 changed files with 492 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ACKNOWLEDGMENTS.txt
View File

@@ -27,4 +27,10 @@ Distributed under zlib license (See zlib/README)
The Unarchiver:
Copyright (C) 2006-2013 Dag Ågren
Distributed under the LGPLv2 license (See unpacktool/LICENSE.txt)
Distributed under the LGPLv2 license (See unpacktool/LICENSE.txt)
MACE Audio decoder:
Copyright (c) 2002 Laszlo Torok <torokl@alpha.dfmk.hu>
Distributed under the LGPLv2 license (See macedec.cpp comments)

8
Documentation/readme.txt
View File

@@ -90,3 +90,11 @@ The "unpacktool" utility is heavily based on code from The Unarchiver.
Copyright (C) 2006-2013 Dag Ågren
Distributed under the LGPLv2 license (See license_lgplv2.txt)
FFmpeg:
The "gpr2gpa" tool uses MACE decompression code from FFmpeg.
Copyright (c) 2002 Laszlo Torok <torokl@alpha.dfmk.hu>
Distributed under the LGPLv2 license (See license_lgplv2.txt)

249
gpr2gpa/gpr2gpa.cpp
View File

@@ -22,14 +22,29 @@
#include "WindowsUnicodeToolShim.h"
#include "macedec.h"
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <Windows.h>
enum AudioCompressionCodecID
{
AudioCompressionCodecID_VariableRate = -2,
AudioCompressionCodecID_FixedRate = -1,
AudioCompressionCodecID_Uncompressed = 0,
AudioCompressionCodecID_TwoToOne = 1,
AudioCompressionCodecID_EightToOne = 2,
AudioCompressionCodecID_ThreeToOne = 3,
AudioCompressionCodecID_SixToOne = 4,
};
struct PlannedEntry
{
std::vector<uint8_t> m_contents;
std::vector<uint8_t> m_uncompressedContents;
std::vector<uint8_t> m_compressedContents;
std::string m_name;
bool m_isDirectory;
@@ -205,7 +220,7 @@ void ConvertToMSDOSTimestamp(const PortabilityLayer::CombinedTimestamp &ts, uint
msdosDate = day | (month << 5) | (yearsSince1980 << 9);
}
void ExportZipFile(const char *path, const std::vector<PlannedEntry> &entries, const PortabilityLayer::CombinedTimestamp &ts)
void ExportZipFile(const char *path, std::vector<PlannedEntry> &entries, const PortabilityLayer::CombinedTimestamp &ts)
{
FILE *outF = fopen_utf8(path, "wb");
if (!outF)
@@ -221,20 +236,27 @@ void ExportZipFile(const char *path, const std::vector<PlannedEntry> &entries, c
std::vector<PortabilityLayer::ZipCentralDirectoryFileHeader> cdirRecords;
// Why does OMP require signed indexes? When do I ever want negative iterations? Uggghh.
int numEntries = entries.size();
#pragma omp parallel for
for (int i = 0; i < numEntries; i++)
{
PlannedEntry &entry = entries[i];
if (entry.m_uncompressedContents.size() > 0)
{
if (!TryDeflate(entry.m_uncompressedContents, entry.m_compressedContents))
entry.m_compressedContents.resize(0);
if (entry.m_compressedContents.size() >= entry.m_uncompressedContents.size())
entry.m_compressedContents.resize(0);
}
}
for (const PlannedEntry &entry : entries)
{
std::vector<uint8_t> compressed;
if (entry.m_contents.size() != 0)
{
if (!TryDeflate(entry.m_contents, compressed))
compressed.resize(0);
if (compressed.size() >= entry.m_contents.size())
compressed.resize(0);
}
bool isCompressed = compressed.size() != 0;
bool isCompressed = entry.m_compressedContents.size() != 0;
PortabilityLayer::ZipCentralDirectoryFileHeader cdirHeader;
@@ -252,11 +274,11 @@ void ExportZipFile(const char *path, const std::vector<PlannedEntry> &entries, c
else if (isCompressed)
cdirHeader.m_versionRequired = PortabilityLayer::ZipConstants::kCompressedRequiredVersion;
if (entry.m_contents.size() > 0)
cdirHeader.m_crc = crc32(0, &entry.m_contents[0], static_cast<uint32_t>(entry.m_contents.size()));
if (entry.m_uncompressedContents.size() > 0)
cdirHeader.m_crc = crc32(0, &entry.m_uncompressedContents[0], static_cast<uint32_t>(entry.m_uncompressedContents.size()));
cdirHeader.m_compressedSize = static_cast<uint32_t>(isCompressed ? compressed.size() : entry.m_contents.size());
cdirHeader.m_uncompressedSize = static_cast<uint32_t>(entry.m_contents.size());
cdirHeader.m_compressedSize = static_cast<uint32_t>(isCompressed ? entry.m_compressedContents.size() : entry.m_uncompressedContents.size());
cdirHeader.m_uncompressedSize = static_cast<uint32_t>(entry.m_uncompressedContents.size());
cdirHeader.m_fileNameLength = static_cast<uint32_t>(entry.m_name.size());
cdirHeader.m_extraFieldLength = 0;
cdirHeader.m_commentLength = 0;
@@ -286,9 +308,9 @@ void ExportZipFile(const char *path, const std::vector<PlannedEntry> &entries, c
fwrite(entry.m_name.c_str(), 1, entry.m_name.size(), outF);
if (isCompressed)
fwrite(&compressed[0], 1, compressed.size(), outF);
else if (entry.m_contents.size() > 0)
fwrite(&entry.m_contents[0], 1, entry.m_contents.size(), outF);
fwrite(&entry.m_compressedContents[0], 1, entry.m_compressedContents.size(), outF);
else if (entry.m_uncompressedContents.size() > 0)
fwrite(&entry.m_uncompressedContents[0], 1, entry.m_uncompressedContents.size(), outF);
}
long cdirPos = ftell(outF);
@@ -715,6 +737,49 @@ void PadAlignWave(std::vector<uint8_t> &outWAV)
outWAV.push_back(0);
}
bool DecompressSound(int compressionID, int channelCount, const void *sndData, size_t numFrames, std::vector<uint8_t> &decompressed)
{
if (compressionID == AudioCompressionCodecID_ThreeToOne)
{
if (channelCount != 1)
{
fprintf(stderr, "Unsupported MACE decode channel layout\n");
return false;
}
fprintf(stderr, "Unimplemented audio codec\n");
return false;
}
else if (compressionID = AudioCompressionCodecID_SixToOne)
{
if (channelCount != 1)
{
fprintf(stderr, "Unsupported MACE decode channel layout\n");
return false;
}
MaceChannelDecState state;
memset(&state, 0, sizeof(state));
const uint8_t *packets = static_cast<const uint8_t*>(sndData);
for (size_t i = 0; i < numFrames; i++)
{
uint8_t samples[6];
DecodeMACE6(&state, packets[i], samples);
for (int s = 0; s < 6; s++)
decompressed.push_back(samples[s]);
}
}
else
{
fprintf(stderr, "Unknown audio compression format\n");
return false;
}
return true;
}
bool ImportSound(std::vector<uint8_t> &outWAV, const void *inData, size_t inSize)
{
// Glider PRO has a hard-coded expectation that the sound will have exactly 20 bytes of prefix.
@@ -732,6 +797,56 @@ bool ImportSound(std::vector<uint8_t> &outWAV, const void *inData, size_t inSize
uint8_t m_baseFrequency;
};
struct ExtHeader
{
BEUInt32_t m_samplePtr;
BEUInt32_t m_channelCount;
BEFixed32_t m_sampleRate;
BEUInt32_t m_loopStart;
BEUInt32_t m_loopEnd;
uint8_t m_encoding;
uint8_t m_baseFrequency;
BEUInt32_t m_numSamples;
BEUInt16_t m_sampleRateExponentAndSign;
BEUInt32_t m_sampleRateFractionHigh;
BEUInt32_t m_sampleRateFractionLow;
BEUInt32_t m_markerPtr;
BEUInt32_t m_instrumentPtr;
BEUInt32_t m_recordingDevicesPtr;
BEUInt16_t m_sampleSize;
uint8_t m_reserved[14];
};
struct CmpHeader
{
BEUInt32_t m_samplePtr;
BEUInt32_t m_channelCount;
BEFixed32_t m_sampleRate;
BEUInt32_t m_loopStart;
BEUInt32_t m_loopEnd;
uint8_t m_encoding;
uint8_t m_baseFrequency;
BEUInt32_t m_numFrames;
BEUInt16_t m_sampleRateExponentAndSign;
BEUInt32_t m_sampleRateFractionHigh;
BEUInt32_t m_sampleRateFractionLow;
BEUInt32_t m_markerPtr;
BEUInt32_t m_format;
uint8_t m_reserved1[4];
BEUInt32_t m_stateVars;
BEUInt32_t m_leftOverSamples;
BEInt16_t m_compressionID;
BEUInt16_t m_packetSize;
BEUInt16_t m_synthesizerID;
BEUInt16_t m_sampleSize;
};
const int hs = sizeof(CmpHeader);
GP_STATIC_ASSERT(sizeof(ExtHeader) == 64);
GP_STATIC_ASSERT(sizeof(CmpHeader) == 64);
if (inSize < hardCodedPrefixSize)
return false;
@@ -744,12 +859,76 @@ bool ImportSound(std::vector<uint8_t> &outWAV, const void *inData, size_t inSize
BufferHeader header;
memcpy(&header, sndBufferData, sizeof(header));
sndBufferData += sizeof(header);
inSize -= sizeof(header);
std::vector<uint8_t> decompressedSound;
uint32_t dataLength = header.m_length;
if (dataLength > inSize)
return false;
uint32_t dataLength = 0;
if (header.m_encoding == 0xfe)
{
if (inSize < sizeof(CmpHeader))
return false;
CmpHeader cmpHeader;
memcpy(&cmpHeader, sndBufferData, sizeof(cmpHeader));
sndBufferData += sizeof(ExtHeader);
inSize -= sizeof(ExtHeader);
if (!DecompressSound(cmpHeader.m_compressionID, cmpHeader.m_channelCount, sndBufferData, cmpHeader.m_numFrames, decompressedSound))
return false;
dataLength = decompressedSound.size();
if (decompressedSound.size() > 0)
sndBufferData = &decompressedSound[0];
}
else if (header.m_encoding == 0xff)
{
if (inSize < sizeof(ExtHeader))
return false;
ExtHeader extHeader;
memcpy(&extHeader, sndBufferData, sizeof(extHeader));
#if 0
uint64_t sampleRateFraction = (static_cast<uint64_t>(static_cast<uint32_t>(extHeader.m_sampleRateFractionHigh)) << 32) | static_cast<uint32_t>(extHeader.m_sampleRateFractionLow);
uint16_t sampleRateExponentAndSign = extHeader.m_sampleRateExponentAndSign;
int32_t sampleRateExponent = static_cast<int32_t>(sampleRateExponentAndSign & 0x7fff) - 16447;
double sampleRate = static_cast<double>(sampleRateFraction) * pow(2.0, sampleRateExponent);
#endif
uint16_t bitsPerSample = extHeader.m_sampleSize;
if (bitsPerSample != 8)
{
fprintf(stderr, "Sound had unexpected bit rate\n");
return false;
}
if (extHeader.m_channelCount != 1)
{
fprintf(stderr, "Sound had unexpected channel count\n");
return false;
}
dataLength = extHeader.m_numSamples * extHeader.m_channelCount * bitsPerSample / 8;
sndBufferData += sizeof(ExtHeader);
inSize -= sizeof(ExtHeader);
if (dataLength > inSize)
return false;
}
else
{
dataLength = header.m_length;
sndBufferData += sizeof(header);
inSize -= sizeof(header);
if (dataLength > inSize)
return false;
}
uint32_t sampleRate = header.m_sampleRate.m_intPart;
if (static_cast<int>(header.m_sampleRate.m_fracPart) >= 0x8000)
@@ -1106,8 +1285,8 @@ bool ApplyPatch(const std::vector<uint8_t> &patchFileContents, std::vector<Plann
}
entry->m_isDirectory = false;
entry->m_contents.clear();
ReadFileToVector(f, entry->m_contents);
entry->m_uncompressedContents.clear();
ReadFileToVector(f, entry->m_uncompressedContents);
fclose(f);
}
}
@@ -1216,7 +1395,7 @@ int ConvertSingleFile(const char *resPath, const PortabilityLayer::CombinedTimes
entry.m_name = resName;
if (ImportPICT(entry.m_contents, resData, resSize))
if (ImportPICT(entry.m_uncompressedContents, resData, resSize))
contents.push_back(entry);
else
fprintf(stderr, "Failed to import PICT res %i\n", static_cast<int>(res.m_resID));
@@ -1229,7 +1408,7 @@ int ConvertSingleFile(const char *resPath, const PortabilityLayer::CombinedTimes
entry.m_name = resName;
if (ImportSound(entry.m_contents, resData, resSize))
if (ImportSound(entry.m_uncompressedContents, resData, resSize))
contents.push_back(entry);
}
else if (typeList.m_resType == indexStringTypeID)
@@ -1240,7 +1419,7 @@ int ConvertSingleFile(const char *resPath, const PortabilityLayer::CombinedTimes
entry.m_name = resName;
if (ImportIndexedString(entry.m_contents, resData, resSize))
if (ImportIndexedString(entry.m_uncompressedContents, resData, resSize))
contents.push_back(entry);
}
else if (typeList.m_resType == ditlTypeID)
@@ -1251,7 +1430,7 @@ int ConvertSingleFile(const char *resPath, const PortabilityLayer::CombinedTimes
entry.m_name = resName;
if (ImportDialogItemTemplate(entry.m_contents, resData, resSize))
if (ImportDialogItemTemplate(entry.m_uncompressedContents, resData, resSize))
contents.push_back(entry);
}
else
@@ -1262,9 +1441,9 @@ int ConvertSingleFile(const char *resPath, const PortabilityLayer::CombinedTimes
sprintf_s(resName, "%s/%i.bin", resTag.m_id, static_cast<int>(res.m_resID));
entry.m_name = resName;
entry.m_contents.resize(res.GetSize());
entry.m_uncompressedContents.resize(res.GetSize());
memcpy(&entry.m_contents[0], resData, resSize);
memcpy(&entry.m_uncompressedContents[0], resData, resSize);
contents.push_back(entry);
}
@@ -1344,7 +1523,7 @@ int ConvertDirectory(const std::string &basePath, const PortabilityLayer::Combin
int PrintUsage()
{
fprintf(stderr, "Usage: gpr2gpa <input.gpr> <input.ts> <output.gpa> [patch.json]\n");
fprintf(stderr, " gpr2gpa <input dir>\* <input.ts>\n");
fprintf(stderr, " gpr2gpa <input dir>\\* <input.ts>\n");
fprintf(stderr, " gpr2gpa <input dir>/* <input.ts>\n");
fprintf(stderr, " gpr2gpa * <input.ts>\n");
return -1;

6
gpr2gpa/gpr2gpa.vcxproj
View File

@@ -106,6 +106,7 @@
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<OpenMPSupport>true</OpenMPSupport>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
@@ -126,6 +127,7 @@
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<ConformanceMode>true</ConformanceMode>
<OpenMPSupport>true</OpenMPSupport>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -155,6 +157,10 @@
</ItemGroup>
<ItemGroup>
<ClCompile Include="gpr2gpa.cpp" />
<ClCompile Include="macedec.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="macedec.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">

8
gpr2gpa/gpr2gpa.vcxproj.filters
View File

@@ -18,5 +18,13 @@
<ClCompile Include="gpr2gpa.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="macedec.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="macedec.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

238
gpr2gpa/macedec.cpp Normal file
View File

@@ -0,0 +1,238 @@
/*
* MACE decoder
* Based on FFmpeg MACE decoder
* Copyright (c) 2002 Laszlo Torok <torokl@alpha.dfmk.hu>
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* Adapted to libavcodec by Francois Revol <revol@free.fr>
* (removed 68k REG stuff, changed types, added some statics and consts,
* libavcodec api, context stuff, interlaced stereo out).
*/
#include <stdint.h>
#include <algorithm>
#include "macedec.h"
static const int16_t MACEtab1[] = {-13, 8, 76, 222, 222, 76, 8, -13};
static const int16_t MACEtab3[] = {-18, 140, 140, -18};
static const int16_t MACEtab2[][4] = {
{ 37, 116, 206, 330}, { 39, 121, 216, 346},
{ 41, 127, 225, 361}, { 42, 132, 235, 377},
{ 44, 137, 245, 392}, { 46, 144, 256, 410},
{ 48, 150, 267, 428}, { 51, 157, 280, 449},
{ 53, 165, 293, 470}, { 55, 172, 306, 490},
{ 58, 179, 319, 511}, { 60, 187, 333, 534},
{ 63, 195, 348, 557}, { 66, 205, 364, 583},
{ 69, 214, 380, 609}, { 72, 223, 396, 635},
{ 75, 233, 414, 663}, { 79, 244, 433, 694},
{ 82, 254, 453, 725}, { 86, 265, 472, 756},
{ 90, 278, 495, 792}, { 94, 290, 516, 826},
{ 98, 303, 538, 862}, { 102, 316, 562, 901},
{ 107, 331, 588, 942}, { 112, 345, 614, 983},
{ 117, 361, 641, 1027}, { 122, 377, 670, 1074},
{ 127, 394, 701, 1123}, { 133, 411, 732, 1172},
{ 139, 430, 764, 1224}, { 145, 449, 799, 1280},
{ 152, 469, 835, 1337}, { 159, 490, 872, 1397},
{ 166, 512, 911, 1459}, { 173, 535, 951, 1523},
{ 181, 558, 993, 1590}, { 189, 584, 1038, 1663},
{ 197, 610, 1085, 1738}, { 206, 637, 1133, 1815},
{ 215, 665, 1183, 1895}, { 225, 695, 1237, 1980},
{ 235, 726, 1291, 2068}, { 246, 759, 1349, 2161},
{ 257, 792, 1409, 2257}, { 268, 828, 1472, 2357},
{ 280, 865, 1538, 2463}, { 293, 903, 1606, 2572},
{ 306, 944, 1678, 2688}, { 319, 986, 1753, 2807},
{ 334, 1030, 1832, 2933}, { 349, 1076, 1914, 3065},
{ 364, 1124, 1999, 3202}, { 380, 1174, 2088, 3344},
{ 398, 1227, 2182, 3494}, { 415, 1281, 2278, 3649},
{ 434, 1339, 2380, 3811}, { 453, 1398, 2486, 3982},
{ 473, 1461, 2598, 4160}, { 495, 1526, 2714, 4346},
{ 517, 1594, 2835, 4540}, { 540, 1665, 2961, 4741},
{ 564, 1740, 3093, 4953}, { 589, 1818, 3232, 5175},
{ 615, 1898, 3375, 5405}, { 643, 1984, 3527, 5647},
{ 671, 2072, 3683, 5898}, { 701, 2164, 3848, 6161},
{ 733, 2261, 4020, 6438}, { 766, 2362, 4199, 6724},
{ 800, 2467, 4386, 7024}, { 836, 2578, 4583, 7339},
{ 873, 2692, 4786, 7664}, { 912, 2813, 5001, 8008},
{ 952, 2938, 5223, 8364}, { 995, 3070, 5457, 8739},
{ 1039, 3207, 5701, 9129}, { 1086, 3350, 5956, 9537},
{ 1134, 3499, 6220, 9960}, { 1185, 3655, 6497, 10404},
{ 1238, 3818, 6788, 10869}, { 1293, 3989, 7091, 11355},
{ 1351, 4166, 7407, 11861}, { 1411, 4352, 7738, 12390},
{ 1474, 4547, 8084, 12946}, { 1540, 4750, 8444, 13522},
{ 1609, 4962, 8821, 14126}, { 1680, 5183, 9215, 14756},
{ 1756, 5415, 9626, 15415}, { 1834, 5657, 10057, 16104},
{ 1916, 5909, 10505, 16822}, { 2001, 6173, 10975, 17574},
{ 2091, 6448, 11463, 18356}, { 2184, 6736, 11974, 19175},
{ 2282, 7037, 12510, 20032}, { 2383, 7351, 13068, 20926},
{ 2490, 7679, 13652, 21861}, { 2601, 8021, 14260, 22834},
{ 2717, 8380, 14897, 23854}, { 2838, 8753, 15561, 24918},
{ 2965, 9144, 16256, 26031}, { 3097, 9553, 16982, 27193},
{ 3236, 9979, 17740, 28407}, { 3380, 10424, 18532, 29675},
{ 3531, 10890, 19359, 31000}, { 3688, 11375, 20222, 32382},
{ 3853, 11883, 21125, 32767}, { 4025, 12414, 22069, 32767},
{ 4205, 12967, 23053, 32767}, { 4392, 13546, 24082, 32767},
{ 4589, 14151, 25157, 32767}, { 4793, 14783, 26280, 32767},
{ 5007, 15442, 27452, 32767}, { 5231, 16132, 28678, 32767},
{ 5464, 16851, 29957, 32767}, { 5708, 17603, 31294, 32767},
{ 5963, 18389, 32691, 32767}, { 6229, 19210, 32767, 32767},
{ 6507, 20067, 32767, 32767}, { 6797, 20963, 32767, 32767},
{ 7101, 21899, 32767, 32767}, { 7418, 22876, 32767, 32767},
{ 7749, 23897, 32767, 32767}, { 8095, 24964, 32767, 32767},
{ 8456, 26078, 32767, 32767}, { 8833, 27242, 32767, 32767},
{ 9228, 28457, 32767, 32767}, { 9639, 29727, 32767, 32767}
};
static const int16_t MACEtab4[][2] = {
{ 64, 216}, { 67, 226}, { 70, 236}, { 74, 246},
{ 77, 257}, { 80, 268}, { 84, 280}, { 88, 294},
{ 92, 307}, { 96, 321}, { 100, 334}, { 104, 350},
{ 109, 365}, { 114, 382}, { 119, 399}, { 124, 416},
{ 130, 434}, { 136, 454}, { 142, 475}, { 148, 495},
{ 155, 519}, { 162, 541}, { 169, 564}, { 176, 590},
{ 185, 617}, { 193, 644}, { 201, 673}, { 210, 703},
{ 220, 735}, { 230, 767}, { 240, 801}, { 251, 838},
{ 262, 876}, { 274, 914}, { 286, 955}, { 299, 997},
{ 312, 1041}, { 326, 1089}, { 341, 1138}, { 356, 1188},
{ 372, 1241}, { 388, 1297}, { 406, 1354}, { 424, 1415},
{ 443, 1478}, { 462, 1544}, { 483, 1613}, { 505, 1684},
{ 527, 1760}, { 551, 1838}, { 576, 1921}, { 601, 2007},
{ 628, 2097}, { 656, 2190}, { 686, 2288}, { 716, 2389},
{ 748, 2496}, { 781, 2607}, { 816, 2724}, { 853, 2846},
{ 891, 2973}, { 930, 3104}, { 972, 3243}, { 1016, 3389},
{ 1061, 3539}, { 1108, 3698}, { 1158, 3862}, { 1209, 4035},
{ 1264, 4216}, { 1320, 4403}, { 1379, 4599}, { 1441, 4806},
{ 1505, 5019}, { 1572, 5244}, { 1642, 5477}, { 1715, 5722},
{ 1792, 5978}, { 1872, 6245}, { 1955, 6522}, { 2043, 6813},
{ 2134, 7118}, { 2229, 7436}, { 2329, 7767}, { 2432, 8114},
{ 2541, 8477}, { 2655, 8854}, { 2773, 9250}, { 2897, 9663},
{ 3026, 10094}, { 3162, 10546}, { 3303, 11016}, { 3450, 11508},
{ 3604, 12020}, { 3765, 12556}, { 3933, 13118}, { 4108, 13703},
{ 4292, 14315}, { 4483, 14953}, { 4683, 15621}, { 4892, 16318},
{ 5111, 17046}, { 5339, 17807}, { 5577, 18602}, { 5826, 19433},
{ 6086, 20300}, { 6358, 21205}, { 6642, 22152}, { 6938, 23141},
{ 7248, 24173}, { 7571, 25252}, { 7909, 26380}, { 8262, 27557},
{ 8631, 28786}, { 9016, 30072}, { 9419, 31413}, { 9839, 32767},
{ 10278, 32767}, { 10737, 32767}, { 11216, 32767}, { 11717, 32767},
{ 12240, 32767}, { 12786, 32767}, { 13356, 32767}, { 13953, 32767},
{ 14576, 32767}, { 15226, 32767}, { 15906, 32767}, { 16615, 32767}
};
static const struct {
const int16_t *tab1; const int16_t *tab2; int stride;
} tabs[] = {
{MACEtab1, &MACEtab2[0][0], 4},
{MACEtab3, &MACEtab4[0][0], 2},
{MACEtab1, &MACEtab2[0][0], 4}
};
static uint8_t CompactOutput(int16_t v)
{
return ((v >> 8) & 0xff) ^ 0x80;
}
/**
* MACE version of av_clip_int16(). We have to do this to keep binary
* identical output to the binary decoder.
*/
static inline int16_t mace_broken_clip_int16(int n)
{
if (n > 32767)
return 32767;
else if (n < -32768)
return -32767;
else
return n;
}
static int16_t read_table(MaceChannelDecState *chd, uint8_t val, int tab_idx)
{
int16_t current;
if (val < tabs[tab_idx].stride)
current = tabs[tab_idx].tab2[((chd->index & 0x7f0) >> 4) * tabs[tab_idx].stride + val];
else
current = - 1 - tabs[tab_idx].tab2[((chd->index & 0x7f0) >> 4)*tabs[tab_idx].stride + 2*tabs[tab_idx].stride-val-1];
if (( chd->index += tabs[tab_idx].tab1[val]-(chd->index >> 5) ) < 0)
chd->index = 0;
return current;
}
static void chomp3(MaceChannelDecState *chd, uint8_t *output, uint8_t val, int tab_idx)
{
int16_t current = read_table(chd, val, tab_idx);
current = mace_broken_clip_int16(current + chd->level);
chd->level = current - (current >> 3);
*output = CompactOutput(current);
}
static void chomp6(MaceChannelDecState *chd, uint8_t *output, uint8_t val, int tab_idx)
{
int16_t current = read_table(chd, val, tab_idx);
if ((chd->previous ^ current) >= 0) {
chd->factor = std::min<int32_t>(chd->factor + 506, 32767);
} else {
if (chd->factor - 314 < -32768)
chd->factor = -32767;
else
chd->factor -= 314;
}
current = mace_broken_clip_int16(current + chd->level);
chd->level = (current*chd->factor) >> 15;
current >>= 1;
output[0] = CompactOutput(chd->previous + chd->prev2 -
((chd->prev2-current) >> 2));
output[1] = CompactOutput(chd->previous + current +
((chd->prev2-current) >> 2));
chd->prev2 = chd->previous;
chd->previous = current;
}
void DecodeMACE3(MaceChannelDecState *chd, uint8_t pkt, uint8_t *output)
{
uint8_t val[3] = { pkt & 7 , (pkt >> 3) & 3, pkt >> 5 };
for (int l = 0; l < 3; l++)
{
chomp3(chd, output, val[l], l);
output++;
}
}
void DecodeMACE6(MaceChannelDecState *chd, uint8_t pkt, uint8_t *output)
{
uint8_t val[3] = {pkt >> 5, (pkt >> 3) & 3, pkt & 7 };
for (int l = 0; l < 3; l++)
{
chomp6(chd, output, val[l], l);
output += 2;
}
}

11
gpr2gpa/macedec.h Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
#include <stdint.h>
struct MaceChannelDecState
{
int16_t index, factor, prev2, previous, level;
};
void DecodeMACE3(MaceChannelDecState *chd, uint8_t pkt, uint8_t *output);
void DecodeMACE6(MaceChannelDecState *chd, uint8_t pkt, uint8_t *output);