diff options
Diffstat (limited to 'Src/Plugins/Input/in_cdda/DAEPlay.cpp')
| -rw-r--r-- | Src/Plugins/Input/in_cdda/DAEPlay.cpp | 423 |
1 files changed, 423 insertions, 0 deletions
diff --git a/Src/Plugins/Input/in_cdda/DAEPlay.cpp b/Src/Plugins/Input/in_cdda/DAEPlay.cpp new file mode 100644 index 00000000..30495ab9 --- /dev/null +++ b/Src/Plugins/Input/in_cdda/DAEPlay.cpp @@ -0,0 +1,423 @@ +#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; +}
\ No newline at end of file |