mirror of
https://github.com/claunia/cuetools.net.git
synced 2025-12-16 18:14:25 +00:00
This commit is contained in:
chudov
558
CUETools.Codecs.APE/CUETools.Codecs.APE.cpp
Normal file
558
CUETools.Codecs.APE/CUETools.Codecs.APE.cpp
Normal file
@@ -0,0 +1,558 @@
|
||||
// This is the main DLL file.
|
||||
|
||||
using namespace System;
|
||||
using namespace System::Text;
|
||||
using namespace System::Collections::Generic;
|
||||
using namespace System::Collections::Specialized;
|
||||
using namespace System::Runtime::InteropServices;
|
||||
using namespace System::IO;
|
||||
using namespace APETagsDotNet;
|
||||
using namespace CUETools::Codecs;
|
||||
|
||||
#ifndef _WAVEFORMATEX_
|
||||
#define _WAVEFORMATEX_
|
||||
|
||||
#define BOOL int
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#define HWND long
|
||||
|
||||
/*
|
||||
* extended waveform format structure used for all non-PCM formats. this
|
||||
* structure is common to all non-PCM formats.
|
||||
*/
|
||||
typedef struct tWAVEFORMATEX
|
||||
{
|
||||
Int16 wFormatTag; /* format type */
|
||||
Int16 nChannels; /* number of channels (i.e. mono, stereo...) */
|
||||
Int32 nSamplesPerSec; /* sample rate */
|
||||
Int32 nAvgBytesPerSec; /* for buffer estimation */
|
||||
Int16 nBlockAlign; /* block size of data */
|
||||
Int16 wBitsPerSample; /* number of bits per sample of mono data */
|
||||
Int16 cbSize; /* the count in bytes of the size of */
|
||||
/* extra information (after cbSize) */
|
||||
} WAVEFORMATEX, *PWAVEFORMATEX, *NPWAVEFORMATEX, *LPWAVEFORMATEX;
|
||||
|
||||
#endif /* _WAVEFORMATEX_ */
|
||||
|
||||
#include "All.h"
|
||||
#include "MACLib.h"
|
||||
#include "IO.h"
|
||||
|
||||
namespace CUETools { namespace Codecs { namespace APE {
|
||||
|
||||
class CWinFileIO : public CIO
|
||||
{
|
||||
public:
|
||||
|
||||
// construction / destruction
|
||||
CWinFileIO(GCHandle gchIO, GCHandle gchBuffer)
|
||||
{
|
||||
_gchIO = gchIO;
|
||||
_gchBuffer = gchBuffer;
|
||||
}
|
||||
~CWinFileIO()
|
||||
{
|
||||
}
|
||||
|
||||
// open / close
|
||||
int Open(const wchar_t * pName)
|
||||
{
|
||||
throw gcnew Exception("CIO::Open Unsupported.");
|
||||
}
|
||||
int Close()
|
||||
{
|
||||
throw gcnew Exception("CIO::Close Unsupported.");
|
||||
}
|
||||
|
||||
// read / write
|
||||
int Read(void * pBuffer, unsigned int nBytesToRead, unsigned int * pBytesRead);
|
||||
int Write(const void * pBuffer, unsigned int nBytesToWrite, unsigned int * pBytesWritten);
|
||||
|
||||
// seek
|
||||
int Seek(int nDistance, unsigned int nMoveMode);
|
||||
|
||||
// other functions
|
||||
int SetEOF()
|
||||
{
|
||||
throw gcnew Exception("CIO::SetEOF unsupported.");
|
||||
}
|
||||
|
||||
// creation / destruction
|
||||
int Create(const wchar_t * pName)
|
||||
{
|
||||
throw gcnew Exception("CIO::Create unsupported.");
|
||||
}
|
||||
|
||||
int Delete()
|
||||
{
|
||||
throw gcnew Exception("CIO::Delete unsupported.");
|
||||
}
|
||||
|
||||
// attributes
|
||||
int GetPosition();
|
||||
int GetSize();
|
||||
|
||||
int GetName(wchar_t * pBuffer)
|
||||
{
|
||||
throw gcnew Exception("CIO::GetName unsupported.");
|
||||
}
|
||||
|
||||
private:
|
||||
GCHandle _gchIO;
|
||||
GCHandle _gchBuffer;
|
||||
};
|
||||
|
||||
public ref class APEReader : public IAudioSource
|
||||
{
|
||||
public:
|
||||
APEReader(String^ path, Stream^ IO)
|
||||
{
|
||||
pAPEDecompress = NULL;
|
||||
_sampleOffset = 0;
|
||||
_bufferOffset = 0;
|
||||
_bufferLength = 0;
|
||||
_path = path;
|
||||
|
||||
int nRetVal = 0;
|
||||
|
||||
_IO = (IO != nullptr) ? IO : gcnew FileStream (path, FileMode::Open, FileAccess::Read, FileShare::Read);
|
||||
_readBuffer = gcnew array<unsigned char>(0x4000);
|
||||
_gchIO = GCHandle::Alloc(_IO);
|
||||
_gchReadBuffer = GCHandle::Alloc(_readBuffer);
|
||||
_winFileIO = new CWinFileIO(_gchIO, _gchReadBuffer);
|
||||
pAPEDecompress = CreateIAPEDecompressEx (_winFileIO, &nRetVal);
|
||||
if (!pAPEDecompress) {
|
||||
throw gcnew Exception("Unable to open file.");
|
||||
}
|
||||
|
||||
_sampleRate = pAPEDecompress->GetInfo (APE_INFO_SAMPLE_RATE, 0, 0);
|
||||
_bitsPerSample = pAPEDecompress->GetInfo (APE_INFO_BITS_PER_SAMPLE, 0, 0);
|
||||
_channelCount = pAPEDecompress->GetInfo (APE_INFO_CHANNELS, 0, 0);
|
||||
|
||||
// make a buffer to hold 16384 blocks of audio data
|
||||
nBlockAlign = pAPEDecompress->GetInfo (APE_INFO_BLOCK_ALIGN, 0, 0);
|
||||
_samplesBuffer = gcnew array<unsigned char> (16384 * nBlockAlign);
|
||||
|
||||
// loop through the whole file
|
||||
_sampleCount = pAPEDecompress->GetInfo (APE_DECOMPRESS_TOTAL_BLOCKS, 0, 0); // * ?
|
||||
}
|
||||
|
||||
~APEReader ()
|
||||
{
|
||||
if (_winFileIO)
|
||||
delete _winFileIO;
|
||||
if (_gchIO.IsAllocated)
|
||||
_gchIO.Free();
|
||||
if (_gchReadBuffer.IsAllocated)
|
||||
_gchReadBuffer.Free();
|
||||
}
|
||||
|
||||
virtual property Int32 BitsPerSample {
|
||||
Int32 get() {
|
||||
return _bitsPerSample;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property Int32 ChannelCount {
|
||||
Int32 get() {
|
||||
return _channelCount;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property Int32 SampleRate {
|
||||
Int32 get() {
|
||||
return _sampleRate;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property UInt64 Length {
|
||||
UInt64 get() {
|
||||
return _sampleCount;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property UInt64 Position
|
||||
{
|
||||
UInt64 get() {
|
||||
return _sampleOffset - SamplesInBuffer;
|
||||
}
|
||||
void set(UInt64 offset) {
|
||||
_sampleOffset = offset;
|
||||
_bufferOffset = 0;
|
||||
_bufferLength = 0;
|
||||
if (pAPEDecompress->Seek ((int) offset /*? */))
|
||||
throw gcnew Exception("Unable to seek.");
|
||||
}
|
||||
}
|
||||
|
||||
virtual property UInt64 Remaining {
|
||||
UInt64 get() {
|
||||
return _sampleCount - _sampleOffset + SamplesInBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
virtual void Close()
|
||||
{
|
||||
if (pAPEDecompress)
|
||||
{
|
||||
delete pAPEDecompress;
|
||||
pAPEDecompress = NULL;
|
||||
}
|
||||
if (_IO != nullptr)
|
||||
{
|
||||
_IO->Close ();
|
||||
_IO = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property String^ Path {
|
||||
String^ get() {
|
||||
return _path;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property NameValueCollection^ Tags {
|
||||
NameValueCollection^ get ()
|
||||
{
|
||||
if (!_tags)
|
||||
{
|
||||
APETagDotNet^ apeTag = gcnew APETagDotNet (_IO, true);
|
||||
_tags = apeTag->GetStringTags (true);
|
||||
apeTag->Close ();
|
||||
}
|
||||
return _tags;
|
||||
}
|
||||
void set (NameValueCollection ^tags)
|
||||
{
|
||||
_tags = tags;
|
||||
}
|
||||
}
|
||||
|
||||
virtual bool UpdateTags(bool preserveTime)
|
||||
{
|
||||
Close ();
|
||||
APETagDotNet^ apeTag = gcnew APETagDotNet (_path, true, false);
|
||||
apeTag->SetStringTags (_tags, true);
|
||||
apeTag->Save();
|
||||
apeTag->Close();
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual UInt32 Read([Out] array<Int32, 2>^ buff, UInt32 sampleCount)
|
||||
{
|
||||
UInt32 buffOffset = 0;
|
||||
UInt32 samplesNeeded = sampleCount;
|
||||
|
||||
while (samplesNeeded != 0)
|
||||
{
|
||||
if (SamplesInBuffer == 0)
|
||||
{
|
||||
int nBlocksRetrieved;
|
||||
pin_ptr<unsigned char> pSampleBuffer = &_samplesBuffer[0];
|
||||
if (pAPEDecompress->GetData ((char *) pSampleBuffer, 16384, &nBlocksRetrieved))
|
||||
throw gcnew Exception("An error occurred while decoding.");
|
||||
_bufferOffset = 0;
|
||||
_bufferLength = nBlocksRetrieved;
|
||||
_sampleOffset += nBlocksRetrieved;
|
||||
}
|
||||
UInt32 copyCount = Math::Min(samplesNeeded, SamplesInBuffer);
|
||||
AudioSamples::BytesToFLACSamples_16(_samplesBuffer, _bufferOffset*nBlockAlign, buff, buffOffset, copyCount, _channelCount);
|
||||
samplesNeeded -= copyCount;
|
||||
buffOffset += copyCount;
|
||||
_bufferOffset += copyCount;
|
||||
}
|
||||
return sampleCount;
|
||||
}
|
||||
|
||||
private:
|
||||
IAPEDecompress * pAPEDecompress;
|
||||
|
||||
NameValueCollection^ _tags;
|
||||
Int64 _sampleCount, _sampleOffset;
|
||||
Int32 _bitsPerSample, _channelCount, _sampleRate;
|
||||
UInt32 _bufferOffset, _bufferLength;
|
||||
int nBlockAlign;
|
||||
array<unsigned char>^ _samplesBuffer;
|
||||
String^ _path;
|
||||
Stream^ _IO;
|
||||
array<unsigned char>^ _readBuffer;
|
||||
CWinFileIO* _winFileIO;
|
||||
GCHandle _gchIO, _gchReadBuffer;
|
||||
|
||||
property UInt32 SamplesInBuffer
|
||||
{
|
||||
UInt32 get ()
|
||||
{
|
||||
return (UInt32) (_bufferLength - _bufferOffset);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
public ref class APEWriter : IAudioDest
|
||||
{
|
||||
public:
|
||||
APEWriter(String^ path, Int32 bitsPerSample, Int32 channelCount, Int32 sampleRate)
|
||||
{
|
||||
if (channelCount != 1 && channelCount != 2)
|
||||
throw gcnew Exception("Only stereo and mono audio formats are allowed.");
|
||||
if (bitsPerSample != 16 && bitsPerSample != 24)
|
||||
throw gcnew Exception("Monkey's Audio doesn't support selected bits per sample value.");
|
||||
|
||||
_path = path;
|
||||
_tags = gcnew NameValueCollection();
|
||||
_winFileIO = NULL;
|
||||
|
||||
_compressionLevel = COMPRESSION_LEVEL_NORMAL;
|
||||
|
||||
_bitsPerSample = bitsPerSample;
|
||||
_channelCount = channelCount;
|
||||
_sampleRate = sampleRate;
|
||||
_blockAlign = _channelCount * ((_bitsPerSample + 7) / 8);
|
||||
|
||||
int nRetVal;
|
||||
pAPECompress = CreateIAPECompress (&nRetVal);
|
||||
if (!pAPECompress)
|
||||
throw gcnew Exception("Unable to open APE compressor.");
|
||||
}
|
||||
|
||||
~APEWriter()
|
||||
{
|
||||
if (_winFileIO)
|
||||
delete _winFileIO;
|
||||
if (_gchIO.IsAllocated)
|
||||
_gchIO.Free();
|
||||
if (_gchBuffer.IsAllocated)
|
||||
_gchBuffer.Free();
|
||||
}
|
||||
|
||||
virtual void Close()
|
||||
{
|
||||
if (pAPECompress)
|
||||
{
|
||||
pAPECompress->Finish (NULL, 0, 0);
|
||||
delete pAPECompress;
|
||||
pAPECompress = NULL;
|
||||
}
|
||||
|
||||
if ((_finalSampleCount != 0) && (_samplesWritten != _finalSampleCount)) {
|
||||
throw gcnew Exception("Samples written differs from the expected sample count.");
|
||||
}
|
||||
|
||||
if (_tags->Count > 0)
|
||||
{
|
||||
APETagDotNet^ apeTag = gcnew APETagDotNet (_IO, true);
|
||||
apeTag->SetStringTags (_tags, true);
|
||||
apeTag->Save();
|
||||
apeTag->Close();
|
||||
_tags->Clear ();
|
||||
}
|
||||
|
||||
if (_IO != nullptr)
|
||||
{
|
||||
_IO->Close ();
|
||||
_IO = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
virtual void Delete()
|
||||
{
|
||||
try { Close (); } catch (Exception^) {}
|
||||
File::Delete(_path);
|
||||
}
|
||||
|
||||
virtual property Int64 FinalSampleCount
|
||||
{
|
||||
Int64 get()
|
||||
{
|
||||
return _finalSampleCount;
|
||||
}
|
||||
void set(Int64 value)
|
||||
{
|
||||
if (value < 0)
|
||||
throw gcnew Exception("Invalid final sample count.");
|
||||
if (_initialized)
|
||||
throw gcnew Exception("Final sample count cannot be changed after encoding begins.");
|
||||
_finalSampleCount = value;
|
||||
}
|
||||
}
|
||||
|
||||
virtual property Int64 BlockSize
|
||||
{
|
||||
void set(Int64 value)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
virtual property int BitsPerSample
|
||||
{
|
||||
int get() { return _bitsPerSample; }
|
||||
}
|
||||
|
||||
virtual void Write(array<Int32,2>^ buff, UInt32 sampleCount)
|
||||
{
|
||||
if (_sampleBuffer == nullptr || _sampleBuffer.Length < sampleCount * _blockAlign)
|
||||
_sampleBuffer = gcnew array<unsigned char>(sampleCount * _blockAlign);
|
||||
AudioSamples::FLACSamplesToBytes(buff, 0, _sampleBuffer, 0, sampleCount, _channelCount, _bitsPerSample);
|
||||
if (!_initialized) Initialize();
|
||||
pin_ptr<unsigned char> pSampleBuffer = &_sampleBuffer[0];
|
||||
if (pAPECompress->AddData (pSampleBuffer, sampleCount * _blockAlign))
|
||||
throw gcnew Exception("An error occurred while encoding.");
|
||||
_samplesWritten += sampleCount;
|
||||
}
|
||||
|
||||
virtual property String^ Path
|
||||
{
|
||||
String^ get() {
|
||||
return _path;
|
||||
}
|
||||
}
|
||||
|
||||
virtual bool SetTags (NameValueCollection^ tags)
|
||||
{
|
||||
_tags = tags;
|
||||
return true;
|
||||
}
|
||||
|
||||
property Int32 CompressionLevel {
|
||||
Int32 get() {
|
||||
return _compressionLevel;
|
||||
}
|
||||
void set(Int32 value) {
|
||||
if ((value < 1) || (value > 5)) {
|
||||
throw gcnew Exception("Invalid compression mode.");
|
||||
}
|
||||
_compressionLevel = value * 1000;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
IAPECompress * pAPECompress;
|
||||
bool _initialized;
|
||||
Int32 _finalSampleCount, _samplesWritten;
|
||||
Int32 _bitsPerSample, _channelCount, _sampleRate, _blockAlign;
|
||||
Int32 _compressionLevel;
|
||||
NameValueCollection^ _tags;
|
||||
String^ _path;
|
||||
Stream^ _IO;
|
||||
GCHandle _gchIO, _gchBuffer;
|
||||
CWinFileIO* _winFileIO;
|
||||
array<unsigned char>^ _writeBuffer;
|
||||
array<unsigned char>^ _sampleBuffer;
|
||||
|
||||
void Initialize() {
|
||||
_IO = gcnew FileStream (_path, FileMode::Create, FileAccess::ReadWrite, FileShare::Read);
|
||||
_writeBuffer = gcnew array<unsigned char>(0x4000);
|
||||
|
||||
_gchIO = GCHandle::Alloc(_IO);
|
||||
_gchBuffer = GCHandle::Alloc(_writeBuffer);
|
||||
_winFileIO = new CWinFileIO(_gchIO, _gchBuffer);
|
||||
|
||||
WAVEFORMATEX waveFormat;
|
||||
FillWaveFormatEx (&waveFormat, _sampleRate, _bitsPerSample, _channelCount);
|
||||
|
||||
int res = pAPECompress->StartEx (_winFileIO,
|
||||
&waveFormat,
|
||||
(_finalSampleCount == 0) ? MAX_AUDIO_BYTES_UNKNOWN : _finalSampleCount * _blockAlign,
|
||||
_compressionLevel,
|
||||
NULL,
|
||||
CREATE_WAV_HEADER_ON_DECOMPRESSION);
|
||||
if (res)
|
||||
throw gcnew Exception("Unable to create the encoder.");
|
||||
|
||||
_initialized = true;
|
||||
}
|
||||
};
|
||||
|
||||
int CWinFileIO::Read(void * pBuffer, unsigned int nBytesToRead, unsigned int * pBytesRead)
|
||||
{
|
||||
array<unsigned char>^ buff = (array<unsigned char>^) _gchBuffer.Target;
|
||||
if (buff->Length < nBytesToRead)
|
||||
{
|
||||
Array::Resize (buff, nBytesToRead);
|
||||
_gchBuffer.Target = buff;
|
||||
}
|
||||
int len = ((Stream^)_gchIO.Target)->Read (buff, 0, nBytesToRead);
|
||||
if (len) Marshal::Copy (buff, 0, (IntPtr)pBuffer, len);
|
||||
*pBytesRead = len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CWinFileIO::Write(const void * pBuffer, unsigned int nBytesToWrite, unsigned int * pBytesWritten)
|
||||
{
|
||||
array<unsigned char>^ buff = (array<unsigned char>^) _gchBuffer.Target;
|
||||
if (buff->Length < nBytesToWrite)
|
||||
{
|
||||
Array::Resize (buff, nBytesToWrite);
|
||||
_gchBuffer.Target = buff;
|
||||
}
|
||||
Marshal::Copy ((IntPtr)(void*)pBuffer, buff, 0, nBytesToWrite);
|
||||
((Stream^)_gchIO.Target)->Write (buff, 0, nBytesToWrite);
|
||||
*pBytesWritten = nBytesToWrite;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CWinFileIO::GetPosition()
|
||||
{
|
||||
return ((Stream^)_gchIO.Target)->Position;
|
||||
}
|
||||
|
||||
int CWinFileIO::GetSize()
|
||||
{
|
||||
return ((Stream^)_gchIO.Target)->Length;
|
||||
}
|
||||
|
||||
int CWinFileIO::Seek(int delta, unsigned int mode)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
case FILE_BEGIN:
|
||||
((Stream^)_gchIO.Target)->Seek (delta, System::IO::SeekOrigin::Begin);
|
||||
break;
|
||||
case FILE_END:
|
||||
((Stream^)_gchIO.Target)->Seek (delta, System::IO::SeekOrigin::End);
|
||||
break;
|
||||
case FILE_CURRENT:
|
||||
((Stream^)_gchIO.Target)->Seek (delta, System::IO::SeekOrigin::Current);
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
extern "C"
|
||||
{
|
||||
BOOL GetMMXAvailable();
|
||||
int CalculateDotProduct8(const short* pA, const short* pB, int nOrder);
|
||||
};
|
||||
|
||||
public ref class SSE2Functions
|
||||
{
|
||||
public:
|
||||
SSE2Functions ()
|
||||
{
|
||||
_haveSSE2 = GetMMXAvailable();
|
||||
}
|
||||
int SumInts (short*a, short*b, int count)
|
||||
{
|
||||
if (_haveSSE2 && count == 8)
|
||||
return CalculateDotProduct8(a, b, count);
|
||||
int sum = 0;
|
||||
for (int j = 0; j < count; j++)
|
||||
sum += a[j] * b[j];
|
||||
return sum;
|
||||
}
|
||||
int SumInts (int*a, short*b, int count)
|
||||
{
|
||||
int sum = 0;
|
||||
for (int j = 0; j < count; j++)
|
||||
sum += a[j] * b[j];
|
||||
return sum;
|
||||
}
|
||||
private:
|
||||
bool _haveSSE2;
|
||||
};
|
||||
#endif
|
||||
}}}
|
||||
Reference in New Issue
Block a user