423 lines
11 KiB
C++
423 lines
11 KiB
C++
#include "DAEPlay.h"
|
|
#include "api__in_cdda.h"
|
|
#include "../nu/AutoWide.h"
|
|
#include <strsafe.h>
|
|
|
|
int DAEPlay::getTrackInfo()
|
|
{
|
|
CDROM_TOC tableOfContents = {0};
|
|
DWORD tocSize = sizeof(tableOfContents);
|
|
|
|
if (!DeviceIoControl(hDrive, IOCTL_CDROM_READ_TOC, NULL, 0, &tableOfContents, tocSize, &tocSize, 0))
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
for (int i = tableOfContents.FirstTrack - 1 ; i < tableOfContents.LastTrack ; i += 1)
|
|
{
|
|
if (i == g_track)
|
|
{
|
|
track_length = MSFToBlocks(tableOfContents.TrackData[i+1].Address) - (start_address = MSFToBlocks(tableOfContents.TrackData[i].Address));
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
DAEPlay::CDTextArray* DAEPlay::getCDText()
|
|
{
|
|
// if we've already cached it, return asap
|
|
if (cd_text != 0)
|
|
{
|
|
return cd_text;
|
|
}
|
|
|
|
CDROM_TOC tableOfContents = {0};
|
|
DWORD tocSize = sizeof(tableOfContents), returned = 0;
|
|
|
|
if (!DeviceIoControl(hDrive, IOCTL_CDROM_READ_TOC, NULL, 0, &tableOfContents, tocSize, &tocSize, 0))
|
|
{
|
|
// issue accessing drive
|
|
return (cd_text = (CDTextArray *)-1);
|
|
}
|
|
|
|
// MMC-3 Draft Revision 10g: Table 222 Q Sub-channel control field
|
|
tableOfContents.TrackData[0].Control &= 5;
|
|
if (!(tableOfContents.TrackData[0].Control == 0/* || tableOfContents.TrackData[0 - 1].Control == 1*/))
|
|
{
|
|
// invalid format
|
|
return (cd_text = (CDTextArray *)-1);
|
|
}
|
|
|
|
CDROM_READ_TOC_EX tableOfContentsEx = {0};
|
|
tableOfContentsEx.Format = CDROM_READ_TOC_EX_FORMAT_CDTEXT;
|
|
WORD tocSizeEx = 0;
|
|
// Read the contents to get the size of the actual data
|
|
if (!DeviceIoControl(hDrive, IOCTL_CDROM_READ_TOC_EX, &tableOfContentsEx, sizeof(tableOfContentsEx), &tocSizeEx, sizeof(tocSizeEx), &returned, 0))
|
|
{
|
|
// issue accessing drive
|
|
return (cd_text = (CDTextArray *)-1);
|
|
}
|
|
|
|
// The bytes are swapped so we need to switch them around
|
|
tocSizeEx = ((tocSizeEx>>8) | (tocSizeEx<<8)) + sizeof(tocSizeEx);
|
|
|
|
// Allocate a buffer for reading the actual CD Text data block
|
|
char *pCDTextData = new char[tocSizeEx];
|
|
if (!pCDTextData)
|
|
{
|
|
return (cd_text = (CDTextArray *)-1);
|
|
}
|
|
|
|
memset(pCDTextData, 0, tocSizeEx);
|
|
|
|
// Now read the data
|
|
if(!DeviceIoControl(hDrive, IOCTL_CDROM_READ_TOC_EX, &tableOfContentsEx, sizeof(tableOfContentsEx), pCDTextData, tocSizeEx, &returned, 0))
|
|
{
|
|
delete []pCDTextData;
|
|
return (cd_text = (CDTextArray *)-1);
|
|
}
|
|
|
|
tocSizeEx = (WORD)(returned - sizeof(CDROM_TOC_CD_TEXT_DATA));
|
|
|
|
if(!tocSizeEx)
|
|
{
|
|
delete []pCDTextData;
|
|
return (cd_text = (CDTextArray *)-1);
|
|
}
|
|
|
|
// This is the stuff we really need. It's an array of packs with the data (mostly text)
|
|
CDROM_TOC_CD_TEXT_DATA_BLOCK* pCDTextBlock = ((CDROM_TOC_CD_TEXT_DATA*)(BYTE*)pCDTextData)->Descriptors;
|
|
|
|
// As we go through the packets we'll store the strings in this array. The strings are often in different packets and need to be concatenated together.
|
|
cd_text = new CDTextArray[CD_TEXT_NUM_PACKS];
|
|
UINT m_nGenreCode = -1;
|
|
|
|
// Loop through all the packets extracting the data we need. Each packet starts with a packet type, the track number, language code,
|
|
// character offset, and character size. The packets end with a 2 byte CRC. We don't need most of this stuff to display the info. We can get
|
|
// the packets for any track and they'll have all the data for each track (it's duplicated).
|
|
for( ;tocSizeEx >= sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK); tocSizeEx -= sizeof(CDROM_TOC_CD_TEXT_DATA_BLOCK), pCDTextBlock++)
|
|
{
|
|
if (pCDTextBlock->TrackNumber > tableOfContents.LastTrack) // Track is beyond what is on the disc
|
|
continue;
|
|
|
|
// Only looking for CD Text item packets
|
|
if ((pCDTextBlock->PackType -= 0x80) >= 0x10)
|
|
continue;
|
|
|
|
// Genre is encoded with the code and the supplemental text in the same packet
|
|
if (m_nGenreCode == -1 && pCDTextBlock->PackType == CD_TEXT_GENRE)
|
|
{
|
|
// TODO
|
|
m_nGenreCode = pCDTextBlock->Text[0]*16 + pCDTextBlock->Text[1];
|
|
/*CString Text = !pCDTextBlock->Unicode
|
|
? CString(CStringA((CHAR*)pCDTextBlock->Text+2, CD_TEXT_FIELD_LENGTH-2))
|
|
: CString(CStringW((WCHAR*)pCDTextBlock->WText+2, CD_TEXT_FIELD_LENGTH-2));
|
|
cd_text[pCDTextBlock->PackType][0] = Text;*/
|
|
}
|
|
else
|
|
{
|
|
// Parse the text. There could be more than one item in the text block separated by null bytes so we need to check the whole thing
|
|
// The text is in a block of up to 12 characters. We'll just keep adding to our buffers until we go through all of the packets.
|
|
int nLengthRemaining = CD_TEXT_FIELD_LENGTH;
|
|
UINT nTrack = pCDTextBlock->TrackNumber;
|
|
UINT nOffset = 0;
|
|
// We're at the end of text when:
|
|
// Used up 12 chars
|
|
// Got to a null
|
|
// On the last track
|
|
while (nTrack <= tableOfContents.LastTrack && nLengthRemaining > 0 && nOffset < CD_TEXT_FIELD_LENGTH)
|
|
{
|
|
wchar_t *text = (wchar_t*)calloc(nLengthRemaining + 1, sizeof(wchar_t));
|
|
if (!text) continue;
|
|
|
|
lstrcpyn(text, (pCDTextBlock->Unicode ? pCDTextBlock->WText + nOffset : AutoWide((char *)pCDTextBlock->Text + nOffset)), nLengthRemaining + 1);
|
|
|
|
if (!cd_text[pCDTextBlock->PackType][nTrack])
|
|
cd_text[pCDTextBlock->PackType][nTrack] = (wchar_t*)calloc(lstrlen(text) + 1, sizeof(wchar_t));
|
|
else // TODO error handling
|
|
cd_text[pCDTextBlock->PackType][nTrack] = (wchar_t*)realloc(cd_text[pCDTextBlock->PackType][nTrack], (lstrlen(cd_text[pCDTextBlock->PackType][nTrack]) + lstrlen(text) + 1) * sizeof(wchar_t));
|
|
|
|
if (text[0])
|
|
lstrcat(cd_text[pCDTextBlock->PackType][nTrack], text);
|
|
|
|
nOffset += lstrlen(text) + 1;
|
|
nLengthRemaining = nLengthRemaining - lstrlen(text) - 1;
|
|
++nTrack;
|
|
free(text);
|
|
}
|
|
}
|
|
} while (0);
|
|
|
|
delete []pCDTextData;
|
|
return cd_text;
|
|
}
|
|
|
|
int DAEPlay::threadProc2()
|
|
{
|
|
while (1)
|
|
{
|
|
if (need_seek != -1)
|
|
{
|
|
current_sector = ((need_seek * CD_BLOCKS_PER_SECOND) / 1000) / DEF_SECTORS_PER_READ;
|
|
bytes_in_sbuf = 0;
|
|
line.outMod->Flush(need_seek);
|
|
need_seek = -1;
|
|
}
|
|
|
|
if (fillBuffer(killswitch))
|
|
{
|
|
PostMessage(line.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
|
|
return 0;
|
|
}
|
|
|
|
if (!bytes_in_sbuf && !killswitch)
|
|
{
|
|
//wait for output to be finished
|
|
line.outMod->Write(NULL, 0);
|
|
while (!killswitch && line.outMod->IsPlaying()) Sleep(10);
|
|
if (!killswitch)
|
|
{
|
|
CloseHandle(hDrive);
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
PostMessage(line.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (killswitch)
|
|
{
|
|
CloseHandle(hDrive);
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
char sample_buffer[576*4*2] = {0};
|
|
int bytes = sizeof(sample_buffer) / 2; // enough room for dsp bullcrap
|
|
bytes = min((int)bytes_in_sbuf, (int)bytes);
|
|
memcpy(sample_buffer, sbuf, bytes);
|
|
if (bytes_in_sbuf > bytes) memcpy(sbuf, sbuf + bytes, bytes_in_sbuf - bytes);
|
|
bytes_in_sbuf -= bytes;
|
|
|
|
line.VSAAddPCMData(sample_buffer, g_nch, 16, line.outMod->GetWrittenTime());
|
|
line.SAAddPCMData(sample_buffer, g_nch, 16, line.outMod->GetWrittenTime());
|
|
|
|
if (line.dsp_isactive())
|
|
bytes = line.dsp_dosamples((short *)sample_buffer, bytes / g_nch / 2, 16, g_nch, 44100) * (g_nch * 2);
|
|
|
|
while (line.outMod->CanWrite() < bytes && !killswitch) Sleep(66);
|
|
if (killswitch)
|
|
{
|
|
CloseHandle(hDrive);
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
line.outMod->Write(sample_buffer, bytes);
|
|
}
|
|
|
|
CloseHandle(hDrive);
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
void DAEPlay::stop()
|
|
{
|
|
if (hThread)
|
|
{
|
|
killswitch = 1;
|
|
WaitForSingleObject(hThread, INFINITE);
|
|
}
|
|
|
|
line.outMod->Close();
|
|
}
|
|
|
|
int DAEPlay::open(wchar_t drive, int track) //called by winampGetExtendedRead
|
|
{
|
|
g_track = track-1;
|
|
if (g_track < 0)
|
|
return 1;
|
|
|
|
g_drive = drive;
|
|
|
|
wchar_t CDDevice[8]=L"\\\\.\\x:";
|
|
CDDevice[4] = drive;
|
|
|
|
if (hDrive != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hDrive);
|
|
|
|
hDrive = CreateFile(CDDevice, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hDrive == INVALID_HANDLE_VALUE)
|
|
return 1;
|
|
|
|
// TODO only store the request track!
|
|
if (getTrackInfo())
|
|
return 1;
|
|
|
|
g_playlength = (track_length / CD_BLOCKS_PER_SECOND) * 1000;
|
|
|
|
bytes_in_sbuf = 0;
|
|
|
|
if (!sbuf)
|
|
sbuf = (unsigned char *)malloc(2352 * buf_size);
|
|
if (!sbuf)
|
|
return 1;
|
|
|
|
data = new BYTE[DEF_SECTORS_PER_READ * CDROM_RAW_BYTES_PER_SECTOR];
|
|
if (!data)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int DAEPlay::play(wchar_t drive, int track) //called by winamp2's normal(old) play() interface
|
|
{
|
|
int old_drive = g_drive;
|
|
|
|
if (open(drive, track)) return 1;
|
|
|
|
// do this here as it helps to prevent an audio glitch on first playback and volume is set low
|
|
setvolume(a_v, a_p);
|
|
|
|
int maxlat = line.outMod->Open(44100, g_nch, 16, -1, -1);
|
|
if (maxlat < 0)
|
|
{
|
|
g_drive = 0;
|
|
return 1;
|
|
}
|
|
|
|
// to prevent re-spinning as we're not going to get cd-text later
|
|
// if it's not able to be obtained when first opening the device.
|
|
if (old_drive != drive)
|
|
{
|
|
if ((int)cd_text > 0)
|
|
delete []cd_text;
|
|
cd_text = NULL;
|
|
getCDText();
|
|
}
|
|
|
|
line.SetInfo(1411, 44, g_nch, 1);
|
|
line.SAVSAInit(maxlat, 44100);
|
|
line.VSASetInfo(g_nch, 44100);
|
|
line.is_seekable = 1;
|
|
|
|
bytes_in_sbuf = 0;
|
|
current_sector = 0;
|
|
killswitch = 0;
|
|
DWORD thread_id = 0;
|
|
hThread = CreateThread(NULL, NULL, &threadProc, (LPVOID)this, NULL, &thread_id);
|
|
SetThreadPriority(hThread, AGAVE_API_CONFIG->GetInt(playbackConfigGroupGUID, L"priority", THREAD_PRIORITY_HIGHEST));
|
|
|
|
//open the device thru MCI (for getfileinfo to work properly)
|
|
g_playtrack = track;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int DAEPlay::fillBuffer(int kill)
|
|
{
|
|
if (!kill && bytes_in_sbuf <= 0)
|
|
{
|
|
if (current_sector < (track_length / DEF_SECTORS_PER_READ))
|
|
{
|
|
// Contains an offset into the CD-ROM disc where data will be read. You can calculate this offset by multiplying the starting sector number for the request times 2048.
|
|
RAW_READ_INFO _RawReadInfo = {0};
|
|
_RawReadInfo.DiskOffset.QuadPart = ((current_sector * DEF_SECTORS_PER_READ) + start_address) * CDROM_COOKED_BYTES_PER_SECTOR;
|
|
_RawReadInfo.TrackMode = CDDA;
|
|
_RawReadInfo.SectorCount = DEF_SECTORS_PER_READ;
|
|
|
|
DWORD data_length = DEF_SECTORS_PER_READ * CDROM_RAW_BYTES_PER_SECTOR;
|
|
if (!DeviceIoControl(hDrive, IOCTL_CDROM_RAW_READ, &_RawReadInfo, sizeof(_RawReadInfo),
|
|
data, data_length, &data_length, 0))
|
|
{
|
|
CloseHandle(hDrive);
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
return 1;
|
|
}
|
|
|
|
// TODO make sure the buffer size is enough for our needs
|
|
memcpy(sbuf, data, DEF_SECTORS_PER_READ * CDROM_RAW_BYTES_PER_SECTOR);
|
|
bytes_in_sbuf += DEF_SECTORS_PER_READ * CDROM_RAW_BYTES_PER_SECTOR;
|
|
}
|
|
current_sector++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int DAEPlay::read(char *dest, int len, int *killswitch) //called by winampGetExtendedRead_getData
|
|
{
|
|
int l = 0;
|
|
|
|
// TODO make sure this will handle a CD ejection...
|
|
while (l < len && !*killswitch)
|
|
{
|
|
if (fillBuffer(*killswitch))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (!bytes_in_sbuf) break;
|
|
|
|
int bytes = min(bytes_in_sbuf, len - l);
|
|
memcpy(dest + l, sbuf, bytes);
|
|
|
|
if (bytes_in_sbuf > bytes) memcpy(sbuf, sbuf + bytes, bytes_in_sbuf - bytes);
|
|
bytes_in_sbuf -= bytes;
|
|
|
|
l += bytes;
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
DAEPlay::DAEPlay()
|
|
{
|
|
sbuf = NULL;
|
|
data = NULL;
|
|
cd_text = NULL;
|
|
bytes_in_sbuf = 0;
|
|
buf_size = 64; //make it configitem
|
|
g_track = -1;
|
|
|
|
// fix these three as that's normal
|
|
g_nch = 2;
|
|
g_srate = 44100;
|
|
g_bps = 16;
|
|
|
|
killswitch = 0;
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
hThread = NULL;
|
|
need_seek = -1;
|
|
current_sector = 0;
|
|
start_address = 0;
|
|
track_length = 0;
|
|
}
|
|
|
|
DAEPlay::~DAEPlay()
|
|
{
|
|
if (hDrive != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(hDrive);
|
|
hDrive = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (sbuf)
|
|
{
|
|
free(sbuf);
|
|
sbuf = NULL;
|
|
}
|
|
|
|
if (data)
|
|
{
|
|
delete []data;
|
|
data = NULL;
|
|
}
|
|
|
|
if ((int)cd_text > 0)
|
|
{
|
|
delete []cd_text;
|
|
}
|
|
cd_text = NULL;
|
|
} |