k4rli/winamp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial community commit

Browse Source
This commit is contained in:
Jef
2024-09-24 14:54:57 +02:00
parent 537bcbc862
commit 20d28e80a5
16810 changed files with 4640254 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Src/burnlib/api.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef __WASABI_API_H
#define __WASABI_API_H
#include <api/service/api_service.h>
extern api_service *serviceManager;
#define WASABI_API_SVC serviceManager
#endif

18
Src/burnlib/burnlib.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef NULLSOFT_BURN_LIBRARY_HEADER
#define NULLSOFT_BURN_LIBRARY_HEADER
#include "./main.h"
#include "./item.h"
#include "./playlist.h"
#include "./eraseMedium.h"
#include "./uiUpdatingData.h"
#include "./uiUnitReady.h"
#include "./uiCheckMedium.h"
#include "./uiEraseMedium.h"
#include "./uiBurnPlaylist.h"
#endif //NULLSOFT_BURN_LIBRARY_HEADER

1092
Src/burnlib/burnlib.rc Normal file
View File

File diff suppressed because it is too large Load Diff

67
Src/burnlib/burnlib.sln Normal file
View File

@@ -0,0 +1,67 @@
Microsoft Visual Studio Solution File, Format Version 8.00
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "burnlib", "burnlib.vcproj", "{374717BA-EF3A-4BF6-AC4D-A532E08BE904}"
ProjectSection(ProjectDependencies) = postProject
{8FBD5E01-B920-44D8-9687-88AE0C3CA833} = {8FBD5E01-B920-44D8-9687-88AE0C3CA833}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "burnlibres", "resdll\resdll.vcproj", "{8FBD5E01-B920-44D8-9687-88AE0C3CA833}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "winampv6", "..\Winamp\winampv6.vcproj", "{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}"
ProjectSection(ProjectDependencies) = postProject
{8FBD5E01-B920-44D8-9687-88AE0C3CA833} = {8FBD5E01-B920-44D8-9687-88AE0C3CA833}
{374717BA-EF3A-4BF6-AC4D-A532E08BE904} = {374717BA-EF3A-4BF6-AC4D-A532E08BE904}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "in_wmvdrm", "..\in_wmvdrm\in_wmvdrm.vcproj", "{9362E6C2-EFCC-4104-8671-78222E0A5FCC}"
ProjectSection(ProjectDependencies) = postProject
{8FBD5E01-B920-44D8-9687-88AE0C3CA833} = {8FBD5E01-B920-44D8-9687-88AE0C3CA833}
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Profiling = Profiling
Release = Release
Revoked = Revoked
EndGlobalSection
GlobalSection(ProjectConfiguration) = postSolution
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Debug.ActiveCfg = Debug|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Debug.Build.0 = Debug|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Profiling.ActiveCfg = Release|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Profiling.Build.0 = Release|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Release.ActiveCfg = Release|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Release.Build.0 = Release|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Revoked.ActiveCfg = Release|Win32
{374717BA-EF3A-4BF6-AC4D-A532E08BE904}.Revoked.Build.0 = Release|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Debug.ActiveCfg = Debug|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Debug.Build.0 = Debug|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Profiling.ActiveCfg = Release|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Profiling.Build.0 = Release|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Release.ActiveCfg = Release|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Release.Build.0 = Release|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Revoked.ActiveCfg = Release|Win32
{8FBD5E01-B920-44D8-9687-88AE0C3CA833}.Revoked.Build.0 = Release|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Debug.ActiveCfg = Debug|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Debug.Build.0 = Debug|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Profiling.ActiveCfg = Profiling|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Profiling.Build.0 = Profiling|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Release.ActiveCfg = Release|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Release.Build.0 = Release|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Revoked.ActiveCfg = Release|Win32
{7DE5C6C7-DAF2-42F9-9324-C8CF4E7E8AC5}.Revoked.Build.0 = Release|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Debug.ActiveCfg = Debug|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Debug.Build.0 = Debug|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Profiling.ActiveCfg = Profiling|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Profiling.Build.0 = Profiling|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Release.ActiveCfg = Release|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Release.Build.0 = Release|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Revoked.ActiveCfg = Revoked|Win32
{9362E6C2-EFCC-4104-8671-78222E0A5FCC}.Revoked.Build.0 = Revoked|Win32
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection
GlobalSection(ExtensibilityAddIns) = postSolution
EndGlobalSection
EndGlobal

284
Src/burnlib/burnlib.vcproj Normal file
View File

@@ -0,0 +1,284 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="burnlib"
ProjectGUID="{374717BA-EF3A-4BF6-AC4D-A532E08BE904}"
RootNamespace="burnlib"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
ConfigurationType="4"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="../Wasabi"
PreprocessorDefinitions="WIN32;_DEBUG;_LIB;"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
TreatWChar_tAsBuiltInType="true"
ForceConformanceInForLoopScope="true"
UsePrecompiledHeader="0"
PrecompiledHeaderThrough=""
WarningLevel="3"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
OutputFile="./lib/burnlibd.lib"
IgnoreAllDefaultLibraries="true"
IgnoreDefaultLibraryNames=""
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="4"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="1"
FavorSizeOrSpeed="2"
AdditionalIncludeDirectories="../Wasabi;"
PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
StringPooling="true"
ExceptionHandling="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
UsePrecompiledHeader="0"
PrecompiledHeaderThrough="burnlib.h"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
OutputFile="./lib/burnlib.lib"
IgnoreAllDefaultLibraries="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\common.cpp"
>
</File>
<File
RelativePath=".\eraseMedium.cpp"
>
</File>
<File
RelativePath=".\item.cpp"
>
</File>
<File
RelativePath=".\main.cpp"
>
</File>
<File
RelativePath=".\playlist.cpp"
>
</File>
<File
RelativePath=".\uiBurnPlayList.cpp"
>
</File>
<File
RelativePath=".\uiCheckMedium.cpp"
>
</File>
<File
RelativePath=".\uiEraseMedium.cpp"
>
</File>
<File
RelativePath=".\uiUnitReady.cpp"
>
</File>
<File
RelativePath=".\uiUpdatingData.cpp"
>
</File>
<File
RelativePath=".\unitStatusText.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\api.h"
>
</File>
<File
RelativePath=".\burnlib.h"
>
<FileConfiguration
Name="Debug|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCustomBuildTool"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\eraseMedium.h"
>
</File>
<File
RelativePath=".\item.h"
>
</File>
<File
RelativePath=".\main.h"
>
</File>
<File
RelativePath=".\manager.h"
>
</File>
<File
RelativePath=".\playlist.h"
>
</File>
<File
RelativePath=".\primosdk.h"
>
</File>
<File
RelativePath=".\resource.h"
>
</File>
<File
RelativePath=".\uiBurnPlaylist.h"
>
</File>
<File
RelativePath=".\uiCheckMedium.h"
>
</File>
<File
RelativePath=".\uiEraseMedium.h"
>
</File>
<File
RelativePath=".\uiUnitReady.h"
>
</File>
<File
RelativePath=".\uiUpdatingData.h"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

261
Src/burnlib/common.cpp Normal file
View File

@@ -0,0 +1,261 @@
#include "./main.h"
#include "./resource.h"
#include "./primosdk.h"
#include <strsafe.h>
DWORD BeginBurn(obj_primo *primoSDK, DWORD drive, WABURNSTRUCT *burnstruct)
{
burnstruct->primoSDK = primoSDK;
burnstruct->drive = drive;
DWORD rc[3] = { PRIMOSDK_ERROR, PRIMOSDK_ERROR, PRIMOSDK_ERROR};
burnstruct->blocker = (PBYTE)("WINAMPBURNER v1.0");
DWORD retCode = PRIMOSDK_OK;
// init Sonic PrimoSDK
if (!primoSDK)
return PRIMOSDK_NOTLOADED;
// block drive
rc[0] = primoSDK->UnitVxBlock(&burnstruct->drive, PRIMOSDK_LOCK, burnstruct->blocker);
if (PRIMOSDK_OK != rc[0]) retCode = rc[0];
else
{
rc[1] = primoSDK->UnitAIN(&burnstruct->drive, PRIMOSDK_LOCK);
if (PRIMOSDK_OK != rc[1]) retCode = rc[1];
else
{
rc[2] = primoSDK->UnitLock(&burnstruct->drive, PRIMOSDK_LOCK);
if (PRIMOSDK_OK != rc[2]) retCode = rc[2];
}
}
if (PRIMOSDK_OK != retCode)
{
if (PRIMOSDK_OK == rc[2]) primoSDK->UnitLock(&burnstruct->drive, PRIMOSDK_UNLOCK);
if (PRIMOSDK_OK == rc[1]) primoSDK->UnitAIN(&burnstruct->drive, PRIMOSDK_UNLOCK);
if (PRIMOSDK_OK == rc[0]) primoSDK->UnitVxBlock(&burnstruct->drive, PRIMOSDK_UNLOCK, burnstruct->blocker);
burnstruct->drive = 0x0000;
burnstruct->blocker = NULL;
burnstruct->primoSDK = NULL;
}
return retCode;
}
DWORD EndBurn(WABURNSTRUCT *burnstruct)
{
if (!burnstruct) return PRIMOSDK_ERROR;
if (0x0000 == burnstruct->drive) return PRIMOSDK_OK;
DWORD rc[4];
rc[0] = burnstruct->primoSDK->UnitLock(&burnstruct->drive, PRIMOSDK_UNLOCK);
rc[1] = burnstruct->primoSDK->MoveMedium(&burnstruct->drive,
PRIMOSDK_IMMEDIATE | ((burnstruct->eject) ? PRIMOSDK_OPENTRAYEJECT : 0));
if (0 == burnstruct->eject)
rc[1] = PRIMOSDK_OK;
rc[2] = burnstruct->primoSDK->UnitAIN(&burnstruct->drive, PRIMOSDK_UNLOCK);
rc[3] = burnstruct->primoSDK->UnitVxBlock(&burnstruct->drive, PRIMOSDK_UNLOCK, burnstruct->blocker);
burnstruct->drive = 0x0000;
burnstruct->blocker = NULL;
int len = sizeof(rc)/sizeof(DWORD);
for (int i = 0; i < len; i++) { if (PRIMOSDK_OK != rc[i]) return rc[i]; }
return PRIMOSDK_OK;
}
DWORD GetMediumInfo(obj_primo *primoSDK, DWORD *drive, WAMEDIUMINFO *info)
{
DWORD retCode(PRIMOSDK_OK), erasable(0);
if (MAXDWORD != info->mediumType || MAXDWORD != info->mediumFormat || MAXDWORD != info->erasable ||
MAXDWORD != info->tracks || MAXDWORD != info->usedSectors || MAXDWORD != info->freeSectors || MAXDWORD != info->recordable)
{
retCode = primoSDK->DiscInfoEx(drive, 0,(MAXDWORD == info->mediumType && MAXDWORD == info->recordable) ? NULL : &info->mediumType,
(MAXDWORD == info->mediumFormat) ? NULL : &info->mediumFormat,
&erasable,
(MAXDWORD == info->tracks) ? NULL : &info->tracks,
(MAXDWORD == info->usedSectors) ? NULL : &info->usedSectors,
(MAXDWORD == info->freeSectors) ? NULL : &info->freeSectors);
if (MAXDWORD != info->erasable) info->erasable = (TRUE == erasable);
if (MAXDWORD != info->recordable) info->recordable = (PRIMOSDK_COMPLIANTGOLD == info->mediumType || PRIMOSDK_BLANK == info->mediumType);
if (PRIMOSDK_OK != retCode) return retCode;
}
DWORD medium, rfu3;
BOOL needMediumInfo = (MAXDWORD != info->medium || MAXDWORD != info->isCD || MAXDWORD != info->isDCD || MAXDWORD != info->isDVD || MAXDWORD != info->isDLDVD);
if (MAXDWORD != info->protectedDVD || needMediumInfo)
{
retCode = primoSDK->DiscInfo2(drive, !needMediumInfo ? NULL : &medium,
(MAXDWORD == info->protectedDVD) ? NULL : &info->protectedDVD,
NULL,
!needMediumInfo ? NULL : &info->medium,
&rfu3);
}
if (MAXDWORD != info->isCD) info->isCD = (PRIMOSDK_CDROM == info->medium || PRIMOSDK_CDR == info->medium || PRIMOSDK_CDRW == info->medium);
if (MAXDWORD != info->isDCD) info->isDCD = (PRIMOSDK_DDCDR == info->medium || PRIMOSDK_DDCDRW == info->medium);
if (MAXDWORD != info->isDVD) info->isDVD = (PRIMOSDK_DDCDROM == info->medium || PRIMOSDK_DVDR == info->medium || PRIMOSDK_DVDROM == info->medium || PRIMOSDK_DVDRAM == info->medium ||
PRIMOSDK_DVDRW == info->medium || PRIMOSDK_DVDPRW == info->medium || PRIMOSDK_DVDPR == info->medium);
if (MAXDWORD != info->isDLDVD) info->isDLDVD = (PRIMOSDK_DVDPR9 == info->medium);
return retCode;
}
wchar_t* GetMediumText(wchar_t *buffer, unsigned int cchBuffer,DWORD medium)
{
UINT uid = IDS_UNKNOWN;
switch(medium)
{
case PRIMOSDK_CDROM: uid = IDS_MEDIUM_CD; break;
case PRIMOSDK_CDR: uid = IDS_MEDIUM_CDR; break;
case PRIMOSDK_CDRW: uid = IDS_MEDIUM_CDRW; break;
case PRIMOSDK_DVDR: uid = IDS_MEDIUM_DVDR; break;
case PRIMOSDK_DVDROM: uid = IDS_MEDIUM_DVD; break;
case PRIMOSDK_DVDRAM: uid = IDS_MEDIUM_DVDRAM; break;
case PRIMOSDK_DVDRW: uid = IDS_MEDIUM_DVDRW; break;
case PRIMOSDK_DVDPRW: uid = IDS_MEDIUM_DVDPRW; break;
case PRIMOSDK_DVDPR: uid = IDS_MEDIUM_DVDPR; break;
case PRIMOSDK_DDCDROM: uid = IDS_MEDIUM_DDCD; break;
case PRIMOSDK_DDCDR: uid = IDS_MEDIUM_DDCDR; break;
case PRIMOSDK_DDCDRW: uid = IDS_MEDIUM_DDCDRW; break;
case PRIMOSDK_DVDPR9: uid = IDS_MEDIUM_DVDPR9; break;
case PRIMOSDK_DVDR9: uid = IDS_MEDIUM_DVDR9; break;
case PRIMOSDK_BDR: uid = IDS_MEDIUM_BDR; break;
case PRIMOSDK_BDRE: uid = IDS_MEDIUM_BDRE; break;
}
LoadStringW(hResource, uid, buffer, cchBuffer);
return buffer;
}
wchar_t*GetMediumTypeText(wchar_t *buffer, unsigned int cchBuffer, DWORD type)
{
UINT uid = IDS_UNKNOWN;
switch(type)
{
case PRIMOSDK_SILVER: uid = IDS_MEDIUMTYPE_SILVER; break;
case PRIMOSDK_COMPLIANTGOLD: uid = IDS_MEDIUMTYPE_COMPILATIONGOLD; break;
case PRIMOSDK_OTHERGOLD: uid = IDS_MEDIUMTYPE_OTHERGOLD; break;
case PRIMOSDK_BLANK: uid = IDS_MEDIUMTYPE_BLANK; break;
}
LoadStringW(hResource, uid, buffer, cchBuffer);
return buffer;
}
wchar_t* GetMediumFormatText(wchar_t *buffer, unsigned int cchBuffer, DWORD format)
{
UINT uid = IDS_UNKNOWN;
switch(format)
{
case PRIMOSDK_B1: uid = IDS_MEDIUMFORMAT_B1; break;
case PRIMOSDK_D1: uid = IDS_MEDIUMFORMAT_D1; break;
case PRIMOSDK_D2: uid = IDS_MEDIUMFORMAT_D2; break;
case PRIMOSDK_D3: uid = IDS_MEDIUMFORMAT_D3; break;
case PRIMOSDK_D4: uid = IDS_MEDIUMFORMAT_D4; break;
case PRIMOSDK_D5: uid = IDS_MEDIUMFORMAT_D5; break;
case PRIMOSDK_D6: uid = IDS_MEDIUMFORMAT_D6; break;
case PRIMOSDK_D7: uid = IDS_MEDIUMFORMAT_D7; break;
case PRIMOSDK_D8: uid = IDS_MEDIUMFORMAT_D8; break;
case PRIMOSDK_D9: uid = IDS_MEDIUMFORMAT_D9; break;
case PRIMOSDK_A1: uid = IDS_MEDIUMFORMAT_A1; break;
case PRIMOSDK_A2: uid = IDS_MEDIUMFORMAT_A2; break;
case PRIMOSDK_A3: uid = IDS_MEDIUMFORMAT_A3; break;
case PRIMOSDK_A4: uid = IDS_MEDIUMFORMAT_A4; break;
case PRIMOSDK_A5: uid = IDS_MEDIUMFORMAT_A5; break;
case PRIMOSDK_M1: uid = IDS_MEDIUMFORMAT_M1; break;
case PRIMOSDK_M2: uid = IDS_MEDIUMFORMAT_M2; break;
case PRIMOSDK_M3: uid = IDS_MEDIUMFORMAT_M3; break;
case PRIMOSDK_M4: uid = IDS_MEDIUMFORMAT_M4; break;
case PRIMOSDK_M5: uid = IDS_MEDIUMFORMAT_M5; break;
case PRIMOSDK_M6: uid = IDS_MEDIUMFORMAT_M6; break;
case PRIMOSDK_F1: uid = IDS_MEDIUMFORMAT_F1; break;
case PRIMOSDK_F2: uid = IDS_MEDIUMFORMAT_F2; break;
case PRIMOSDK_F3: uid = IDS_MEDIUMFORMAT_F3; break;
case PRIMOSDK_F4: uid = IDS_MEDIUMFORMAT_F4; break;
case PRIMOSDK_F5: uid = IDS_MEDIUMFORMAT_F5; break;
case PRIMOSDK_F8: uid = IDS_MEDIUMFORMAT_F8; break;
case PRIMOSDK_FA: uid = IDS_MEDIUMFORMAT_FA; break;
case PRIMOSDK_GENERICCD: uid = IDS_MEDIUMFORMAT_GENERICCD; break;
}
LoadStringW(hResource, uid, buffer, cchBuffer);
return buffer;
}
wchar_t* GetPrimoCodeText(wchar_t *buffer, unsigned int cchBuffer, DWORD primoCode)
{
UINT uid = IDS_UNKNOWN;
switch(primoCode)
{
case PRIMOSDK_OK: uid = IDS_PRIMOCODE_OK; break;
case PRIMOSDK_CMDSEQUENCE: uid = IDS_PRIMOCODE_CMDSEQUENCE; break;
case PRIMOSDK_NOASPI: uid = IDS_PRIMOCODE_NOASPI; break; //PRIMOSDK_NO_DRIVER - is the same code
case PRIMOSDK_INTERR: uid = IDS_PRIMOCODE_INTERR; break;
case PRIMOSDK_BADPARAM: uid = IDS_PRIMOCODE_BADPARAM; break;
case PRIMOSDK_ALREADYEXIST: uid = IDS_PRIMOCODE_ALREADYEXIST; break;
case PRIMOSDK_NOTREADABLE: uid = IDS_PRIMOCODE_NOTREADABLE; break;
case PRIMOSDK_NOSPACE: uid = IDS_PRIMOCODE_NOSPACE; break;
case PRIMOSDK_INVALIDMEDIUM: uid = IDS_PRIMOCODE_INVALIDMEDIUM; break;
case PRIMOSDK_RUNNING: uid = IDS_PRIMOCODE_RUNNING; break;
case PRIMOSDK_BUR: uid = IDS_PRIMOCODE_BUR; break;
case PRIMOSDK_SCSIERROR: uid = IDS_PRIMOCODE_SCSIERROR; break;
case PRIMOSDK_UNITERROR: uid = IDS_PRIMOCODE_UNITERROR; break;
case PRIMOSDK_NOTREADY: uid = IDS_PRIMOCODE_NOTREADY; break;
case PRIMOSDK_INVALIDSOURCE: uid = IDS_PRIMOCODE_INVALIDSOURCE; break;
case PRIMOSDK_INCOMPATIBLE: uid = IDS_PRIMOCODE_INCOMPATIBLE; break;
case PRIMOSDK_FILEERROR: uid = IDS_PRIMOCODE_FILEERROR; break;
case PRIMOSDK_ITSADEMO: uid = IDS_PRIMOCODE_ITSADEMO; break;
case PRIMOSDK_USERABORT: uid = IDS_PRIMOCODE_USERABORT; break;
case PRIMOSDK_BADHANDLE: uid = IDS_PRIMOCODE_BADHANDLE; break;
case PRIMOSDK_BADUNIT: uid = IDS_PRIMOCODE_BADUNIT; break;
case PRIMOSDK_ERRORLOADING: uid = IDS_PRIMOCODE_ERRORLOADING; break;
case PRIMOSDK_NOAINCONTROL: uid = IDS_PRIMOCODE_NOAINCONTROL; break;
case PRIMOSDK_READERROR: uid = IDS_PRIMOCODE_READERROR; break;
case PRIMOSDK_WRITEERROR: uid = IDS_PRIMOCODE_WRITEERROR; break;
case PRIMOSDK_TMPOVERFLOW: uid = IDS_PRIMOCODE_TMPOVERFLOW; break;
case PRIMOSDK_DVDSTRUCTERROR: uid = IDS_PRIMOCODE_DVDSTRUCTERROR; break;
case PRIMOSDK_FILETOOLARGE: uid = IDS_PRIMOCODE_FILETOOLARGE; break;
case PRIMOSDK_CACHEFULL: uid = IDS_PRIMOCODE_CACHEFULL; break;
case PRIMOSDK_FEATURE_NOT_SUPPORTED: uid = IDS_PRIMOCODE_FEATURE_NOT_SUPPORTED; break;
case PRIMOSDK_FEATURE_DISABLED: uid = IDS_PRIMOCODE_FEATURE_DISABLED; break;
case PRIMOSDK_CALLBACK_ERROR: uid = IDS_PRIMOCODE_CALLBACK_ERROR; break;
case PRIMOSDK_PROTECTEDWMA: uid = IDS_PRIMOCODE_PROTECTEDWMA; break;
}
LoadStringW(hResource, uid, buffer, cchBuffer);
return buffer;
}
wchar_t* GetBussText(wchar_t *buffer, unsigned int cchBuffer, DWORD bussType)
{
UINT uid = IDS_UNKNOWN;
switch(bussType)
{
case PRIMOSDK_ATAPI: uid = IDS_BUSSTYPE_ATAPI; break;
case PRIMOSDK_SCSI: uid = IDS_BUSSTYPE_SCSI; break;
case PRIMOSDK_1394: uid = IDS_BUSSTYPE_1394; break;
case PRIMOSDK_USB: uid = IDS_BUSSTYPE_USB; break;
case PRIMOSDK_USB2: uid = IDS_BUSSTYPE_USB2; break;
}
LoadStringW(hResource, uid, buffer, cchBuffer);
return buffer;
}
wchar_t* GetTrackTypeText(wchar_t *buffer, unsigned int cchBuffer, DWORD trackType)
{
UINT uid = IDS_UNKNOWN;
switch(trackType)
{
case PRIMOSDK_AUDIO_TRACK: uid = IDS_TRACKTYPE_AUDIO; break;
case PRIMOSDK_MODE1_TRACK: uid = IDS_TRACKTYPE_TRACK2; break;
case PRIMOSDK_MODE2_TRACK: uid = IDS_TRACKTYPE_TRACK2; break;
}
LoadStringW(hResource, uid, buffer, cchBuffer);
return buffer;
}
wchar_t* GetTimeString(wchar_t *string, unsigned int cchLen, unsigned int timesec)
{
unsigned int min = timesec / 60;
if (min > 0) timesec = timesec % 60;
unsigned int hour = min / 60;
if (hour > 0) min = min % 60;
StringCchPrintfW(string, cchLen, L"%02d:%02d:%02d", hour, min, timesec);
return string;
}

183
Src/burnlib/eraseMedium.cpp Normal file
View File

@@ -0,0 +1,183 @@
#include "./eraseMedium.h"
#include "api.h"
#include <api/service/waservicefactory.h>
EraseMedium::EraseMedium(void)
{
primoSDK=0;
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(obj_primo::getServiceGuid());
if (sf) primoSDK = reinterpret_cast<obj_primo *>(sf->getInterface());
hThread = NULL;
evntStop = NULL;
evntThreadExit = NULL;
errorCode = PRIMOSDK_OK;
notifyCB = NULL;
}
EraseMedium::~EraseMedium(void)
{
Stop();
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(obj_primo::getServiceGuid());
if (sf) sf->releaseInterface(primoSDK);
}
DWORD EraseMedium::SetEject(DWORD eject)
{
DWORD tmp = this->eject;
this->eject = eject;
return tmp;
}
DWORD EraseMedium::Start(DWORD drive, DWORD eraseMode, ERASEMEDIUMCALLBACK notifyCB, void *userParam, int block)
{
this->notifyCB = notifyCB;
this->userparam = userParam;
OnNotify(ERASEMEDIUM_READY, PRIMOSDK_OK);
if (hThread)
{
OnNotify(ERASEMEDIUM_ALREADYSTARTED, PRIMOSDK_OK);
return PRIMOSDK_OK;
}
OnNotify(ERASEMEDIUM_INITIALIZING, PRIMOSDK_OK);
if (!primoSDK)
{
OnNotify(ERASEMEDIUM_UNABLEINITPRIMO, PRIMOSDK_NOTLOADED);
return errorCode;
}
// check unit
errorCode = primoSDK->UnitReady(&drive);
if (PRIMOSDK_OK != errorCode)
{
OnNotify(ERASEMEDIUM_DEVICENOTREADY, errorCode);
return errorCode;
}
// check that disc is erasable
DWORD erasable;
errorCode = primoSDK->DiscInfoEx(&drive, 0, NULL, NULL, &erasable, NULL, NULL, NULL);
if (PRIMOSDK_OK != errorCode)
{
OnNotify(ERASEMEDIUM_DISCINFOERROR, errorCode);
return errorCode;
}
if (!erasable)
{
OnNotify(ERASEMEDIUM_DISCNOTERASABLE, PRIMOSDK_OK);
return errorCode;
}
// begin burn
errorCode = BeginBurn(primoSDK, drive, &bs);
if (PRIMOSDK_OK != errorCode)
{
OnNotify(ERASEMEDIUM_BEGINBURNFAILED, errorCode);
return errorCode;
}
// erasing
errorCode = primoSDK->EraseMedium(&bs.drive, eraseMode);
if(PRIMOSDK_OK == errorCode)
{
OnNotify(ERASEMEDIUM_ERASING, PRIMOSDK_OK);
evntStop = CreateEvent(NULL, FALSE, FALSE, NULL);
if (block) errorCode = StatusThread(this);
else
{
DWORD threadID;
hThread = CreateThread(NULL, 0, StatusThread, (LPVOID)this, NULL, &threadID);
}
}
else
{
OnNotify(ERASEMEDIUM_ERASEMEDIUMFAILED, errorCode);
}
return errorCode;
}
void EraseMedium::Stop(void)
{
if (hThread && evntStop)
{
DWORD waitResult;
MSG msg;
if (!evntThreadExit) evntThreadExit = CreateEvent(NULL, FALSE, FALSE, NULL);
SetEvent(evntStop);
while(WAIT_TIMEOUT == (waitResult = WaitForSingleObject(evntThreadExit, 10)))
{
if (!evntStop) break;
while(PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
}
CloseHandle(evntThreadExit);
evntThreadExit = NULL;
}
}
DWORD EraseMedium::OnNotify(DWORD eraseCode, DWORD primoCode)
{
return (notifyCB) ? notifyCB(this, userparam, eraseCode, primoCode) : ERASEMEDIUM_CONTINUE;
}
DWORD WINAPI EraseMedium::StatusThread(void* parameter)
{
EraseMedium *object = (EraseMedium*)parameter;
DWORD current, total, waitResult;
object->errorCode = PRIMOSDK_RUNNING;
while(PRIMOSDK_RUNNING == object->errorCode && WAIT_TIMEOUT == (waitResult = WaitForSingleObject(object->evntStop, 1000)))
{
if (ERASEMEDIUM_STOP == object->OnNotify(ERASEMEDIUM_ERASING, PRIMOSDK_OK)) SetEvent(object->evntStop);
object->errorCode = object->primoSDK->RunningStatus(PRIMOSDK_GETSTATUS, &current, &total);
}
if (WAIT_OBJECT_0 == waitResult)
{ // aborting
object->OnNotify(ERASEMEDIUM_CANCELING, PRIMOSDK_OK);
DWORD test = object->primoSDK->RunningStatus(PRIMOSDK_ABORT, &current, &total);
do
{
Sleep(1000);
object->errorCode = object->primoSDK->RunningStatus(PRIMOSDK_GETSTATUS, &current, &total);
}while(PRIMOSDK_RUNNING == object->errorCode);
}
if (PRIMOSDK_OK != object->errorCode && PRIMOSDK_USERABORT != object->errorCode)
{
object->OnNotify(ERASEMEDIUM_ERASEMEDIUMFAILED, object->errorCode);
}
// check unit status
DWORD cmd, sense, asc, ascq;
object->errorCode = object->primoSDK->UnitStatus(&object->bs.drive, &cmd, &sense, &asc, &ascq);
if (object->errorCode != PRIMOSDK_OK)
{
object->OnNotify(ERASEMEDIUM_ERASEMEDIUMFAILED, object->errorCode);
}
// end burn
object->bs.eject = object->eject;
object->OnNotify(ERASEMEDIUM_FINISHING, PRIMOSDK_OK);
DWORD errorCode2 = EndBurn(&object->bs);
if (PRIMOSDK_OK != errorCode2)
{
object->OnNotify(ERASEMEDIUM_ENDBURNFAILED, object->errorCode);
}
if (PRIMOSDK_OK == object->errorCode) object->errorCode = errorCode2;
object->primoSDK->Release();
CloseHandle(object->hThread);
object->hThread = NULL;
CloseHandle(object->evntStop);
object->evntStop = NULL;
object->OnNotify( (PRIMOSDK_USERABORT == object->errorCode) ? ERASEMEDIUM_ABORTED : ERASEMEDIUM_COMPLETED, object->errorCode);
if (object->evntThreadExit) SetEvent(object->evntThreadExit);
return object->errorCode;
}

68
Src/burnlib/eraseMedium.h Normal file
View File

@@ -0,0 +1,68 @@
#ifndef NULLSOFT_ERASEMEDIUM_HEADER
#define NULLSOFT_ERASEMEDIUM_HEADER
#include "./main.h"
#include "./primosdk.h"
#define ERASEMEDIUM_STATUS 0x0000
#define ERASEMEDIUM_ERROR 0x1000
// status messages
#define ERASEMEDIUM_READY ((ERASEMEDIUM_STATUS) + 0x0001)
#define ERASEMEDIUM_INITIALIZING ((ERASEMEDIUM_STATUS) + 0x0002)
#define ERASEMEDIUM_ERASING ((ERASEMEDIUM_STATUS) + 0x0003)
#define ERASEMEDIUM_FINISHING ((ERASEMEDIUM_STATUS) + 0x0004)
#define ERASEMEDIUM_CANCELING ((ERASEMEDIUM_STATUS) + 0x0005)
#define ERASEMEDIUM_COMPLETED ((ERASEMEDIUM_STATUS) + 0x0006)
#define ERASEMEDIUM_ABORTED ((ERASEMEDIUM_STATUS) + 0x0007)
// error messages
#define ERASEMEDIUM_ALREADYSTARTED ((ERASEMEDIUM_ERROR) + 0x0001)
#define ERASEMEDIUM_UNABLEINITPRIMO ((ERASEMEDIUM_ERROR) + 0x0002)
#define ERASEMEDIUM_DEVICENOTREADY ((ERASEMEDIUM_ERROR) + 0x0003)
#define ERASEMEDIUM_DISCINFOERROR ((ERASEMEDIUM_ERROR) + 0x0004)
#define ERASEMEDIUM_DISCNOTERASABLE ((ERASEMEDIUM_ERROR) + 0x0005)
#define ERASEMEDIUM_BEGINBURNFAILED ((ERASEMEDIUM_ERROR) + 0x0006)
#define ERASEMEDIUM_ENDBURNFAILED ((ERASEMEDIUM_ERROR) + 0x0007)
#define ERASEMEDIUM_ERASEMEDIUMFAILED ((ERASEMEDIUM_ERROR) + 0x0008)
// callback returns
#define ERASEMEDIUM_CONTINUE 0
#define ERASEMEDIUM_STOP 1
typedef DWORD (WINAPI *ERASEMEDIUMCALLBACK)(void*, void*, DWORD, DWORD);
class EraseMedium
{
public:
BURNLIB_API EraseMedium(void);
BURNLIB_API ~EraseMedium(void);
public:
BURNLIB_API DWORD Start(DWORD drive, DWORD eraseMode, ERASEMEDIUMCALLBACK notifyCB, void *userParam, int block);
BURNLIB_API void Stop(void);
BURNLIB_API DWORD GetErrorCode(void) { return errorCode; }
BURNLIB_API BOOL IsRunning(void) { return (NULL != hThread); }
public:
BURNLIB_API DWORD SetEject(DWORD eject);
protected:
DWORD OnNotify(DWORD eraseCode, DWORD primoCode);
static DWORD WINAPI StatusThread(void* parameter);
protected:
WABURNSTRUCT bs;
obj_primo *primoSDK;
unsigned int eject;
HANDLE hThread;
HANDLE evntStop;
HANDLE evntThreadExit;
DWORD errorCode;
void* userparam;
ERASEMEDIUMCALLBACK notifyCB;
};
#endif //NULLSOFT_ERASEMEDIUM_HEADER

252
Src/burnlib/item.cpp Normal file
View File

@@ -0,0 +1,252 @@
#include "./item.h"
#include <strsafe.h>
#define DECODEBUFFER_SIZE 4096*4
DWORD BurnerItem::zeroMem[] = {0x00,};
BurnerItem::BurnerItem(void)
{
fullname = NULL;
title = NULL;
length = 0;
sizeBytes = 0;
sizeSectors = 0;
preGap = 0;
fposition = 0;
fhandle = NULL;
heap = GetProcessHeap();
ZeroMemory(ISRC, 12);
itemStatus = BURNERITEM_READY;
percentCompleted = 0;
errorCode = BURNERITEM_SUCCESS;
if (zeroMem[0] == 0x00) FillMemory(zeroMem, ZEROMEM_SIZE, 0xFFFFFFFF);
}
BurnerItem::~BurnerItem(void)
{
Destroy();
}
HRESULT BurnerItem::Create(const wchar_t* fullname, const wchar_t *title, int length)
{
if (this->fullname)
{
errorCode = BURNERITEM_ALREADYCREATED;
return errorCode;
}
this->fullname = DuplicateString(heap, fullname, lstrlenW(fullname));
this->title = DuplicateString(heap, title, lstrlenW(title));
this->length = length;
itemStatus = BURNERITEM_READY;
errorCode = BURNERITEM_SUCCESS;
return errorCode;
}
void BurnerItem::Destroy(void)
{
if (fullname)
{
HeapFree(heap, NULL, fullname);
fullname = NULL;
}
if (title)
{
HeapFree(heap, NULL, title);
title = NULL;
}
length = 0;
sizeBytes = 0;
sizeSectors = 0;
preGap = 0;
fposition = 0;
fhandle = NULL;
ZeroMemory(ISRC, 12);
}
HRESULT BurnerItem::Decode(BurnManager *manager, void *fileHandle, BURNERITEMCALLBACK notifyCB, void *userparam)
{
itemStatus = BURNERITEM_DECODING;
if (notifyCB) notifyCB(this, userparam, BURNERITEM_DECODESTARTING, BURNERITEM_SUCCESS);
if (!fullname)
{
errorCode = BURNERITEM_BADFILENAME;
itemStatus = BURNERITEM_DECODED;
if (notifyCB) notifyCB(this, userparam, BURNERITEM_DECODEFINISHED, errorCode);
return errorCode;
}
ifc_audiostream *stream = manager->CreateDecoder(fullname);
if (!stream)
{
errorCode = BURNERITEM_UNABLEOPENFILE;
itemStatus = BURNERITEM_DECODED;
if (notifyCB) notifyCB(this, userparam, BURNERITEM_DECODEFINISHED, errorCode);
return errorCode;
}
fposition = 0;
LONG fposLow(0), fposHigh(0);
fposLow = SetFilePointer(fileHandle, 0, &fposHigh, FILE_CURRENT);
fposition = (((__int64)fposHigh) << 32) | fposLow;
DWORD decoded = 0;
sizeBytes = 0;
sizeSectors = 0;
double percent = 0.0;
int iopercent = -1;
percentCompleted = 0;
errorCode = BURNERITEM_DECODEPROGRESS;
do
{
unsigned __int8 buffer[DECODEBUFFER_SIZE] = {0};
int decode_killswitch=0, decode_error;
decoded = (DWORD)stream->ReadAudio(buffer, DECODEBUFFER_SIZE, &decode_killswitch, &decode_error);
if (decoded > 0)
{
DWORD written = 0;
if (!WriteFile(fileHandle, buffer, decoded, &written, NULL))
{
errorCode = BURNERITEM_WRITEERROR;
break;
}
sizeBytes += decoded;
double step = ((double)decoded) / (((double)length) * 176.4f)*100.0f;
percent += step;
percentCompleted = (int)percent;
if (iopercent != percentCompleted)
{
iopercent = percentCompleted;
if (notifyCB)
{
if (BURNERITEM_CONTINUE != notifyCB(this, userparam, BURNERITEM_DECODEPROGRESS, percentCompleted))
{
errorCode = BURNERITEM_DECODECANCELING;
break;
}
}
}
}
} while(decoded);
if (stream) manager->CloseDecoder(stream);
itemStatus = BURNERITEM_DECODED;
DWORD notifyCode = BURNERITEM_DECODEFINISHED;
switch(errorCode)
{
case BURNERITEM_DECODECANCELING:
errorCode = BURNERITEM_ABORTED;
itemStatus = BURNERITEM_ABORTED;
break;
case BURNERITEM_DECODEPROGRESS:
sizeSectors = (DWORD)(sizeBytes/2352 + ((sizeBytes%2352) ? 1 : 0));
errorCode = BURNERITEM_SUCCESS;
break;
}
if (notifyCB) notifyCB(this, userparam, notifyCode, errorCode);
return errorCode;
}
HRESULT BurnerItem::AddStream(obj_primo *primoSDK, void *fileHandle)
{
fhandle = fileHandle;
needSetFilePos = TRUE;
streamedSize = 0;
errorCode = primoSDK->AddAudioStream(StreamFiller, this, 0, GetSizeInSectors());
return errorCode;
}
void BurnerItem::SetPreGap(unsigned int preGap)
{
this->preGap = preGap;
}
void BurnerItem::SetISRC(unsigned __int8 *ISRC)
{
CopyMemory(this->ISRC, ISRC, 12);
}
int BurnerItem::GetStatus(DWORD *retCode)
{
if(retCode)
{
switch(itemStatus)
{
case BURNERITEM_DECODING:
case BURNERITEM_BURNING:
*retCode = percentCompleted;
break;
default:
*retCode = errorCode;
}
}
return itemStatus;
}
DWORD BurnerItem::StreamFiller(PBYTE pBuffer, DWORD dwBytesRequested, PDWORD pdwBytesWritten, PVOID pContext)
{
BurnerItem *item = (BurnerItem*) pContext;
if (item->needSetFilePos)
{
LONG fposLow = (LONG) item->fposition;
LONG fposHigh = (LONG) (item->fposition >> 32);
SetFilePointer(item->fhandle, fposLow, &fposHigh, FILE_BEGIN);
item->streamedSize = 0;
item->needSetFilePos = FALSE;
}
DWORD needToRead;
item->streamedSize += dwBytesRequested;
// check if we need to fill with zero
if (item->streamedSize > item->sizeBytes)
{
needToRead = (DWORD)min(0, ((long)item->sizeBytes) - long(item->streamedSize - dwBytesRequested));
}
else
{
needToRead = dwBytesRequested;
}
// read from file
if (needToRead)
{
*pdwBytesWritten = 0;
if (!ReadFile(item->fhandle, pBuffer, needToRead, pdwBytesWritten, NULL))
{
DWORD le = GetLastError();
item->itemStatus = BURNERITEM_BURNED;
item->errorCode = BURNERITEM_READSTREAMERROR;
}
//else
//{
// LONG fposLow(0), fposHigh(0);
// fposLow = SetFilePointer(item->fhandle, 0, &fposHigh, FILE_CURRENT);
// SetFilePointer(item->fhandle, -((LONG)*pdwBytesWritten), NULL, FILE_CURRENT);
// DWORD written(0);
// long needToZerro(*pdwBytesWritten)l
// while(needToZerro > 0)
// {
// DWORD write = min(ZEROMEM_SIZE*sizeof(DWORD), needToZerro);
// if (!WriteFile(item->fhandle, &zeroMem, write, &written, NULL)) break;
// needToZerro -= written;
// }
// SetFilePointer(item->fhandle, fposLow, &fposHigh, FILE_BEGIN);
//}
}
else
{
*pdwBytesWritten = 0;
}
return (BURNERITEM_SUCCESS == item->errorCode) ? PRIMOSDK_OK : PRIMOSDK_ERROR;
}
wchar_t* BurnerItem::DuplicateString(void *heap, const wchar_t *source, unsigned int cchSource)
{
wchar_t *dest = (wchar_t*) HeapAlloc(heap, NULL, (cchSource + 1) * sizeof(wchar_t));
CopyMemory(dest, source, cchSource * sizeof(wchar_t));
dest[cchSource] = 0x0000;
return dest;
}

105
Src/burnlib/item.h Normal file
View File

@@ -0,0 +1,105 @@
#pragma once
#include "./main.h"
#include "../Agave/DecodeFile/api_decodefile.h"
#include "../Agave/DecodeFile/ifc_audiostream.h"
#include "./manager.h"
//#include "../primo/obj_primo.h"
#define BURNERITEM_SUCCESS 0x0000
#define BURNERITEM_STATUS 0x0000
#define BURNERITEM_ERROR 0x1000
// states
#define BURNERITEM_SKIPPED 0x0100
#define BURNERITEM_READY 0x0101
#define BURNERITEM_LICENSING 0x0102
#define BURNERITEM_LICENSED 0x0103
#define BURNERITEM_DECODING 0x0104
#define BURNERITEM_DECODED 0x0105
#define BURNERITEM_BURNING 0x0106
#define BURNERITEM_BURNED 0x0107
// error codes
#define BURNERITEM_FAILED ((BURNERITEM_ERROR) + 0x001)
#define BURNERITEM_BADFILENAME ((BURNERITEM_ERROR) + 0x002)
#define BURNERITEM_UNABLEOPENFILE ((BURNERITEM_ERROR) + 0x003)
#define BURNERITEM_WRITEERROR ((BURNERITEM_ERROR) + 0x004)
#define BURNERITEM_DECODEERROR ((BURNERITEM_ERROR) + 0x005)
#define BURNERITEM_ALREADYCREATED ((BURNERITEM_ERROR) + 0x006)
#define BURNERITEM_ADDSTREAMFAILED ((BURNERITEM_ERROR) + 0x007)
#define BURNERITEM_READSTREAMERROR ((BURNERITEM_ERROR) + 0x008)
#define BURNERITEM_ABORTED ((BURNERITEM_ERROR) + 0x009)
#define BURNERITEM_CANCELING ((BURNERITEM_ERROR) + 0x00A)
// statuses
#define BURNERITEM_DECODESTARTING ((BURNERITEM_STATUS) + 0x001)
#define BURNERITEM_DECODEPROGRESS ((BURNERITEM_STATUS) + 0x002)
#define BURNERITEM_DECODECANCELING ((BURNERITEM_STATUS) + 0x003)
#define BURNERITEM_DECODEFINISHED ((BURNERITEM_STATUS) + 0x004)
// callback returns
#define BURNERITEM_CONTINUE 0
#define BURNERITEM_STOP 1
typedef DWORD (WINAPI *BURNERITEMCALLBACK)(void*, void*, DWORD, DWORD); // sender, parameter, notifyCode, errorCode
#define ZEROMEM_SIZE 1024
class BurnerItem
{
friend class BurnerPlaylist;
public:
BURNLIB_API BurnerItem(void);
BURNLIB_API ~BurnerItem(void);
public:
BURNLIB_API HRESULT Create(const wchar_t *fullname, const wchar_t *title, int length);
BURNLIB_API void Destroy(void);
BURNLIB_API HRESULT Decode(BurnManager *manager, void *fileHandle, BURNERITEMCALLBACK notifyCB, void *userparam);
BURNLIB_API HRESULT AddStream(obj_primo *primoSDK, void *fileHandle);
public:
BURNLIB_API const wchar_t* GetFullName(void) { return fullname; }
BURNLIB_API const wchar_t* GetTitle(void) { return title; }
BURNLIB_API int GetLength(void) { return length; }
BURNLIB_API unsigned __int64 GetSize(void) { return sizeBytes; }
BURNLIB_API DWORD GetSizeInSectors(void) { return sizeSectors; }
BURNLIB_API unsigned int GetPreGap(void) { return preGap; }
BURNLIB_API unsigned __int8* GetISRC(void) { return ISRC; }
BURNLIB_API __int64 GetDecodedFilePosition(void) { return fposition; }
BURNLIB_API int GetStatus(DWORD *retCode); // if retCode not NULL - can return completed percentage or error code
void SetPreGap(unsigned int preGap);
void SetISRC(unsigned __int8 *ISRC);
protected:
static wchar_t* DuplicateString(void *heap, const wchar_t *source, unsigned int cchSource);
static DWORD StreamFiller(PBYTE pBuffer, DWORD dwBytesRequested, PDWORD pdwBytesWritten, PVOID pContext);
protected:
void *heap;
wchar_t *fullname;
wchar_t *title;
int length;
unsigned __int64 sizeBytes;
DWORD sizeSectors;
unsigned int preGap;
unsigned __int8 ISRC[12];
void* fhandle;
__int64 fposition;
BOOL needSetFilePos;
unsigned __int64 streamedSize;
int percentCompleted;
int itemStatus;
DWORD errorCode;
static DWORD zeroMem[ZEROMEM_SIZE];
};

24
Src/burnlib/main.cpp Normal file
View File

@@ -0,0 +1,24 @@
// burnlib.cpp : Defines the entry point for the DLL application.
//
#include "main.h"
extern api_service *serviceManager;
api_language *WASABI_API_LNG_BURN = 0;
HINSTANCE dllInstance = NULL;
HMODULE hResource = NULL;
HWND winampWnd = NULL;
// must be first call before you start using library
void InitializeBurningLibrary(api_service *wasabiServiceManager, HINSTANCE _dllInstance, HWND _winampWnd)
{
dllInstance = _dllInstance;
serviceManager = wasabiServiceManager;
winampWnd = _winampWnd;
waServiceFactory *sf = serviceManager->service_getServiceByGuid(languageApiGUID);
if (sf) WASABI_API_LNG_BURN = reinterpret_cast<api_language*>(sf->getInterface());
// need to have this initialised before we try to do anything with localisation features
hResource = WASABI_API_LNG_BURN->StartLanguageSupport(LoadLibraryW(L"burnlib.dll"),burnlibLangGUID);
}

30
Src/burnlib/main.h Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include <windows.h>
#ifdef BURNLIB_EXPORTS
#define BURNLIB_API //__declspec(dllexport)
#else
#define BURNLIB_API //__declspec(dllimport)
#endif
extern HINSTANCE dllInstance;
extern HMODULE hResource;
extern HWND winampWnd;
#include <api/service/api_service.h>
#include <api/service/waServiceFactory.h>
#include "../Agave/Language/api_language.h"
#include "./primosdk.h"
//library Initialization
BURNLIB_API void InitializeBurningLibrary(api_service *wasabiServiceManager, HINSTANCE, HWND);
// text values (englsih)
BURNLIB_API wchar_t* GetMediumText(wchar_t *buffer, unsigned int cchBuffer, DWORD medium);
BURNLIB_API wchar_t* GetMediumTypeText(wchar_t *buffer, unsigned int cchBuffer, DWORD type);
BURNLIB_API wchar_t* GetMediumFormatText(wchar_t *buffer, unsigned int cchBuffer, DWORD format);
BURNLIB_API wchar_t* GetUnitStatusText(wchar_t *buffer, unsigned int cchBuffer, DWORD sense, DWORD asc, DWORD ascq);
BURNLIB_API wchar_t* GetTrackTypeText(wchar_t *buffer, unsigned int cchBuffer, DWORD trackType);
BURNLIB_API wchar_t* GetPrimoCodeText(wchar_t *buffer, unsigned int cchBuffer, DWORD primoCode);
BURNLIB_API wchar_t* GetBussText(wchar_t *buffer, unsigned int cchBuffer, DWORD bussType);
wchar_t* GetTimeString(wchar_t *string, unsigned int cchLen, unsigned int timesec);

42
Src/burnlib/manager.h Normal file
View File

@@ -0,0 +1,42 @@
#pragma once
#include "../Agave/DecodeFile/ifc_audiostream.h"
#include "../Agave/DecodeFile/api_decodefile.h"
enum
{
BURN_OK = 0, // OK to burn
BURN_GENERAL_FAILURE = 1, // can't burn, not 100% sure why
BURN_FILE_NOT_FOUND = 2, // file doesn't exist
BURN_DRM_NO_LICENSE = 3, // user doesn't have a license to open this DRM protected track
BURN_DRM_NOT_ALLOWED = 4, // DRM license disallows burning
BURN_DRM_BURN_COUNT_EXCEEDED= 5, // user has done too many burns already
BURN_NO_DECODER=6, // no decoder was found to decompress this file
};
typedef unsigned __int32 WRESULT;
class BurnManagerCallback
{
public:
virtual void OnLicenseCallback(size_t numFiles, WRESULT *results) = 0;
};
class BurnManager
{
public:
BurnManager();
~BurnManager();
public:
void SetDecodeAPI(api_decodefile *decoderAPI);
api_decodefile *GetDecodeAPI(void);
void SetFiles(size_t numFiles, const wchar_t **filenames, BurnManagerCallback *callback);
ifc_audiostream *CreateDecoder(const wchar_t *filename);
void CloseDecoder(ifc_audiostream *decoder);
void CancelBurn();
void BurnFinished();
private:
api_decodefile *decodeFile;
void *context; // pImpl (pointer to implementation)
};

686
Src/burnlib/playlist.cpp Normal file
View File

@@ -0,0 +1,686 @@
#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

157
Src/burnlib/playlist.h Normal file
View File

@@ -0,0 +1,157 @@
#ifndef NULLSOFT_BurnerPlaylist_HEADER
#define NULLSOFT_BurnerPlaylist_HEADER
#include "./main.h"
#include "./api.h"
#include <api/service/waServiceFactory.h>
#include "../playlist/api_playlistmanager.h"
#include "../playlist/ifc_playlistloadercallback.h"
#include "../winamp/api_decodefile.h"
#include "../nu/vector.h"
#include "./item.h"
#include "./manager.h"
#define BURNERPLAYLIST_SUCCESS 0x0000
#define BURNERPLAYLIST_STATUS 0x0000
#define BURNERPLAYLIST_ERROR 0x1000
// error codes
#define BURNERPLAYLIST_FAILED ((BURNERPLAYLIST_ERROR) + 0x001)
#define BURNERPLAYLIST_BADFILENAME ((BURNERPLAYLIST_ERROR) + 0x002)
#define BURNERPLAYLIST_UNABLEOPENFILE ((BURNERPLAYLIST_ERROR) + 0x003)
#define BURNERPLAYLIST_WRITEERROR ((BURNERPLAYLIST_ERROR) + 0x004)
#define BURNERPLAYLIST_DECODEERROR ((BURNERPLAYLIST_ERROR) + 0x005)
#define BURNERPLAYLIST_DECODESERVICEFAILED ((BURNERPLAYLIST_ERROR) + 0x006)
#define BURNERPLAYLIST_THREADCREATEFAILED ((BURNERPLAYLIST_ERROR) + 0x007)
#define BURNERPLAYLIST_NOFILES ((BURNERPLAYLIST_ERROR) + 0x008)
#define BURNERPLAYLIST_WRONGFILECOUNT ((BURNERPLAYLIST_ERROR) + 0x009)
//
#define BURNERPLAYLIST_ABORTED ((BURNERPLAYLIST_STATUS) +0x100)
#define BURNERPLAYLIST_DECODENEXTITEM ((BURNERPLAYLIST_ERROR) + 0x111)
#define BURNERPLAYLIST_DECODEITEM ((BURNERPLAYLIST_ERROR) + 0x112)
#define BURNERPLAYLIST_NEWAUDIOFAILED ((BURNERPLAYLIST_ERROR) + 0x131)
#define BURNERPLAYLIST_ADDITEMFAILED ((BURNERPLAYLIST_ERROR) + 0x132)
#define BURNERPLAYLIST_ADDITEMSKIPPED ((BURNERPLAYLIST_ERROR) + 0x133)
#define BURNERPLAYLIST_ITEMADDED ((BURNERPLAYLIST_ERROR) + 0x134)
#define BURNERPLAYLIST_BEGINBURN ((BURNERPLAYLIST_ERROR) + 0x135)
#define BURNERPLAYLIST_ENDBURN ((BURNERPLAYLIST_ERROR) + 0x136)
#define BURNERPLAYLIST_BEGINBURNFAILED ((BURNERPLAYLIST_ERROR) + 0x137)
#define BURNERPLAYLIST_ENDBURNFAILED ((BURNERPLAYLIST_ERROR) + 0x138)
#define BURNERPLAYLIST_WRITEAUDIOFAILED ((BURNERPLAYLIST_ERROR) + 0x139)
#define BURNERPLAYLIST_WRITELEADIN ((BURNERPLAYLIST_ERROR) + 0x13A)
#define BURNERPLAYLIST_WRITEDATA ((BURNERPLAYLIST_ERROR) + 0x13B)
#define BURNERPLAYLIST_WRITELEADOUT ((BURNERPLAYLIST_ERROR) + 0x13C)
#define BURNERPLAYLIST_DISCOPEN ((BURNERPLAYLIST_ERROR) + 0x13D)
#define BURNERPLAYLIST_DISCCLOSE ((BURNERPLAYLIST_ERROR) + 0x13E)
#define BURNERPLAYLIST_WRITEITEMBEGIN ((BURNERPLAYLIST_ERROR) + 0x13F)
#define BURNERPLAYLIST_WRITEITEMEND ((BURNERPLAYLIST_ERROR) + 0x140)
#define BURNERPLAYLIST_BURNFAILED ((BURNERPLAYLIST_ERROR) + 0x141)
//
#define BURNERPLAYLIST_FILENOTLICENSED ((BURNERPLAYLIST_ERROR) + 0x150)
// statuses
#define BURNERPLAYLIST_LICENSINGFINISHED ((BURNERPLAYLIST_STATUS) + 0x001)
#define BURNERPLAYLIST_LICENSINGSTARTING ((BURNERPLAYLIST_STATUS) + 0x002)
#define BURNERPLAYLIST_LICENSINGPROGRESS ((BURNERPLAYLIST_STATUS) + 0x003)
#define BURNERPLAYLIST_DECODEFINISHED ((BURNERPLAYLIST_STATUS) + 0x010)
#define BURNERPLAYLIST_DECODESTARTING ((BURNERPLAYLIST_STATUS) + 0x011)
#define BURNERPLAYLIST_DECODEPROGRESS ((BURNERPLAYLIST_STATUS) + 0x012)
#define BURNERPLAYLIST_DECODECANCELING ((BURNERPLAYLIST_STATUS) + 0x013)
#define BURNERPLAYLIST_BURNFINISHED ((BURNERPLAYLIST_STATUS) + 0x031)
#define BURNERPLAYLIST_BURNSTARTING ((BURNERPLAYLIST_STATUS) + 0x032)
#define BURNERPLAYLIST_BURNPROGRESS ((BURNERPLAYLIST_STATUS) + 0x033)
#define BURNERPLAYLIST_BURNCANCELING ((BURNERPLAYLIST_STATUS) + 0x034)
#define BURNERPLAYLIST_BURNFINISHING ((BURNERPLAYLIST_STATUS) + 0x035)
// callback returns
#define BURNERPLAYLIST_CONTINUE 0
#define BURNERPLAYLIST_STOP 1
typedef Vector<BurnerItem*> BurnerVector;
typedef struct _BPLDECODEINFO
{
BurnerItem *iInstance;
int iIndex;
DWORD iNotifyCode;
DWORD iErrorCode;
float percentCompleted;
}BPLDECODEINFO;
typedef struct _BPLRUNSTATUS
{
DWORD sCurrent;
DWORD sTotal;
BurnerItem *iInstance;
int iIndex;
float percentCompleted;
}BPLRUNSTATUS;
typedef DWORD (WINAPI *BURNERPLAYLISTCALLBACK)(void *sender, void *userparam, DWORD notifyCode, DWORD errorCode, ULONG_PTR param);
class BurnerPlaylist : private ifc_playlistloadercallback, BurnerVector, BurnManagerCallback
{
public:
BURNLIB_API BurnerPlaylist(void);
BURNLIB_API ~BurnerPlaylist(void);
BURNLIB_API HRESULT Load(const wchar_t *filename);
BURNLIB_API HRESULT CheckLicense(BURNERPLAYLISTCALLBACK notifyCB, void *userparam);
BURNLIB_API HRESULT Decode(void* hFile, BURNERPLAYLISTCALLBACK notifyCB, void *userparam, BOOL block);
BURNLIB_API HRESULT Burn(obj_primo *primoSDK, DWORD drive, DWORD maxspeed, DWORD burnFlags, void* hFile,
BURNERPLAYLISTCALLBACK notifyCB, void *userparam, BOOL block);
BURNLIB_API DWORD AddCompilationToCDDB(void);
BURNLIB_API size_t GetCount(void) { return size(); }
BURNLIB_API DWORD GetTotalLengthMS(void) { return length; }
BURNLIB_API BurnerItem* &operator[](size_t index) { return BurnerVector::at(index); }
BURNLIB_API BurnerItem* &at(size_t index) { return BurnerVector::at(index); }
BURNLIB_API DWORD GetTotalSectors(void);
BURNLIB_API BOOL SetEjectWhenDone(BOOL eject) { BOOL tmp = ejectDone; ejectDone = eject; return tmp; }
BURNLIB_API DWORD GetStatus(DWORD *retCode); // if retCode not NULL - can return completed percentage or error code
// state based calls
BURNLIB_API size_t GetStateCount(DWORD state, DWORD code);
BURNLIB_API DWORD GetStateLengthMS(DWORD state, DWORD code);
BURNLIB_API DWORD GetStateSectors(DWORD state, DWORD code);
protected:
static DWORD WINAPI DecodeWorker(void* param);
static DWORD WINAPI BurnerWorker(void* param);
void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info);
static DWORD WINAPI OnItemDecode(void* sender, void *param, DWORD notifyCode, DWORD errorCode);
DWORD OnNotify(DWORD notifyCode, DWORD errorCode, ULONG_PTR param);
void OnLicenseCallback(size_t numFiles, WRESULT *results);
RECVS_DISPATCH;
protected:
unsigned long length;
wchar_t tmpfullname;
obj_primo *primoSDK;
DWORD drive;
BURNERPLAYLISTCALLBACK notifyCB;
void *userparam;
HANDLE hThread;
HANDLE hFile;
BPLDECODEINFO *activeDecode;
float percentStep;
DWORD maxspeed;
DWORD burnFlags;
DWORD statusCode;
DWORD errorCode;
HANDLE evntCancel;
BOOL ejectDone;
BurnManager manager;
};
#endif //NULLSOFT_BurnerPlaylist_HEADER

53
Src/burnlib/primosdk.h Normal file
View File

@@ -0,0 +1,53 @@
#ifndef NULLSOFT_PRIMOSDK_INTEGRATION_HEADER
#define NULLSOFT_PRIMOSDK_INTEGRATION_HEADER
#include "./main.h"
// PrimoSDK wrapper
#define PRIMOSDK_OK 0x0000 - declared in PRIMODSK.H
#define PRIMOSDK_ERROR 0x0001
#define PRIMOSDK_ALREADYLOADED 0x1000
#define PRIMOSDK_LOAD_DLLFAILED 0x1001
#define PRIMOSDK_LOAD_FUNCFAILED 0x1002
#define PRIMOSDK_NOTLOADED 0x1003
#define PRIMOSDK_FUNCNOTLOADED 0x1004
#define PRIMOSDK_NULLHANDLE 0x1005
#define PRIMOSDK_INTERR 0x1006
#define PRIMOSDK_UNLOCK 0
#define PRIMOSDK_WRITE 0
#include "../primo/obj_primo.h"
// MAXDWORD - for not care
typedef struct _WAMEDIUMINFO
{
DWORD medium;
DWORD mediumType;
DWORD tracks;
DWORD mediumFormat;
DWORD freeSectors;
DWORD usedSectors;
DWORD protectedDVD;
DWORD erasable;
DWORD recordable;
DWORD isCD;
DWORD isDCD;
DWORD isDVD;
DWORD isDLDVD;
}WAMEDIUMINFO;
typedef struct _WABURNSTRUCT
{
obj_primo *primoSDK; // sdk object
DWORD drive; // working drive (filled by BeginBurn)
PBYTE blocker; // current blocker name (filled by BeginBurn)
int eject; // if set to TRUE - endBurn will eject disc otherwise just stop motor
} WABURNSTRUCT; // passed to the BeginBurn or EndBurn functions
BURNLIB_API DWORD GetMediumInfo(obj_primo *primoSDK, DWORD *drive, WAMEDIUMINFO *info);
BURNLIB_API DWORD BeginBurn(obj_primo *primoSDK, DWORD drive, WABURNSTRUCT *burnstruct);
BURNLIB_API DWORD EndBurn(WABURNSTRUCT *burnstruct);
#endif // NULLSOFT_PRIMOSDK_INTEGRATION_HEADER

225
Src/burnlib/resdll/resdll.vcproj Normal file
View File

@@ -0,0 +1,225 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="burnlibres"
ProjectGUID="{8FBD5E01-B920-44D8-9687-88AE0C3CA833}"
RootNamespace="burnlibres"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="Debug"
IntermediateDirectory="Debug"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;RESDLL_EXPORTS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
IgnoreImportLibrary="true"
ShowProgress="0"
OutputFile="$(ProgramFiles)\Winamp\burnlib.dll"
LinkIncremental="1"
IgnoreAllDefaultLibraries="true"
IgnoreDefaultLibraryNames="msvcrtd.lib"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/resdll.pdb"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
ResourceOnlyDLL="true"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary="../lib/burnlibres.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
WholeProgramOptimization="0"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;RESDLL_EXPORTS"
RuntimeLibrary="0"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
IgnoreImportLibrary="true"
ShowProgress="0"
OutputFile="$(ProgramFiles)\Winamp\burnlib.dll"
LinkIncremental="1"
GenerateManifest="false"
IgnoreAllDefaultLibraries="true"
GenerateDebugInformation="false"
ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
ResourceOnlyDLL="true"
RandomizedBaseAddress="1"
ImportLibrary="../lib/burnlibres.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath="..\resource.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
<File
RelativePath="..\burnlib.rc"
>
</File>
<File
RelativePath="..\resources\disc1.bmp"
>
</File>
<File
RelativePath="..\resources\drive1.bmp"
>
</File>
<File
RelativePath="..\resources\testmode.bmp"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

650
Src/burnlib/resource.h Normal file
View File

@@ -0,0 +1,650 @@
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by burnlib.rc
//
#define IDD_DLG_UNITNOTREADY 9
#define IDD_DLG_WRONGMEDIUM 102
#define IDD_DLG_ERASEMEDIUMSTATUS 103
#define IDD_DLG_ERASEMEDIUMPREPARE 104
#define IDD_DLG_UPDATING 105
#define IDB_DRIVE1 106
#define IDB_DISC1 107
#define IDD_DLG_BURNER 108
#define IDB_TESTMODE 109
#define IDS_MEDIUM_BDR 110
#define IDS_COLUMN_INDEX 111
#define IDS_COLUMN_TITLE 112
#define IDS_COLUMN_DURATION 113
#define IDD_DLG 113
#define IDD_DLG_COMPILATION 113
#define IDS_COLUMN_STATUS 114
#define IDS_COLUMN_FILE 115
#define IDS_OK 116
#define IDS_CANCEL 117
#define IDS_STOP 118
#define IDS_CLOSE 119
#define IDS_UNKNOWN 120
#define IDS_YES 121
#define IDS_NO 122
#define IDS_MEDIUM_CD 123
#define IDS_MEDIUM_CDR 124
#define IDS_MEDIUM_CDRW 125
#define IDS_MEDIUM_DVD 126
#define IDS_MEDIUM_DVDR 127
#define IDS_MEDIUM_DVDRW 128
#define IDS_MEDIUM_DVDPR 129
#define IDS_MEDIUM_DVDPRW 130
#define IDS_MEDIUM_DVDRAM 131
#define IDS_MEDIUM_DDCD 132
#define IDS_MEDIUM_DDCDR 133
#define IDS_MEDIUM_DDCDRW 134
#define IDS_MEDIUM_DVDPR9 135
#define IDS_MEDIUM_DVDR9 136
#define IDS_MEDIUM_BDRE 137
#define IDS_MEDIUMTYPE_SILVER 138
#define IDS_MEDIUMTYPE_COMPILATIONGOLD 139
#define IDS_MEDIUMTYPE_OTHERGOLD 140
#define IDS_MEDIUMTYPE_BLANK 141
#define IDS_MEDIUMFORMAT_B1 142
#define IDS_MEDIUMFORMAT_D1 143
#define IDS_MEDIUMFORMAT_D2 144
#define IDS_MEDIUMFORMAT_D3 145
#define IDS_MEDIUMFORMAT_D4 146
#define IDS_MEDIUMFORMAT_D5 147
#define IDS_MEDIUMFORMAT_D6 148
#define IDS_MEDIUMFORMAT_D7 149
#define IDS_MEDIUMFORMAT_D8 150
#define IDS_MEDIUMFORMAT_D9 151
#define IDS_MEDIUMFORMAT_A1 152
#define IDS_MEDIUMFORMAT_A2 153
#define IDS_MEDIUMFORMAT_A3 154
#define IDS_MEDIUMFORMAT_A4 155
#define IDS_MEDIUMFORMAT_A5 156
#define IDS_MEDIUMFORMAT_M1 157
#define IDS_MEDIUMFORMAT_M2 158
#define IDS_MEDIUMFORMAT_M3 159
#define IDS_MEDIUMFORMAT_M4 160
#define IDS_MEDIUMFORMAT_M5 161
#define IDS_MEDIUMFORMAT_M6 162
#define IDS_MEDIUMFORMAT_F1 163
#define IDS_MEDIUMFORMAT_F2 164
#define IDS_MEDIUMFORMAT_F3 165
#define IDS_MEDIUMFORMAT_F4 166
#define IDS_MEDIUMFORMAT_F5 167
#define IDS_MEDIUMFORMAT_F8 168
#define IDS_MEDIUMFORMAT_FA 169
#define IDS_MEDIUMFORMAT_GENERICCD 170
#define IDS_BUSSTYPE_ATAPI 171
#define IDS_BUSSTYPE_SCSI 172
#define IDS_BUSSTYPE_1394 173
#define IDS_BUSSTYPE_USB 174
#define IDS_BUSSTYPE_USB2 175
#define IDS_TRACKTYPE_AUDIO 176
#define IDS_TRACKTYPE_TRACK1 177
#define IDS_TRACKTYPE_TRACK2 178
#define IDS_PRIMOCODE_OK 179
#define IDS_PRIMOCODE_CMDSEQUENCE 180
#define IDS_PRIMOCODE_NOASPI 181
#define IDS_PRIMOCODE_INTERR 182
#define IDS_PRIMOCODE_BADPARAM 183
#define IDS_PRIMOCODE_ALREADYEXIST 184
#define IDS_PRIMOCODE_NOTREADABLE 185
#define IDS_PRIMOCODE_NOSPACE 186
#define IDS_PRIMOCODE_INVALIDMEDIUM 187
#define IDS_PRIMOCODE_RUNNING 188
#define IDS_PRIMOCODE_BUR 189
#define IDS_PRIMOCODE_SCSIERROR 190
#define IDS_PRIMOCODE_UNITERROR 191
#define IDS_PRIMOCODE_NOTREADY 192
#define IDS_PRIMOCODE_INVALIDSOURCE 193
#define IDS_PRIMOCODE_INCOMPATIBLE 194
#define IDS_PRIMOCODE_FILEERROR 195
#define IDS_PRIMOCODE_ITSADEMO 196
#define IDS_PRIMOCODE_USERABORT 197
#define IDS_PRIMOCODE_BADHANDLE 198
#define IDS_PRIMOCODE_BADUNIT 199
#define IDS_PRIMOCODE_ERRORLOADING 200
#define IDS_PRIMOCODE_NOAINCONTROL 201
#define IDS_PRIMOCODE_READERROR 202
#define IDS_PRIMOCODE_WRITEERROR 203
#define IDS_PRIMOCODE_TMPOVERFLOW 204
#define IDS_PRIMOCODE_DVDSTRUCTERROR 205
#define IDS_PRIMOCODE_FILETOOLARGE 206
#define IDS_PRIMOCODE_CACHEFULL 207
#define IDS_PRIMOCODE_FEATURE_NOT_SUPPORTED 208
#define IDS_PRIMOCODE_FEATURE_DISABLED 209
#define IDS_PRIMOCODE_CALLBACK_ERROR 210
#define IDS_PRIMOCODE_PROTECTEDWMA 211
#define IDS_DRIVEERRORCODE_000000 212
#define IDS_DRIVEERRORCODE_000001 213
#define IDS_DRIVEERRORCODE_000002 214
#define IDS_DRIVEERRORCODE_000003 215
#define IDS_DRIVEERRORCODE_000004 216
#define IDS_DRIVEERRORCODE_000005 217
#define IDS_DRIVEERRORCODE_000011 218
#define IDS_DRIVEERRORCODE_000012 219
#define IDS_DRIVEERRORCODE_000013 220
#define IDS_DRIVEERRORCODE_000014 221
#define IDS_DRIVEERRORCODE_000015 222
#define IDS_DRIVEERRORCODE_000016 223
#define IDS_DRIVEERRORCODE_010B00 224
#define IDS_DRIVEERRORCODE_010B01 225
#define IDS_DRIVEERRORCODE_010B02 226
#define IDS_DRIVEERRORCODE_010C0A 227
#define IDS_DRIVEERRORCODE_011700 228
#define IDS_DRIVEERRORCODE_011701 229
#define IDS_DRIVEERRORCODE_011702 230
#define IDS_DRIVEERRORCODE_011703 231
#define IDS_DRIVEERRORCODE_011704 232
#define IDS_DRIVEERRORCODE_011705 233
#define IDS_DRIVEERRORCODE_011706 234
#define IDS_DRIVEERRORCODE_011707 235
#define IDS_DRIVEERRORCODE_011708 236
#define IDS_DRIVEERRORCODE_011709 237
#define IDS_DRIVEERRORCODE_011800 238
#define IDS_DRIVEERRORCODE_011801 239
#define IDS_DRIVEERRORCODE_011802 240
#define IDS_DRIVEERRORCODE_011803 241
#define IDS_DRIVEERRORCODE_011804 242
#define IDS_DRIVEERRORCODE_011805 243
#define IDS_DRIVEERRORCODE_011806 244
#define IDS_DRIVEERRORCODE_011807 245
#define IDS_DRIVEERRORCODE_011808 246
#define IDS_DRIVEERRORCODE_011E00 247
#define IDS_DRIVEERRORCODE_013700 248
#define IDS_DRIVEERRORCODE_015D00 249
#define IDS_DRIVEERRORCODE_015D01 250
#define IDS_DRIVEERRORCODE_015DFF 251
#define IDS_DRIVEERRORCODE_016A00 252
#define IDS_DRIVEERRORCODE_017301 253
#define IDS_DRIVEERRORCODE_017306 254
#define IDS_DRIVEERRORCODE_020400 255
#define IDS_DRIVEERRORCODE_020401 256
#define IDS_DRIVEERRORCODE_020402 257
#define IDS_DRIVEERRORCODE_020403 258
#define IDS_DRIVEERRORCODE_020404 259
#define IDS_DRIVEERRORCODE_020405 260
#define IDS_DRIVEERRORCODE_020406 261
#define IDS_DRIVEERRORCODE_020407 262
#define IDS_DRIVEERRORCODE_020408 263
#define IDS_DRIVEERRORCODE_020500 264
#define IDS_DRIVEERRORCODE_020600 265
#define IDS_DRIVEERRORCODE_023000 266
#define IDS_DRIVEERRORCODE_023001 267
#define IDS_DRIVEERRORCODE_023002 268
#define IDS_DRIVEERRORCODE_023003 269
#define IDS_DRIVEERRORCODE_023004 270
#define IDS_DRIVEERRORCODE_023005 271
#define IDS_DRIVEERRORCODE_023007 272
#define IDS_DRIVEERRORCODE_023502 273
#define IDS_DRIVEERRORCODE_023A00 274
#define IDS_DRIVEERRORCODE_023A01 275
#define IDS_DRIVEERRORCODE_023A02 276
#define IDS_DRIVEERRORCODE_023E00 277
#define IDS_DRIVEERRORCODE_025300 278
#define IDS_DRIVEERRORCODE_025302 279
#define IDS_DRIVEERRORCODE_025700 280
#define IDS_DRIVEERRORCODE_026800 281
#define IDS_DRIVEERRORCODE_030014 282
#define IDS_DRIVEERRORCODE_030200 283
#define IDS_DRIVEERRORCODE_030280 284
#define IDS_DRIVEERRORCODE_030281 285
#define IDS_DRIVEERRORCODE_030282 286
#define IDS_DRIVEERRORCODE_030283 287
#define IDS_DRIVEERRORCODE_030300 288
#define IDS_DRIVEERRORCODE_030301 289
#define IDS_DRIVEERRORCODE_030302 290
#define IDS_DRIVEERRORCODE_030600 291
#define IDS_DRIVEERRORCODE_030C00 292
#define IDS_DRIVEERRORCODE_030C01 293
#define IDS_DRIVEERRORCODE_030C02 294
#define IDS_DRIVEERRORCODE_030C03 295
#define IDS_DRIVEERRORCODE_030C04 296
#define IDS_DRIVEERRORCODE_030C05 297
#define IDS_DRIVEERRORCODE_030C06 298
#define IDS_DRIVEERRORCODE_030C07 299
#define IDS_DRIVEERRORCODE_030C08 300
#define IDS_DRIVEERRORCODE_030C09 301
#define IDS_DRIVEERRORCODE_030C0A 302
#define IDS_DRIVEERRORCODE_031000 303
#define IDS_DRIVEERRORCODE_031100 304
#define IDS_DRIVEERRORCODE_031101 305
#define IDS_DRIVEERRORCODE_031102 306
#define IDS_DRIVEERRORCODE_031103 307
#define IDS_DRIVEERRORCODE_031104 308
#define IDS_DRIVEERRORCODE_031105 309
#define IDS_DRIVEERRORCODE_031106 310
#define IDS_DRIVEERRORCODE_031107 311
#define IDS_DRIVEERRORCODE_031108 312
#define IDS_DRIVEERRORCODE_031109 313
#define IDS_DRIVEERRORCODE_03110A 314
#define IDS_DRIVEERRORCODE_03110B 315
#define IDS_DRIVEERRORCODE_03110C 316
#define IDS_DRIVEERRORCODE_03110D 317
#define IDS_DRIVEERRORCODE_03110E 318
#define IDS_DRIVEERRORCODE_03110F 319
#define IDS_DRIVEERRORCODE_031110 320
#define IDS_DRIVEERRORCODE_031200 321
#define IDS_DRIVEERRORCODE_031300 322
#define IDS_DRIVEERRORCODE_031400 323
#define IDS_DRIVEERRORCODE_031401 324
#define IDS_DRIVEERRORCODE_031402 325
#define IDS_DRIVEERRORCODE_031403 326
#define IDS_DRIVEERRORCODE_031404 327
#define IDS_DRIVEERRORCODE_031405 328
#define IDS_DRIVEERRORCODE_031406 329
#define IDS_DRIVEERRORCODE_031500 330
#define IDS_DRIVEERRORCODE_031501 331
#define IDS_DRIVEERRORCODE_031502 332
#define IDS_DRIVEERRORCODE_031600 333
#define IDS_DRIVEERRORCODE_031601 334
#define IDS_DRIVEERRORCODE_031602 335
#define IDS_DRIVEERRORCODE_031603 336
#define IDS_DRIVEERRORCODE_031604 337
#define IDS_DRIVEERRORCODE_031900 338
#define IDS_DRIVEERRORCODE_031901 339
#define IDS_DRIVEERRORCODE_031902 340
#define IDS_DRIVEERRORCODE_031903 341
#define IDS_DRIVEERRORCODE_031F00 342
#define IDS_DRIVEERRORCODE_032D00 343
#define IDS_DRIVEERRORCODE_033000 344
#define IDS_DRIVEERRORCODE_033100 345
#define IDS_DRIVEERRORCODE_033101 346
#define IDS_DRIVEERRORCODE_033102 347
#define IDS_DRIVEERRORCODE_033200 348
#define IDS_DRIVEERRORCODE_033201 349
#define IDS_DRIVEERRORCODE_033300 350
#define IDS_DRIVEERRORCODE_033600 351
#define IDS_DRIVEERRORCODE_033B00 352
#define IDS_DRIVEERRORCODE_033B01 353
#define IDS_DRIVEERRORCODE_033B02 354
#define IDS_DRIVEERRORCODE_033B03 355
#define IDS_DRIVEERRORCODE_033B06 356
#define IDS_DRIVEERRORCODE_033B07 357
#define IDS_DRIVEERRORCODE_033B08 358
#define IDS_DRIVEERRORCODE_033B09 359
#define IDS_DRIVEERRORCODE_033B0A 360
#define IDS_DRIVEERRORCODE_033B0B 361
#define IDS_DRIVEERRORCODE_033B0C 362
#define IDS_DRIVEERRORCODE_035100 363
#define IDS_DRIVEERRORCODE_035200 364
#define IDS_DRIVEERRORCODE_035700 365
#define IDS_DRIVEERRORCODE_035C02 366
#define IDS_DRIVEERRORCODE_036100 367
#define IDS_DRIVEERRORCODE_036101 368
#define IDS_DRIVEERRORCODE_036102 369
#define IDS_DRIVEERRORCODE_036C00 370
#define IDS_DRIVEERRORCODE_036D00 371
#define IDS_DRIVEERRORCODE_0370NN 372
#define IDS_DRIVEERRORCODE_037100 373
#define IDS_DRIVEERRORCODE_037200 374
#define IDS_DRIVEERRORCODE_037201 375
#define IDS_DRIVEERRORCODE_037202 376
#define IDS_DRIVEERRORCODE_037300 377
#define IDS_DRIVEERRORCODE_037302 378
#define IDS_DRIVEERRORCODE_037303 379
#define IDS_DRIVEERRORCODE_037304 380
#define IDS_DRIVEERRORCODE_037305 381
#define IDS_DRIVEERRORCODE_040017 382
#define IDS_DRIVEERRORCODE_040100 383
#define IDS_DRIVEERRORCODE_040500 384
#define IDS_DRIVEERRORCODE_040800 385
#define IDS_DRIVEERRORCODE_040801 386
#define IDS_DRIVEERRORCODE_040802 387
#define IDS_DRIVEERRORCODE_040803 388
#define IDS_DRIVEERRORCODE_040900 389
#define IDS_DRIVEERRORCODE_040901 390
#define IDS_DRIVEERRORCODE_040902 391
#define IDS_DRIVEERRORCODE_040903 392
#define IDS_DRIVEERRORCODE_040904 393
#define IDS_DRIVEERRORCODE_041B00 394
#define IDS_DRIVEERRORCODE_041C00 395
#define IDS_DRIVEERRORCODE_041C01 396
#define IDS_DRIVEERRORCODE_041C02 397
#define IDS_DRIVEERRORCODE_043400 398
#define IDS_DRIVEERRORCODE_043500 399
#define IDS_DRIVEERRORCODE_043503 400
#define IDS_DRIVEERRORCODE_043B04 401
#define IDS_DRIVEERRORCODE_043B05 402
#define IDS_DRIVEERRORCODE_043B16 403
#define IDS_DRIVEERRORCODE_043E01 404
#define IDS_DRIVEERRORCODE_043E02 405
#define IDS_DRIVEERRORCODE_044000 406
#define IDS_DRIVEERRORCODE_0440NN 407
#define IDS_DRIVEERRORCODE_044100 408
#define IDS_DRIVEERRORCODE_044200 409
#define IDS_DRIVEERRORCODE_044400 410
#define IDS_DRIVEERRORCODE_044600 411
#define IDS_DRIVEERRORCODE_044700 412
#define IDS_DRIVEERRORCODE_044A00 413
#define IDS_DRIVEERRORCODE_044B00 414
#define IDS_DRIVEERRORCODE_044C00 415
#define IDS_DRIVEERRORCODE_045300 416
#define IDS_DRIVEERRORCODE_045400 417
#define IDS_DRIVEERRORCODE_046000 418
#define IDS_DRIVEERRORCODE_046200 419
#define IDS_DRIVEERRORCODE_046500 420
#define IDS_DRIVEERRORCODE_046600 421
#define IDS_DRIVEERRORCODE_046601 422
#define IDS_DRIVEERRORCODE_046602 423
#define IDS_DRIVEERRORCODE_046603 424
#define IDS_DRIVEERRORCODE_046700 425
#define IDS_DRIVEERRORCODE_046701 426
#define IDS_DRIVEERRORCODE_046702 427
#define IDS_DRIVEERRORCODE_046703 428
#define IDS_DRIVEERRORCODE_046704 429
#define IDS_DRIVEERRORCODE_046705 430
#define IDS_DRIVEERRORCODE_046706 431
#define IDS_DRIVEERRORCODE_046707 432
#define IDS_DRIVEERRORCODE_046901 433
#define IDS_DRIVEERRORCODE_046902 434
#define IDS_DRIVEERRORCODE_046E00 435
#define IDS_DRIVEERRORCODE_04B600 436
#define IDS_DRIVEERRORCODE_050011 437
#define IDS_DRIVEERRORCODE_050700 438
#define IDS_DRIVEERRORCODE_051A00 439
#define IDS_DRIVEERRORCODE_052000 440
#define IDS_DRIVEERRORCODE_052100 441
#define IDS_DRIVEERRORCODE_052101 442
#define IDS_DRIVEERRORCODE_052102 443
#define IDS_DRIVEERRORCODE_052200 444
#define IDS_DRIVEERRORCODE_052400 445
#define IDS_DRIVEERRORCODE_052500 446
#define IDS_DRIVEERRORCODE_052600 447
#define IDS_DRIVEERRORCODE_052601 448
#define IDS_DRIVEERRORCODE_052602 449
#define IDS_DRIVEERRORCODE_052603 450
#define IDS_DRIVEERRORCODE_052604 451
#define IDS_DRIVEERRORCODE_052700 452
#define IDS_DRIVEERRORCODE_052701 453
#define IDS_DRIVEERRORCODE_052702 454
#define IDS_DRIVEERRORCODE_052703 455
#define IDS_DRIVEERRORCODE_052704 456
#define IDS_DRIVEERRORCODE_052705 457
#define IDS_DRIVEERRORCODE_052B00 458
#define IDS_DRIVEERRORCODE_052C00 459
#define IDS_DRIVEERRORCODE_052C01 460
#define IDS_DRIVEERRORCODE_052C02 461
#define IDS_DRIVEERRORCODE_052C03 462
#define IDS_DRIVEERRORCODE_052C04 463
#define IDS_DRIVEERRORCODE_053000 464
#define IDS_DRIVEERRORCODE_053002 465
#define IDS_DRIVEERRORCODE_053004 466
#define IDS_DRIVEERRORCODE_053005 467
#define IDS_DRIVEERRORCODE_053006 468
#define IDS_DRIVEERRORCODE_053008 469
#define IDS_DRIVEERRORCODE_053009 470
#define IDS_DRIVEERRORCODE_053501 471
#define IDS_DRIVEERRORCODE_053504 472
#define IDS_DRIVEERRORCODE_053800 473
#define IDS_DRIVEERRORCODE_053900 474
#define IDS_DRIVEERRORCODE_053D00 475
#define IDS_DRIVEERRORCODE_054300 476
#define IDS_DRIVEERRORCODE_055302 477
#define IDS_DRIVEERRORCODE_055500 478
#define IDS_DRIVEERRORCODE_056300 479
#define IDS_DRIVEERRORCODE_056301 480
#define IDS_DRIVEERRORCODE_056400 481
#define IDS_DRIVEERRORCODE_056401 482
#define IDS_DRIVEERRORCODE_056F00 483
#define IDS_DRIVEERRORCODE_056F01 484
#define IDS_DRIVEERRORCODE_056F02 485
#define IDS_DRIVEERRORCODE_056F03 486
#define IDS_DRIVEERRORCODE_056F04 487
#define IDS_DRIVEERRORCODE_056F05 488
#define IDS_DRIVEERRORCODE_057203 489
#define IDS_DRIVEERRORCODE_057204 490
#define IDS_DRIVEERRORCODE_057205 491
#define IDS_DRIVEERRORCODE_058100 492
#define IDS_DRIVEERRORCODE_058500 493
#define IDS_DRIVEERRORCODE_060A00 494
#define IDS_DRIVEERRORCODE_062800 495
#define IDS_DRIVEERRORCODE_062801 496
#define IDS_DRIVEERRORCODE_062900 497
#define IDS_DRIVEERRORCODE_062901 498
#define IDS_DRIVEERRORCODE_062902 499
#define IDS_DRIVEERRORCODE_062903 500
#define IDS_DRIVEERRORCODE_062904 501
#define IDS_DRIVEERRORCODE_062A00 502
#define IDS_DRIVEERRORCODE_062A01 503
#define IDS_DRIVEERRORCODE_062A02 504
#define IDS_DRIVEERRORCODE_062A03 505
#define IDS_DRIVEERRORCODE_062E00 506
#define IDS_DRIVEERRORCODE_062F00 507
#define IDS_DRIVEERRORCODE_063B0D 508
#define IDS_DRIVEERRORCODE_063B0E 509
#define IDS_DRIVEERRORCODE_063B0F 510
#define IDS_DRIVEERRORCODE_063B11 511
#define IDS_DRIVEERRORCODE_063B12 512
#define IDS_DRIVEERRORCODE_063B13 513
#define IDS_DRIVEERRORCODE_063B14 514
#define IDS_DRIVEERRORCODE_063B15 515
#define IDS_DRIVEERRORCODE_063F00 516
#define IDS_DRIVEERRORCODE_063F01 517
#define IDS_DRIVEERRORCODE_063F02 518
#define IDS_DRIVEERRORCODE_063F03 519
#define IDS_DRIVEERRORCODE_065501 520
#define IDS_DRIVEERRORCODE_065A00 521
#define IDS_DRIVEERRORCODE_065A01 522
#define IDS_DRIVEERRORCODE_065A02 523
#define IDS_DRIVEERRORCODE_065A03 524
#define IDS_DRIVEERRORCODE_065B00 525
#define IDS_DRIVEERRORCODE_065B01 526
#define IDS_DRIVEERRORCODE_065B02 527
#define IDS_DRIVEERRORCODE_065B03 528
#define IDS_DRIVEERRORCODE_065C00 529
#define IDS_DRIVEERRORCODE_065C01 530
#define IDS_DRIVEERRORCODE_065E00 531
#define IDS_DRIVEERRORCODE_065E01 532
#define IDS_DRIVEERRORCODE_065E02 533
#define IDS_DRIVEERRORCODE_065E03 534
#define IDS_DRIVEERRORCODE_065E04 535
#define IDS_DRIVEERRORCODE_066A00 536
#define IDS_DRIVEERRORCODE_066B00 537
#define IDS_DRIVEERRORCODE_066B01 538
#define IDS_DRIVEERRORCODE_066B02 539
#define IDS_DRIVEERRORCODE_072700 540
#define IDS_DRIVEERRORCODE_072701 541
#define IDS_DRIVEERRORCODE_072702 542
#define IDS_DRIVEERRORCODE_072703 543
#define IDS_DRIVEERRORCODE_072704 544
#define IDS_DRIVEERRORCODE_072705 545
#define IDS_DRIVEERRORCODE_082102 546
#define IDS_DRIVEERRORCODE_098000 547
#define IDS_DRIVEERRORCODE_098001 548
#define IDS_DRIVEERRORCODE_098005 549
#define IDS_DRIVEERRORCODE_098006 550
#define IDS_DRIVEERRORCODE_098007 551
#define IDS_DRIVEERRORCODE_09800A 552
#define IDS_DRIVEERRORCODE_09800B 553
#define IDS_DRIVEERRORCODE_09800C 554
#define IDS_DRIVEERRORCODE_0B0006 555
#define IDS_DRIVEERRORCODE_0B1111 556
#define IDS_DRIVEERRORCODE_0B4300 557
#define IDS_DRIVEERRORCODE_0B4500 558
#define IDS_DRIVEERRORCODE_0B4800 559
#define IDS_DRIVEERRORCODE_0B4900 560
#define IDS_DRIVEERRORCODE_0B4DNN 561
#define IDS_DRIVEERRORCODE_0B4E00 562
#define IDS_DRIVEERRORCODE_0BB900 563
#define IDS_DRIVEERRORCODE_0E1D00 564
#define IDS_DRIVEERRORCODE_0X0D00 565
#define IDS_DRIVEERRORCODE_0X0E00 566
#define IDS_DRIVEERRORCODE_0X0F00 567
#define IDS_DRIVEERRORCODE_0X2300 568
#define IDS_DRIVEERRORCODE_0X4F00 569
#define IDS_DRIVEERRORCODE_0X5000 570
#define IDS_DRIVEERRORCODE_0X5001 571
#define IDS_DRIVEERRORCODE_0X5002 572
#define IDS_DRIVEERRORCODE_0X5301 573
#define IDS_DRIVEERRORCODE_0X5400 574
#define IDS_DRIVEERRORCODE_0X5501 575
#define IDS_DRIVEERRORCODE_0X5600 576
#define IDS_DRIVEERRORCODE_0X5800 577
#define IDS_DRIVEERRORCODE_0X5900 578
#define IDS_DRIVEERRORCODE_0X5F00 579
#define IDS_DRIVEERRORCODE_0X80XX 580
#define IDS_UNITNOTREADY 581
#define IDS_WAITINGFORDRIVE 582
#define IDS_CONFIRMATION 583
#define IDS_MB_CANCELOPERATION 584
#define IDS_UPDATINGDATA 585
#define IDS_UNABLEGETDISCINFO 586
#define IDS_READINGDISCINFO 587
#define IDS_DISCERASABLE 588
#define IDS_DISCNONERASABLE 589
#define IDS_DISCINFOFORMAT 590
#define IDS_DISCSIZEFORMAT 591
#define IDS_WRONGMEDIUM 592
#define IDS_SELECTERASEMETHOD 593
#define IDS_QUICKERASE 594
#define IDS_COMPLETEERASE 595
#define IDS_ERASEREQDISC 596
#define IDS_INITIALIZING 597
#define IDS_FINISHING 598
#define IDS_COMPLETING 599
#define IDS_STARTING 600
#define IDS_CANCELING 601
#define IDS_ABORTING 602
#define IDS_FINISHED 603
#define IDS_ABORTED 604
#define IDS_ERROR 605
#define IDS_COMPLETED 606
#define IDS_READY 607
#define IDS_CANCELED 608
#define IDS_ERASING 609
#define IDS_UNKNOWNERROR 610
#define IDS_DRIVENOTREADY 611
#define IDS_MEDIUMERASEFAILED 612
#define IDS_UNABLEINITERASE 613
#define IDS_UNABLEFINERASE 614
#define IDS_ALREADYERASING 615
#define IDS_PRIMOINITFAILED 616
#define IDS_BURNINGCDDA 617
#define IDS_ERROROCCURED 618
#define IDS_TMPCREATEFAILED 619
#define IDS_BURNINGABORTEDBYUSER 620
#define IDS_SHOWLESS 621
#define IDS_SHOWMORE 622
#define IDS_PREPARING 623
#define IDS_BURNING 624
#define IDS_CHECKINGDISC 625
#define IDS_BURNREQDISC 626
#define IDS_SPEEDBEST 627
#define IDS_SPEEDMAX 628
#define IDS_SPEEDMIN 629
#define IDS_SPEEDMED 630
#define IDS_SPEED 631
#define IDS_AT 632
#define IDS_BURNINGCANCELED 633
#define IDS_REASON 634
#define IDS_CURRENTOPERATION 635
#define IDS_LICENSEFAILED 636
#define IDS_LICENSEFAILEDMSG 637
#define IDS_BURNERROR 638
#define IDS_LICENSESUCCESS 639
#define IDS_LICENSEPROGRESS 640
#define IDS_LICENSEITEMPROGRESS 641
#define IDS_LICENSEITEMSUCCESS 642
#define IDS_LICENSEITEMFAILED 643
#define IDS_SKIPPED 644
#define IDS_SCHEDULED 645
#define IDS_PREPARINGDATA 646
#define IDS_PREPARESUCCESS 647
#define IDS_PREPAREFAILED 648
#define IDS_PREPAREFAILEDMSG 649
#define IDS_OF 650
#define IDS_PREPAREITEMSUCCESS 651
#define IDS_PREPAREITEMFAILED 652
#define IDS_BURNITEMADDFAILED 653
#define IDS_INITIALIZINGBURNER 654
#define IDS_MASTERINGDISC 655
#define IDS_BURNITEMSUCCESS 656
#define IDS_WRITELEADIN 657
#define IDS_WRITELEADOUT 658
#define IDS_DISCOPEN 659
#define IDS_DISCCLOSE 660
#define IDS_BURNPROGRESS 661
#define IDS_RELEASINGBURNER 662
#define IDS_BURNFAILED 663
#define IDS_BURNSUCCESS 664
#define IDS_BURNINGCOMPLETED 665
#define IDS_BURNINGSTOPPED 666
#define IDS_FILENOTFOUND 667
#define IDS_DRMNOLICENSE 668
#define IDS_DRMNOBURNING 669
#define IDS_DRMBURNCOUNTEXCEEDED 670
#define IDS_NODECODER 671
#define IDS_NOFILES 672
#define IDS_DECODESERVICEFAILED 673
#define IDS_LICENSEWRONGFILECOUNT 674
#define IDS_BADFILENAME 675
#define IDS_CACHEWRITEFAILED 676
#define IDS_DECODESTARTFAILED 677
#define IDS_BURNSTARTFAILED 678
#define IDS_MASTERINGFAILED 679
#define IDS_BEGINBURNFAILED 680
#define IDS_ENDBURNFAILED 681
#define IDS_WRITEAUDIOFAILED 682
#define IDS_LIBERRORPREFIX 683
#define IDS_DRVERRORPREFIX 684
#define IDS_CHKDSCWRONGPARAMETER 685
#define IDS_CHKDSCMSGPUMPFAILED 686
#define IDS_CHKDSCDIALOGFAILED 687
#define IDS_MB_CANCELBURNING 688
#define IDS_TEMPORARY_FILE 689
#define IDC_CHECK1 1001
#define IDC_CHECK_EJECT 1001
#define IDC_BTN_EJECT 1001
#define IDC_CHK_AUTOCLOSE 1001
#define IDC_PROGRESS1 1002
#define IDC_PRG_PROGRESS 1002
#define IDC_PRG_TOTAL 1002
#define IDC_COMBO1 1003
#define IDC_CMB_ERASEMETHOD 1003
#define IDC_CHK_EJECT 1003
#define IDC_CAPTION 1004
#define IDC_CHK_ADDTODB 1004
#define IDC_DESCRIPTION 1005
#define IDC_CHK_ADDTODB2 1005
#define IDC_CHK_HIDEWINDOW 1005
#define IDC_PIC 1006
#define IDC_LBL_DETECTED 1007
#define IDC_LBL_REASON_VAL 1007
#define IDC_LBL_REQUIRED 1008
#define IDC_LBL_DETECTEDMEDIUM 1009
#define IDC_LBL_REQUESTEDMEDIUM 1010
#define IDC_LBL_HELP 1011
#define IDC_LBL_DOTS 1012
#define IDC_LBL_TEXT 1013
#define IDC_BTN_ERASE 1014
#define IDC_LBL_TIME 1015
#define IDC_LBL_STATUS 1016
#define IDC_LBL_REASON 1017
#define IDC_LBL_DESCRIPTION 1018
#define IDC_BTN_EXTENDEDVIEW 1019
#define IDC_LST_DETAILS 1022
#define IDC_GRP_OPTIONS 1023
#define IDC_LBL_CURRENTOPERATION 1024
#define IDC_LBL_ELAPSED 1025
#define IDC_LBL_ESTIMATED 1026
#define IDC_LBL_CAPTION 1027
#define IDC_LBL_PERCENT 1028
#define IDC_LBL_CURRENTOPERATION_VAL 1029
#define IDC_LBL_ELAPSED_VAL 1030
#define IDC_LBL_ESTIMATED_VAL 1031
#define IDC_PIC_TESTMODE 1032
#define IDC_BUTTON1 1033
#define IDC_BTN_CONTINUE 1033
#define IDS_STRING111 65535
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 114
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1036
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

BIN
Src/burnlib/resources/disc1.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 30 KiB

BIN
Src/burnlib/resources/drive1.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.7 KiB

BIN
Src/burnlib/resources/testmode.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.3 KiB

1345
Src/burnlib/uiBurnPlayList.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

133
Src/burnlib/uiBurnPlaylist.h Normal file
View File

@@ -0,0 +1,133 @@
#pragma once
#include "./main.h"
#include <commctrl.h>
#include "./playlist.h"
#define WM_BURNER ((WM_USER) + 0x400)
#define WM_BURNGETSTATUS ((WM_BURNER) + 0x001)
#define WM_BURNGETITEMSTATUS ((WM_BURNER) + 0x002)
#define WM_BURNUPDATEOWNER ((WM_BURNER) + 0x003) // wParam = 0; lParam = ownerWnd
#define WM_BURNCONFIGCHANGED ((WM_BURNER) + 0x004) // wParam = changed item; lParam = new value
#define WM_BURNNOTIFY ((WM_BURNER) + 0x100) // wParam = Notify code, lParam notify data
// Notification types
#define BURN_READY 0xFFF // lParam = hwnd
#define BURN_DESTROYED 0x001
#define BURN_WORKING 0x002
#define BURN_FINISHED 0x003
#define BURN_STATECHANGED 0x004
#define BURN_CONFIGCHANGED 0x005
#define BURN_ITEMSTATECHANGED 0x010
#define BURN_ITEMDECODEPROGRESS 0x011
#define BURN_ITEMBURNPROGRESS 0x012
// status types
#define BURNSTATUS_DRIVE 0x0000
#define BURNSTATUS_ELAPSED 0x0001
#define BURNSTATUS_ESTIMATED 0x0002
#define BURNSTATUS_PROGRESS 0x0003
#define BURNSTATUS_STATE 0x0004
#define BURNSTATUS_ERROR 0x0005
#define BURNPLAYLISTUI_SUCCESS 0x0000
#define BURNPLAYLISTUI_PRIMOSDKNOTSET 0x0105
//stages
#define PLSTAGE_READY 0x00
#define PLSTAGE_LICENSED 0x01
#define PLSTAGE_DECODED 0x02
#define PLSTAGE_BURNED 0x03
// config items
#define BURNCFG_AUTOCLOSE 0x01
#define BURNCFG_AUTOEJECT 0x02
#define BURNCFG_ADDTODB 0x03
#define BURNCFG_HIDEVIEW 0x04
class BurnPlaylistUI
{
public:
BURNLIB_API BurnPlaylistUI(void);
BURNLIB_API ~BurnPlaylistUI(void);
public:
BURNLIB_API DWORD Burn(obj_primo *primoSDK, DWORD drive, DWORD maxspeed, DWORD burnFlags,
BurnerPlaylist *playlist, const wchar_t* tempPath, HWND ownerWnd);
protected:
static DWORD CALLBACK OnLicensingPlaylist(void *sender, void *userparam, DWORD notifyCode, DWORD errorCode, ULONG_PTR param);
static DWORD CALLBACK OnDecodePlaylist(void *sender, void *userparam, DWORD notifyCode, DWORD errorCode, ULONG_PTR param);
static DWORD CALLBACK OnBurnPlaylist(void *sender, void *userparam, DWORD notifyCode, DWORD errorCode, ULONG_PTR param);
static LRESULT CALLBACK WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void OnLicense(void);
void OnDecode(void);
void OnBurn(void);
void OnInitDialog(HWND hwndDlg);
void OnCancel(void);
void OnDestroy(void);
void SetExtendedView(BOOL extView);
void SetColumns(void);
void FillList(void);
void SetProgress(int position);
void UpdateTime(BOOL recalcEstimates);
void ReportError(unsigned int stringCode, BOOL allowContinue);
void ReportError(const wchar_t *errorString, BOOL allowContinue);
DWORD DrawList(NMLVCUSTOMDRAW* cd);
HBITMAP CreateStripBmp(HDC compDC);
void SetReadyClose(BOOL ready);
void UpdateItemStatus(int index);
void SetItemStatusText(int index, unsigned int stringCode, BOOL redraw);
void SetCurrentOperation(unsigned int stringCode);
int MessageBox(unsigned int messageCode, unsigned int captionCode, unsigned int uType);
protected:
struct aproxtime
{
DWORD license;
DWORD convert;
DWORD transition;
DWORD chkdisc;
DWORD init;
DWORD leadin;
DWORD burn;
DWORD leadout;
DWORD finish;
};
protected:
HWND hwnd;
HWND ownerWnd;
DWORD drive;
DWORD maxspeed;
DWORD burnFlags;
BOOL extendedView;
DWORD errCode;
obj_primo *primoSDK;
BurnerPlaylist *playlist;
unsigned int startedTime;
unsigned int estimatedTime;
wchar_t *tmpfilename;
HANDLE hTmpFile;
int currentPercent;
DWORD prevRefresh;
HBITMAP stripBmp;
BOOL cancelOp;
HANDLE workDone;
aproxtime estimated;
BOOL readyClose;
DWORD controlTime;
DWORD realSpeed;
DWORD stage;
DWORD count; // count of items to process (actual)
DWORD processed; // count of actually processed items
};

300
Src/burnlib/uiCheckMedium.cpp Normal file
View File

@@ -0,0 +1,300 @@
#include "./uiCheckMedium.h"
#include "./resource.h"
#include <strsafe.h>
#include "./uiEraseMedium.h"
#include "./uiUnitReady.h"
#define AINSTATE_DISABLE PRIMOSDK_LOCK
#define AINSTATE_ENABLE PRIMOSDK_UNLOCK
CheckMediumUI::CheckMediumUI(void)
{
hwnd = NULL;
drive = NULL;
primoSDK = NULL;
errPrimo = 0;
errReady = 0;
}
CheckMediumUI::~CheckMediumUI(void)
{
if (hwnd) DestroyWindow(hwnd);
}
DWORD CheckMediumUI::Check(obj_primo *primoSDK, DWORD *drive, WAMEDIUMINFO *medium, const wchar_t *description, BOOL disableAIN, BOOL showErase, HWND ownerWnd)
{
if (!medium) return CHECKMEDIUMUI_DISCNOTSET;
if (!drive) return CHECKMEDIUMUI_DRIVENOTSET;
if (!primoSDK) return CHECKMEDIUMUI_PRIMOSDKNOTSET;
this->desiredMedium = medium;
this->drive = drive;
this->primoSDK = primoSDK;
this->disableAIN = (disableAIN) ? AINSTATE_DISABLE : 0 ;
this->showErase = showErase;
this->description = description;
this->ownerWnd = ownerWnd;
hwnd = NULL;
errPrimo = PRIMOSDK_OK;
errReady = CHECKMEDIUMUI_NOMATCH;
deadLoop = 0;
LPCDLGTEMPLATE templ = NULL;
HRSRC hres = FindResourceExW(hResource, MAKEINTRESOURCEW(5), MAKEINTRESOURCEW(IDD_DLG_WRONGMEDIUM), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
if (hres) templ = (LPCDLGTEMPLATE)LoadResource(hResource, hres);
HWND dlgWnd = CreateDialogIndirectParamW(dllInstance, templ, ownerWnd, (DLGPROC)WndProc, (LPARAM)this);
if (!dlgWnd) return CHECKMEDIUMUI_UNABLETOCREATEDIALOG;
MSG msg;
BOOL ret;
while( 0 != (ret = GetMessageW(&msg, hwnd, 0, 0)))
{
if (ret == -1)
{
errReady = CHECKMEDIUMUI_MESSAGEPUMPERROR;
break;
}
if (IsDialogMessage(hwnd, &msg)) continue;
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
return errReady;
}
DWORD CheckMediumUI::Rescan(void)
{
wchar_t buffer[256] = {0};
if (hwnd)
{
EnableWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
LoadStringW(hResource, IDS_UPDATINGDATA, buffer, 256);
SetWindowLong(GetDlgItem(hwnd, IDC_LBL_DETECTEDMEDIUM), GWL_STYLE, WS_CHILD | WS_VISIBLE | SS_CENTER | SS_CENTERIMAGE);
SetDlgItemTextW(hwnd, IDC_LBL_DETECTEDMEDIUM, buffer);
}
if (!drive) return CHECKMEDIUMUI_DRIVENOTSET;
if (!primoSDK) return CHECKMEDIUMUI_PRIMOSDKNOTSET;
UpdatingDataUI updateDlg;
LoadStringW(hResource, IDS_READINGDISCINFO, buffer, 256);
updateDlg.Show(800, buffer, TRUE, hwnd);
WAMEDIUMINFO detectedMedium;
ZeroMemory(&detectedMedium, sizeof(WAMEDIUMINFO));
errPrimo = GetMediumInfo(primoSDK, drive, &detectedMedium);
updateDlg.Hide();
if (PRIMOSDK_OK != errPrimo)
{
SetWindowLong(GetDlgItem(hwnd, IDC_LBL_DETECTEDMEDIUM), GWL_STYLE, WS_CHILD | WS_VISIBLE | SS_CENTER | SS_CENTERIMAGE);
LoadStringW(hResource, IDS_UNABLEGETDISCINFO, buffer, 256);
SetDlgItemTextW(hwnd, IDC_LBL_DETECTEDMEDIUM, buffer);
EnableWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_BTN_ERASE), FALSE);
EnableWindow(hwnd, FALSE);
if (AINSTATE_DISABLE == disableAIN && primoSDK)
{
primoSDK->UnitAIN(drive, disableAIN);
disableAIN = AINSTATE_ENABLE;
}
UnitReadyUI ready;
DWORD test = ready.Check(primoSDK, drive, FALSE, hwnd);
if (UNITREADYUI_DRIVEREADY == test) deadLoop++;
if (deadLoop == 5)
{ /// dead loop detected - PRIMOSDK broken - recomended restart of the computer
errReady = CHECKMEDIUMUI_DEADLOOP;
if(hwnd) PostMessage(hwnd, WM_DESTROY, 0, 0);
return errReady;
}
EnableWindow(hwnd, TRUE);
UpdateWindow(hwnd);
switch(test)
{
case UNITREADYUI_DRIVEREADY:
break;
case UNITREADYUI_PRIMOSDKERROR:
errReady = CHECKMEDIUMUI_PRIMOSDKERROR;
break;
case UNITREADYUI_CANCELED:
errReady = CHECKMEDIUMUI_CANCELED;
break;
default:
errReady = CHECKMEDIUMUI_PRIMOSDKERROR;
break;
}
if (UNITREADYUI_DRIVEREADY != test)
{
if(hwnd) PostMessage(hwnd, WM_DESTROY, 0, 0);
return errReady;
}
PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDOK, BN_CLICKED), 0); // start other rescan
errReady = CHECKMEDIUMUI_DRIVENOTREADY;
return errReady;
}
if (hwnd)
{
EnableWindow(GetDlgItem(hwnd, IDCANCEL), TRUE);
SetDlgItemTextW(hwnd, IDC_LBL_DETECTEDMEDIUM, L"");
}
errReady = CHECKMEDIUMUI_MATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->medium && desiredMedium->medium != detectedMedium.medium) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->mediumType && desiredMedium->mediumType != detectedMedium.mediumType) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->mediumFormat && desiredMedium->mediumFormat != detectedMedium.mediumFormat) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->tracks && desiredMedium->tracks != detectedMedium.tracks) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->erasable && desiredMedium->erasable != detectedMedium.erasable) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->freeSectors && desiredMedium->freeSectors > detectedMedium.freeSectors) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->usedSectors && desiredMedium->usedSectors < detectedMedium.usedSectors) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->recordable && desiredMedium->recordable != detectedMedium.recordable) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->isCD && desiredMedium->isCD != detectedMedium.isCD) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->isDCD && desiredMedium->isDCD != detectedMedium.isDCD) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->isDVD && desiredMedium->isDVD != detectedMedium.isDVD) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady && MAXDWORD != desiredMedium->isDLDVD && desiredMedium->isDLDVD != detectedMedium.isDLDVD) errReady = CHECKMEDIUMUI_NOMATCH;
if (CHECKMEDIUMUI_MATCH == errReady)
{
if(hwnd) PostMessage(hwnd, WM_DESTROY, 0, 0);
}
else if (hwnd)
{
wchar_t buffer[4096] = {0};
SetWindowLong(GetDlgItem(hwnd, IDC_LBL_DETECTEDMEDIUM), GWL_STYLE, WS_CHILD | WS_VISIBLE | SS_LEFT);
SetDlgItemTextW(hwnd, IDC_LBL_DETECTEDMEDIUM, GetMediumInfoText(buffer, 4096, &detectedMedium));
if (showErase) EnableWindow(GetDlgItem(hwnd, IDC_BTN_ERASE), (detectedMedium.erasable && detectedMedium.usedSectors > 0));
ShowWindow(hwnd, SW_SHOWNORMAL);
SetForegroundWindow(hwnd);
BringWindowToTop(hwnd);
MessageBeep(MB_ICONEXCLAMATION);
UpdateWindow(hwnd);
}
return errReady;
}
wchar_t* CheckMediumUI::GetMediumInfoText(wchar_t *buffer, unsigned int cchBuffer, WAMEDIUMINFO *info)
{
buffer[0] = 0x0000;
wchar_t format[64] = {0}, freeSize[256] = {0}, usedSize[256] = {0}, medium[32] = {0}, mtype[128] = {0}, mformat[128] = {0}, erasable[32] = {0};
LoadStringW(hResource, IDS_DISCINFOFORMAT, format, 64);
LoadStringW(hResource, (info->erasable) ? IDS_DISCERASABLE : IDS_DISCNONERASABLE, erasable, 32);
StringCchPrintfW(buffer, cchBuffer, format, GetMediumText(medium, 32, info->medium),
erasable,
GetSizeText(freeSize, 256, info->freeSectors),
GetSizeText(usedSize, 256, info->usedSectors),
GetMediumFormatText(mformat, 128,info->mediumFormat),
GetMediumTypeText(mtype, 128, info->mediumType));
return buffer;
}
wchar_t* CheckMediumUI::GetSizeText(wchar_t *buffer, unsigned int cchBuffer, unsigned int sectors)
{
wchar_t format[32] = {0},tmp[256] = {0};
DWORD minutes = sectors/(75*60);
DWORD kb = MulDiv(sectors, 2048,1024);
DWORD mb = kb / 1024;
LoadStringW(hResource, IDS_DISCSIZEFORMAT, format, 32);
StringCchPrintfW(tmp, 256, format, minutes, mb, sectors);
StringCchCatW(buffer, cchBuffer, tmp);
return buffer;
}
void CheckMediumUI::OnInitDialog(HWND hwndDlg)
{
hwnd = hwndDlg;
HANDLE hImage = LoadBitmapW(hResource, MAKEINTRESOURCEW(IDB_DISC1));
if(hImage==NULL){
hImage = LoadBitmapW(dllInstance, MAKEINTRESOURCEW(IDB_DISC1));
}
SendDlgItemMessage(hwnd, IDC_PIC, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hImage);
wchar_t format[64] = {0}, buffer[66] = {0};
LoadStringW(hResource, IDS_WRONGMEDIUM, format, 64);
StringCchPrintfW(buffer, 64, format, (char)*drive);
SetWindowTextW(GetDlgItem(hwnd, IDC_CAPTION), buffer);
SetWindowTextW(GetDlgItem(hwnd, IDC_LBL_REQUESTEDMEDIUM), description);
HWND btnWnd = GetDlgItem(hwnd, IDC_BTN_ERASE);
EnableWindow(btnWnd, showErase);
ShowWindow(btnWnd, showErase);
Rescan();
}
void CheckMediumUI::OnCancel(void)
{
wchar_t msg[256] = {0}, caption[64] = {0};
LoadStringW(hResource, IDS_MB_CANCELOPERATION, msg, 256);
LoadStringW(hResource, IDS_CONFIRMATION, caption, 64);
if (MessageBoxW(hwnd, msg, caption, MB_YESNO | MB_ICONQUESTION) == IDYES)
{
errReady = CHECKMEDIUMUI_CANCELED;
if(hwnd) DestroyWindow(hwnd);
hwnd = NULL;
}
}
void CheckMediumUI::OnDestroy(void)
{
if (AINSTATE_ENABLE == disableAIN && primoSDK)
{
primoSDK->UnitAIN(drive, disableAIN);
disableAIN = AINSTATE_DISABLE;
}
ShowWindow(hwnd, SW_HIDE);
hwnd = NULL;
drive = NULL;
primoSDK = NULL;
deadLoop = 0;
}
void CheckMediumUI::OnEraseClicked(void)
{
EraseMediumUI eraseMedium;
eraseMedium.Erase(*drive, FALSE, hwnd); // do not perform disc check
UpdateWindow(hwnd);
Rescan();
}
LRESULT CheckMediumUI::WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static CheckMediumUI *object = NULL;
switch(uMsg)
{
case WM_INITDIALOG:
object = (CheckMediumUI*)lParam;
object->OnInitDialog(hwndDlg);
break;
case WM_DESTROY:
object->OnDestroy();
PostQuitMessage(object->errReady);
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
object->Rescan();
break;
case IDCANCEL:
object->OnCancel();
break;
case IDC_BTN_ERASE:
if (BN_CLICKED == HIWORD(wParam)) object->OnEraseClicked();
break;
}
break;
}
return 0;
}

55
Src/burnlib/uiCheckMedium.h Normal file
View File

@@ -0,0 +1,55 @@
#pragma once
#include "./main.h"
#include "./primosdk.h"
#define CHECKMEDIUMUI_MATCH 0x000
#define CHECKMEDIUMUI_NOMATCH 0x001
#define CHECKMEDIUMUI_CANCELED 0x002
#define CHECKMEDIUMUI_PRIMOSDKERROR 0x101
#define CHECKMEDIUMUI_UNABLETOCREATEDIALOG 0x102
#define CHECKMEDIUMUI_MESSAGEPUMPERROR 0x103
#define CHECKMEDIUMUI_DRIVENOTSET 0x104
#define CHECKMEDIUMUI_PRIMOSDKNOTSET 0x105
#define CHECKMEDIUMUI_DISCNOTSET 0x106
#define CHECKMEDIUMUI_DRIVENOTREADY 0x107
#define CHECKMEDIUMUI_DEADLOOP 0x108
class CheckMediumUI
{
public:
BURNLIB_API CheckMediumUI(void);
BURNLIB_API ~CheckMediumUI(void);
public:
BURNLIB_API DWORD Check(obj_primo *primoSDK, DWORD *drive, WAMEDIUMINFO *medium, const wchar_t *description, BOOL disableAIN, BOOL showErase, HWND ownerWnd);
BURNLIB_API DWORD GetPrimoError(void) { return errPrimo; }
protected:
DWORD Rescan(void);
static LRESULT CALLBACK WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void OnInitDialog(HWND hwndDlg);
void OnCancel(void);
void OnDestroy(void);
void OnEraseClicked(void);
wchar_t* GetMediumInfoText(wchar_t *buffer, unsigned int cchBuffer, WAMEDIUMINFO *info);
wchar_t* GetSizeText(wchar_t *buffer, unsigned int cchBuffer, unsigned int sectors);
protected:
HWND hwnd;
HWND ownerWnd;
WAMEDIUMINFO *desiredMedium;
DWORD *drive;
obj_primo *primoSDK;
DWORD errPrimo;
DWORD errReady;
BOOL disableAIN;
BOOL showErase;
DWORD deadLoop;
const wchar_t *description;
};

340
Src/burnlib/uiEraseMedium.cpp Normal file
View File

@@ -0,0 +1,340 @@
#include "./uiEraseMedium.h"
#include "api.h"
#include <api/service/waservicefactory.h>
#include "./resource.h"
#include <strsafe.h>
#include <commctrl.h>
#include "./uiCheckMedium.h"
#define ERASETIME_QUICKMODE 50 // in seconds
#define ERASETIME_FULLMODE 510 // in seconds
#define TIMER_CLOCK_ID 1979
#define TIMER_CLOCK_INTERVAL 1000
EraseMediumUI::EraseMediumUI(void)
{
eraseMedium = NULL;
}
EraseMediumUI::~EraseMediumUI(void)
{
if (eraseMedium)
{
delete(eraseMedium);
eraseMedium = NULL;
}
}
DWORD EraseMediumUI::SetEject(int ejectmode)
{
return (eraseMedium) ? eraseMedium->SetEject(ejectmode) : 0;
}
DWORD EraseMediumUI::Erase(DWORD drive, BOOL discCheck, HWND ownerWnd)
{
this->drive = drive;
this->discCheck = discCheck;
DWORD retCode;
LPCDLGTEMPLATE templ = NULL;
HRSRC hres = FindResourceExW(hResource, MAKEINTRESOURCEW(5), MAKEINTRESOURCEW(IDD_DLG_ERASEMEDIUMPREPARE), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
templ = (hres) ? (LPCDLGTEMPLATE)LoadResource(hResource, hres) : NULL;
retCode = (DWORD)DialogBoxIndirectParamW(dllInstance, templ, ownerWnd, (DLGPROC)PrepareWndProc, (LPARAM)this);
if (ERASEMEDIUMUI_OK != retCode) return retCode;
hres = FindResourceExW(hResource, MAKEINTRESOURCEW(5), MAKEINTRESOURCEW(IDD_DLG_ERASEMEDIUMSTATUS), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
templ = (hres) ? (LPCDLGTEMPLATE)LoadResource(hResource, hres) : NULL;
retCode = (DWORD)DialogBoxIndirectParamW(dllInstance, templ, ownerWnd, (DLGPROC)EraseWndProc, (LPARAM)this);
if (ERASEMEDIUM_ABORTED == retCode) return ERASEMEDIUMUI_CANCELED;
else if (retCode > ERASEMEDIUM_ERROR) return ERASEMEDIUMUI_ERROR;
return ERASEMEDIUMUI_OK;
}
void EraseMediumUI::OnPrepareInit(HWND hwndDlg)
{
prepareWnd = hwndDlg;
wchar_t format[96] = {0}, buffer[98] = {0};
LoadStringW(hResource, IDS_SELECTERASEMETHOD, format, 96);
StringCchPrintfW(buffer, 98, format, drive);
SetDlgItemTextW(prepareWnd, IDC_CAPTION, buffer);
HWND cmbWnd = GetDlgItem(prepareWnd, IDC_CMB_ERASEMETHOD);
LoadStringW(hResource, IDS_QUICKERASE, buffer, 98);
SendMessageW(cmbWnd, CB_ADDSTRING, 0, (LPARAM)buffer);
LoadStringW(hResource, IDS_COMPLETEERASE, buffer, 98);
SendMessageW(cmbWnd, CB_ADDSTRING, 0, (LPARAM)buffer);
SendMessageW(cmbWnd, CB_SETCURSEL, 0, 0);
PostMessageW(prepareWnd, WM_COMMAND, MAKEWPARAM(IDC_CMB_ERASEMETHOD, CBN_SELCHANGE), 0);
ShowWindow(prepareWnd, SW_SHOWNORMAL);
SetForegroundWindow(prepareWnd);
BringWindowToTop(prepareWnd);
}
void EraseMediumUI::OnPrepareOk()
{
switch(SendMessage(GetDlgItem(prepareWnd, IDC_CMB_ERASEMETHOD), CB_GETCURSEL, 0,0))
{
case 1: eraseMode = PRIMOSDK_ERASEFULL; break;
default: eraseMode = PRIMOSDK_ERASEQUICK; break;
}
if (discCheck)
{
// check that disc is erasable
obj_primo *primo=0;
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(obj_primo::getServiceGuid());
if (sf) primo = reinterpret_cast<obj_primo *>(sf->getInterface());
if (primo)
{
WAMEDIUMINFO mi;
FillMemory(&mi, sizeof(WAMEDIUMINFO), 0xFF);
mi.erasable = TRUE;
CheckMediumUI cm;
wchar_t buffer[256] = {0};
LoadStringW(hResource, IDS_ERASEREQDISC, buffer, 256);
DWORD retCode = cm.Check(primo, &drive, &mi, buffer, TRUE, FALSE, prepareWnd);
switch(retCode)
{
case CHECKMEDIUMUI_MATCH: eraseCode = ERASEMEDIUMUI_OK; break;
case CHECKMEDIUMUI_CANCELED: eraseCode = ERASEMEDIUMUI_CANCELED; break;
default: eraseCode = ERASEMEDIUMUI_PRIMOSDKERROR; break;
}
sf->releaseInterface(primo);
}
else
eraseCode = ERASEMEDIUMUI_PRIMOSDKERROR;
}
else
{
eraseCode = ERASEMEDIUMUI_OK;
}
EndDialog(prepareWnd, eraseCode);
}
void EraseMediumUI::OnEraseTimerClock(void)
{
actualTime = (GetTickCount() - startTick) / 1000;
wchar_t time[32], *current;
current = time;
GetTimeString(current, 32, actualTime);
unsigned int len = lstrlenW(current);
current[len] = L'/';
len++;
current += len;
if (estimateTime < actualTime) estimateTime = actualTime;
GetTimeString(current, 32 - len, estimateTime);
SetWindowTextW(GetDlgItem(eraseWnd, IDC_LBL_TIME), time);
SendMessage(GetDlgItem(eraseWnd, IDC_PRG_PROGRESS), PBM_SETPOS, (int)(((float)actualTime/(float)estimateTime)*100), 0);
}
void EraseMediumUI::OnEraseInit(HWND hwndDlg)
{
eraseWnd = hwndDlg;
CheckDlgButton(eraseWnd, IDC_CHECK_EJECT, BST_CHECKED);
EnableWindow(GetDlgItem(eraseWnd, IDC_BTN_EJECT), FALSE);
eraseMedium = new(EraseMedium);
if (!eraseMedium) EndDialog(eraseWnd, ERASEMEDIUMUI_UNABLETOCREATEOBJECT);
startTick = GetTickCount();
OnEraseTimerClock();
ShowWindow(eraseWnd, SW_SHOWNORMAL);
SetForegroundWindow(eraseWnd);
BringWindowToTop(eraseWnd);
UpdateWindow(eraseWnd);
SetTimer(eraseWnd, TIMER_CLOCK_ID, TIMER_CLOCK_INTERVAL, NULL);
SendMessage(GetDlgItem(eraseWnd, IDC_PRG_PROGRESS), PBM_SETRANGE, 0, MAKELPARAM(0, 100));
eraseMedium->Start(drive, eraseMode, OnEraseNotify, this, FALSE); // will catch all errors in calback
EnableWindow(GetDlgItem(eraseWnd, IDC_BTN_EJECT), TRUE);
}
void EraseMediumUI::OnEraseClose(DWORD exitCode)
{
EnableWindow(GetDlgItem(eraseWnd, IDC_BTN_EJECT), FALSE);
if (eraseMedium)
{
HWND btnWnd = GetDlgItem(eraseWnd, IDCANCEL);
EnableWindow(btnWnd, FALSE);
eraseMedium->Stop();
wchar_t buffer[24] = {0};
LoadStringW(hResource, IDS_CLOSE, buffer, 24);
SetWindowTextW(btnWnd, buffer);
EnableWindow(btnWnd, TRUE);
primoCode = eraseMedium->GetErrorCode();
delete(eraseMedium);
eraseMedium = NULL;
}
eraseCode = exitCode;
KillTimer(eraseWnd, TIMER_CLOCK_ID);
estimateTime = 0; // will force it to be the same with actual
OnEraseTimerClock();
}
LRESULT EraseMediumUI::PrepareWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static EraseMediumUI *object = NULL;
switch(uMsg)
{
case WM_INITDIALOG:
object = (EraseMediumUI*)lParam;
object->OnPrepareInit(hwndDlg);
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
object->OnPrepareOk();
break;
case IDCANCEL:
{
wchar_t msg[256] = {0}, caption[64] = {0};
LoadStringW(hResource, IDS_MB_CANCELOPERATION, msg, 256);
LoadStringW(hResource, IDS_CONFIRMATION, caption, 64);
if (MessageBoxW(hwndDlg, msg, caption, MB_YESNO | MB_ICONQUESTION) == IDYES)
{
EndDialog(hwndDlg, LOWORD(wParam));
}
break;
}
case IDC_CMB_ERASEMETHOD:
switch(HIWORD(wParam))
{
case CBN_SELCHANGE:
switch(SendMessage(GetDlgItem(hwndDlg, IDC_CMB_ERASEMETHOD), CB_GETCURSEL, 0,0))
{
case 0:
object->estimateTime= ERASETIME_QUICKMODE;
break;
case 1:
object->estimateTime = ERASETIME_FULLMODE;
break;
default:
object->estimateTime =0;
break;
}
wchar_t time[16] = {0};
SetWindowTextW(GetDlgItem(hwndDlg, IDC_LBL_TIME), GetTimeString(time, 16, object->estimateTime));
break;
}
break;
}
break;
}
return 0;
}
LRESULT EraseMediumUI::EraseWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static EraseMediumUI *object = NULL;
switch(uMsg)
{
case WM_INITDIALOG:
object = (EraseMediumUI*)lParam;
object->OnEraseInit(hwndDlg);
break;
case WM_CLOSE:
object->OnEraseClose((DWORD)wParam);
return 1;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDCANCEL:
if (object->eraseMedium)
{
wchar_t msg[256] = {0}, caption[64] = {0};
LoadStringW(hResource, IDS_MB_CANCELOPERATION, msg, 256);
LoadStringW(hResource, IDS_CONFIRMATION, caption, 64);
if (MessageBoxW(hwndDlg, msg, caption, MB_YESNO | MB_ICONQUESTION) == IDYES) object->OnEraseClose(ERASEMEDIUM_ABORTED);
}
EndDialog(hwndDlg, object->eraseCode);
break;
case IDC_BTN_EJECT:
if (BN_CLICKED == HIWORD(wParam) && object->eraseMedium)
{
object->eraseMedium->SetEject(BST_CHECKED == IsDlgButtonChecked (hwndDlg,IDC_BTN_EJECT));
}
break;
}
break;
case WM_TIMER:
switch(wParam)
{
case TIMER_CLOCK_ID:
object->OnEraseTimerClock();
break;
}
break;
}
return 0;
}
DWORD EraseMediumUI::OnEraseNotify(void *sender, void *param, DWORD eraseCode, DWORD primoCode)
{
EraseMediumUI *object = (EraseMediumUI*)param;
unsigned int strcode;
BOOL finished = FALSE;
if (ERASEMEDIUM_ERROR < eraseCode)
{// some error happened;
finished = TRUE;
switch(eraseCode)
{
case ERASEMEDIUM_ALREADYSTARTED: strcode = IDS_ALREADYERASING; break;
case ERASEMEDIUM_UNABLEINITPRIMO: strcode = IDS_PRIMOINITFAILED; break;
case ERASEMEDIUM_BEGINBURNFAILED: strcode = IDS_UNABLEINITERASE; break;
case ERASEMEDIUM_ENDBURNFAILED: strcode = IDS_UNABLEFINERASE; break;
case ERASEMEDIUM_ERASEMEDIUMFAILED: strcode = IDS_MEDIUMERASEFAILED; break;
case ERASEMEDIUM_DEVICENOTREADY: strcode = IDS_DRIVENOTREADY; break;
case ERASEMEDIUM_DISCINFOERROR: strcode = IDS_UNABLEGETDISCINFO; break;
case ERASEMEDIUM_DISCNOTERASABLE: strcode = IDS_DISCNONERASABLE; break;
default: strcode = IDS_UNKNOWNERROR; break;
}
MessageBeep(MB_ICONHAND);
}
else
{
switch(eraseCode)
{
case ERASEMEDIUM_READY: strcode = IDS_READY; break;
case ERASEMEDIUM_INITIALIZING: strcode = IDS_INITIALIZING; break;
case ERASEMEDIUM_ERASING: strcode = IDS_ERASING; break;
case ERASEMEDIUM_FINISHING: strcode = IDS_FINISHING; break;
case ERASEMEDIUM_CANCELING: strcode = IDS_CANCELING; break;
case ERASEMEDIUM_COMPLETED: strcode = IDS_COMPLETED; finished = TRUE; MessageBeep(MB_OK); break;
case ERASEMEDIUM_ABORTED: strcode = IDS_ABORTED; finished = TRUE; MessageBeep(MB_OK); break;
}
}
wchar_t buffer[224] = {0};
LoadStringW(hResource, strcode, buffer, 224);
if (ERASEMEDIUM_ERROR < eraseCode)
{
wchar_t txtStatus[256] = {0}, error[24] = {0};
LoadStringW(hResource, IDS_ERROR, error, 24);
StringCchPrintfW(txtStatus, 256, L"%s! %s", error, buffer);
}
else
{
SetWindowTextW(GetDlgItem(object->eraseWnd, IDC_LBL_STATUS), buffer);
}
if (finished) PostMessage(object->eraseWnd, WM_CLOSE, eraseCode, 0);
return ERASEMEDIUM_CONTINUE;
}

51
Src/burnlib/uiEraseMedium.h Normal file
View File

@@ -0,0 +1,51 @@
#pragma once
#include "./main.h"
#include "./eraseMedium.h"
#define ERASEMEDIUMUI_OK 0x000
#define ERASEMEDIUMUI_ERROR 0x001
#define ERASEMEDIUMUI_CANCELED 0x002
#define ERASEMEDIUMUI_PRIMOSDKERROR 0x101
#define ERASEMEDIUMUI_UNABLETOCREATEDIALOG 0x102
#define ERASEMEDIUMUI_MESSAGEPUMPERROR 0x103
#define ERASEMEDIUMUI_DRIVENOTSET 0x104
#define ERASEMEDIUMUI_PRIMOSDKNOTSET 0x105
#define ERASEMEDIUMUI_UNABLETOCREATEOBJECT 0x106
class EraseMediumUI
{
public:
BURNLIB_API EraseMediumUI(void);
BURNLIB_API ~EraseMediumUI(void);
public:
BURNLIB_API DWORD Erase(DWORD drive, BOOL discCheck, HWND ownerWnd);
BURNLIB_API DWORD SetEject(int ejectmode);
protected:
static LRESULT CALLBACK PrepareWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
static LRESULT CALLBACK EraseWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void OnPrepareInit(HWND hwndDlg);
void OnPrepareOk();
void OnEraseInit(HWND hwndDlg);
void OnEraseTimerClock(void);
void OnEraseClose(DWORD exitCode);
static DWORD CALLBACK OnEraseNotify(void *sender, void *param, DWORD eraseCode, DWORD primoCode);
protected:
DWORD drive;
HWND prepareWnd;
HWND eraseWnd;
EraseMedium *eraseMedium;
DWORD eraseMode;
DWORD startTick;
unsigned int actualTime;
unsigned int estimateTime;
DWORD eraseCode;
DWORD primoCode;
BOOL discCheck;
};

230
Src/burnlib/uiUnitReady.cpp Normal file
View File

@@ -0,0 +1,230 @@
#include "./uiUnitReady.h"
#include "./resource.h"
#include <strsafe.h>
#define TIMER_REFRESH_ID 1979
#define TIMER_REFRESH_INTERVAL 300
UnitReadyUI::UnitReadyUI(void)
{
hwnd = NULL;
drive = NULL;
primoSDK = NULL;
errPrimo = 0;
errReady = 0;
updateDlg = NULL;
}
UnitReadyUI::~UnitReadyUI(void)
{
if (updateDlg) delete(updateDlg);
updateDlg = NULL;
if (hwnd) DestroyWindow(hwnd);
}
DWORD UnitReadyUI::Check(obj_primo *primoSDK, DWORD *drive, BOOL showRetry, HWND ownerWnd)
{
if (!drive) return UNITREADYUI_DRIVENOTSET;
if (!primoSDK) return UNITREADYUI_PRIMOSDKNOTSET;
this->drive = drive;
this->primoSDK = primoSDK;
hwnd = NULL;
errPrimo = PRIMOSDK_OK;
errReady = UNITREADYUI_NOTREADY;
statSense = MAXDWORD;
statAsc = MAXDWORD;
statAscQ = MAXDWORD;
if (updateDlg) delete(updateDlg);
updateDlg = NULL;
Rescan();
if (UNITREADYUI_DRIVEREADY == errReady || UNITREADYUI_CANCELED == errReady || UNITREADYUI_PRIMOSDKERROR == errReady) return errReady;
LPCDLGTEMPLATE templ = NULL;
HRSRC hres = FindResourceExW(hResource, MAKEINTRESOURCEW(5), MAKEINTRESOURCEW(IDD_DLG_UNITNOTREADY), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
if (hres) templ = (LPCDLGTEMPLATE)LoadResource(hResource, hres);
HWND dlgWnd = CreateDialogIndirectParamW(dllInstance, templ, ownerWnd, (DLGPROC)WndProc, (LPARAM)this);
if (!dlgWnd) return UNITREADYUI_UNABLETOCREATEDIALOG;
wchar_t caption[64] = {0}, buffer[48] = {0};
LoadStringW(hResource, IDS_UNITNOTREADY, buffer, 48);
StringCchPrintfW(caption, 64, buffer, (char)*drive);
SetWindowTextW(GetDlgItem(hwnd, IDC_CAPTION), caption);
ShowWindow(GetDlgItem(hwnd, IDOK), showRetry);
MSG msg;
BOOL ret;
while( 0 != (ret = GetMessageW(&msg, NULL, 0, 0)))
{
if (ret == -1)
{
errReady = UNITREADYUI_MESSAGEPUMPERROR;
break;
}
if (IsDialogMessage(hwnd, &msg)) continue;
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
return errReady;
}
DWORD UnitReadyUI::Rescan(void)
{
if (!drive) return UNITREADYUI_DRIVENOTSET;
if (!primoSDK) return UNITREADYUI_PRIMOSDKNOTSET;
if (hwnd) KillTimer(hwnd, TIMER_REFRESH_ID);
errPrimo = primoSDK->UnitReady(drive);
switch(errPrimo)
{
case PRIMOSDK_NOTREADY:
if (hwnd)
{
DWORD cmd(0), sense(0), asc(0), ascq(0);
primoSDK->UnitStatus(drive, &cmd, &sense, &asc, &ascq);
if (sense != statSense || asc != statAsc || ascq != statAscQ)
{
statSense = sense;
statAsc = asc;
statAscQ = ascq;
if ((sense == 0x02 && asc == 0x04 && ascq == 0x01) ||
(sense == 0x06 && asc == 0x28 && ascq == 0x00))
{
if (!updateDlg)
{
// ShowWindow(hwnd, SW_HIDE);
UpdateWindow(GetParent(hwnd));
updateDlg = new UpdatingDataUI;
wchar_t buffer[64] = {0};
LoadStringW(hResource, IDS_WAITINGFORDRIVE, buffer, 64);
updateDlg->Show(0, buffer, TRUE, hwnd);
}
}
else
{
if(updateDlg)
{
updateDlg->Hide();
delete(updateDlg);
updateDlg = NULL;
}
wchar_t buffer[256] = {0}, pe[512] = {0};
StringCchPrintfW(buffer, 256, L"%s.", GetUnitStatusText(pe, 512, sense, asc, ascq));
SetWindowTextW(GetDlgItem(hwnd, IDC_LBL_REASON_VAL), buffer);
ShowWindow(hwnd, SW_SHOW);
SetForegroundWindow(hwnd);
BringWindowToTop(hwnd);
UpdateWindow(hwnd);
MessageBeep(MB_ICONEXCLAMATION);
}
}
}
errReady = UNITREADYUI_NOTREADY;
SetTimer(hwnd, TIMER_REFRESH_ID, TIMER_REFRESH_INTERVAL, NULL);
break;
case PRIMOSDK_OK:
if (updateDlg)
{
updateDlg->Hide();
delete(updateDlg);
updateDlg = NULL;
}
errReady = UNITREADYUI_DRIVEREADY;
if(hwnd) PostMessage(hwnd, WM_DESTROY, 0, 0);
break;
default:
if (updateDlg)
{
updateDlg->Hide();
delete(updateDlg);
updateDlg = NULL;
}
errReady = UNITREADYUI_PRIMOSDKERROR;
if(hwnd) PostMessage(hwnd, WM_DESTROY, 0, 0);
hwnd = NULL;
}
return errReady;
}
void UnitReadyUI::OnInitDialog(HWND hwndDlg)
{
hwnd = hwndDlg;
HANDLE hImage =LoadBitmapW(hResource, MAKEINTRESOURCEW(IDB_DRIVE1));
if(hImage==NULL){
hImage = LoadBitmapW(dllInstance, MAKEINTRESOURCEW(IDB_DRIVE1));
}
SendDlgItemMessage(hwnd, IDC_PIC, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hImage);
Rescan();
}
void UnitReadyUI::OnCancel(void)
{
KillTimer(hwnd, TIMER_REFRESH_ID);
wchar_t msg[256] = {0}, caption[64] = {0};
LoadStringW(hResource, IDS_MB_CANCELOPERATION, msg, 256);
LoadStringW(hResource, IDS_CONFIRMATION, caption, 64);
if (MessageBoxW(hwnd, msg, caption, MB_YESNO | MB_ICONQUESTION) == IDYES)
{
errReady = UNITREADYUI_CANCELED;
if(hwnd) DestroyWindow(hwnd);
hwnd = NULL;
}
else
{
SetTimer(hwnd, TIMER_REFRESH_ID, TIMER_REFRESH_INTERVAL, NULL);
}
}
void UnitReadyUI::OnDestroy(void)
{
ShowWindow(hwnd, SW_HIDE);
hwnd = NULL;
drive = NULL;
primoSDK = NULL;
}
LRESULT UnitReadyUI::WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static UnitReadyUI *object = NULL;
switch(uMsg)
{
case WM_INITDIALOG:
object = (UnitReadyUI*)lParam;
object->OnInitDialog(hwndDlg);
break;
case WM_DESTROY:
object->OnDestroy();
PostQuitMessage(object->errReady);
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
object->Rescan();
break;
case IDCANCEL:
object->OnCancel();
break;
}
break;
case WM_TIMER:
switch(wParam)
{
case TIMER_REFRESH_ID:
object->Rescan();
break;
}
break;
}
return 0;
}

47
Src/burnlib/uiUnitReady.h Normal file
View File

@@ -0,0 +1,47 @@
#pragma once
#include "./main.h"
#include "./uiUpdatingData.h"
#include "../primo/obj_primo.h"
#define UNITREADYUI_DRIVEREADY 0x000
#define UNITREADYUI_NOTREADY 0x001
#define UNITREADYUI_CANCELED 0x002
#define UNITREADYUI_PRIMOSDKERROR 0x101
#define UNITREADYUI_UNABLETOCREATEDIALOG 0x102
#define UNITREADYUI_MESSAGEPUMPERROR 0x103
#define UNITREADYUI_DRIVENOTSET 0x104
#define UNITREADYUI_PRIMOSDKNOTSET 0x105
class UnitReadyUI
{
public:
BURNLIB_API UnitReadyUI(void);
BURNLIB_API ~UnitReadyUI(void);
public:
BURNLIB_API DWORD Check(obj_primo *primoSDK, DWORD *drive, BOOL showRetry, HWND ownerWnd);
BURNLIB_API DWORD GetPrimoError(void) { return errPrimo; }
protected:
DWORD Rescan(void);
static LRESULT CALLBACK WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void OnInitDialog(HWND hwndDlg);
void OnCancel(void);
void OnDestroy(void);
protected:
HWND hwnd;
DWORD *drive;
obj_primo *primoSDK;
DWORD errPrimo;
DWORD errReady;
UpdatingDataUI *updateDlg;
DWORD statSense;
DWORD statAsc;
DWORD statAscQ;
};

206
Src/burnlib/uiUpdatingData.cpp Normal file
View File

@@ -0,0 +1,206 @@
#include "./uiUpdatingData.h"
#include "./resource.h"
#include <strsafe.h>
#define TIMER_SHOWDIALOG_ID 1979
#define TIMER_ANIMATION_ID 1978
#define TIMER_ANIMATION_INTERVAL 500
#define ANIMATION_CUBE_SIDE 16
#define ANIMATION_CUBE_SPACING 4
UpdatingDataUI::UpdatingDataUI(void)
{
hwnd = NULL;
hThread = NULL;
evntExit = NULL;
evntStarted = NULL;
text[0] = 0x0000;
}
UpdatingDataUI::~UpdatingDataUI(void)
{
Hide();
}
void UpdatingDataUI::Show(int delay,HWND ownerWnd)
{
wchar_t buffer[128] = {0};
LoadStringW(hResource, IDS_UPDATINGDATA, buffer, 128);
Show(delay, buffer, TRUE, ownerWnd);
}
void UpdatingDataUI::Show(int delay, const wchar_t* text, int animation, HWND ownerWnd)
{
this->delay = delay;
this->ownerWnd = ownerWnd;
StringCchCopyW(this->text, 128, text);
this->animation = animation;
animStep = 0;
evntExit = CreateEvent(NULL, FALSE, FALSE, NULL);
evntStarted = CreateEvent(NULL, FALSE, FALSE, NULL);
DWORD id;
hThread = CreateThread(NULL, 0, MessagePump, this, 0, &id);
WaitForSingleObject(evntStarted, INFINITE);
CloseHandle(evntStarted);
evntStarted = NULL;
}
void UpdatingDataUI::Hide(void)
{
if (hwnd) PostMessage(hwnd, WM_CLOSE, 0, 0);
if (evntExit)
{
WaitForSingleObject(evntExit, INFINITE);
CloseHandle(evntExit);
evntExit = NULL;
}
if (hThread)
{
CloseHandle(hThread);
hThread = NULL;
}
}
void UpdatingDataUI::OnInitDialog(HWND hwndDlg)
{
hwnd = hwndDlg;
SetTimer(hwnd, TIMER_SHOWDIALOG_ID, delay, NULL);
SetEvent(evntStarted);
}
void UpdatingDataUI::OnShowTimer(void)
{
KillTimer(hwnd, TIMER_SHOWDIALOG_ID);
RECT rect;
if (ownerWnd)
{
RECT ownerRect;
GetWindowRect(hwnd, &rect);
GetWindowRect(ownerWnd, &ownerRect);
SetWindowPos(hwnd, HWND_TOPMOST, ownerRect.left + ((ownerRect.right - ownerRect.left) - (rect.right - rect.left))/2,
ownerRect.top + ((ownerRect.bottom - ownerRect.top) - (rect.bottom - rect.top))/2,
0,0, SWP_NOSIZE);
}
SetDlgItemTextW(hwnd, IDC_LBL_TEXT, text);
if (animation)
{
GetClientRect(hwnd, &rect);
int width = (rect.right - rect.left);
animStep = 0;
SetRect(&animRect, 10, (rect.bottom - rect.top) - ANIMATION_CUBE_SIDE - 8, width - 8, (rect.bottom - rect.top) - 10);
animMaxStep = ((animRect.right - animRect.left) + ANIMATION_CUBE_SPACING) / (ANIMATION_CUBE_SIDE + ANIMATION_CUBE_SPACING);
SetTimer(hwnd, TIMER_ANIMATION_ID, TIMER_ANIMATION_INTERVAL, NULL);
}
else
{
SetRect(&animRect, 0, 0, 0, 0);
animMaxStep = 0;
}
ShowWindow(hwnd, SW_SHOWNORMAL);
UpdateWindow(hwnd);
}
void UpdatingDataUI::OnAnimationTimer(void)
{
animStep++;
if (animStep == animMaxStep) animStep = 0;
InvalidateRect(hwnd, &animRect, FALSE);
}
void UpdatingDataUI::OnDestroy(void)
{
hwnd = NULL;
}
void UpdatingDataUI::OnPaint(PAINTSTRUCT *ps)
{
if (RectVisible(ps->hdc, &animRect))
{
HBRUSH br = GetSysColorBrush(COLOR_3DFACE);
HBRUSH sbr = CreateSolidBrush(RGB(254, 172, 1));
HBRUSH oldBrush;
HPEN oldPen, pen = CreatePen(PS_SOLID, 2, RGB(21, 72, 9));
oldPen = (HPEN)SelectObject(ps->hdc, pen);
oldBrush = (HBRUSH)SelectObject(ps->hdc, br);
RECT cube = {animRect.left, animRect.top, animRect.left + ANIMATION_CUBE_SIDE, animRect.top + ANIMATION_CUBE_SIDE};
for (int i = 0; i < animMaxStep; i++)
{
SelectObject(ps->hdc, (i == animStep) ? sbr : br);
Rectangle(ps->hdc, cube.left, cube.top, cube.right, cube.bottom);
cube.left = cube.right + ANIMATION_CUBE_SPACING;
cube.right = cube.left + ANIMATION_CUBE_SIDE;
}
SelectObject(ps->hdc, oldPen);
SelectObject(ps->hdc,oldBrush);
// DeleteObject(br);
DeleteObject(sbr);
}
}
DWORD UpdatingDataUI::MessagePump(void *param)
{
UpdatingDataUI *object = (UpdatingDataUI*)param;
LPCDLGTEMPLATE templ = NULL;
HRSRC hres = FindResourceExW(hResource, MAKEINTRESOURCEW(5), MAKEINTRESOURCEW(IDD_DLG_UPDATING), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
if (hres) templ = (LPCDLGTEMPLATE)LoadResource(hResource, hres);
HWND dlgWnd = CreateDialogIndirectParamW(dllInstance, templ, NULL, (DLGPROC)WndProc, (LPARAM)object);
if (!dlgWnd) return 1;
MSG msg;
BOOL ret;
while( 0 != (ret = GetMessageW(&msg, dlgWnd, 0, 0)))
{
if (ret == -1) break;
if (IsDialogMessage(dlgWnd, &msg)) continue;
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
SetEvent(object->evntExit);
return 0;
}
LRESULT UpdatingDataUI::WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static UpdatingDataUI *object = NULL;
switch(uMsg)
{
case WM_INITDIALOG:
object = (UpdatingDataUI*)lParam;
object->OnInitDialog(hwndDlg);
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
if (BeginPaint(hwndDlg, &ps))
{
object->OnPaint(&ps);
EndPaint(hwndDlg, &ps);
}
}
break;
case WM_CLOSE:
DestroyWindow(hwndDlg);
break;
case WM_DESTROY:
ShowWindow(hwndDlg, SW_HIDE);
PostQuitMessage(1);
object->OnDestroy();
break;
case WM_TIMER:
switch(wParam)
{
case TIMER_SHOWDIALOG_ID:
object->OnShowTimer();
break;
case TIMER_ANIMATION_ID:
object->OnAnimationTimer();
break;
}
break;
}
return 0;
}

40
Src/burnlib/uiUpdatingData.h Normal file
View File

@@ -0,0 +1,40 @@
#pragma once
#include "./main.h"
class UpdatingDataUI
{
public:
BURNLIB_API UpdatingDataUI(void);
BURNLIB_API ~UpdatingDataUI(void);
public:
BURNLIB_API void Show(int delay, HWND ownerWnd);
BURNLIB_API void Show(int delay, const wchar_t* text, int animation, HWND ownerWnd);
BURNLIB_API void Hide(void);
protected:
static LRESULT CALLBACK WndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void OnInitDialog(HWND hwndDlg);
void OnDestroy(void);
void OnShowTimer(void);
void OnAnimationTimer(void);
void OnPaint(PAINTSTRUCT *ps);
static DWORD WINAPI MessagePump(void* param);
protected:
HWND hwnd;
HWND ownerWnd;
HANDLE hThread;
HANDLE evntExit;
HANDLE evntStarted;
int delay;
wchar_t text[128];
int animation;
int animStep;
int animMaxStep;
RECT animRect;
};

996
Src/burnlib/unitStatusText.cpp Normal file
View File

@@ -0,0 +1,996 @@
#include "./main.h"
#include "./resource.h"
#include <strsafe.h>
wchar_t* GetUnitStatusText(wchar_t *buffer, unsigned int cchBuffer, DWORD sense, DWORD asc, DWORD ascq)
{
DWORD strcode = IDS_UNKNOWN;
switch(sense)
{
case 0x00:
switch(asc)
{
case 0x00:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_000000; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_000001; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_000002; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_000003; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_000004; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_000005; break;
case 0x11: strcode = IDS_DRIVEERRORCODE_000011; break;
case 0x12: strcode = IDS_DRIVEERRORCODE_000012; break;
case 0x13: strcode = IDS_DRIVEERRORCODE_000013; break;
case 0x14: strcode = IDS_DRIVEERRORCODE_000014; break;
case 0x15: strcode = IDS_DRIVEERRORCODE_000015; break;
case 0x16: strcode = IDS_DRIVEERRORCODE_000016; break;
}
break;
}
break;
case 0x01:
switch(asc)
{
case 0x0B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_010B00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_010B01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_010B02; break;
}
break;
case 0x0C:
switch(ascq)
{
case 0x0A: strcode = IDS_DRIVEERRORCODE_010C0A; break;
}
break;
case 0x17:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_011700; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_011701; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_011702; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_011703; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_011704; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_011705; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_011706; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_011707; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_011708; break;
case 0x09: strcode = IDS_DRIVEERRORCODE_011709; break;
}
break;
case 0x18:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_011800; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_011801; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_011802; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_011803; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_011804; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_011805; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_011806; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_011807; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_011808; break;
}
break;
case 0x1E:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_011E00; break;
}
break;
case 0x37:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_013700; break;
}
break;
case 0x5D:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_015D00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_015D01; break;
case 0xFF: strcode = IDS_DRIVEERRORCODE_015DFF; break;
}
break;
case 0x6A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_016A00; break;
}
break;
case 0x73:
switch(ascq)
{
case 0x01: strcode = IDS_DRIVEERRORCODE_017301; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_017306; break;
}
break;
}
break;
case 0x02:
switch(asc)
{
case 0x04:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_020400; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_020401; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_020402; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_020403; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_020404; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_020405; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_020406; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_020407; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_020408; break;
}
break;
case 0x05:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_020500; break;
}
break;
case 0x06:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_020600; break;
}
break;
case 0x30:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_023000; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_023001; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_023002; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_023003; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_023004; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_023005; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_023007; break;
}
break;
case 0x35:
switch(ascq)
{
case 0x02: strcode = IDS_DRIVEERRORCODE_023502; break;
}
break;
case 0x3A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_023A00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_023A01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_023A02; break;
}
break;
case 0x3E:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_023E00; break;
}
break;
case 0x53:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_025300; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_025302; break;
}
break;
case 0x57:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_025700; break;
}
break;
case 0x68:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_026800; break;
}
break;
}
break;
case 0x03:
switch(asc)
{
case 0x00:
switch(ascq)
{
case 0x14: strcode = IDS_DRIVEERRORCODE_030014; break;
}
break;
case 0x02:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_030200; break;
case 0x80: strcode = IDS_DRIVEERRORCODE_030280; break;
case 0x81: strcode = IDS_DRIVEERRORCODE_030281; break;
case 0x82: strcode = IDS_DRIVEERRORCODE_030282; break;
case 0x83: strcode = IDS_DRIVEERRORCODE_030283; break;
}
break;
case 0x03:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_030300; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_030301; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_030302; break;
}
break;
case 0x06:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_030600; break;
}
break;
case 0x0C:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_030C00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_030C01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_030C02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_030C03; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_030C04; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_030C05; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_030C06; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_030C07; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_030C08; break;
case 0x09: strcode = IDS_DRIVEERRORCODE_030C09; break;
case 0x0A: strcode = IDS_DRIVEERRORCODE_030C0A; break;
}
break;
case 0x10:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031000; break;
}
break;
case 0x11:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031100; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_031101; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_031102; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_031103; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_031104; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_031105; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_031106; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_031107; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_031108; break;
case 0x09: strcode = IDS_DRIVEERRORCODE_031109; break;
case 0x0A: strcode = IDS_DRIVEERRORCODE_03110A; break;
case 0x0B: strcode = IDS_DRIVEERRORCODE_03110B; break;
case 0x0C: strcode = IDS_DRIVEERRORCODE_03110C; break;
case 0x0D: strcode = IDS_DRIVEERRORCODE_03110D; break;
case 0x0E: strcode = IDS_DRIVEERRORCODE_03110E; break;
case 0x0F: strcode = IDS_DRIVEERRORCODE_03110F; break;
case 0x10: strcode = IDS_DRIVEERRORCODE_031110; break;
}
break;
case 0x12:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031200; break;
}
break;
case 0x13:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031300; break;
}
break;
case 0x14:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031400; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_031401; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_031402; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_031403; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_031404; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_031405; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_031406; break;
}
break;
case 0x15:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031500; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_031501; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_031502; break;
}
break;
case 0x16:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031600; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_031601; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_031602; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_031603; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_031604; break;
}
break;
case 0x19:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031900; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_031901; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_031902; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_031903; break;
}
break;
case 0x1F:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_031F00; break;
}
break;
case 0x2D:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_032D00; break;
}
break;
case 0x30:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_033000; break;
}
break;
case 0x31:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_033100; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_033101; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_033102; break;
}
break;
case 0x32:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_033200; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_033201; break;
}
break;
case 0x33:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_033300; break;
}
break;
case 0x36:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_033600; break;
}
break;
case 0x3B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_033B00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_033B01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_033B02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_033B03; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_033B06; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_033B07; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_033B08; break;
case 0x09: strcode = IDS_DRIVEERRORCODE_033B09; break;
case 0x0A: strcode = IDS_DRIVEERRORCODE_033B0A; break;
case 0x0B: strcode = IDS_DRIVEERRORCODE_033B0B; break;
case 0x0C: strcode = IDS_DRIVEERRORCODE_033B0C; break;
}
break;
case 0x51:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_035100; break;
}
break;
case 0x52:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_035200; break;
}
break;
case 0x57:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_035700; break;
}
break;
case 0x5C:
switch(ascq)
{
case 0x02: strcode = IDS_DRIVEERRORCODE_035C02; break;
}
break;
case 0x61:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_036100; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_036101; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_036102; break;
}
break;
case 0x6C:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_036C00; break;
}
break;
case 0x6D:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_036D00; break;
}
break;
case 0x70: strcode = IDS_DRIVEERRORCODE_0370NN; break;
case 0x71:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_037100; break;
}
break;
case 0x72:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_037200; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_037201; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_037202; break;
}
break;
case 0x73:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_037300; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_037302; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_037303; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_037304; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_037305; break;
}
break;
}
break;
case 0x04:
switch(asc)
{
case 0x00:
switch(ascq)
{
case 0x17: strcode = IDS_DRIVEERRORCODE_040017; break;
}
break;
case 0x01:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_040100; break;
}
break;
case 0x05:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_040500; break;
}
break;
case 0x08:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_040800; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_040801; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_040802; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_040803; break;
}
break;
case 0x09:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_040900; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_040901; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_040902; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_040903; break;
}
break;
case 0x1B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_041B00; break;
}
break;
case 0x1C:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_041C00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_041C01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_041C02; break;
}
break;
case 0x34:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_043400; break;
}
break;
case 0x35:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_043500; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_043503; break;
}
break;
case 0x3B:
switch(ascq)
{
case 0x04: strcode = IDS_DRIVEERRORCODE_043B04; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_043B05; break;
case 0x16: strcode = IDS_DRIVEERRORCODE_043B16; break;
}
break;
case 0x3E:
switch(ascq)
{
case 0x01: strcode = IDS_DRIVEERRORCODE_043E01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_043E02; break;
}
break;
case 0x44:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_044400; break;
}
break;
case 0x46:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_044600; break;
}
break;
case 0x47:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_044700; break;
}
break;
case 0x4A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_044A00; break;
}
break;
case 0x4B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_044B00; break;
}
break;
case 0x4C:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_044C00; break;
}
break;
case 0x53:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_045300; break;
}
break;
case 0x54:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_045400; break;
}
break;
case 0x60:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_046000; break;
}
break;
case 0x62:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_046200; break;
}
break;
case 0x65:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_046500; break;
}
break;
case 0x66:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_046600; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_046601; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_046602; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_046603; break;
}
break;
case 0x67:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_046700; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_046701; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_046702; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_046703; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_046704; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_046705; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_046706; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_046707; break;
}
break;
case 0x69:
switch(ascq)
{
case 0x01: strcode = IDS_DRIVEERRORCODE_046901; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_046902; break;
}
break;
case 0x6E:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_046E00; break;
}
break;
case 0xB6:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_04B600; break;
}
break;
}
break;
case 0x05:
switch(asc)
{
case 0x00:
switch(ascq)
{
case 0x11: strcode = IDS_DRIVEERRORCODE_050011; break;
}
break;
case 0x07:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_050700; break;
}
break;
case 0x1A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_051A00; break;
}
break;
case 0x20:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052000; break;
}
break;
case 0x21:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052100; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_052101; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_052102; break;
}
break;
case 0x24:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052400; break;
}
break;
case 0x25:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052500; break;
}
break;
case 0x26:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052600; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_052601; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_052602; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_052603; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_052604; break;
}
break;
case 0x27:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052700; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_052701; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_052702; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_052703; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_052704; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_052705; break;
}
break;
case 0x2B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052B00; break;
}
break;
case 0x2C:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_052C00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_052C01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_052C02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_052C03; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_052C04; break;
}
break;
case 0x30:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_053000; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_053002; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_053004; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_053005; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_053006; break;
case 0x08: strcode = IDS_DRIVEERRORCODE_053008; break;
case 0x09: strcode = IDS_DRIVEERRORCODE_053009; break;
}
break;
case 0x35:
switch(ascq)
{
case 0x01: strcode = IDS_DRIVEERRORCODE_053501; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_053504; break;
}
break;
case 0x39:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_053900; break;
}
break;
case 0x3D:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_053D00; break;
}
break;
case 0x43:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_054300; break;
}
break;
case 0x53:
switch(ascq)
{
case 0x02: strcode = IDS_DRIVEERRORCODE_055302; break;
}
break;
case 0x55:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_055500; break;
}
break;
case 0x63:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_056300; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_056301; break;
}
break;
case 0x64:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_056400; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_056401; break;
}
break;
case 0x6F:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_056F00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_056F01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_056F02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_056F03; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_056F04; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_056F05; break;
}
break;
case 0x72:
switch(ascq)
{
case 0x03: strcode = IDS_DRIVEERRORCODE_057203; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_057205; break;
}
break;
case 0x81:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_058100; break;
}
break;
case 0x85:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_058500; break;
}
break;
}
break;
case 0x06:
switch(asc)
{
case 0x0A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_060A00; break;
}
break;
case 0x28:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_062800; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_062801; break;
}
break;
case 0x29:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_062900; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_062901; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_062902; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_062903; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_062904; break;
}
break;
case 0x2A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_062A00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_062A01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_062A02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_062A03; break;
}
break;
case 0x2E:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_062E00; break;
}
break;
case 0x2F:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_062F00; break;
}
break;
case 0x3B:
switch(ascq)
{
case 0x0D: strcode = IDS_DRIVEERRORCODE_063B0D; break;
case 0x0E: strcode = IDS_DRIVEERRORCODE_063B0E; break;
case 0x0F: strcode = IDS_DRIVEERRORCODE_063B0F; break;
case 0x11: strcode = IDS_DRIVEERRORCODE_063B11; break;
case 0x12: strcode = IDS_DRIVEERRORCODE_063B12; break;
case 0x13: strcode = IDS_DRIVEERRORCODE_063B13; break;
case 0x14: strcode = IDS_DRIVEERRORCODE_063B14; break;
case 0x15: strcode = IDS_DRIVEERRORCODE_063B15; break;
}
break;
case 0x3F:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_063F00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_063F01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_063F02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_063F03; break;
}
break;
case 0x55:
switch(ascq)
{
case 0x01: strcode = IDS_DRIVEERRORCODE_065501; break;
}
break;
case 0x5A:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_065A00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_065A01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_065A02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_065A03; break;
}
break;
case 0x5B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_065B00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_065B01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_065B02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_065B03; break;
}
break;
case 0x5C:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_065C00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_065C01; break;
}
break;
case 0x5E:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_065E00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_065E01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_065E02; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_065E03; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_065E04; break;
}
break;
case 0x6B:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_066B00; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_066B01; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_066B02; break;
}
break;
}
break;
case 0x07:
switch(asc)
{
case 0x27:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_072700; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_072701; break;
case 0x02: strcode = IDS_DRIVEERRORCODE_072702; break;
case 0x03: strcode = IDS_DRIVEERRORCODE_072703; break;
case 0x04: strcode = IDS_DRIVEERRORCODE_072704; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_072705; break;
}
break;
}
break;
case 0x08:
switch(asc)
{
case 0x21:
switch(ascq)
{
case 0x02: strcode = IDS_DRIVEERRORCODE_082102; break;
}
break;
}
break;
case 0x09:
switch(asc)
{
case 0x80:
switch(ascq)
{
case 0x00: strcode = IDS_DRIVEERRORCODE_098000; break;
case 0x01: strcode = IDS_DRIVEERRORCODE_098001; break;
case 0x05: strcode = IDS_DRIVEERRORCODE_098005; break;
case 0x06: strcode = IDS_DRIVEERRORCODE_098006; break;
case 0x07: strcode = IDS_DRIVEERRORCODE_098007; break;
case 0x0A: strcode = IDS_DRIVEERRORCODE_09800A; break;
case 0x0B: strcode = IDS_DRIVEERRORCODE_09800B; break;
case 0x0C: strcode = IDS_DRIVEERRORCODE_09800C; break;
}
break;
}
break;
}
LoadStringW(hResource, strcode, buffer, cchBuffer);
if (IDS_UNKNOWN == strcode) StringCchCatW(buffer, cchBuffer, L".");
return buffer;
}