static bool_t Load(ape* p)
{
format_reader* Reader = p->Format.Reader;
char Path8[MAXPATH];
tchar_t Path[MAXPATH];
int errorCode = 0;
int size;
wchar_t* PathW;
Reader->Input->Get(Reader->Input,STREAM_URL,Path,sizeof(Path));
TcsToStr(Path8,sizeof(Path8),Path);
size = sizeof(wchar_t) * strlen(Path8);
PathW = (wchar_t*)malloc(size);
size = mbstowcs(PathW, Path8, size);
p->Decoder = CreateIAPEDecompress(PathW, &errorCode);
free(PathW);
if (!p->Decoder)
{
#if defined(TARGET_WINCE) || defined(TARGET_WIN32)
TCHAR cNumber[255]; _stprintf(cNumber, _T("Could not load decoder, Error code: %d"), errorCode);
MessageBox(NULL, cNumber, L"Error", MB_OK);
#endif
return 0;
}
return 1;
}
EmErrorCode MacDecoder::Open(const string& url)
{
int err;
str_utf16* pFileName = GetUTF16FromUTF8((str_utf8*)url.c_str());
m_pDecompress = CreateIAPEDecompress(pFileName, &err);
delete[] pFileName;
if (m_pDecompress == nullptr || err != ERROR_SUCCESS)
return ErrorCode::DecoderFailedToOpen;
m_Channels = m_pDecompress->GetInfo(APE_INFO_CHANNELS);
m_SampleRate = m_pDecompress->GetInfo(APE_INFO_SAMPLE_RATE);
m_BitsPerSample = m_pDecompress->GetInfo(APE_INFO_BITS_PER_SAMPLE);
m_Duration = m_pDecompress->GetInfo(APE_INFO_LENGTH_MS);
m_BlockAlign = m_pDecompress->GetInfo(APE_INFO_BLOCK_ALIGN);
m_BlocksPerFrame = m_pDecompress->GetInfo(APE_INFO_BLOCKS_PER_FRAME);
m_BlockCount = m_pDecompress->GetInfo(APE_INFO_TOTAL_BLOCKS);
m_BlocksPerRead = m_BlocksPerFrame / 16;
m_BlockIndex = 0;
return ErrorCode::Ok;
}
bool CMyAPEInfo::ReadFileData(CSongMetaData & MetaData) const
{
int nRetVal=0;
#ifdef __WXMAC__
IAPEDecompress * pAPEDecompress = CreateIAPEDecompress(MetaData.Filename.GetFullPath().mb_str(wxConvFile), &nRetVal);
#else
IAPEDecompress * pAPEDecompress = CreateIAPEDecompress(MetaData.Filename.GetFullPath().wc_str(wxConvFile), &nRetVal);
#endif
if (pAPEDecompress != NULL)
{
MetaData.nBitrate = pAPEDecompress->GetInfo(APE_INFO_AVERAGE_BITRATE);
MetaData.nDuration_ms = pAPEDecompress->GetInfo(APE_DECOMPRESS_LENGTH_MS);
MetaData.nFilesize = pAPEDecompress->GetInfo(APE_INFO_APE_TOTAL_BYTES);
delete pAPEDecompress; /* Delete IAPEDecompress interface */
return true;
}
return false;
}
int __stdcall RemoveTag(char * pFilename)
{
CSmartPtr<wchar_t> spFilename(GetUTF16FromANSI(pFilename), TRUE);
int nErrorCode = ERROR_SUCCESS;
CSmartPtr<IAPEDecompress> spAPEDecompress(CreateIAPEDecompress(spFilename, &nErrorCode));
if (spAPEDecompress == NULL) return -1;
GET_TAG(spAPEDecompress)->Remove(FALSE);
return 0;
}
long __stdcall c_GetAPEDuration(const str_ansi * pFilename)
{
CSmartPtr<wchar_t> spFilename(GetUTF16FromANSI(pFilename), TRUE);
int error;
IAPEDecompress *pDecompress = CreateIAPEDecompress(spFilename, &error);
if (!pDecompress)
return 0;
long ret = pDecompress->GetInfo(APE_INFO_LENGTH_MS, 0, 0);
delete pDecompress;
return ret;
}
bool MUSIKAPEDecoder::OpenMedia(const char *FileName)
{
int nRetVal=0;
CSmartPtr<wchar_t> wsFileName;
wsFileName.Assign(GetUTF16FromANSI(FileName),TRUE);
IAPEDecompress * pAPEDecompress = CreateIAPEDecompress(wsFileName, &nRetVal);
if (pAPEDecompress != NULL)
{
m_ApeInfo.pAPEDecompress = pAPEDecompress;
m_Info.bitrate = pAPEDecompress->GetInfo(APE_INFO_AVERAGE_BITRATE);
m_Info.bits_per_sample = pAPEDecompress->GetInfo(APE_INFO_BITS_PER_SAMPLE);
m_Info.channels = pAPEDecompress->GetInfo(APE_INFO_CHANNELS);
m_Info.frequency = pAPEDecompress->GetInfo(APE_INFO_SAMPLE_RATE);
m_Info.SampleCount = pAPEDecompress->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS);
int bytesPerBlock = m_Info.channels * (m_Info.bits_per_sample >> 3);
int decoder_buffer_size = bytesPerBlock * (int)((APEDecodeBufferSec * pAPEDecompress->GetInfo(APE_INFO_SAMPLE_RATE)) + 0.5);
m_Info.FileSize = pAPEDecompress->GetInfo(APE_INFO_APE_TOTAL_BYTES);
return CreateBuffer(decoder_buffer_size);
}
__declspec(dllexport) HANDLE FAR PASCAL OpenFilterInput( LPSTR lpstrFilename, int far *lSamprate,
WORD far *wBitsPerSample, WORD far *wChannels, HWND hWnd, int far *lChunkSize)
{
///////////////////////////////////////////////////////////////////////////////
// open the APE file
///////////////////////////////////////////////////////////////////////////////
CSmartPtr<wchar_t> spUTF16(CAPECharacterHelper::GetUTF16FromANSI(lpstrFilename), TRUE);
IAPEDecompress * pAPEDecompress = CreateIAPEDecompress(spUTF16);
if (pAPEDecompress == NULL)
return NULL;
*lSamprate= pAPEDecompress->GetInfo(APE_INFO_SAMPLE_RATE);
*wChannels=(WORD) pAPEDecompress->GetInfo(APE_INFO_CHANNELS);
*wBitsPerSample=(WORD) pAPEDecompress->GetInfo(APE_INFO_BITS_PER_SAMPLE);
if (*wBitsPerSample == 24) *wBitsPerSample = 32;
// this doesn't matter (but must be careful to avoid alignment problems)
*lChunkSize = 16384 * (*wBitsPerSample / 8) * *wChannels;
return (HANDLE) pAPEDecompress;
}
int main(int argc, char* argv[])
{
///////////////////////////////////////////////////////////////////////////////
// error check the command line parameters
///////////////////////////////////////////////////////////////////////////////
if (argc != 2)
{
printf("~~~Improper Usage~~~\r\n\r\n");
printf("Usage Example: Sample 1.exe 'c:\\1.ape'\r\n\r\n");
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// variable declares
///////////////////////////////////////////////////////////////////////////////
int nRetVal = 0; // generic holder for return values
char cTempBuffer[256]; ZeroMemory(&cTempBuffer[0], 256); // generic buffer for string stuff
char * pFilename = argv[1]; // the file to open
IAPEDecompress * pAPEDecompress = NULL; // APE interface
CSmartPtr<wchar_t> spInput;
spInput.Assign(GetUTF16FromANSI(argv[1]), TRUE);
//*
///////////////////////////////////////////////////////////////////////////////
// open the file and error check
///////////////////////////////////////////////////////////////////////////////
pAPEDecompress = CreateIAPEDecompress(spInput, &nRetVal);
if (pAPEDecompress == NULL)
{
printf("Error opening APE file. (error code %d)\r\n\r\n", nRetVal);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// display some information about the file
///////////////////////////////////////////////////////////////////////////////
printf("Displaying information about '%s':\r\n\r\n", pFilename);
// file format information
printf("File Format:\r\n");
printf("\tVersion: %.2f\r\n", float(pAPEDecompress->GetInfo(APE_INFO_FILE_VERSION)) / float(1000));
switch (pAPEDecompress->GetInfo(APE_INFO_COMPRESSION_LEVEL))
{
case COMPRESSION_LEVEL_FAST: printf("\tCompression level: Fast\r\n\r\n"); break;
case COMPRESSION_LEVEL_NORMAL: printf("\tCompression level: Normal\r\n\r\n"); break;
case COMPRESSION_LEVEL_HIGH: printf("\tCompression level: High\r\n\r\n"); break;
case COMPRESSION_LEVEL_EXTRA_HIGH: printf("\tCompression level: Extra High\r\n\r\n"); break;
}
// audio format information
printf("Audio Format:\r\n");
printf("\tSamples per second: %" PRIiPTR "\r\n", pAPEDecompress->GetInfo(APE_INFO_SAMPLE_RATE));
printf("\tBits per sample: %" PRIiPTR "\r\n", pAPEDecompress->GetInfo(APE_INFO_BITS_PER_SAMPLE));
printf("\tNumber of channels: %" PRIiPTR "\r\n", pAPEDecompress->GetInfo(APE_INFO_CHANNELS));
printf("\tPeak level: %" PRIiPTR "\r\n\r\n", pAPEDecompress->GetInfo(APE_INFO_PEAK_LEVEL));
// size and duration information
printf("Size and Duration:\r\n");
printf("\tLength of file (s): %" PRIiPTR "\r\n", pAPEDecompress->GetInfo(APE_INFO_LENGTH_MS) / 1000);
printf("\tFile Size (kb): %" PRIiPTR "\r\n\r\n", pAPEDecompress->GetInfo(APE_INFO_APE_TOTAL_BYTES) / 1024);
// tag information
printf("Tag Information:\r\n");
CAPETag * pAPETag = (CAPETag *) pAPEDecompress->GetInfo(APE_INFO_TAG);
BOOL bHasID3Tag = pAPETag->GetHasID3Tag();
BOOL bHasAPETag = pAPETag->GetHasAPETag();
if (bHasID3Tag || bHasAPETag)
{
printf("\tID3 Tag: %s, APE Tag: %s", bHasID3Tag ? "Yes" : "No", bHasAPETag ? "" : "No");
if (bHasAPETag)
{
printf("%d", pAPETag->GetAPETagVersion() / 1000);
}
printf("\n\n");
// iterate through all the tag fields
//BOOL bFirst = TRUE;
CAPETagField * pTagField;
// while (pAPETag->GetNextTagField(bFirst, &pTagField))
int index = 0;
while ((pTagField = pAPETag->GetTagField(index)) != NULL)
{
//bFirst = FALSE;
index ++;
// output the tag field properties (don't output huge fields like images, etc.)
if (pTagField->GetFieldValueSize() > 128)
{
printf("\t%s: --- too much data to display ---\r\n", GetANSIFromUTF16(pTagField->GetFieldName()));
}
else
{
/*
const wchar_t *fieldName;
char *name;
wchar_t fieldValue[255];
char *value;
fieldName = pTagField->GetFieldName();
name = GetANSIFromUTF16(fieldName);
memset(fieldValue, 0, 255 * sizeof(wchar_t));
int len;
pAPETag->GetFieldString(fieldName, fieldValue, &len);
value = GetANSIFromUTF16(fieldValue);
*/
const wchar_t *fieldName;
char *name;
const char *fieldValue;
char *value;
fieldName = pTagField->GetFieldName();
name = GetANSIFromUTF16(fieldName);
fieldValue = pTagField->GetFieldValue();
if (pAPETag->GetAPETagVersion() == CURRENT_APE_TAG_VERSION)
{
value = GetANSIFromUTF8((unsigned char *)fieldValue);
}
else
{
value = (char *)fieldValue;
}
printf("\t%s : %s\n", name, value);
}
}
}
else
{
printf("\tNot tagged\r\n\r\n");
}
///////////////////////////////////////////////////////////////////////////////
// cleanup (just delete the object
///////////////////////////////////////////////////////////////////////////////
delete pAPEDecompress;
///////////////////////////////////////////////////////////////////////////////
// quit
///////////////////////////////////////////////////////////////////////////////
return 0;
}
APE_DECOMPRESS_HANDLE __stdcall c_APEDecompress_CreateW(const str_utf16 * pFilename, int * pErrorCode)
{
return (APE_DECOMPRESS_HANDLE) CreateIAPEDecompress(pFilename, pErrorCode);
}
/*****************************************************************************************
CAPEDecompress wrapper(s)
*****************************************************************************************/
APE_DECOMPRESS_HANDLE __stdcall c_APEDecompress_Create(const str_ansi * pFilename, int * pErrorCode)
{
CSmartPtr<wchar_t> spFilename(GetUTF16FromANSI(pFilename), TRUE);
return (APE_DECOMPRESS_HANDLE) CreateIAPEDecompress(spFilename, pErrorCode);
}
HRESULT ApeDecoder::Open( LPWSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags )
{
//char ex[2048] = "ape";
//if(!isFile_ex(strFileName,ex))
//{
// return M_FILE_EXTENSION_NOT_EXPECTED;//E_FAIL;
//}
if(WAVEFILE_READ != dwFlags)
{
return M_INVALID_PARAMETERS;//E_FAIL;
}
int nRetVal = 0;
m_pAPEDecompress = CreateIAPEDecompress(strFileName,&nRetVal);
if(NULL == m_pAPEDecompress)
{
return M_APE_FAIL_CREATE_DECODER;//E_FAIL;
}
m_block_algin = m_pAPEDecompress->GetInfo(APE_INFO_BLOCK_ALIGN);
m_nWaveDataAllocSize = APE_BLOCKS_NUM * m_block_algin;
m_pWaveDataAlloc = (BYTE*) malloc(m_nWaveDataAllocSize);
m_pWaveDataBuffer = m_pWaveDataAlloc;
m_total_blocks = m_pAPEDecompress->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS);
m_id3.bitrate = m_pAPEDecompress->GetInfo(APE_DECOMPRESS_AVERAGE_BITRATE);
// get and set wave header
nRetVal = m_pAPEDecompress->GetInfo(APE_INFO_WAVEFORMATEX,(int) m_pwfx,0);
if(0 != nRetVal)
{
return M_APE_FAIL_GET_WAVE_INFO;//E_FAIL;
}
m_dwSize = m_pAPEDecompress->GetInfo(APE_INFO_WAV_DATA_BYTES);
if(m_dwSize <= 0)
{
return M_APE_FAIL_GET_INFO;//E_FAIL;
}
m_id3.duration_times = (float)m_dwSize / (float)m_pwfx->nAvgBytesPerSec;
m_id3.EmptyTags();
CAPETag * pAPETag = (CAPETag *) m_pAPEDecompress->GetInfo(APE_INFO_TAG);
BOOL bHasID3Tag = pAPETag->GetHasID3Tag();
BOOL bHasAPETag = pAPETag->GetHasAPETag();
if (bHasID3Tag || bHasAPETag)
{
// iterate through all the tag fields
CAPETagField * pTagField = pAPETag->GetTagField(APE_TAG_FIELD_TITLE);
if(pTagField)
{
/*printf("%X\n",pTagField->GetFieldValue()[0]);
printf("%X\n",pTagField->GetFieldValue()[1]);
printf("%X\n",pTagField->GetFieldValue()[2]);*/
if(pTagField->GetIsUTF8Text())
{
CCharWCharHelper cwh;
cwh.ZMultiByteToWideChar(pTagField->GetFieldValue(),ZUTF8);
m_id3.title.SetData(cwh.GetWideChar(),cwh.GetWideCharLength());
}
else
m_id3.title.SetData(pTagField->GetFieldValue(),strlen(pTagField->GetFieldValue()));
}
pTagField = pAPETag->GetTagField(APE_TAG_FIELD_ARTIST);
if(pTagField)
{
if(pTagField->GetIsUTF8Text())
{
CCharWCharHelper cwh;
cwh.ZMultiByteToWideChar(pTagField->GetFieldValue(),ZUTF8);
m_id3.artist.SetData(cwh.GetWideChar(),cwh.GetWideCharLength());
}
else
m_id3.artist.SetData(pTagField->GetFieldValue(),strlen(pTagField->GetFieldValue()));
}
pTagField = pAPETag->GetTagField(APE_TAG_FIELD_ALBUM);
if(pTagField)
{
if(pTagField->GetIsUTF8Text())
{
CCharWCharHelper cwh;
cwh.ZMultiByteToWideChar(pTagField->GetFieldValue(),ZUTF8);
m_id3.album.SetData(cwh.GetWideChar(),cwh.GetWideCharLength());
}
else
m_id3.album.SetData(pTagField->GetFieldValue(),strlen(pTagField->GetFieldValue()));
}
pTagField = pAPETag->GetTagField(APE_TAG_FIELD_YEAR);
if(pTagField)
{
if(pTagField->GetIsUTF8Text())
{
CCharWCharHelper cwh;
cwh.ZMultiByteToWideChar(pTagField->GetFieldValue(),ZUTF8);
m_id3.year.SetData(cwh.GetWideChar(),cwh.GetWideCharLength());
}
else
m_id3.year.SetData(pTagField->GetFieldValue(),strlen(pTagField->GetFieldValue()));
}
pTagField = pAPETag->GetTagField(APE_TAG_FIELD_COMMENT);
if(pTagField)
{
if(pTagField->GetIsUTF8Text())
{
CCharWCharHelper cwh;
cwh.ZMultiByteToWideChar(pTagField->GetFieldValue(),ZUTF8);
m_id3.comment.SetData(cwh.GetWideChar(),cwh.GetWideCharLength());
}
else
m_id3.comment.SetData(pTagField->GetFieldValue(),strlen(pTagField->GetFieldValue()));
}
pTagField = pAPETag->GetTagField(APE_TAG_FIELD_GENRE);
if(pTagField)
{
if(pTagField->GetIsUTF8Text())
{
CCharWCharHelper cwh;
cwh.ZMultiByteToWideChar(pTagField->GetFieldValue(),ZUTF8);
m_id3.genre.SetData(cwh.GetWideChar(),cwh.GetWideCharLength());
}
else
m_id3.genre.SetData(pTagField->GetFieldValue(),strlen(pTagField->GetFieldValue()));
}
}
return S_OK;
}
int main(int argc, char* argv[])
{
///////////////////////////////////////////////////////////////////////////////
// error check the command line parameters
///////////////////////////////////////////////////////////////////////////////
if (argc != 2)
{
printf("~~~Improper Usage~~~\r\n\r\n");
printf("Usage Example: Sample 1.exe 'c:\\1.ape'\r\n\r\n");
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// variable declares
///////////////////////////////////////////////////////////////////////////////
int nRetVal = 0; // generic holder for return values
char cTempBuffer[256]; ZeroMemory(&cTempBuffer[0], 256); // generic buffer for string stuff
char * pFilename = argv[1]; // the file to open
IAPEDecompress * pAPEDecompress = NULL; // APE interface
///////////////////////////////////////////////////////////////////////////////
// open the file and error check
///////////////////////////////////////////////////////////////////////////////
pAPEDecompress = CreateIAPEDecompress(pFilename, &nRetVal);
if (pAPEDecompress == NULL)
{
printf("Error opening APE file. (error code %d)\r\n\r\n", nRetVal);
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// display some information about the file
///////////////////////////////////////////////////////////////////////////////
printf("Displaying information about '%s':\r\n\r\n", pFilename);
// file format information
printf("File Format:\r\n");
printf("\tVersion: %.2f\r\n", float(pAPEDecompress->GetInfo(APE_INFO_FILE_VERSION)) / float(1000));
switch (pAPEDecompress->GetInfo(APE_INFO_COMPRESSION_LEVEL))
{
case COMPRESSION_LEVEL_FAST: printf("\tCompression level: Fast\r\n\r\n"); break;
case COMPRESSION_LEVEL_NORMAL: printf("\tCompression level: Normal\r\n\r\n"); break;
case COMPRESSION_LEVEL_HIGH: printf("\tCompression level: High\r\n\r\n"); break;
case COMPRESSION_LEVEL_EXTRA_HIGH: printf("\tCompression level: Extra High\r\n\r\n"); break;
}
// audio format information
printf("Audio Format:\r\n");
printf("\tSamples per second: %d\r\n", pAPEDecompress->GetInfo(APE_INFO_SAMPLE_RATE));
printf("\tBits per sample: %d\r\n", pAPEDecompress->GetInfo(APE_INFO_BITS_PER_SAMPLE));
printf("\tNumber of channels: %d\r\n", pAPEDecompress->GetInfo(APE_INFO_CHANNELS));
printf("\tPeak level: %d\r\n\r\n", pAPEDecompress->GetInfo(APE_INFO_PEAK_LEVEL));
// size and duration information
printf("Size and Duration:\r\n");
printf("\tLength of file (s): %d\r\n", pAPEDecompress->GetInfo(APE_INFO_LENGTH_MS) / 1000);
printf("\tFile Size (kb): %d\r\n\r\n", pAPEDecompress->GetInfo(APE_INFO_APE_TOTAL_BYTES) / 1024);
// tag information
printf("Tag Information:\r\n");
CAPETag * pAPETag = (CAPETag *) pAPEDecompress->GetInfo(APE_INFO_TAG);
BOOL bHasID3Tag = pAPETag->GetHasID3Tag();
BOOL bHasAPETag = pAPETag->GetHasAPETag();
if (bHasID3Tag || bHasAPETag)
{
// iterate through all the tag fields
BOOL bFirst = TRUE;
CAPETagField * pTagField;
while (pAPETag->GetNextTagField(bFirst, &pTagField))
{
bFirst = FALSE;
// output the tag field properties (don't output huge fields like images, etc.)
if (pTagField->GetFieldValueSize() > 128)
{
printf("\t%s: --- too much data to display ---\r\n", pTagField->GetFieldName());
}
else
{
printf("\t%s: %s\r\n", pTagField->GetFieldName(), pTagField->GetFieldValue());
}
}
}
else
{
printf("\tNot tagged\r\n\r\n");
}
///////////////////////////////////////////////////////////////////////////////
// cleanup (just delete the object
///////////////////////////////////////////////////////////////////////////////
delete pAPEDecompress;
///////////////////////////////////////////////////////////////////////////////
// quit
///////////////////////////////////////////////////////////////////////////////
return 0;
}
