SilverMoonStudio/EHS
3
0
Fork 0
Code Issues 8 Pull Requests Actions Projects 1 Releases 2 Wiki Activity
EHS/src/io/audio/Audio.cpp

2121 lines
70 KiB
C++
Raw Blame History

#include "ehs/io/audio/Audio.h"
#include "ehs/io/File.h"
#include "ehs/io/RIFF.h"
namespace ehs
{
Array<AudioCodec> Audio::codecs;
bool Audio::HasCodec(const UInt_64 hashExt)
{
for (UInt_64 i = 0; i < codecs.Size(); ++i)
if (codecs[i].GetHashExt() == hashExt)
return true;
return false;
}
bool Audio::HasCodec(const Str_8& ext)
{
return HasCodec(ext.Hash_64());
}
bool Audio::AddCodec(AudioCodec codec)
{
if (HasCodec(codec.GetHashExt()))
return false;
codecs.Push(std::move(codec));
return true;
}
const AudioCodec* Audio::GetCodec(const UInt_64 hashExt)
{
for (UInt_64 i = 0; i < codecs.Size(); ++i)
if (codecs[i].GetHashExt() == hashExt)
return &codecs[i];
return nullptr;
}
const AudioCodec* Audio::GetCodec(const Str_8& ext)
{
return GetCodec(ext.Hash_64());
}
Audio::~Audio()
{
delete[] data;
delete[] peak;
}
Audio::Audio()
: sampleRate(0), dataType(DataType::FLOAT), byteDepth(0), channels(0), frames(0), length(0.0f), data(nullptr),
peak(nullptr)
{
AddType("Audio");
}
Audio::Audio(const Str_8& filePath)
: Resource(File::ParseName_8(filePath)), sampleRate(0), dataType(DataType::FLOAT), byteDepth(0), channels(0),
frames(0), length(0.0f), data(nullptr), peak(nullptr)
{
AddType("Audio");
File file(filePath, Mode::READ, Disposition::OPEN);
Str_8 ext = file.GetExtension();
const AudioCodec* codec = GetCodec(ext);
if (!codec)
{
EHS_LOG_INT(LogType::ERR, 0, "Codec not found for file extension, \"" + ext + "\".");
return;
}
Serializer<UInt_64> data = file.ReadSerializer_64(codec->GetEndianness(), file.Size());
file.Release();
codec->Decode(data, this);
}
Audio::Audio(const Str_8& filePath, DataType type)
: Resource(File::ParseName_8(filePath)), sampleRate(0), dataType(DataType::FLOAT), byteDepth(0), channels(0),
frames(0), length(0.0f), data(nullptr), peak(nullptr)
{
AddType("Audio");
File file(filePath, Mode::READ, Disposition::OPEN);
Str_8 ext = file.GetExtension();
const AudioCodec* codec = GetCodec(ext);
if (!codec)
{
EHS_LOG_INT(LogType::ERR, 0, "Codec not found for file extension, \"" + ext + "\".");
return;
}
Serializer<UInt_64> data = file.ReadSerializer_64(codec->GetEndianness(), file.Size());
file.Release();
codec->Decode(data, this);
ToDataType(type);
}
Audio::Audio(Str_8 id, const UInt_64 sampleRate, const DataType dataType, const UInt_8 channels, const UInt_64 frames, const Byte* const data)
: Resource((Str_8&&)id), dataType(dataType), byteDepth(ToByteDepth(dataType)), sampleRate(sampleRate),
channels(channels), frames(frames), length((float)frames / (float)sampleRate),
data(new Byte[GetSize()]), peak(new Byte[byteDepth])
{
Util::Copy(this->data, data, GetSize());
AddType("Audio");
}
Audio::Audio(Str_8 id, const UInt_64 sampleRate, const DataType dataType, const UInt_8 channels, const Serializer<UInt_64>& data)
: Resource((Str_8&&)id), sampleRate(sampleRate), dataType(dataType), byteDepth(ToByteDepth(dataType)),
channels(channels), frames(data.Size() / channels / byteDepth), length((float)frames / (float)sampleRate),
data(new Byte[data.Size()]), peak(new Byte[byteDepth])
{
Util::Copy(this->data, data, data.Size());
AddType("Audio");
}
Audio::Audio(Str_8 id, const UInt_64 sampleRate, const DataType dataType, const UInt_8 channels, const Vector<Byte>& data)
: Resource((Str_8&&)id), sampleRate(sampleRate), dataType(dataType), byteDepth(ToByteDepth(dataType)),
channels(channels), frames(data.Size() / channels / byteDepth), length((float)frames / (float)sampleRate),
data(new Byte[data.Size()]), peak(new Byte[byteDepth])
{
Util::Copy(this->data, data, data.Size());
AddType("Audio");
}
Audio::Audio(Str_8 id, const UInt_64 sampleRate, const DataType dataType, const UInt_8 channels, const Array<Byte>& data)
: Resource((Str_8&&)id), sampleRate(sampleRate), dataType(dataType), byteDepth(ToByteDepth(dataType)),
channels(channels), frames(data.Size() / channels / byteDepth), length((float)frames / (float)sampleRate),
data(new Byte[data.Size()]), peak(new Byte[byteDepth])
{
Util::Copy(this->data, data, data.Size());
AddType("Audio");
}
Audio::Audio(Str_8 id, const UInt_64 sampleRate, const DataType dataType, const UInt_8 channels, const UInt_64 frames)
: Resource((Str_8&&)id), sampleRate(sampleRate), dataType(dataType), byteDepth(ToByteDepth(dataType)),
channels(channels), frames(frames), length((float)frames / (float)sampleRate),
data(new Byte[GetSize()]), peak(new Byte[byteDepth])
{
AddType("Audio");
}
Audio::Audio(Audio&& audio) noexcept
: Resource((Resource&&)audio), sampleRate(audio.sampleRate), dataType(audio.dataType),
byteDepth(audio.byteDepth), channels(audio.channels), frames(audio.frames), length(audio.length),
data(audio.data), peak(audio.peak)
{
audio.sampleRate = 0;
audio.dataType = DataType::FLOAT;
audio.byteDepth = ToByteDepth(audio.dataType);
audio.channels = 0;
audio.frames = 0;
audio.length = 0.0f;
audio.data = nullptr;
audio.peak = nullptr;
}
Audio::Audio(const Audio& audio)
: Resource(audio), sampleRate(audio.sampleRate), dataType(audio.dataType), byteDepth(audio.byteDepth),
channels(audio.channels), frames(audio.frames), length(audio.length), data(new Byte[GetSize()]),
peak(new Byte[audio.byteDepth])
{
Util::Copy(data, audio.data, GetSize());
}
Audio& Audio::operator=(Audio&& audio) noexcept
{
if (this == &audio)
return *this;
Resource::operator=((Resource&&)audio);
sampleRate = audio.sampleRate;
dataType = audio.dataType;
byteDepth = audio.byteDepth;
channels = audio.channels;
frames = audio.frames;
length = audio.length;
delete[] data;
data = audio.data;
delete[] peak;
peak = audio.peak;
audio.sampleRate = 0;
audio.dataType = DataType::FLOAT;
audio.byteDepth = ToByteDepth(audio.dataType);
audio.channels = 0;
audio.frames = 0;
audio.length = 0.0f;
audio.data = nullptr;
audio.peak = nullptr;
return *this;
}
Audio& Audio::operator=(const Audio& audio)
{
if (this == &audio)
return *this;
Resource::operator=(audio);
sampleRate = audio.sampleRate;
dataType = audio.dataType;
byteDepth = audio.byteDepth;
channels = audio.channels;
length = audio.length;
frames = audio.frames;
delete[] data;
data = new Byte[audio.GetSize()];
Util::Copy(data, audio.data, audio.GetSize());
delete[] peak;
peak = new Byte[audio.byteDepth];
Util::Copy(peak, audio.peak, audio.byteDepth);
return *this;
}
Audio::operator const Byte*() const
{
return data;
}
Audio::operator Byte*()
{
return data;
}
void Audio::Release()
{
sampleRate = 0;
dataType = DataType::FLOAT;
byteDepth = 0;
channels = 0;
frames = 0;
length = 0.0f;
delete[] data;
data = nullptr;
delete[] peak;
peak = nullptr;
}
UInt_64 Audio::GetSampleRate() const
{
return sampleRate;
}
DataType Audio::GetDataType() const
{
return dataType;
}
UInt_8 Audio::GetByteDepth() const
{
return byteDepth;
}
UInt_8 Audio::GetBitDepth() const
{
return byteDepth * 8;
}
UInt_8 Audio::GetChannels() const
{
return channels;
}
UInt_64 Audio::GetFrameCount() const
{
return frames;
}
UInt_64 Audio::GetSampleCount() const
{
return channels * frames;
}
UInt_8 Audio::GetFrameSize() const
{
return byteDepth * channels;
}
UInt_64 Audio::GetSize() const
{
return byteDepth * channels * frames;
}
float Audio::GetLength() const
{
return length;
}
Byte* Audio::GetFrame(UInt_64 frameIndex) const
{
return &data[frameIndex * GetFrameSize()];
}
Array<Byte> Audio::FrameAsMono(const UInt_64 frameIndex) const
{
Array<Byte> result(byteDepth);
ToMono(1, result, frameIndex);
return result;
}
Array<Byte> Audio::FrameAsStereo(const UInt_64 frameIndex) const
{
Array<Byte> result;
if (channels == 1)
{
result.Resize(byteDepth * channels);
Mono_to_Stereo(1, result, frameIndex);
}
else if (channels == 2)
{
return {&data[byteDepth * channels * frameIndex], (UInt_64)(byteDepth * channels)};
}
else if (channels == 6)
{
result.Resize(byteDepth * channels);
Five_One_to_Stereo(1, result, frameIndex);
}
else if (channels == 8)
{
result.Resize(byteDepth * channels);
Seven_One_to_Stereo(1, result, frameIndex);
}
else
{
EHS_LOG_INT(LogType::ERR, 0, "Conversion from " + Str_8::FromNum(channels) + " channels, to 2 channels is unsupported.");
}
return result;
}
Array<Byte> Audio::FrameAsFive_One(const UInt_64 frameIndex) const
{
Array<Byte> result;
if (channels == 1)
{
result.Resize(byteDepth * 6 );
Mono_to_Five_One(1, result, frameIndex);
}
else if (channels == 2)
{
result.Resize(byteDepth * 6);
Stereo_to_Five_One(1, result, frameIndex);
}
else if (channels == 6)
{
return {&data[byteDepth * channels * frameIndex], (UInt_64)(byteDepth * channels)};
}
else if (channels == 8)
{
result.Resize(byteDepth * 6);
Seven_One_to_Five_One(1, result, frameIndex);
}
else
{
EHS_LOG_INT(LogType::ERR, 0, "Conversion from " + Str_8::FromNum(channels) + " channels, to 6 channels is unsupported.");
}
return result;
}
Array<Byte> Audio::FrameAsSeven_One(const UInt_64 frameIndex) const
{
Array<Byte> result;
if (channels == 1)
{
result.Resize(byteDepth * 8);
Mono_to_Seven_One(1, result, frameIndex);
}
else if (channels == 2)
{
result.Resize(byteDepth * 8);
Stereo_to_Seven_One(1, result, frameIndex);
}
else if (channels == 6)
{
result.Resize(byteDepth * 8);
Five_One_to_Seven_One(1, result, frameIndex);
}
else if (channels == 8)
{
return {&data[byteDepth * channels * frameIndex], (UInt_64)(byteDepth * channels)};
}
else
{
EHS_LOG_INT(LogType::ERR, 0, "Conversion from " + Str_8::FromNum(channels) + " channels, to 8 channels is unsupported.");
}
return result;
}
SInt_8 Audio::SampleAsSInt_8(const UInt_64 sampleIndex) const
{
switch (dataType)
{
case DataType::SINT_8:
return ((SInt_8 *)data)[sampleIndex];
case DataType::SINT_16:
return (SInt_8)((double)((SInt_16 *)data)[sampleIndex] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_8_MAX);
case DataType::FLOAT:
return (SInt_8)(((double *)data)[sampleIndex] * (double)EHS_SINT_8_MAX);
case DataType::SINT_32:
return (SInt_8)((double)((SInt_32 *)data)[sampleIndex] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_8_MAX);
case DataType::SINT_64:
return (SInt_8)((double)((SInt_64 *)data)[sampleIndex] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_8_MAX);
default:
return 0;
}
}
SInt_16 Audio::SampleAsSInt_16(const UInt_64 sampleIndex) const
{
switch (dataType)
{
case DataType::SINT_8:
return (SInt_16)((double)((SInt_8*)data)[sampleIndex] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_16_MAX);
case DataType::SINT_16:
return ((SInt_16 *)data)[sampleIndex];
case DataType::FLOAT:
return (SInt_16)(((double *)data)[sampleIndex] * (double)EHS_SINT_16_MAX);
case DataType::SINT_32:
return (SInt_16)((double)((SInt_32 *)data)[sampleIndex] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_16_MAX);
case DataType::SINT_64:
return (SInt_16)((double)((SInt_64 *)data)[sampleIndex] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_16_MAX);
default:
return 0;
}
}
float Audio::SampleAsFloat(const UInt_64 sampleIndex) const
{
switch (dataType)
{
case DataType::SINT_8:
return (float)((SInt_8*)data)[sampleIndex] / (float)EHS_SINT_8_MAX;
case DataType::SINT_16:
return (float)((SInt_16*)data)[sampleIndex] / (float)EHS_SINT_16_MAX;
case DataType::FLOAT:
return ((float*)data)[sampleIndex];
case DataType::SINT_32:
return (float)((SInt_32*)data)[sampleIndex] / (float)EHS_SINT_32_MAX;
case DataType::SINT_64:
return (float)((SInt_64*)data)[sampleIndex] / (float)EHS_SINT_64_MAX;
default:
return 0;
}
}
SInt_32 Audio::SampleAsSInt_32(const UInt_64 sampleIndex) const
{
switch (dataType)
{
case DataType::SINT_8:
return (SInt_32)((double)((SInt_8 *)data)[sampleIndex] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_32_MAX);
case DataType::SINT_16:
return (SInt_32)((double)((SInt_16 *)data)[sampleIndex] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_32_MAX);
case DataType::FLOAT:
return (SInt_32)(((double *)data)[sampleIndex] * (double)EHS_SINT_32_MAX);
case DataType::SINT_32:
return ((SInt_32 *)data)[sampleIndex];
case DataType::SINT_64:
return (SInt_32)((double)((SInt_64 *)data)[sampleIndex] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_32_MAX);
default:
return 0;
}
}
SInt_64 Audio::SampleAsSInt_64(const UInt_64 sampleIndex) const
{
switch (dataType)
{
case DataType::SINT_8:
return (SInt_64)((double)((SInt_8 *)data)[sampleIndex] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_64_MAX);
case DataType::SINT_16:
return (SInt_64)((double)((SInt_16 *)data)[sampleIndex] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_64_MAX);
case DataType::FLOAT:
return (SInt_64)(((double *)data)[sampleIndex] * (double)EHS_SINT_64_MAX);
case DataType::SINT_32:
return (SInt_64)((double)((SInt_32 *)data)[sampleIndex] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_64_MAX);
case DataType::SINT_64:
return ((SInt_64 *)data)[sampleIndex];
default:
return 0;
}
}
SInt_8 Audio::PeakAsSInt_8() const
{
switch (dataType)
{
case DataType::SINT_8:
return *(SInt_8*)peak;
case DataType::SINT_16:
return (SInt_8)((double)*(SInt_16 *)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_8_MAX);
case DataType::FLOAT:
return (SInt_8)(*(double *)peak * (double)EHS_SINT_8_MAX);
case DataType::SINT_32:
return (SInt_8)((double)*(SInt_32 *)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_8_MAX);
case DataType::SINT_64:
return (SInt_8)((double)*(SInt_64 *)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_8_MAX);
default:
return 0;
}
}
SInt_16 Audio::PeakAsSInt_16() const
{
switch (dataType)
{
case DataType::SINT_8:
return (SInt_16)((double)*(SInt_8 *)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_16_MAX);
case DataType::SINT_16:
return *(SInt_16*)peak;
case DataType::FLOAT:
return (SInt_16)(*(double*)peak * (double)EHS_SINT_16_MAX);
case DataType::SINT_32:
return (SInt_16)((double)*(SInt_32 *)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_16_MAX);
case DataType::SINT_64:
return (SInt_16)((double)*(SInt_64 *)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_16_MAX);
default:
return 0;
}
}
float Audio::PeakAsFloat() const
{
switch (dataType)
{
case DataType::SINT_8:
return (float)*(SInt_8*)peak / (float)EHS_SINT_8_MAX;
case DataType::SINT_16:
return (float)*(SInt_16*)peak / (float)EHS_SINT_16_MAX;
case DataType::FLOAT:
return *(float*)peak;
case DataType::SINT_32:
return (float)*(SInt_32*)peak / (float)EHS_SINT_32_MAX;
case DataType::SINT_64:
return (float)*(SInt_64*)peak / (float)EHS_SINT_64_MAX;
default:
return 0;
}
}
SInt_32 Audio::PeakAsSInt_32() const
{
switch (dataType)
{
case DataType::SINT_8:
return (SInt_32)((double)*(SInt_8 *)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_32_MAX);
case DataType::SINT_16:
return (SInt_32)((double)*(SInt_16 *)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_32_MAX);
case DataType::FLOAT:
return (SInt_32)(*(double *)peak * (double)EHS_SINT_32_MAX);
case DataType::SINT_32:
return *(SInt_32 *)peak;
case DataType::SINT_64:
return (SInt_32)((double)*(SInt_64 *)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_32_MAX);
default:
return 0;
}
}
SInt_64 Audio::PeakAsSInt_64() const
{
switch (dataType)
{
case DataType::SINT_8:
return (SInt_64)((double)*(SInt_8 *)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_64_MAX);
case DataType::SINT_16:
return (SInt_64)((double)*(SInt_16 *)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_64_MAX);
case DataType::FLOAT:
return (SInt_64)(*(double *)peak * (double)EHS_SINT_64_MAX);
case DataType::SINT_32:
return (SInt_64)((double)*(SInt_32 *)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_64_MAX);
case DataType::SINT_64:
return *(SInt_64 *)peak;
default:
return 0;
}
}
void Audio::SetPeak(const UInt_64 size, const Byte* newPeak)
{
Util::Copy(peak, newPeak, size);
}
const Byte* Audio::GetPeak() const
{
return peak;
}
void Audio::ToDataType(const DataType newDataType)
{
if (dataType == newDataType)
return;
UInt_8 newByteDepth = ToByteDepth(newDataType);
Byte* newData = new Byte[GetSampleCount() * newByteDepth];
Byte* newPeak = new Byte[newByteDepth];
if (dataType == DataType::SINT_16 && newDataType == DataType::SINT_8)
SInt_16_to_SInt_8(newData, newPeak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_8)
Float_to_SInt_8(newData, newPeak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::SINT_8)
SInt_32_to_SInt_8(newData, newPeak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::SINT_8)
SInt_64_to_SInt_8(newData, newPeak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::SINT_16)
SInt_8_to_SInt_16(newData, newPeak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_16)
Float_to_SInt_16(newData, newPeak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::SINT_16)
SInt_32_to_SInt_16(newData, newPeak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::SINT_16)
SInt_64_to_SInt_16(newData, newPeak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::FLOAT)
SInt_8_to_Float(newData, newPeak);
else if (dataType == DataType::SINT_16 && newDataType == DataType::FLOAT)
SInt_16_to_Float(newData, newPeak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::FLOAT)
SInt_32_to_Float(newData, newPeak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::FLOAT)
SInt_64_to_Float(newData, newPeak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::SINT_32)
SInt_8_to_SInt_32(newData, newPeak);
else if (dataType == DataType::SINT_16 && newDataType == DataType::SINT_32)
SInt_16_to_SInt_32(newData, newPeak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_32)
Float_to_SInt_32(newData, newPeak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::SINT_32)
SInt_64_to_SInt_32(newData, newPeak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::SINT_64)
SInt_8_to_SInt_64(newData, newPeak);
else if (dataType == DataType::SINT_16 && newDataType == DataType::SINT_64)
SInt_16_to_SInt_64(newData, newPeak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_64)
Float_to_SInt_64(newData, newPeak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::SINT_64)
SInt_32_to_SInt_64(newData, newPeak);
dataType = newDataType;
byteDepth = ToByteDepth(newDataType);
delete[] data;
data = newData;
delete[] peak;
peak = newPeak;
}
Audio Audio::GetAsDataType(const DataType newDataType) const
{
if (dataType == newDataType)
return *this;
Audio result;
result.sampleRate = sampleRate;
result.dataType = newDataType;
result.byteDepth = ToByteDepth(newDataType);
result.channels = channels;
result.frames = frames;
result.length = length;
result.data = new Byte[result.GetSize()];
result.peak = new Byte[result.byteDepth];
if (dataType == DataType::SINT_16 && newDataType == DataType::SINT_8)
SInt_16_to_SInt_8(result.data, result.peak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_8)
Float_to_SInt_8(result.data, result.peak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::SINT_8)
SInt_32_to_SInt_8(result.data, result.peak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::SINT_8)
SInt_64_to_SInt_8(result.data, result.peak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::SINT_16)
SInt_8_to_SInt_16(result.data, result.peak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_16)
Float_to_SInt_16(result.data, result.peak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::SINT_16)
SInt_32_to_SInt_16(result.data, result.peak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::SINT_16)
SInt_64_to_SInt_16(result.data, result.peak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::FLOAT)
SInt_8_to_Float(result.data, result.peak);
else if (dataType == DataType::SINT_16 && newDataType == DataType::FLOAT)
SInt_16_to_Float(result.data, result.peak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::FLOAT)
SInt_32_to_Float(result.data, result.peak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::FLOAT)
SInt_64_to_Float(result.data, result.peak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::SINT_32)
SInt_8_to_SInt_32(result.data, result.peak);
else if (dataType == DataType::SINT_16 && newDataType == DataType::SINT_32)
SInt_16_to_SInt_32(result.data, result.peak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_32)
Float_to_SInt_32(result.data, result.peak);
else if (dataType == DataType::SINT_64 && newDataType == DataType::SINT_32)
SInt_64_to_SInt_32(result.data, result.peak);
else if (dataType == DataType::SINT_8 && newDataType == DataType::SINT_64)
SInt_8_to_SInt_64(result.data, result.peak);
else if (dataType == DataType::SINT_16 && newDataType == DataType::SINT_64)
SInt_16_to_SInt_64(result.data, result.peak);
else if (dataType == DataType::FLOAT && newDataType == DataType::SINT_64)
Float_to_SInt_64(result.data, result.peak);
else if (dataType == DataType::SINT_32 && newDataType == DataType::SINT_64)
SInt_32_to_SInt_64(result.data, result.peak);
return result;
}
void Audio::ToChannels(const UInt_8 newChannels)
{
if (!data || newChannels == channels)
return;
Byte* result;
if (newChannels == 1)
{
result = new Byte[byteDepth * newChannels * frames];
ToMono(frames, result, 0);
}
else if (channels == 1 && newChannels == 2)
{
result = new Byte[byteDepth * newChannels * frames];
Mono_to_Stereo(frames, result, 0);
}
else if (channels == 6 && newChannels == 2)
{
result = new Byte[byteDepth * newChannels * frames];
Five_One_to_Stereo(frames, result, 0);
}
else if (channels == 8 && newChannels == 2)
{
result = new Byte[byteDepth * newChannels * frames];
Seven_One_to_Stereo(frames, result, 0);
}
else if (channels == 1 && newChannels == 6)
{
result = new Byte[byteDepth * newChannels * frames];
Mono_to_Five_One(frames, result, 0);
}
else if (channels == 2 && newChannels == 6)
{
result = new Byte[byteDepth * newChannels * frames];
Stereo_to_Five_One(frames, result, 0);
}
else if (channels == 8 && newChannels == 6)
{
result = new Byte[byteDepth * newChannels * frames];
Seven_One_to_Five_One(frames, result, 0);
}
else if (channels == 1 && newChannels == 8)
{
result = new Byte[byteDepth * newChannels * frames];
Mono_to_Seven_One(frames, result, 0);
}
else if (channels == 2 && newChannels == 8)
{
result = new Byte[byteDepth * newChannels * frames];
Stereo_to_Seven_One(frames, result, 0);
}
else if (channels == 6 && newChannels == 8)
{
result = new Byte[byteDepth * newChannels * frames];
Five_One_to_Seven_One(frames, result, 0);
}
else
{
EHS_LOG_INT(LogType::ERR, 0, "Conversion from " + Str_8::FromNum(channels) + " channels, to " +
Str_8::FromNum(newChannels) + " channels is unsupported.");
return;
}
channels = newChannels;
delete[] data;
data = result;
}
Audio Audio::GetAsChannels(const UInt_8 newChannels) const
{
Audio result;
if (!data || newChannels == channels)
return result;
if (newChannels == 1)
{
result.data = new Byte[byteDepth * newChannels * frames];
ToMono(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 1 && newChannels == 2)
{
result.data = new Byte[byteDepth * newChannels * frames];
Mono_to_Stereo(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 6 && newChannels == 2)
{
result.data = new Byte[byteDepth * newChannels * frames];
Five_One_to_Stereo(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 8 && newChannels == 2)
{
result.data = new Byte[byteDepth * newChannels * frames];
Seven_One_to_Stereo(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 1 && newChannels == 6)
{
result.data = new Byte[byteDepth * newChannels * frames];
Mono_to_Five_One(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 2 && newChannels == 6)
{
result.data = new Byte[byteDepth * newChannels * frames];
Stereo_to_Five_One(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 8 && newChannels == 6)
{
result.data = new Byte[byteDepth * newChannels * frames];
Seven_One_to_Five_One(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 1 && newChannels == 8)
{
result.data = new Byte[byteDepth * newChannels * frames];
Mono_to_Seven_One(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 2 && newChannels == 8)
{
result.data = new Byte[byteDepth * newChannels * frames];
Stereo_to_Seven_One(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else if (channels == 6 && newChannels == 8)
{
result.data = new Byte[byteDepth * newChannels * frames];
Five_One_to_Seven_One(frames, result.data, 0);
result.peak = new Byte[byteDepth];
Util::Copy(result.peak, peak, byteDepth);
}
else
{
EHS_LOG_INT(LogType::ERR, 0, "Conversion from " + Str_8::FromNum(channels) + " channels, to " +
Str_8::FromNum(newChannels) + " channels is unsupported.");
return result;
}
result.sampleRate = sampleRate;
result.dataType = dataType;
result.byteDepth = byteDepth;
result.channels = newChannels;
result.frames = frames;
result.length = (float)frames / (float)sampleRate;
return result;
}
bool Audio::Export(const Str_8& filePath) const
{
Str_8 ext = File::ParseExt_8(filePath);
const AudioCodec* codec = GetCodec(ext);
if (!codec)
{
EHS_LOG_INT(LogType::ERR, 0, "Codec not found for file extension, \"" + ext + "\".");
return false;
}
Serializer<UInt_64> result;
if (!codec->Encode(result, this))
return false;
File file(filePath, Mode::WRITE, Disposition::CREATE_PERSISTENT);
file.WriteSerializer_64(result);
return true;
}
void Audio::ToMono(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffset = channels * (frameOffset + i);
((SInt_8*)newData)[i] = (((SInt_8*)data)[sampleOffset] + ((SInt_8*)data)[sampleOffset + 1]) / (PeakAsSInt_8() * 2);
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffset = channels * (frameOffset + i);
((SInt_16*)newData)[i] = (((SInt_16*)data)[sampleOffset] + ((SInt_16*)data)[sampleOffset + 1]) / (PeakAsSInt_16() * 2);
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffset = channels * (frameOffset + i);
((float*)newData)[i] = (((float*)data)[sampleOffset] + ((float*)data)[sampleOffset + 1]) / (PeakAsFloat() * 2.0f);
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffset = channels * (frameOffset + i);
((SInt_32*)newData)[i] = (((SInt_32*)data)[sampleOffset] + ((SInt_32*)data)[sampleOffset + 1]) / (PeakAsSInt_32() * 2);
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffset = channels * (frameOffset + i);
((SInt_64*)newData)[i] = (((SInt_64*)data)[sampleOffset] + ((SInt_64*)data)[sampleOffset + 1]) / (PeakAsSInt_64() * 2);
}
return;
}
default:
return;
}
}
void Audio::Mono_to_Stereo(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB];
}
return;
}
default:
return;
}
}
void Audio::Five_One_to_Stereo(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB + 1];
}
return;
}
default:
return;
}
}
void Audio::Seven_One_to_Stereo(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 2 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB + 1];
}
return;
}
default:
return;
}
}
void Audio::Mono_to_Five_One(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 2] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 3] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 4] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 5] = ((SInt_8*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 2] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 3] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 4] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 5] = ((SInt_16*)data)[sampleOffsetB];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 2] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 3] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 4] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 5] = ((float*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 2] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 3] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 4] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 5] = ((SInt_32*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 2] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 3] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 4] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 5] = ((SInt_64*)data)[sampleOffsetB];
}
return;
}
default:
return;
}
}
void Audio::Stereo_to_Five_One(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB + 1];
((SInt_8*)newData)[sampleOffsetA + 2] = (((SInt_8*)data)[sampleOffsetB] + ((SInt_8*)data)[sampleOffsetB + 1]) / (PeakAsSInt_8() * 2);
((SInt_8*)newData)[sampleOffsetA + 3] = ((SInt_8*)newData)[sampleOffsetA + 2];
((SInt_8*)newData)[sampleOffsetA + 4] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 5] = ((SInt_8*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB + 1];
((SInt_16*)newData)[sampleOffsetA + 2] = (((SInt_16*)data)[sampleOffsetB] + ((SInt_16*)data)[sampleOffsetB + 1]) / (PeakAsSInt_16() * 2);
((SInt_16*)newData)[sampleOffsetA + 3] = ((SInt_16*)newData)[sampleOffsetA + 2];
((SInt_16*)newData)[sampleOffsetA + 4] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 5] = ((SInt_16*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB + 1];
((float*)newData)[sampleOffsetA + 2] = (((float*)data)[sampleOffsetB] + ((float*)data)[sampleOffsetB + 1]) / (PeakAsFloat() * 2.0f);
((float*)newData)[sampleOffsetA + 3] = ((float*)newData)[sampleOffsetA + 2];
((float*)newData)[sampleOffsetA + 4] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 5] = ((float*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB + 1];
((SInt_32*)newData)[sampleOffsetA + 2] = (((SInt_32*)data)[sampleOffsetB] + ((SInt_32*)data)[sampleOffsetB + 1]) / (PeakAsSInt_32() * 2);
((SInt_32*)newData)[sampleOffsetA + 3] = ((SInt_32*)newData)[sampleOffsetA + 2];
((SInt_32*)newData)[sampleOffsetA + 4] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 5] = ((SInt_32*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB + 1];
((SInt_64*)newData)[sampleOffsetA + 2] = (((SInt_64*)data)[sampleOffsetB] + ((SInt_64*)data)[sampleOffsetB + 1]) / (PeakAsSInt_64() * 2);
((SInt_64*)newData)[sampleOffsetA + 3] = ((SInt_64*)newData)[sampleOffsetA + 2];
((SInt_64*)newData)[sampleOffsetA + 4] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 5] = ((SInt_64*)data)[sampleOffsetB + 1];
}
return;
}
default:
return;
}
}
void Audio::Seven_One_to_Five_One(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB + 1];
((SInt_8*)newData)[sampleOffsetA + 2] = ((SInt_8*)data)[sampleOffsetB + 2];
((SInt_8*)newData)[sampleOffsetA + 3] = ((SInt_8*)data)[sampleOffsetB + 3];
((SInt_8*)newData)[sampleOffsetA + 4] = ((SInt_8*)data)[sampleOffsetB + 4];
((SInt_8*)newData)[sampleOffsetA + 5] = ((SInt_8*)data)[sampleOffsetB + 5];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB + 1];
((SInt_16*)newData)[sampleOffsetA + 2] = ((SInt_16*)data)[sampleOffsetB + 2];
((SInt_16*)newData)[sampleOffsetA + 3] = ((SInt_16*)data)[sampleOffsetB + 3];
((SInt_16*)newData)[sampleOffsetA + 4] = ((SInt_16*)data)[sampleOffsetB + 4];
((SInt_16*)newData)[sampleOffsetA + 5] = ((SInt_16*)data)[sampleOffsetB + 5];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB + 1];
((float*)newData)[sampleOffsetA + 2] = ((float*)data)[sampleOffsetB + 2];
((float*)newData)[sampleOffsetA + 3] = ((float*)data)[sampleOffsetB + 3];
((float*)newData)[sampleOffsetA + 4] = ((float*)data)[sampleOffsetB + 4];
((float*)newData)[sampleOffsetA + 5] = ((float*)data)[sampleOffsetB + 5];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB + 1];
((SInt_32*)newData)[sampleOffsetA + 2] = ((SInt_32*)data)[sampleOffsetB + 2];
((SInt_32*)newData)[sampleOffsetA + 3] = ((SInt_32*)data)[sampleOffsetB + 3];
((SInt_32*)newData)[sampleOffsetA + 4] = ((SInt_32*)data)[sampleOffsetB + 4];
((SInt_32*)newData)[sampleOffsetA + 5] = ((SInt_32*)data)[sampleOffsetB + 5];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 6 * i;
UInt_64 sampleOffsetB = 8 * (frameOffset + i);
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB + 1];
((SInt_64*)newData)[sampleOffsetA + 2] = ((SInt_64*)data)[sampleOffsetB + 2];
((SInt_64*)newData)[sampleOffsetA + 3] = ((SInt_64*)data)[sampleOffsetB + 3];
((SInt_64*)newData)[sampleOffsetA + 4] = ((SInt_64*)data)[sampleOffsetB + 4];
((SInt_64*)newData)[sampleOffsetA + 5] = ((SInt_64*)data)[sampleOffsetB + 5];
}
return;
}
default:
return;
}
}
void Audio::Mono_to_Seven_One(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 2] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 3] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 4] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 5] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 6] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 7] = ((SInt_8*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 2] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 3] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 4] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 5] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 6] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 7] = ((SInt_16*)data)[sampleOffsetB];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 2] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 3] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 4] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 5] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 6] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 7] = ((float*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 2] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 3] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 4] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 5] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 6] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 7] = ((SInt_32*)data)[sampleOffsetB];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = frameOffset + i;
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 2] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 3] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 4] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 5] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 6] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 7] = ((SInt_64*)data)[sampleOffsetB];
}
return;
}
default:
return;
}
}
void Audio::Stereo_to_Seven_One(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB + 1];
((SInt_8*)newData)[sampleOffsetA + 2] = (((SInt_8*)data)[sampleOffsetB] + ((SInt_8*)data)[sampleOffsetB + 1]) / (PeakAsSInt_8() * 2);
((SInt_8*)newData)[sampleOffsetA + 3] = ((SInt_8*)newData)[sampleOffsetA + 2];
((SInt_8*)newData)[sampleOffsetA + 4] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 5] = ((SInt_8*)data)[sampleOffsetB + 1];
((SInt_8*)newData)[sampleOffsetA + 6] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 7] = ((SInt_8*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB + 1];
((SInt_16*)newData)[sampleOffsetA + 2] = (((SInt_16*)data)[sampleOffsetB] + ((SInt_16*)data)[sampleOffsetB + 1]) / (PeakAsSInt_16() * 2);
((SInt_16*)newData)[sampleOffsetA + 3] = ((SInt_16*)newData)[sampleOffsetA + 2];
((SInt_16*)newData)[sampleOffsetA + 4] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 5] = ((SInt_16*)data)[sampleOffsetB + 1];
((SInt_16*)newData)[sampleOffsetA + 6] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 7] = ((SInt_16*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB + 1];
((float*)newData)[sampleOffsetA + 2] = (((float*)data)[sampleOffsetB] + ((float*)data)[sampleOffsetB + 1]) / (PeakAsFloat() * 2.0f);
((float*)newData)[sampleOffsetA + 3] = ((float*)newData)[sampleOffsetA + 2];
((float*)newData)[sampleOffsetA + 4] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 5] = ((float*)data)[sampleOffsetB + 1];
((float*)newData)[sampleOffsetA + 6] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 7] = ((float*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB + 1];
((SInt_32*)newData)[sampleOffsetA + 2] = (((SInt_32*)data)[sampleOffsetB] + ((SInt_32*)data)[sampleOffsetB + 1]) / (PeakAsSInt_32() * 2);
((SInt_32*)newData)[sampleOffsetA + 3] = ((SInt_32*)newData)[sampleOffsetA + 2];
((SInt_32*)newData)[sampleOffsetA + 4] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 5] = ((SInt_32*)data)[sampleOffsetB + 1];
((SInt_32*)newData)[sampleOffsetA + 6] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 7] = ((SInt_32*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 2 * (frameOffset + i);
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB + 1];
((SInt_64*)newData)[sampleOffsetA + 2] = (((SInt_64*)data)[sampleOffsetB] + ((SInt_64*)data)[sampleOffsetB + 1]) / (PeakAsSInt_64() * 2);
((SInt_64*)newData)[sampleOffsetA + 3] = ((SInt_64*)newData)[sampleOffsetA + 2];
((SInt_64*)newData)[sampleOffsetA + 4] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 5] = ((SInt_64*)data)[sampleOffsetB + 1];
((SInt_64*)newData)[sampleOffsetA + 6] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 7] = ((SInt_64*)data)[sampleOffsetB + 1];
}
return;
}
default:
return;
}
}
void Audio::Five_One_to_Seven_One(const UInt_64 newFrameCount, Byte* newData, const UInt_64 frameOffset) const
{
switch (dataType)
{
case DataType::SINT_8:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_8*)newData)[sampleOffsetA] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 1] = ((SInt_8*)data)[sampleOffsetB + 1];
((SInt_8*)newData)[sampleOffsetA + 2] = ((SInt_8*)data)[sampleOffsetB + 2];
((SInt_8*)newData)[sampleOffsetA + 3] = ((SInt_8*)data)[sampleOffsetB + 3];
((SInt_8*)newData)[sampleOffsetA + 4] = ((SInt_8*)data)[sampleOffsetB + 4];
((SInt_8*)newData)[sampleOffsetA + 5] = ((SInt_8*)data)[sampleOffsetB + 5];
((SInt_8*)newData)[sampleOffsetA + 6] = ((SInt_8*)data)[sampleOffsetB];
((SInt_8*)newData)[sampleOffsetA + 7] = ((SInt_8*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_16:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_16*)newData)[sampleOffsetA] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 1] = ((SInt_16*)data)[sampleOffsetB + 1];
((SInt_16*)newData)[sampleOffsetA + 2] = ((SInt_16*)data)[sampleOffsetB + 2];
((SInt_16*)newData)[sampleOffsetA + 3] = ((SInt_16*)data)[sampleOffsetB + 3];
((SInt_16*)newData)[sampleOffsetA + 4] = ((SInt_16*)data)[sampleOffsetB + 4];
((SInt_16*)newData)[sampleOffsetA + 5] = ((SInt_16*)data)[sampleOffsetB + 5];
((SInt_16*)newData)[sampleOffsetA + 6] = ((SInt_16*)data)[sampleOffsetB];
((SInt_16*)newData)[sampleOffsetA + 7] = ((SInt_16*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::FLOAT:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((float*)newData)[sampleOffsetA] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 1] = ((float*)data)[sampleOffsetB + 1];
((float*)newData)[sampleOffsetA + 2] = ((float*)data)[sampleOffsetB + 2];
((float*)newData)[sampleOffsetA + 3] = ((float*)data)[sampleOffsetB + 3];
((float*)newData)[sampleOffsetA + 4] = ((float*)data)[sampleOffsetB + 4];
((float*)newData)[sampleOffsetA + 5] = ((float*)data)[sampleOffsetB + 5];
((float*)newData)[sampleOffsetA + 6] = ((float*)data)[sampleOffsetB];
((float*)newData)[sampleOffsetA + 7] = ((float*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_32:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_32*)newData)[sampleOffsetA] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 1] = ((SInt_32*)data)[sampleOffsetB + 1];
((SInt_32*)newData)[sampleOffsetA + 2] = ((SInt_32*)data)[sampleOffsetB + 2];
((SInt_32*)newData)[sampleOffsetA + 3] = ((SInt_32*)data)[sampleOffsetB + 3];
((SInt_32*)newData)[sampleOffsetA + 4] = ((SInt_32*)data)[sampleOffsetB + 4];
((SInt_32*)newData)[sampleOffsetA + 5] = ((SInt_32*)data)[sampleOffsetB + 5];
((SInt_32*)newData)[sampleOffsetA + 6] = ((SInt_32*)data)[sampleOffsetB];
((SInt_32*)newData)[sampleOffsetA + 7] = ((SInt_32*)data)[sampleOffsetB + 1];
}
return;
}
case DataType::SINT_64:
{
for (UInt_64 i = 0; i < newFrameCount; ++i)
{
UInt_64 sampleOffsetA = 8 * i;
UInt_64 sampleOffsetB = 6 * (frameOffset + i);
((SInt_64*)newData)[sampleOffsetA] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 1] = ((SInt_64*)data)[sampleOffsetB + 1];
((SInt_64*)newData)[sampleOffsetA + 2] = ((SInt_64*)data)[sampleOffsetB + 2];
((SInt_64*)newData)[sampleOffsetA + 3] = ((SInt_64*)data)[sampleOffsetB + 3];
((SInt_64*)newData)[sampleOffsetA + 4] = ((SInt_64*)data)[sampleOffsetB + 4];
((SInt_64*)newData)[sampleOffsetA + 5] = ((SInt_64*)data)[sampleOffsetB + 5];
((SInt_64*)newData)[sampleOffsetA + 6] = ((SInt_64*)data)[sampleOffsetB];
((SInt_64*)newData)[sampleOffsetA + 7] = ((SInt_64*)data)[sampleOffsetB + 1];
}
return;
}
default:
return;
}
}
void Audio::SInt_16_to_SInt_8(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
newData[a] = (Byte)((double)((SInt_16*)data)[a] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_8_MAX);
*(SInt_8*)newPeak = (SInt_8)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_8_MAX);
}
void Audio::Float_to_SInt_8(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_8*)newData)[a] = (SInt_8)((double)((float*)data)[a] * (double)EHS_SINT_8_MAX);
*(SInt_8*)newPeak = (SInt_8)((double)(*(float*)peak) * (double)EHS_SINT_8_MAX);
}
void Audio::SInt_32_to_SInt_8(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
newData[a] = (Byte)((double)((SInt_32*)data)[a] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_8_MAX);
*(SInt_8*)newPeak = (SInt_8)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_8_MAX);
}
void Audio::SInt_64_to_SInt_8(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
newData[a] = (Byte)((double)((SInt_64*)data)[a] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_8_MAX);
*(SInt_8*)newPeak = (SInt_8)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_8_MAX);
}
void Audio::SInt_8_to_SInt_16(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_16*)newData)[a] = (SInt_16)((double)(SInt_8)data[a] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_16_MAX);
*(SInt_16*)newPeak = (SInt_16)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_16_MAX);
}
void Audio::Float_to_SInt_16(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_16*)newData)[a] = (SInt_16)((double)((float*)data)[a] * (double)EHS_SINT_16_MAX);
*(SInt_16*)newPeak = (SInt_16)((double)(*(float*)peak) * (double)EHS_SINT_16_MAX);
}
void Audio::SInt_32_to_SInt_16(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_16*)newData)[a] = (SInt_16)((double)((SInt_32*)data)[a] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_16_MAX);
*(SInt_16*)newPeak = (SInt_16)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_16_MAX);
}
void Audio::SInt_64_to_SInt_16(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_16*)newData)[a] = (SInt_16)((double)((SInt_64*)data)[a] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_16_MAX);
*(SInt_16*)newPeak = (SInt_16)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_16_MAX);
}
void Audio::SInt_8_to_Float(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((float*)newData)[a] = (float)((double)(((SInt_8*)data)[a]) / (double)EHS_SINT_8_MAX);
*(float*)newPeak = (float)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX);
}
void Audio::SInt_16_to_Float(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((float*)newData)[a] = (float)((double)(((SInt_16*)data)[a]) / (double)EHS_SINT_16_MAX);
*(float*)newPeak = (float)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX);
}
void Audio::SInt_32_to_Float(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((float*)newData)[a] = (float)((double)(((SInt_32*)data)[a]) / (double)EHS_SINT_32_MAX);
*(float*)newPeak = (float)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX);
}
void Audio::SInt_64_to_Float(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((float*)newData)[a] = (float)((double)(((SInt_64*)data)[a]) / (double)EHS_SINT_64_MAX);
*(float*)newPeak = (float)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX);
}
void Audio::SInt_8_to_SInt_32(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_32*)newData)[a] = (SInt_32)((double)(SInt_8)data[a] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_32_MAX);
*(SInt_32*)newPeak = (SInt_32)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_32_MAX);
}
void Audio::SInt_16_to_SInt_32(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_32*)newData)[a] = (SInt_32)((double)((SInt_16*)data)[a] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_32_MAX);
*(SInt_32*)newPeak = (SInt_32)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_32_MAX);
}
void Audio::Float_to_SInt_32(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_32*)newData)[a] = (SInt_32)(((double*)data)[a] * (double)EHS_SINT_32_MAX);
*(SInt_32*)newPeak = (SInt_32)(*(double*)peak * (double)EHS_SINT_32_MAX);
}
void Audio::SInt_64_to_SInt_32(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_32*)newData)[a] = (SInt_32)((double)((SInt_64*)data)[a] / (double)EHS_SINT_64_MAX * (double)EHS_SINT_32_MAX);
*(SInt_32*)newPeak = (SInt_32)((double)*(SInt_64*)peak / (double)EHS_SINT_64_MAX * (double)EHS_SINT_32_MAX);
}
void Audio::SInt_8_to_SInt_64(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_64*)newData)[a] = (SInt_64)((double)(SInt_8)data[a] / (double)EHS_SINT_8_MAX * (double)EHS_SINT_64_MAX);
*(SInt_64*)newPeak = (SInt_64)((double)*(SInt_8*)peak / (double)EHS_SINT_8_MAX * (double)EHS_SINT_64_MAX);
}
void Audio::SInt_16_to_SInt_64(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_64*)newData)[a] = (SInt_64)((double)((SInt_16*)data)[a] / (double)EHS_SINT_16_MAX * (double)EHS_SINT_64_MAX);
*(SInt_64*)newPeak = (SInt_64)((double)*(SInt_16*)peak / (double)EHS_SINT_16_MAX * (double)EHS_SINT_64_MAX);
}
void Audio::Float_to_SInt_64(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_64*)newData)[a] = (SInt_64)(((double*)data)[a] * (double)EHS_SINT_64_MAX);
*(SInt_64*)newPeak = (SInt_64)(*(double*)peak * (double)EHS_SINT_64_MAX);
}
void Audio::SInt_32_to_SInt_64(Byte* newData, Byte* newPeak) const
{
for (UInt_64 a = 0; a < GetSampleCount(); ++a)
((SInt_64*)newData)[a] = (SInt_64)((double)((SInt_32*)data)[a] / (double)EHS_SINT_32_MAX * (double)EHS_SINT_64_MAX);
*(SInt_64*)newPeak = (SInt_64)((double)*(SInt_32*)peak / (double)EHS_SINT_32_MAX * (double)EHS_SINT_64_MAX);
}
bool EncodeEHA(const ehs::AudioCodec* const codec, ehs::Serializer<ehs::UInt_64>& out, const ehs::Audio* const in)
{
Serializer<UInt_64> result(codec->GetEndianness());
result.WriteVersion({1, 0, 0});
result.Write(in->GetSampleRate());
result.Write(in->GetDataType());
result.Write(in->GetByteDepth());
result.Write(in->GetChannels());
result.Write(in->GetFrameCount());
UInt_64 size = in->GetSize();
UInt_8 byteDepth = in->GetByteDepth();
result.Resize(result.Size() + size + byteDepth);
Util::Copy(&result[result.GetOffset()], &in[0], size);
result.SetOffset(result.GetOffset() + size);
Util::Copy(&result[result.GetOffset()], in->GetPeak(), byteDepth);
return true;
}
bool DecodeEHA(const ehs::AudioCodec* const codec, ehs::Serializer<ehs::UInt_64>& in, ehs::Audio* const out)
{
Version version = in.ReadVersion();
if (version != Version(1, 0, 0))
{
EHS_LOG_INT(LogType::ERR, 0, "Incompatible audio file version.");
return false;
}
UInt_64 sampleRate = in.Read<UInt_64>();
DataType dataType = in.Read<DataType>();
UInt_8 byteDepth = in.Read<UInt_8>();
UInt_8 channels = in.Read<UInt_8>();
UInt_64 frames = in.Read<UInt_64>();
*out = Audio(out->GetId(), sampleRate, dataType, channels, frames);
UInt_64 size = out->GetSize();
Util::Copy(&(*out)[0], &in[in.GetOffset()], size);
in.SetOffset(in.GetOffset() + size);
out->SetPeak(byteDepth, &in[in.GetOffset()]);
return true;
}
bool DecodeWAV(const ehs::AudioCodec* const codec, ehs::Serializer<ehs::UInt_64>& in, ehs::Audio* out)
{
RIFF riff(in);
if (riff.GetType() != "WAVE")
{
EHS_LOG_INT(LogType::ERR, 0, "Data is not in WAVE format.");
return false;
}
RIFF_Chunk fmt = riff.GetChunk("fmt ");
if (!fmt.IsValid())
{
EHS_LOG_INT(LogType::ERR, 1, "Wave does not have a format chunk.");
return false;
}
Serializer<> fmtSer = fmt.GetData();
RIFF_Chunk dChunk = riff.GetChunk("data");
if (!dChunk.IsValid())
{
EHS_LOG_INT(LogType::ERR, 2, "Wave does not have a data chunk.");
return false;
}
UInt_16 compression = fmtSer.Read<UInt_16>();
if (compression == 0x2)
{
EHS_LOG_INT(LogType::ERR, 3, "Microsoft ADPCM compression unsupported.");
return false;
}
else if (compression == 0x6)
{
EHS_LOG_INT(LogType::ERR, 4, "ITU G.711 a-law compression unsupported.");
return false;
}
else if (compression == 0x7)
{
EHS_LOG_INT(LogType::ERR, 5, "ITU G.711 µ-law compression unsupported.");
return false;
}
else if (compression == 0x11)
{
EHS_LOG_INT(LogType::ERR, 6, "IMA ADPCM compression unsupported.");
return false;
}
else if (compression == 0x16)
{
EHS_LOG_INT(LogType::ERR, 7, "TU G.723 ADPCM (Yamaha) compression unsupported.");
return false;
}
else if (compression == 0x31)
{
EHS_LOG_INT(LogType::ERR, 8, "GSM 6.10 compression unsupported.");
return false;
}
else if (compression == 0x40)
{
EHS_LOG_INT(LogType::ERR, 9, "ITU G.721 ADPCM compression unsupported.");
return false;
}
else if (compression == 0x50)
{
EHS_LOG_INT(LogType::ERR, 10, "MPEG compression unsupported.");
return false;
}
else if (compression == 0xFFFF)
{
EHS_LOG_INT(LogType::ERR, 11, "Experimental compression unsupported.");
return false;
}
else if (compression != 0x1 && compression != 0x3)
{
EHS_LOG_INT(LogType::ERR, 12, "Wave has unknown compression of " + Str_8::FromNum(compression) + ".");
return false;
}
UInt_16 channels = fmtSer.Read<UInt_16>();
UInt_32 sampleRate = fmtSer.Read<UInt_32>();
fmtSer.SetOffset(fmtSer.GetOffset() + 6);
UInt_8 byteDepth = (UInt_8)(fmtSer.Read<UInt_16>() / 8);
DataType dataType;
if (byteDepth == 1)
dataType = DataType::SINT_8;
else if (byteDepth == 2)
dataType = DataType::SINT_16;
else if (byteDepth == 3)
dataType = DataType::SINT_24;
else if (byteDepth == 4 && compression == 0x3)
dataType = DataType::FLOAT;
else if (byteDepth == 4)
dataType = DataType::SINT_32;
else if (byteDepth == 8)
dataType = DataType::SINT_64;
else
return false;
UInt_64 size = dChunk.GetData().Size();
UInt_64 frames = size / byteDepth / channels;
*out = Audio(out->GetId(), sampleRate, dataType, channels, frames);
Serializer<> dataSer = dChunk.GetData();
for (UInt_32 i = 0; i < dataSer.Size(); i += byteDepth)
{
if (byteDepth == 1)
{
*(SInt_8*)&(*out)[i] = dataSer.Read<SInt_8>();
if ((*out)[i] > *(SInt_8*)out->GetPeak())
out->SetPeak(sizeof(SInt_8), &(*out)[i]);
}
else if (byteDepth == 2)
{
*(SInt_16*)&(*out)[i] = dataSer.Read<SInt_16>();
if (*(SInt_16*)&(*out)[i] > *(SInt_16*)out->GetPeak())
out->SetPeak(sizeof(SInt_16), &(*out)[i]);
}
else if (byteDepth == 3)
{
*(SInt_16*)&(*out)[i + 1] = dataSer.Read<SInt_16>();
(*out)[i] = dataSer.Read<Byte>();
SInt_32 signal = 0;
signal |= (*out)[i];
signal |= (*out)[i + 1] << 8;
signal |= (*out)[i + 2] << 16;
SInt_32 peak = 0;
peak |= out->GetPeak()[0];
peak |= out->GetPeak()[1] << 8;
peak |= out->GetPeak()[2] << 16;
if (signal > peak)
out->SetPeak(3, &(*out)[i]);
}
else if (byteDepth == 4 && compression == 0x3)
{
*(float*)&(*out)[i] = dataSer.Read<float>();
if (*(float*)&(*out)[i] > *(float*)out->GetPeak())
out->SetPeak(sizeof(float), &(*out)[i]);
}
else if (byteDepth == 4)
{
*(SInt_32*)&(*out)[i] = dataSer.Read<SInt_32>();
if (*(SInt_32*)&(*out)[i] > *(SInt_32*)out->GetPeak())
out->SetPeak(sizeof(SInt_32), &(*out)[i]);
}
else if (byteDepth == 8)
{
*(SInt_64*)&(*out)[i] = dataSer.Read<SInt_64>();
if (*(SInt_64*)&(*out)[i] > *(SInt_64*)out->GetPeak())
out->SetPeak(sizeof(SInt_64), &(*out)[i]);
}
}
return true;
}
}
Reference in New Issue View Git Blame Copy Permalink