GARbro-mirror/ArcFormats/ShiinaRio/AudioPAD.cs

184 lines
6.9 KiB
C#

//! \file AudioPAD.cs
//! \date Sun Jun 21 23:44:18 2015
//! \brief ShiinaRio compressed audio format.
//
// Copyright (C) 2015 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
using System;
using System.ComponentModel.Composition;
using System.IO;
using GameRes.Utility;
namespace GameRes.Formats.ShiinaRio
{
[Export(typeof(AudioFormat))]
public class PadAudio : AudioFormat
{
public override string Tag { get { return "PAD"; } }
public override string Description { get { return "ShiinaRio compressed audio format"; } }
public override uint Signature { get { return 0x444150; } } // 'PAD'
public override SoundInput TryOpen (Stream file)
{
var wav_header = new byte[0x2c];
if (0x2c != file.Read (wav_header, 0, 0x2c))
return null;
int pcm_size = LittleEndian.ToInt32 (wav_header, 0x28);
int channels = LittleEndian.ToUInt16 (wav_header, 0x16);
wav_header[0] = (byte)'R';
wav_header[1] = (byte)'I';
wav_header[2] = (byte)'F';
wav_header[3] = (byte)'F';
LittleEndian.Pack (pcm_size+0x24, wav_header, 4);
var decoder = new PadDecoder (file, pcm_size, channels);
decoder.Unpack();
var data = new MemoryStream (decoder.Data, 0, pcm_size);
var wav = new PrefixStream (wav_header, data);
try
{
return new WaveInput (wav);
}
catch
{
wav.Dispose();
throw;
}
}
}
internal class PadDecoder
{
byte[] m_input;
byte[] m_output;
int m_pcm_size;
int m_packed_size;
int m_channels;
public byte[] Data { get { return m_output; } }
public PadDecoder (Stream input, int pcm_size, int channels)
{
m_packed_size = (int)(input.Length - input.Position);
m_pcm_size = pcm_size;
m_channels = channels;
m_output = new byte[pcm_size + 0x9c];
m_input = new byte[m_packed_size];
if (m_packed_size != input.Read (m_input, 0, m_packed_size))
throw new InvalidFormatException ("Unexpected end of file");
}
public byte[] Unpack ()
{
int v10;
double v3 = 0;
double v27 = 0;
double v28 = 0;
int v30 = 0;
var table = new double[69];
table[4] = 0.9375; // 0x3FEE000000000000
table[6] = 1.796875; // 0x3FFCC00000000000
table[7] = -0.8125; // 0xBFEA000000000000
table[8] = 1.53125; // 0x3FF8800000000000
table[9] = -0.859375; // 0xBFEB800000000000
table[10] = 1.90625; // 0x3FFE800000000000
table[11] = -0.9375; // 0xBFEE000000000000
int dst = 0;
int src = 0;
int v5 = m_input[src++];
while (v5 != 0xff)
{
int v7 = m_input[src++];
int v29 = v7 >> 4;
int v9 = v7 & 0xF;
if (2 == m_channels)
{
int next = m_input[src+1];
v10 = next & 0xF;
v30 = next >> 4;
long v = BitConverter.DoubleToInt64Bits (table[12]) & 0xffffffffL;
table[12] = BitConverter.Int64BitsToDouble (v | (long)v10 << 32);
src += 2;
}
else
{
v10 = (int)(BitConverter.DoubleToInt64Bits (table[12]) >> 32);
}
int v12 = 14; // within table
for (int i = 0; i < 14; ++i)
{
int v13 = m_input[src++];
int v14 = (v13 & 0xF) << 12;
if (0 != (v14 & 0x8000))
v14 |= ~0xFFFF;
int v15 = (v13 & 0xF0) << 8;
table[v12 - 1] = (double)(v14 >> v9);
if (0 != (v15 & 0x8000))
v15 |= ~0xFFFF;
table[v12] = (double)(v15 >> v9);
v12 += 2;
}
if (2 == m_channels)
{
v12 = 42; // within table
for (int i = 0; i < 14; ++i)
{
int v18 = m_input[src++];
int v19 = (v18 & 0xF) << 12;
if (0 != (v19 & 0x8000))
v19 |= ~0xFFFF;
int v20 = (byte)(v18 & 0xF0) << 8;
table[v12 - 1] = (double)(v19 >> v10);
if (0 != (v20 & 0x8000))
v20 |= ~0xFFFF;
table[v12] = (double)(v20 >> v10);
v12 += 2;
}
}
v12 = 41; // within table
for (int i = 0; i < 28; ++i)
{
double v22 = v27 * table[2 * v29 + 3];
v27 = table[0];
table[v12 - 28] += v22 + v27 * table[2 * v29 + 2];
table[0] = table[v12 - 28];
LittleEndian.Pack ((short)(table[v12 - 28] + 0.5), m_output, dst);
dst += 2;
if (2 == m_channels)
{
table[v12] += v28 * table[2 * v30 + 3] + v3 * table[2 * v30 + 2];
v28 = v3;
v3 = table[v12];
LittleEndian.Pack ((short)(table[v12] + 0.5), m_output, dst);
dst += 2;
}
++v12;
}
v5 = m_input[src++];
}
return m_output;
}
}
}