winamp/Src/Plugins/Input/in_cdda/DAEPlay.cpp

423 lines
11 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
#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;
}