mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-12-04 20:31:01 -05:00
686 lines
No EOL
22 KiB
C++
686 lines
No EOL
22 KiB
C++
#include "./playlist.h"
|
|
#include "../Agave/DecodeFile/ifc_audiostream.h"
|
|
#include <strsafe.h>
|
|
#include "../winamp/wa_ipc.h"
|
|
|
|
BurnerPlaylist::BurnerPlaylist()
|
|
{
|
|
evntCancel = NULL;
|
|
}
|
|
|
|
BurnerPlaylist::~BurnerPlaylist()
|
|
{
|
|
if (manager.GetDecodeAPI())
|
|
{
|
|
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(decodeFileGUID);
|
|
factory->releaseInterface(manager.GetDecodeAPI());
|
|
manager.SetDecodeAPI(NULL);
|
|
}
|
|
clear();
|
|
}
|
|
|
|
HRESULT BurnerPlaylist::Load(const wchar_t *filename)
|
|
{
|
|
if (!WASABI_API_SVC) return PLAYLISTMANAGER_FAILED;
|
|
waServiceFactory *plmFactory = WASABI_API_SVC->service_getServiceByGuid(api_playlistmanagerGUID);
|
|
if (!plmFactory) return 0;
|
|
api_playlistmanager *plManager = (api_playlistmanager*)plmFactory->getInterface();
|
|
if (!plManager) return 0;
|
|
length = 0;
|
|
int retCode = plManager->Load(filename, this);
|
|
return (PLAYLISTMANAGER_SUCCESS == retCode);
|
|
}
|
|
|
|
DWORD BurnerPlaylist::GetTotalSectors(void)
|
|
{
|
|
DWORD ts = 0;
|
|
for(size_t i = 0; i < GetCount(); i++)
|
|
{
|
|
ts += BurnerVector::at(i)->GetSizeInSectors();
|
|
}
|
|
return ts;
|
|
}
|
|
DWORD BurnerPlaylist::GetStatus(DWORD *retCode)
|
|
{
|
|
if(retCode) *retCode = errorCode;
|
|
return statusCode;
|
|
}
|
|
|
|
size_t BurnerPlaylist::GetStateCount(DWORD state, DWORD code)
|
|
{
|
|
size_t count = 0;
|
|
for (size_t i = 0; i < GetCount(); i++)
|
|
{
|
|
if (BurnerVector::at(i)->itemStatus == state && BurnerVector::at(i)->errorCode == code) count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
DWORD BurnerPlaylist::GetStateLengthMS(DWORD state, DWORD code)
|
|
{
|
|
DWORD len = 0;
|
|
for (size_t i = 0; i < GetCount(); i++)
|
|
{
|
|
if (BurnerVector::at(i)->itemStatus == state && BurnerVector::at(i)->errorCode == code) len += BurnerVector::at(i)->GetLength();
|
|
}
|
|
return len;
|
|
}
|
|
|
|
DWORD BurnerPlaylist::GetStateSectors(DWORD state, DWORD code)
|
|
{
|
|
DWORD ts = 0;
|
|
for(size_t i = 0; i < GetCount(); i++)
|
|
{
|
|
if (BurnerVector::at(i)->itemStatus == state && BurnerVector::at(i)->errorCode == code) ts += BurnerVector::at(i)->GetSizeInSectors();
|
|
}
|
|
return ts;
|
|
}
|
|
|
|
HRESULT BurnerPlaylist::CheckLicense(BURNERPLAYLISTCALLBACK notifyCB, void *userparam)
|
|
{
|
|
this->notifyCB = notifyCB;
|
|
this->userparam = userparam;
|
|
|
|
statusCode = BURNERPLAYLIST_LICENSINGSTARTING;
|
|
errorCode = BURNERPLAYLIST_SUCCESS;
|
|
OnNotify(statusCode, errorCode, 0);
|
|
|
|
size_t count = BurnerVector::size();
|
|
size_t realCount = 0;
|
|
manager.CancelBurn(); // ha-ha
|
|
wchar_t **filenames = (count) ? (wchar_t**)malloc(count*sizeof(wchar_t*)) : NULL;
|
|
DWORD nc, ec;
|
|
|
|
for (size_t i = 0; i < count; i++)
|
|
{
|
|
nc = BurnerVector::at(i)->GetStatus(&ec);
|
|
if (nc == BURNERITEM_READY ||
|
|
((nc == BURNERITEM_LICENSED || nc == BURNERITEM_DECODED) && ec == BURNERITEM_SUCCESS))
|
|
{
|
|
filenames[realCount] = (wchar_t*)BurnerVector::at(i)->GetFullName();
|
|
BurnerVector::at(i)->itemStatus = BURNERITEM_LICENSING;
|
|
errorCode = BURNERPLAYLIST_ITEMADDED;
|
|
realCount++;
|
|
}
|
|
else
|
|
{
|
|
BurnerVector::at(i)->itemStatus = BURNERITEM_SKIPPED;
|
|
errorCode = BURNERPLAYLIST_ADDITEMSKIPPED;
|
|
}
|
|
OnNotify(statusCode, errorCode, i);
|
|
}
|
|
if (realCount == 0)
|
|
{
|
|
statusCode = BURNERPLAYLIST_LICENSINGFINISHED;
|
|
errorCode = BURNERPLAYLIST_NOFILES;
|
|
OnNotify(statusCode, errorCode, 0);
|
|
if (filenames) free(filenames);
|
|
return statusCode;
|
|
}
|
|
if (!manager.GetDecodeAPI())
|
|
{
|
|
api_decodefile *decoder = NULL;
|
|
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(decodeFileGUID);
|
|
if (factory) decoder = (api_decodefile *)factory->getInterface();
|
|
if (!factory || !decoder)
|
|
{
|
|
statusCode = BURNERPLAYLIST_LICENSINGFINISHED;
|
|
errorCode = BURNERPLAYLIST_DECODESERVICEFAILED;
|
|
OnNotify(statusCode, errorCode, 0);
|
|
free(filenames);
|
|
return statusCode;
|
|
}
|
|
manager.SetDecodeAPI(decoder);
|
|
}
|
|
|
|
manager.SetFiles(realCount, (const wchar_t**)filenames, this);
|
|
free(filenames);
|
|
return statusCode;
|
|
}
|
|
|
|
HRESULT BurnerPlaylist::Decode(void* hFile, BURNERPLAYLISTCALLBACK notifyCB, void *userparam, BOOL block)
|
|
{
|
|
this->notifyCB = notifyCB;
|
|
this->userparam = userparam;
|
|
this->hFile = hFile;
|
|
hThread = NULL;
|
|
|
|
statusCode = BURNERPLAYLIST_DECODESTARTING;
|
|
errorCode = BURNERPLAYLIST_SUCCESS;
|
|
OnNotify(statusCode, errorCode, 0);
|
|
|
|
if (!manager.GetDecodeAPI())
|
|
{
|
|
api_decodefile *decoder = NULL;
|
|
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(decodeFileGUID);
|
|
if (factory) decoder = (api_decodefile *)factory->getInterface();
|
|
if (!factory || !decoder)
|
|
{
|
|
statusCode = BURNERPLAYLIST_DECODEFINISHED;
|
|
errorCode = BURNERPLAYLIST_DECODESERVICEFAILED;
|
|
OnNotify(statusCode, errorCode, 0);
|
|
return statusCode;
|
|
}
|
|
manager.SetDecodeAPI(decoder);
|
|
}
|
|
|
|
if (block)
|
|
{
|
|
statusCode = DecodeWorker(this);
|
|
OnNotify(statusCode, errorCode, 100);
|
|
if (manager.GetDecodeAPI())
|
|
{
|
|
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(decodeFileGUID);
|
|
factory->releaseInterface(manager.GetDecodeAPI());
|
|
manager.SetDecodeAPI(NULL);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
DWORD id;
|
|
hThread = CreateThread(NULL, 0, DecodeWorker, this, 0, &id);
|
|
if (NULL == hThread)
|
|
{
|
|
statusCode = BURNERPLAYLIST_DECODEFINISHED;
|
|
errorCode = BURNERPLAYLIST_THREADCREATEFAILED;
|
|
OnNotify(statusCode, errorCode, 0);
|
|
}
|
|
}
|
|
return statusCode;
|
|
}
|
|
|
|
HRESULT BurnerPlaylist::Burn(obj_primo *primoSDK, DWORD drive, DWORD maxspeed, DWORD burnFlags, void* hFile,
|
|
BURNERPLAYLISTCALLBACK notifyCB, void *userparam, BOOL block)
|
|
{
|
|
this->primoSDK = primoSDK;
|
|
this->drive = drive;
|
|
this->hFile = hFile;
|
|
this->maxspeed = maxspeed;
|
|
this->burnFlags = burnFlags;
|
|
this->notifyCB = notifyCB;
|
|
this->userparam = userparam;
|
|
statusCode = BURNERPLAYLIST_BURNSTARTING;
|
|
errorCode = BURNERPLAYLIST_SUCCESS;
|
|
evntCancel = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
OnNotify(statusCode, errorCode, 0); // here we go
|
|
|
|
DWORD retCode;
|
|
DWORD dwUnits[2];
|
|
dwUnits[0] = drive;
|
|
dwUnits[1] = 0xFFFFFFFF;
|
|
retCode = primoSDK->NewAudio(dwUnits);
|
|
if (PRIMOSDK_OK != retCode)
|
|
{
|
|
statusCode = BURNERPLAYLIST_BURNFINISHED;
|
|
errorCode = BURNERPLAYLIST_NEWAUDIOFAILED;
|
|
OnNotify(statusCode, errorCode, retCode);
|
|
return statusCode;
|
|
}
|
|
|
|
if (BurnerVector::size() == 0)
|
|
{
|
|
statusCode = BURNERPLAYLIST_BURNFINISHED;
|
|
errorCode = BURNERPLAYLIST_NOFILES;
|
|
OnNotify(statusCode, errorCode, retCode);
|
|
return statusCode;
|
|
}
|
|
size_t i;
|
|
for(i = 0; i < BurnerVector::size(); i++)
|
|
{
|
|
DWORD ec;
|
|
if (BURNERITEM_DECODED == BurnerVector::at(i)->GetStatus(&ec) && BURNERITEM_SUCCESS == ec)
|
|
{
|
|
BurnerVector::at(i)->itemStatus = BURNERITEM_READY;
|
|
retCode = BurnerVector::at(i)->AddStream(primoSDK, hFile);
|
|
if (PRIMOSDK_OK != retCode)
|
|
{
|
|
BurnerVector::at(i)->itemStatus = BURNERITEM_BURNED;
|
|
BurnerVector::at(i)->errorCode = BURNERITEM_FAILED;
|
|
errorCode = BURNERPLAYLIST_ADDITEMFAILED;
|
|
break;
|
|
}
|
|
else errorCode = BURNERPLAYLIST_ITEMADDED;
|
|
}
|
|
else
|
|
{
|
|
errorCode = BURNERPLAYLIST_ADDITEMSKIPPED;
|
|
BurnerVector::at(i)->itemStatus = BURNERITEM_SKIPPED;
|
|
}
|
|
OnNotify(statusCode, errorCode, i);
|
|
|
|
}
|
|
|
|
if (PRIMOSDK_OK != retCode || (WAIT_OBJECT_0 == WaitForSingleObject(evntCancel, 0)))
|
|
{
|
|
|
|
statusCode = (PRIMOSDK_OK == retCode) ? BURNERPLAYLIST_BURNCANCELING : BURNERPLAYLIST_BURNFINISHING;
|
|
errorCode = (PRIMOSDK_OK == retCode) ? BURNERPLAYLIST_ABORTED : BURNERPLAYLIST_ADDITEMFAILED;
|
|
BPLRUNSTATUS burnStatus;
|
|
|
|
for(i = 0; i < BurnerVector::size(); i++)
|
|
{
|
|
burnStatus.iIndex = (int)i;
|
|
if (BURNERITEM_SKIPPED == BurnerVector::at(burnStatus.iIndex)->itemStatus) continue;
|
|
|
|
BurnerVector::at(burnStatus.iIndex)->itemStatus = (PRIMOSDK_OK == retCode) ? BURNERITEM_ABORTED : BURNERITEM_FAILED;
|
|
OnNotify(statusCode, errorCode, (ULONG_PTR)&burnStatus);
|
|
}
|
|
|
|
CloseHandle(evntCancel);
|
|
evntCancel = NULL;
|
|
primoSDK->CloseAudio();
|
|
statusCode = BURNERPLAYLIST_BURNFINISHED;
|
|
OnNotify(statusCode, errorCode, i);
|
|
return statusCode;
|
|
}
|
|
|
|
if (block)
|
|
{
|
|
DWORD notifyCode = BurnerWorker(this);
|
|
OnNotify(BURNERPLAYLIST_BURNFINISHED, notifyCode, errorCode);
|
|
}
|
|
else
|
|
{
|
|
DWORD id;
|
|
hThread = CreateThread(NULL, 0, BurnerWorker, this, 0, &id);
|
|
if (NULL == hThread)
|
|
{
|
|
statusCode = BURNERPLAYLIST_BURNFINISHED;
|
|
errorCode = BURNERPLAYLIST_THREADCREATEFAILED;
|
|
OnNotify(statusCode, errorCode, i);
|
|
}
|
|
}
|
|
|
|
return statusCode;
|
|
}
|
|
|
|
DWORD BurnerPlaylist::AddCompilationToCDDB(void)
|
|
{
|
|
wchar_t buf[64] = {0};
|
|
wchar_t albumbuf[256]= L"Mix CD ";
|
|
|
|
wchar_t dateString[128] = {0};
|
|
GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, dateString, 128);
|
|
StringCchCatW(albumbuf, 256, dateString);
|
|
|
|
StringCchPrintfW(buf, 64, L"cda://%c.cda", (char)drive);
|
|
extendedFileInfoStructW efis = { buf, L"album", albumbuf, 256, };
|
|
|
|
if (SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW))
|
|
{
|
|
efis.metadata = L"albumartist";
|
|
efis.ret = L"Various Artists";
|
|
SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW);
|
|
efis.metadata = L"genre";
|
|
efis.ret = L"Mix";
|
|
SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW);
|
|
SYSTEMTIME syst;
|
|
GetLocalTime(&syst);
|
|
if (syst.wYear)
|
|
{
|
|
wchar_t yearbuf[64] = {0};
|
|
StringCchPrintfW(yearbuf, 64, L"%04d", syst.wYear);
|
|
efis.metadata = L"year";
|
|
efis.ret = yearbuf;
|
|
SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW);
|
|
}
|
|
wchar_t buf2[32] = {0};
|
|
int index = 1;
|
|
for (size_t i = 0;i < GetCount();i++)
|
|
{
|
|
DWORD is, ec;
|
|
is = BurnerVector::at(i)->GetStatus(&ec);
|
|
if (BURNERITEM_BURNED == is && BURNERITEM_SUCCESS == ec)
|
|
{
|
|
StringCchPrintfW(buf, 64, L"cda://%c,%d.cda", (char)drive, i);
|
|
lstrcpynW(buf2, L"title", 32);
|
|
efis.metadata = buf2;
|
|
efis.ret = const_cast<wchar_t*>(BurnerVector::at(i)->GetTitle());
|
|
SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW);
|
|
|
|
lstrcpynW(buf2, L"artist", 32);
|
|
efis.ret=L"Various Artists"; // TODO: use actual track artist
|
|
SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW);
|
|
|
|
index++;
|
|
}
|
|
}
|
|
SendMessageW(winampWnd, WM_WA_IPC, (WPARAM)0, IPC_WRITE_EXTENDED_FILE_INFO);
|
|
}
|
|
return 1;
|
|
}
|
|
DWORD WINAPI BurnerPlaylist::DecodeWorker(void* param)
|
|
{
|
|
DWORD retCode;
|
|
BurnerPlaylist *playlist = (BurnerPlaylist*)param;
|
|
|
|
playlist->percentStep = (float)(1.f / ((double)playlist->GetCount()));
|
|
playlist->activeDecode = NULL;
|
|
DWORD itemError = BURNERITEM_SUCCESS;
|
|
|
|
// for nice ui reason lets do it twice
|
|
playlist->statusCode = BURNERPLAYLIST_DECODESTARTING;
|
|
for(size_t i = 0; i < playlist->GetCount(); i++)
|
|
{
|
|
DWORD ec;
|
|
if (BURNERITEM_LICENSED == playlist->at(i)->GetStatus(&ec) && BURN_OK == ec)
|
|
{
|
|
playlist->errorCode = BURNERPLAYLIST_ITEMADDED;
|
|
playlist->at(i)->itemStatus = BURNERITEM_READY;
|
|
}
|
|
else
|
|
{
|
|
|
|
playlist->errorCode = BURNERPLAYLIST_ADDITEMSKIPPED;
|
|
playlist->at(i)->itemStatus = BURNERITEM_SKIPPED;
|
|
|
|
}
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, i);
|
|
}
|
|
|
|
// actual work
|
|
for(size_t i = 0; i < playlist->GetCount(); i++)
|
|
{
|
|
if (BURNERITEM_READY == playlist->at(i)->GetStatus(NULL))
|
|
{
|
|
BPLDECODEINFO info;
|
|
info.iInstance = playlist->at(i);
|
|
info.iIndex = (int)i;
|
|
info.iNotifyCode = 0;
|
|
info.iErrorCode = 0;
|
|
info.percentCompleted = (playlist->activeDecode) ? playlist->percentStep*i*100.0f : 0;
|
|
playlist->activeDecode = &info;
|
|
playlist->statusCode = BURNERPLAYLIST_DECODEPROGRESS;
|
|
playlist->errorCode = BURNERPLAYLIST_DECODENEXTITEM;
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, (ULONG_PTR)playlist->activeDecode);
|
|
retCode = playlist->at(i)->Decode(&playlist->manager, playlist->hFile, OnItemDecode, playlist);
|
|
if (BURNERITEM_SUCCESS != retCode)
|
|
{
|
|
itemError = retCode;
|
|
}
|
|
if (BURNERITEM_ABORTED == retCode)
|
|
{
|
|
playlist->statusCode = BURNERPLAYLIST_DECODECANCELING;
|
|
playlist->errorCode = BURNERPLAYLIST_ABORTED;
|
|
DWORD notifyCode = BURNERITEM_DECODEFINISHED;
|
|
for(size_t k = i; k < playlist->GetCount(); k++)
|
|
{
|
|
info.iIndex = (int)k;
|
|
info.iInstance = playlist->at(k);
|
|
info.iInstance->errorCode = BURNERITEM_ABORTED;
|
|
info.iInstance->itemStatus = BURNERITEM_ABORTED;
|
|
OnItemDecode(info.iInstance, playlist, notifyCode, info.iInstance->errorCode);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// release decoderAPI
|
|
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(decodeFileGUID);
|
|
factory->releaseInterface(playlist->manager.GetDecodeAPI());
|
|
playlist->manager.SetDecodeAPI(NULL);
|
|
|
|
if (playlist->hThread)
|
|
{
|
|
CloseHandle(playlist->hThread);
|
|
playlist->hThread = NULL;
|
|
}
|
|
|
|
playlist->statusCode = BURNERPLAYLIST_DECODEFINISHED;
|
|
if (playlist->GetCount() == 0) playlist->errorCode = BURNERPLAYLIST_NOFILES;
|
|
else if (BURNERITEM_ABORTED == itemError) playlist->errorCode = BURNERPLAYLIST_ABORTED;
|
|
else if (BURNERITEM_SUCCESS == itemError) playlist->errorCode = BURNERPLAYLIST_SUCCESS;
|
|
else playlist->errorCode = BURNERPLAYLIST_FAILED;
|
|
|
|
playlist->OnNotify(playlist->statusCode , playlist->errorCode, (ULONG_PTR)playlist->activeDecode);
|
|
playlist->activeDecode = NULL;
|
|
return playlist->statusCode;
|
|
}
|
|
DWORD WINAPI BurnerPlaylist::BurnerWorker(void* param)
|
|
{
|
|
DWORD primoCode;
|
|
BurnerPlaylist *playlist = (BurnerPlaylist*)param;
|
|
|
|
WABURNSTRUCT bs;
|
|
playlist->statusCode = BURNERPLAYLIST_BURNSTARTING;
|
|
playlist->errorCode = BURNERPLAYLIST_BEGINBURN;
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, 0);
|
|
primoCode = BeginBurn(playlist->primoSDK, playlist->drive, &bs);
|
|
bs.eject = TRUE;
|
|
DWORD leadin = 0;
|
|
BPLRUNSTATUS burnStatus;
|
|
ZeroMemory(&burnStatus, sizeof(BPLRUNSTATUS));
|
|
burnStatus.iIndex = -1;
|
|
|
|
BOOL canceled = FALSE;
|
|
DWORD itemSector = 0;
|
|
BOOL cp1 = FALSE;
|
|
if (PRIMOSDK_OK != primoCode)
|
|
{
|
|
playlist->errorCode = BURNERPLAYLIST_BEGINBURNFAILED;
|
|
}
|
|
else
|
|
{
|
|
playlist->statusCode = BURNERPLAYLIST_BURNPROGRESS;
|
|
primoCode = playlist->primoSDK->WriteAudioEx(playlist->burnFlags, playlist->maxspeed, 0x00);
|
|
if (PRIMOSDK_OK == primoCode)
|
|
{
|
|
DWORD waitResult;
|
|
while(BURNERPLAYLIST_BURNPROGRESS == playlist->statusCode && WAIT_TIMEOUT == (waitResult = WaitForSingleObject(playlist->evntCancel, 500)))
|
|
{
|
|
primoCode = playlist->primoSDK->RunningStatus(PRIMOSDK_GETSTATUS, &burnStatus.sCurrent, &burnStatus.sTotal);
|
|
if (PRIMOSDK_RUNNING == primoCode)
|
|
{
|
|
playlist->statusCode = BURNERPLAYLIST_BURNPROGRESS;
|
|
if (burnStatus.sCurrent == 0)
|
|
{
|
|
if (cp1) continue; // do not send anymore
|
|
playlist->errorCode = BURNERPLAYLIST_WRITELEADIN; //BURNERPLAYLIST_DISCOPEN
|
|
cp1 = TRUE;
|
|
}
|
|
else if (burnStatus.sCurrent > 0 && (!leadin || leadin == burnStatus.sCurrent))
|
|
{
|
|
if (!leadin)
|
|
{
|
|
leadin = burnStatus.sCurrent;
|
|
playlist->errorCode = BURNERPLAYLIST_WRITELEADIN; // unreachable :)
|
|
}
|
|
continue;
|
|
}
|
|
else if (burnStatus.sCurrent == burnStatus.sTotal)
|
|
{
|
|
if (burnStatus.iIndex >= 0 && BURNERITEM_BURNING == playlist->at(burnStatus.iIndex)->itemStatus)
|
|
{
|
|
playlist->at(burnStatus.iIndex)->itemStatus = BURNERITEM_BURNED;
|
|
playlist->at(burnStatus.iIndex)->errorCode = BURNERITEM_SUCCESS;
|
|
playlist->at(burnStatus.iIndex)->percentCompleted = 100;
|
|
playlist->OnNotify(playlist->statusCode, BURNERPLAYLIST_WRITEITEMEND, (ULONG_PTR)&burnStatus);
|
|
}
|
|
if (burnStatus.iIndex == -1) continue;
|
|
playlist->errorCode = BURNERPLAYLIST_WRITELEADOUT;
|
|
burnStatus.iIndex = -1;
|
|
burnStatus.iInstance = NULL;
|
|
|
|
}
|
|
else
|
|
{
|
|
playlist->errorCode = BURNERPLAYLIST_WRITEDATA;
|
|
while (itemSector < burnStatus.sCurrent && burnStatus.iIndex < (int)playlist->size())
|
|
{ if (burnStatus.iIndex >= 0 && BURNERITEM_BURNING == playlist->at(burnStatus.iIndex)->itemStatus)
|
|
{
|
|
playlist->at(burnStatus.iIndex)->itemStatus = BURNERITEM_BURNED;
|
|
playlist->at(burnStatus.iIndex)->errorCode = BURNERITEM_SUCCESS;
|
|
playlist->at(burnStatus.iIndex)->percentCompleted = 100;
|
|
playlist->OnNotify(playlist->statusCode, BURNERPLAYLIST_WRITEITEMEND, (ULONG_PTR)&burnStatus);
|
|
}
|
|
while (++burnStatus.iIndex < (int)playlist->size() && BURNERITEM_READY != playlist->at(burnStatus.iIndex)->itemStatus);
|
|
if (burnStatus.iIndex < (int)playlist->size()) itemSector += playlist->at(burnStatus.iIndex)->GetSizeInSectors();
|
|
}
|
|
if ( burnStatus.iIndex >= 0 && burnStatus.iIndex < (int)playlist->size())
|
|
{
|
|
BurnerItem *bi = playlist->at(burnStatus.iIndex);
|
|
burnStatus.iInstance = bi;
|
|
if (BURNERITEM_READY == bi->itemStatus)
|
|
{
|
|
bi->itemStatus = BURNERITEM_BURNING;
|
|
bi->percentCompleted = 0;
|
|
playlist->OnNotify(playlist->statusCode, BURNERPLAYLIST_WRITEITEMBEGIN, (ULONG_PTR)&burnStatus);
|
|
}
|
|
if (BURNERITEM_SUCCESS == bi->errorCode)
|
|
{
|
|
DWORD is = bi->GetSizeInSectors();
|
|
bi->itemStatus = BURNERITEM_BURNING;
|
|
bi->percentCompleted = (is - (itemSector - burnStatus.sCurrent))*100 / is;
|
|
}
|
|
else
|
|
{
|
|
bi->itemStatus = BURNERITEM_BURNED;
|
|
bi->errorCode = BURNERITEM_SUCCESS;
|
|
bi->percentCompleted = 100;
|
|
}
|
|
}
|
|
|
|
}
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, (ULONG_PTR)&burnStatus);
|
|
}
|
|
else
|
|
{
|
|
playlist->errorCode = BURNERPLAYLIST_WRITEAUDIOFAILED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (WAIT_OBJECT_0 == waitResult)
|
|
{ // aborting
|
|
canceled = TRUE;
|
|
|
|
playlist->statusCode = BURNERPLAYLIST_BURNCANCELING;
|
|
playlist->errorCode = BURNERPLAYLIST_ABORTED;
|
|
playlist->at(burnStatus.iIndex)->itemStatus = BURNERITEM_CANCELING;
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, (ULONG_PTR)&burnStatus);
|
|
DWORD test = playlist->primoSDK->RunningStatus(PRIMOSDK_ABORT, &burnStatus.sCurrent, &burnStatus.sTotal);
|
|
do
|
|
{
|
|
Sleep(1000);
|
|
primoCode = playlist->primoSDK->RunningStatus(PRIMOSDK_GETSTATUS, &burnStatus.sCurrent, &burnStatus.sTotal);
|
|
}while(PRIMOSDK_RUNNING == primoCode);
|
|
for (size_t i = 0; i < playlist->GetCount(); i++)
|
|
{
|
|
burnStatus.iIndex = (int)i;
|
|
DWORD cs = playlist->at(burnStatus.iIndex)->itemStatus;
|
|
if (BURNERITEM_BURNING != cs && BURNERITEM_READY != cs && BURNERITEM_CANCELING != cs) continue;
|
|
playlist->at(burnStatus.iIndex)->itemStatus = BURNERITEM_ABORTED;
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, (ULONG_PTR)&burnStatus);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
playlist->errorCode = BURNERPLAYLIST_WRITEAUDIOFAILED;
|
|
}
|
|
}
|
|
if (PRIMOSDK_USERABORT == primoCode) playlist->errorCode = BURNERPLAYLIST_ABORTED;
|
|
else if (PRIMOSDK_OK == primoCode) playlist->errorCode = BURNERPLAYLIST_SUCCESS;
|
|
playlist->statusCode = BURNERPLAYLIST_BURNFINISHING;
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, 0);
|
|
|
|
// check unit status and notify later
|
|
DWORD statCode, cmd(0), sense(0), asc(0), ascq(0);
|
|
statCode = playlist->primoSDK->UnitStatus(&bs.drive, &cmd, &sense, &asc, &ascq);
|
|
|
|
bs.eject = playlist->ejectDone;
|
|
|
|
primoCode = EndBurn(&bs);
|
|
|
|
if (PRIMOSDK_OK != primoCode) playlist->errorCode = BURNERPLAYLIST_ENDBURNFAILED;
|
|
|
|
playlist->primoSDK->CloseAudio();
|
|
|
|
if (playlist->hThread)
|
|
{
|
|
CloseHandle(playlist->hThread);
|
|
playlist->hThread = NULL;
|
|
}
|
|
primoCode = (0xFF000000 & (statCode << 24)) | (0x00FF0000 & (sense << 16)) | (0x0000FF00 & (asc << 8)) | (0x000000FF & ascq);
|
|
if (BURNERPLAYLIST_SUCCESS == playlist->errorCode && statCode != PRIMOSDK_OK) playlist->errorCode = BURNERPLAYLIST_FAILED;
|
|
|
|
if (BURNERPLAYLIST_SUCCESS == playlist->errorCode && (PRIMOSDK_WRITE == (playlist->burnFlags&PRIMOSDK_WRITE)))
|
|
{
|
|
playlist->manager.BurnFinished();
|
|
}
|
|
else
|
|
{
|
|
playlist->manager.CancelBurn();
|
|
}
|
|
|
|
playlist->statusCode = BURNERPLAYLIST_BURNFINISHED;
|
|
playlist->OnNotify(playlist->statusCode, playlist->errorCode, primoCode);
|
|
return playlist->statusCode;
|
|
}
|
|
|
|
DWORD BurnerPlaylist::OnNotify(DWORD notifyCode, DWORD errorCode, ULONG_PTR param)
|
|
{
|
|
DWORD retCode = (notifyCB) ? notifyCB(this, userparam, notifyCode, errorCode, param) : BURNERPLAYLIST_CONTINUE;
|
|
if ( BURNERPLAYLIST_STOP == retCode && evntCancel) SetEvent(evntCancel);
|
|
return retCode;
|
|
}
|
|
|
|
|
|
void BurnerPlaylist::OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info)
|
|
{
|
|
if (NULL == filename) return;
|
|
BurnerItem *item = new BurnerItem();
|
|
item->Create(filename,title, lengthInMS);
|
|
length += lengthInMS;
|
|
push_back(item);
|
|
}
|
|
|
|
DWORD WINAPI BurnerPlaylist::OnItemDecode(void* sender, void *param, DWORD notifyCode, DWORD errorCode)
|
|
{
|
|
BurnerPlaylist *pl = (BurnerPlaylist*)param;
|
|
pl->activeDecode->iNotifyCode = notifyCode;
|
|
pl->activeDecode->iErrorCode = errorCode;
|
|
pl->activeDecode->percentCompleted += pl->percentStep;
|
|
pl->statusCode = BURNERPLAYLIST_DECODEPROGRESS;
|
|
pl->errorCode = BURNERPLAYLIST_DECODEITEM;
|
|
DWORD retCode = pl->OnNotify(pl->statusCode , pl->errorCode , (ULONG_PTR)pl->activeDecode);
|
|
return (BURNERPLAYLIST_STOP == retCode) ? BURNERITEM_STOP : BURNERITEM_CONTINUE;
|
|
}
|
|
|
|
void BurnerPlaylist::OnLicenseCallback(size_t numFiles, WRESULT *results)
|
|
{
|
|
statusCode = BURNERPLAYLIST_LICENSINGPROGRESS;
|
|
DWORD errorCode = BURNERPLAYLIST_SUCCESS;
|
|
size_t realCount = 0;
|
|
size_t allowed = 0;
|
|
for (size_t i = 0; i < BurnerVector::size(); i++)
|
|
{
|
|
if (BURNERITEM_LICENSING == BurnerVector::at(i)->itemStatus)
|
|
{
|
|
if (realCount == numFiles)
|
|
{
|
|
statusCode = BURNERPLAYLIST_LICENSINGFINISHED;
|
|
errorCode = BURNERPLAYLIST_WRONGFILECOUNT;
|
|
break;
|
|
}
|
|
BurnerVector::at(i)->itemStatus = BURNERITEM_LICENSED;
|
|
BurnerVector::at(i)->errorCode = results[realCount];
|
|
OnNotify(statusCode, results[realCount], (LPARAM)i);
|
|
if (BURN_OK != results[realCount]) errorCode = BURNERPLAYLIST_FILENOTLICENSED;
|
|
else allowed++;
|
|
realCount++;
|
|
}
|
|
|
|
}
|
|
statusCode = BURNERPLAYLIST_LICENSINGFINISHED;
|
|
OnNotify(statusCode, errorCode, allowed);
|
|
}
|
|
|
|
#define CBCLASS BurnerPlaylist
|
|
START_DISPATCH;
|
|
VCB(IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile)
|
|
END_DISPATCH;
|
|
#undef CBCLASS |