/******************************************************************************
|* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|* ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|* PARTICULAR PURPOSE.
|*
|* Copyright 1995-2004 Ahead Software AG. All Rights Reserved.
|*-----------------------------------------------------------------------------
|* NeroSDK / NeroCmd
|*
|* PROGRAM: BurnContext.cpp
|*
|* PURPOSE: Central class for CD operations; implementation file
******************************************************************************/
#include "stdafx.h"
#include "BurnContext.h"
#include "Parameters.h"
#include "Response.h"
CBurnContextProgress::CBurnContextProgress ()
{
if (m_pNeroProgress != NULL)
{
m_pNeroProgress->npAbortedCallback = CBurnContext::AbortedCallback;
m_pNeroProgress->npAddLogLineCallback = CBurnContext::AddLogLine;
m_pNeroProgress->npDisableAbortCallback = CBurnContext::DisableAbortCallback;
m_pNeroProgress->npProgressCallback = CBurnContext::ProgressCallback;
m_pNeroProgress->npSetMajorPhaseCallback = CBurnContext::SetMajorPhaseCallback;
m_pNeroProgress->npSetPhaseCallback = CBurnContext::SetPhaseCallback;
m_pNeroProgress->npSubTaskProgressCallback = NULL; // Write buffer fill level callback (we don't use this as it is complicated to visualize)
m_pNeroProgress->npUserData = &CBurnContext::s_NeroSettings;
}
}
// NERO_SETTINGS is needed when calling NeroInit()
NERO_SETTINGS CBurnContext::s_NeroSettings =
{
NULL,
"ahead", "Nero - Burning Rom",
"Nero.txt",
{IdleCallback, &s_NeroSettings},
{UserDialog, &s_NeroSettings}
};
CBurnContext::~CBurnContext ()
{
// Let the NeroAPI perform the required cleanup
if (m_bNeroInitialized)
{
NeroCloseDevice (m_NeroDeviceHandle);
NeroFreeMem (m_NeroDeviceInfos);
NeroFreeMem (m_NeroCDInfo);
NeroFreeCDStamp (m_pCDStamp);
NeroClearErrors ();
}
// NeroDone needs to be called before closing the DLL.
// This is necessary because some clean-up actions like
// stopping threads cannot be done in the close function of the DLL
if (NeroDone ())
{
// If return value is TRUE, some memory leaks were detected.
//
}
NeroAPIGlueDone();
}
CExitCode CBurnContext::GetAvailableDrives (const PARAMETERS & params)
{
// Make sure that NeroGetAvailableDrives has not been called before to prevent multiple
// allocation of memory for NERO_SCSI_DEVICE_INFOS.
_ASSERTE (NULL == m_NeroDeviceInfos);
// NeroGetAvailableDrives returns a list of available WORM and CDROM devices.
// The memory allocated for NERO_SCSI_DEVICE_INFOS must be freed with NeroFreeMem().
// This function returns NULL for errors
m_NeroDeviceInfos = NeroGetAvailableDrivesEx ((NERO_MEDIA_TYPE) params.GetMediaType (), NULL);
return (NULL == m_NeroDeviceInfos)? EXITCODE_ERROR_OBTAINING_AVAILABLE_DRIVES: EXITCODE_OK;
}
// Opens the NeroCMD error log
bool CBurnContext::OpenLogFile (LPCSTR psLogFilename)
{
// We use the CErrorLog class.
// Open returns true if the error log could be opened.
return m_ErrorLog.Open (psLogFilename);
}
CExitCode CBurnContext::NeroLoad (void)
{
// Initialize NeroAPI.
if (! NeroAPIGlueConnect (NULL))
{
return EXITCODE_NEROAPI_DLL_NOT_FOUND;
}
// Set the flag.
m_bNeroInitialized = true;
return EXITCODE_OK;
}
// This function queries the registry for serial number and initializes
// the NeroAPI.
CExitCode CBurnContext::InitNeroAPI (void)
{
// Provide the this-pointer for the UserDialog callback
s_NeroSettings.nstUserDialog.ncCallbackFunction = UserDialog;
s_NeroSettings.nstUserDialog.ncUserData = this;
// Do the actual initialization and map the return value
// into our EXITCODE.
switch (NeroInit (&s_NeroSettings, NULL))
{
case NEROAPI_INIT_OK:
return EXITCODE_OK;
case NEROAPI_INIT_INVALID_SERIAL_NUM:
return EXITCODE_BAD_SERIAL_NUMBER;
case NEROAPI_INIT_DEMOVERSION_EXPIRED:
return EXITCODE_DEMOVERSION_EXPIRED;
case NEROAPI_INIT_ALREADY_INITIALISED:
case NEROAPI_INIT_CANNOT_LOCK:
case NEROAPI_INIT_UNSPECIFIED_ERROR:
case NEROAPI_INIT_INVALID_ARGS:
default:
return EXITCODE_INTERNAL_ERROR;
}
}
// OpenDevice checks if params.m_psDriveName has a matching
// drive in the list of availabe drives and opens it.
CExitCode CBurnContext::OpenDevice (const PARAMETERS & params)
{
if (NULL == params.GetDriveName())
{
// To open a device we must have its name or drive letter.
return EXITCODE_MISSING_DRIVENAME;
}
// Call the support function that enumerates the drives and finds
// the requested drive according to the supplied command line
// parameters.
//
int iDriveIndex = LookForADrive (params);
// If the drive is found (a positive response), try and open it.
//
if (iDriveIndex >= 0)
{
m_NeroDeviceHandle = NeroOpenDevice (&m_NeroDeviceInfos->nsdisDevInfos[iDriveIndex]);
if (NULL == m_NeroDeviceHandle)
{
return EXITCODE_ERROR_OPENNING_DRIVE;
}
}
// Output a list of available drives and return
// an error if the requested device could not be found
if (NULL == m_NeroDeviceHandle)
{
printf ("Drive '%s' not found, available are:\n", params.GetDriveName());
CommandListDrives (params);
return EXITCODE_DRIVE_NOT_FOUND;
}
return EXITCODE_OK;
}
// This function sets the appropriate burn flags according to the user
// supplied parameters.
DWORD CBurnContext::GetBurnFlags (const PARAMETERS & params)
{
DWORD dwFlags;
// Simulation or real mode
dwFlags = (params.GetUseReal ())? NBF_WRITE : NBF_SIMULATE;
// DAO (Disc At Once) or TAO (Track At Once)
// TAO is default
dwFlags |= (params.GetUseTAO ())? 0 : NBF_DAO;
// Disable Abort
// The disable abort callback will be called.
dwFlags |= (params.GetEnableAbort ())? 0: NBF_DISABLE_ABORT;
// Perform source speed test first
dwFlags |= (params.GetUseSpeedTest ())? NBF_SPEED_TEST : 0;
// Close session after write, not the whole disc
dwFlags |= (params.GetCloseSession ())? NBF_CLOSE_SESSION: 0;
// Buffer underrun protection for safer burning
dwFlags |= (params.GetUseUnderRunProt ()) ? NBF_BUF_UNDERRUN_PROT: 0;
// Detect non-empty CDRW
// The DLG_NON_EMPTY_CDRW user callback will be called when trying
// to burn onto a non empty CDRW
dwFlags |= (params.GetDetectNonEmptyCDRW ())? NBF_DETECT_NON_EMPTY_CDRW: 0;
// Enable CD text writing.
// Will be ignored if the drive does not support this feature
dwFlags |= (params.GetUseCDText ())? NBF_CD_TEXT: 0;
// Do not eject CD at the end of the burn process
dwFlags |= (params.GetDisableEject ())? NBF_DISABLE_EJECT: 0;
// Verify Filesystem after writing. Works for ISO only
dwFlags |= (params.GetVerify ())? NBF_VERIFY: 0;
// The speed passed to NeroBurn() is specified in kb/s instead of
// the usual X.
dwFlags |= (params.GetSpeedInKbps () >= 0)? NBF_SPEED_IN_KBS: 0;
// If dvd is burned and a high compatibility mode is specified, this
// flag is used.
dwFlags |= (params.GetUseDVDHighCompatibility ())? NBF_DVDP_BURN_30MM_AT_LEAST: 0;
dwFlags |= (params.GetJapaneseCDText ())? NBF_CD_TEXT_IS_JAPANESE: 0;
dwFlags |= (params.GetBooktypeDVDROM ())? NBF_BOOKTYPE_DVDROM: 0;
dwFlags |= (params.GetNoBooktypeChange ())? NBF_NO_BOOKTYPE_CHANGE: 0;
return dwFlags;
}
// This function is called to exit with a specific error code.
EXITCODE CBurnContext::Exit(CExitCode code)
{
if (code != EXITCODE_OK)
{
LPCSTR psNeroAPIError = code.GetLastError ();
// If the first char is non-null, the string is non-empty
// and we should print it. Otherwise, it looks silly.
//
if (psNeroAPIError[0] != 0)
{
printf("NeroAPI reports: %s.\n", psNeroAPIError);
}
}
return code;
}
CBurnContext::CBurnContext(PARAMETERS* params)
{
// A PARAMETERS reference is required for
// the UserDialog callback.
m_params = params;
m_NeroDeviceHandle = NULL;
m_NeroDeviceInfos = NULL;
m_pCDStamp = NULL;
m_NeroCDInfo = NULL;
m_bNeroInitialized = false;
m_bPrintUserInteractionErrorMessage = false;
// Set Ctrl+C handler.
SetConsoleCtrlHandler (CtrlHandler, TRUE);
}
// This function prints error log lines
// that are passed from outside the CBurnContext class
void CBurnContext::PrintLogLine(LPCSTR s)
{
m_ErrorLog.printf ("%s\n", s);
}
// This function rids the string from spaces from the right.
//
void CBurnContext::TrimStringRight (LPSTR psString)
{
// Loop from the last string character to the first until the first
// non-space character is encountered.
//
for (LPSTR p = psString + strlen (psString) - 1;
psString <= p && *p == ' ';
p --)
{
*p = '\0';
}
}
// This is a support function that enumerates drives and finds the one
// according to the specified command line parameters.
//
int CBurnContext::LookForADrive (const PARAMETERS & params)
{
int i;
LPSTR psTrimmedDriveName = (LPSTR) _alloca (strlen (params.GetDriveName ()) + 1);
strcpy (psTrimmedDriveName, params.GetDriveName ());
TrimStringRight (psTrimmedDriveName);
for (i = 0; i < (int)(m_NeroDeviceInfos->nsdisNumDevInfos); i++)
{
NERO_SCSI_DEVICE_INFO nsdiShort = m_NeroDeviceInfos->nsdisDevInfos[i];
// Check if the full device name has been supplied.
// stricmp performs a lowercase comparison and returns 0 if the strings are identical.
LPSTR psTrimmedDeviceName = (LPSTR) _alloca (strlen (nsdiShort.nsdiDeviceName) + 1);
strcpy (psTrimmedDeviceName, nsdiShort.nsdiDeviceName);
TrimStringRight(psTrimmedDeviceName);
bool bFoundDeviceName = false;
if (0 == stricmp (psTrimmedDriveName, psTrimmedDeviceName))
{
bFoundDeviceName = true;
}
// Check if the user supplied drive name is only one character long
// and see if it matches the drive letter
bool bFoundDriveName = false;
if (1 == strlen(params.GetDriveName()))
{
if (toupper(params.GetDriveName()[0]) == toupper(nsdiShort.nsdiDriveLetter))
{
bFoundDriveName = true;
}
}
// If either a device name or drive name was found try to open the device
if (bFoundDeviceName || bFoundDriveName)
{
// We successfully found the wanted drive. Return the index.
return i;
}
}
return -1;
}
void CBurnContext::PrintUserInteractionMessage (void)
{
if (m_bPrintUserInteractionErrorMessage)
{
m_bPrintUserInteractionErrorMessage = false;
printf ("\nERROR: The operation cannot be performed without user interaction!\n");
}
}
/*
A. Riazi
PARAMETERS class
*/
// This is a constructor for our PARAMETERS struct which holds
// our command line arguments. All values are here set to some
// reasonable defaults.
PARAMETERS::PARAMETERS ()
{
// Set this flag to prevent destruction of strings because we
// don't own them.
m_FileList.m_bOwnData = false;
m_bUserInteraction = true;
m_Command = COMMAND_UNKNOWN;
m_psDriveName = NULL;
m_bReal = false;
m_bTAO = false;
m_bUnderRunProt = false;
m_psArtist = NULL;
m_psTitle = NULL;
m_iReadSpeed = 0; // 0 is maximum DAE speed.
m_iSpeed = -1; // m_iSpeed is speed in X and m_iSpeedInKbps is
m_iSpeedInKbps = -1; // speed in kb/s. -1 means "not set".
m_bCDExtra = false;
m_eEraseMode = NEROAPI_ERASE_QUICK;
m_bEnableAbort = false;
m_bSpeedTest = false;
m_bCloseSession = false;
m_iSessionToImport = -1;
m_bDetectNonEmptyCDRW = false;
m_bCDText = false;
m_bUseRockridge = false;
m_bCreateIsoFS = false;
m_bCreateUdfFS = false;
m_bDVDVideoRealloc = false;
m_bDVDVideoCmpt = false;
// m_bImportRockridge = false; // Not used anymore.
m_bImportIsoOnly = false;
m_bImportUDF = false;
m_bImportVMSSession = false;
m_bPreferRockridge = false;
m_bDisableEject = false;
m_bVerify = false;
m_bDVD = false;
m_bDVDHighCompatibility = false;
m_bAudioSelected = false;
m_bISOSelected = false;
m_psVolumeName = NULL;
m_bDontUseJoliet = false;
m_bMode2 = false;
m_bVolumeNameSupplied = false;
m_BurnType = BURNTYPE_UNKNOWN;
m_psImageFilename = NULL;
m_psOutputImageFilename = NULL;
m_iNumTracks = 0;
m_bProcessedParameterFile = false;
m_bWriteNeroErrorLog = true;
m_psErrorLogFilename = NULL;
m_bNeroLogTimestamp = false;
m_bForceEraseCDRW = false;
m_psTempPath = "";
m_bRecursiveSearch = false;
m_MediaSet = MEDIA_NONE;
m_bUseAllSpace = false;
m_bRelaxJoliet = false;
m_bJapaneseCDText = false;
m_bBooktypeDVDROM = false;
m_bNoBooktypeChange = false;
m_bDisableEjectAfterErase = false;
m_bForceEjectAfterErase = false;
m_psImageInfoFilename = NULL;
m_psSystemIdentifier = NULL;
m_psVolumeSet = NULL;
m_psPublisher = NULL;
m_psDataPreparer = NULL;
m_psApplication = NULL;
m_psCopyright = NULL;
m_psAbstract = NULL;
m_psBibliographic = NULL;
m_bImportSession = false;
m_bBackup = false;
m_VideoResolution = NERO_VIDEO_RESOLUTION_PAL;
m_bEstimateFSOverhead = false;
m_bEstimateData = false;
m_bEstimateExactSize = false;
}
int PARAMETERS::GetFileListSize() const
{
return m_FileList.GetSize();
}
const CSimpleStringArray& PARAMETERS::GetFileList() const
{
return m_FileList;
}
CSimpleStringArray& PARAMETERS::GetFileList()
{
return m_FileList;
}
LPCSTR PARAMETERS::GetErrorLogName() const
{
return m_psErrorLogFilename;
}
COMMAND_LINE_ERRORS PARAMETERS::SetErrorLogName(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_ERROR_LOG_PARAMETER;
}
m_psErrorLogFilename = *argv;
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::SetWriteErrorLog()
{
m_bWriteNeroErrorLog = false;
return CLE_NO_ERROR;
}
bool PARAMETERS::GetWriteErrorLog() const
{
return m_bWriteNeroErrorLog;
}
COMMAND_LINE_ERRORS PARAMETERS::SetProcessedParameterFile()
{
if (COMMAND_UNKNOWN != m_Command)
{
return CLE_MULTIPLE_COMMANDS_SPECIFIED;
}
m_bProcessedParameterFile = true;
return CLE_NO_ERROR;
}
bool PARAMETERS::GetProcessedParameterFile()
{
return m_bProcessedParameterFile;
}
const TRACK PARAMETERS::GetTrack(int iTrack) const
{
return m_Tracks[iTrack];
}
const bool PARAMETERS::StillTrackSpaceLeft() const
{
return m_iNumTracks < sizeof (m_Tracks)/sizeof (m_Tracks[0]);
}
TRACK& PARAMETERS::GetTrack (int iTrack)
{
return m_Tracks[iTrack];
}
const int PARAMETERS::GetTrackNumber(int iTrack) const
{
return m_Tracks[iTrack].m_iTrack;
}
const LPCSTR PARAMETERS::GetTrackFileName (int iTrack) const
{
return m_Tracks[iTrack].m_psFilename;
}
const NERO_TRACKMODE_TYPE PARAMETERS::GetTrackMode(int iTrack) const
{
return m_Tracks[iTrack].m_Mode;
}
COMMAND_LINE_ERRORS PARAMETERS::SetTrackFileName(int iTrack, const char *psName)
{
m_Tracks[iTrack].m_psFilename = psName;
return CLE_NO_ERROR;
}
const int PARAMETERS::GetNumberOfTracks() const
{
return m_iNumTracks;
}
COMMAND_LINE_ERRORS PARAMETERS::SetTrackMode(int iTrack, NERO_TRACKMODE_TYPE eType)
{
m_Tracks[iTrack].m_Mode = eType;
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::IncrementNumberOfTracks()
{
m_iNumTracks++;
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::SetTrackNumber(int iTrack, int iNumber)
{
m_Tracks[iTrack].m_iTrack = iNumber;
return CLE_NO_ERROR;
}
const NEROAPI_CDRW_ERASE_MODE PARAMETERS::GetEraseMode() const
{
return m_eEraseMode;
}
COMMAND_LINE_ERRORS PARAMETERS::SetEraseMode(NEROAPI_CDRW_ERASE_MODE eMode)
{
if (GetEraseMode() == eMode)
{
return CLE_MULTIPLE_COMMANDS_SPECIFIED;
}
m_eEraseMode = eMode;
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImageFileName(const char *psName)
{
m_psImageFilename = psName;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetImageFileName() const
{
return m_psImageFilename;
}
COMMAND_LINE_ERRORS PARAMETERS::SetOutputImageFileName(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_OUTPUT_IMAGE_FILENAME_PARAMETER;
}
m_psOutputImageFilename = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetOutputImageFileName() const
{
return m_psOutputImageFilename;
}
COMMAND_LINE_ERRORS PARAMETERS::SetBurnType(BURNTYPE Type)
{
// The Burn type cannot be set twice
// BURNTYPE_ISOAUDIO is an exception to this rule.
// However, settings for ISO/Audio and mixed more are handled
// in SetAudioSelected and SetISOSelected directly.
// So we do not have to worry about that here.
// Another exception is BURNTYPE_FREESTYLE, where every
// track can be written in a different mode.
// So it is legal to provide that type more than once.
if (BURNTYPE_UNKNOWN != GetBurnType())
{
if (BURNTYPE_FREESTYLE != GetBurnType())
{
// A burn type other than freestyle has been set already.
return CLE_BURN_TYPE_ALREADY_SPECIFIED;
}
else
{
// The burn type set before is freestyle.
// If the new type is not BURNTYPE_FREESTYLE
// we need to return an error.
if (BURNTYPE_FREESTYLE != Type)
{
// Illegal combination of types
return CLE_BURN_TYPE_ALREADY_SPECIFIED;
}
}
}
// Burn type has not been specified yet, so just set it
m_BurnType = Type;
return CLE_NO_ERROR;
}
const BURNTYPE PARAMETERS::GetBurnType() const
{
return m_BurnType;
}
const COMMAND PARAMETERS::GetCommand() const
{
return m_Command;
}
COMMAND_LINE_ERRORS PARAMETERS::SetCommand (COMMAND Command)
{
if (GetCommand() == COMMAND_UNKNOWN)
{
m_Command = Command;
}
else
{
return CLE_MULTIPLE_COMMANDS_SPECIFIED;
}
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetDriveName() const
{
return m_psDriveName;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDriveName (int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_DRIVE_NAME_PARAMETER;
}
m_psDriveName = *argv;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseReal() const
{
return m_bReal;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseReal ()
{
m_bReal = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseTAO() const
{
return m_bTAO;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseTAO ()
{
m_bTAO = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseUnderRunProt() const
{
return m_bUnderRunProt;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseUnderRunProt ()
{
m_bUnderRunProt = true;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetArtist() const
{
return m_psArtist;
}
COMMAND_LINE_ERRORS PARAMETERS::SetArtist (int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_ARTIST_PARAMETER;
}
m_psArtist = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetTitle() const
{
return m_psTitle;
}
COMMAND_LINE_ERRORS PARAMETERS::SetTitle (int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_TITLE_PARAMETER;
}
m_psTitle = *argv;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetAudioSelected() const
{
return m_bAudioSelected;
}
COMMAND_LINE_ERRORS PARAMETERS::SetAudioSelected ()
{
// Audio can only be used in combination with ISO
if (BURNTYPE_UNKNOWN != GetBurnType())
{
if (!GetISOSelected())
{
return CLE_BURN_TYPE_ALREADY_SPECIFIED;
}
}
m_bAudioSelected = true;
m_BurnType = BURNTYPE_ISOAUDIO;
return CLE_NO_ERROR;
}
const int PARAMETERS::GetReadSpeed() const
{
return m_iReadSpeed;
}
COMMAND_LINE_ERRORS PARAMETERS::SetReadSpeed (int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_SPEED_PARAMETER;
}
// check if conversion went right
if (!ATOI (*argv, m_iReadSpeed))
{
return CLE_INVALID_SPEED_PARAMETER;
}
return CLE_NO_ERROR;
}
const int PARAMETERS::GetSpeed() const
{
return m_iSpeed;
}
COMMAND_LINE_ERRORS PARAMETERS::SetSpeed (int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_SPEED_PARAMETER;
}
if (GetSpeedInKbps () >= 0)
{
// If the speed in kbps is already specified, it is an error to
// set the speed in X.
//
return CLE_INVALID_SPEED_PARAMETER;
}
// check if conversion went right
if (!ATOI (*argv, m_iSpeed))
{
return CLE_INVALID_SPEED_PARAMETER;
}
return CLE_NO_ERROR;
}
const int PARAMETERS::GetSpeedInKbps() const
{
return m_iSpeedInKbps;
}
COMMAND_LINE_ERRORS PARAMETERS::SetSpeedInKbps (int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_SPEED_PARAMETER;
}
if (GetSpeed () >= 0)
{
// If the speed in X is already specified, it is an error to
// set the speed in kb/s.
//
return CLE_INVALID_SPEED_PARAMETER;
}
// check if conversion went right
if (!ATOI (*argv, m_iSpeedInKbps))
{
return CLE_INVALID_SPEED_PARAMETER;
}
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseCDExtra() const
{
return m_bCDExtra;
}
COMMAND_LINE_ERRORS PARAMETERS::SetCDExtra ()
{
m_bCDExtra = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetEnableAbort() const
{
return m_bEnableAbort;
}
COMMAND_LINE_ERRORS PARAMETERS::SetEnableAbort ()
{
m_bEnableAbort = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseSpeedTest() const
{
return m_bSpeedTest;
}
COMMAND_LINE_ERRORS PARAMETERS::SetSpeedTest ()
{
m_bSpeedTest = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetCloseSession() const
{
return m_bCloseSession;
}
COMMAND_LINE_ERRORS PARAMETERS::SetCloseSession ()
{
m_bCloseSession = true;
return CLE_NO_ERROR;
}
const int PARAMETERS::GetSessionToImport() const
{
return m_iSessionToImport;
}
COMMAND_LINE_ERRORS PARAMETERS::SetSessionToImport (int& argc, char**& argv)
{
argc--;
argv++;
// By default, session is not imported unless --import is spotted in
// the command line.
//
m_bImportSession = true;
if (argc <= 0)
{
// If there are no more command line arguments, this switch was
// supplied without a session number.
//
m_iSessionToImport = -1;
}
else
{
// Check whether the argument is a number. If it is, take it as
// a part of this switch. If not, backtrack a single position
// in an argument list and let the parser reuse this argument
// while semantically considering that the last session will be
// imported.
//
if (!ATOI (*argv, m_iSessionToImport))
{
argc++;
argv--;
//this switch was supplied without a session number.
m_iSessionToImport = -1;
}
}
return CLE_NO_ERROR;
}
const int PARAMETERS::GetDoImportSession() const
{
// Return a flag that signifies if a session should be imported at all
// or not.
//
return m_bImportSession;
}
const bool PARAMETERS::GetDetectNonEmptyCDRW() const
{
return m_bDetectNonEmptyCDRW;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDetectNonEmptyCDRW ()
{
m_bDetectNonEmptyCDRW = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseCDText() const
{
return m_bCDText;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseCDText ()
{
m_bCDText = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseRockridge() const
{
return m_bUseRockridge;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseRockridge ()
{
m_bUseRockridge = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetCreateIsoFs() const
{
return m_bCreateIsoFS;
}
COMMAND_LINE_ERRORS PARAMETERS::SetCreateIsoFs ()
{
m_bCreateIsoFS = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetCreateUdfFS() const
{
return m_bCreateUdfFS;
}
COMMAND_LINE_ERRORS PARAMETERS::SetCreateUdfFs ()
{
m_bCreateUdfFS = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetDVDVideoRealloc() const
{
return m_bDVDVideoRealloc;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDVDVideoRealloc ()
{
m_bDVDVideoRealloc = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetDVDVideoCmpt() const
{
return m_bDVDVideoCmpt;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDVDVideoCmpt ()
{
m_bDVDVideoCmpt = true;
return CLE_NO_ERROR;
}
// NIITEF_IMPORT_ROCKRIDGE flag is obsolete so we commented the
// code below.
//
/*const bool PARAMETERS::GetImportRockridge() const
{
return m_bImportRockridge;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImportRockridge ()
{
m_bImportRockridge = true;
return CLE_NO_ERROR;
}*/
const bool PARAMETERS::GetImportUDF() const
{
return m_bImportUDF;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImportUDF ()
{
m_bImportUDF = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetImportVMSSession() const
{
return m_bImportVMSSession;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImportVMSSession ()
{
m_bImportVMSSession = true;
return CLE_NO_ERROR;
}
/*
const bool PARAMETERS::GetImportIsoOnly() const
{
return m_bImportIsoOnly;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImportIsoOnly ()
{
m_bImportIsoOnly = true;
return CLE_NO_ERROR;
}
*/
/*
const bool PARAMETERS::GetPreferRockRidge() const
{
return m_bPreferRockridge;
}
COMMAND_LINE_ERRORS PARAMETERS::SetPreferRockridge ()
{
m_bPreferRockridge = true;
return CLE_NO_ERROR;
}
*/
const bool PARAMETERS::GetDisableEject() const
{
return m_bDisableEject;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDisableEject ()
{
m_bDisableEject = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetVerify() const
{
return m_bVerify;
}
COMMAND_LINE_ERRORS PARAMETERS::SetVerify ()
{
m_bVerify = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetISOSelected() const
{
return m_bISOSelected;
}
COMMAND_LINE_ERRORS PARAMETERS::SetISOSelected (int& argc, char**& argv)
{
// ISO can be used in combination with
// any other burn type except BURNTYPE_IMAGE.
if (BURNTYPE_UNKNOWN != GetBurnType())
{
// If ISO has been set already return an error
if (GetISOSelected())
{
return CLE_BURN_TYPE_ALREADY_SPECIFIED;
}
else
{
// The other illegal type in this case
// is BURNTYPE_IMAGE.
if (BURNTYPE_IMAGE == GetBurnType())
{
return CLE_BURN_TYPE_ALREADY_SPECIFIED;
}
}
}
else
{
// No burn type set before
m_BurnType = BURNTYPE_ISOAUDIO;
}
if (argc <= 1)
{
return CLE_MISSING_ISO_PARAMETER;
}
argc--;
argv++;
COMMAND_LINE_ERRORS ecl = SetVolumeName(*argv);
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
ecl = SetVolumeNameSupplied();
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
m_bISOSelected = true;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetVolumeName() const
{
return m_psVolumeName;
}
COMMAND_LINE_ERRORS PARAMETERS::SetVolumeName (char* psName)
{
m_psVolumeName = psName;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetDontUseJoliet() const
{
return m_bDontUseJoliet;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDontUseJoliet ()
{
m_bDontUseJoliet = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseMode2() const
{
return m_bMode2;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseMode2 ()
{
m_bMode2 = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetVolumeNameSupplied() const
{
return m_bVolumeNameSupplied;
}
COMMAND_LINE_ERRORS PARAMETERS::SetVolumeNameSupplied ()
{
m_bVolumeNameSupplied = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseDVD() const
{
return m_bDVD;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseDVD ()
{
m_bDVD = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseDVDHighCompatibility() const
{
return m_bDVDHighCompatibility;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseDVDHighCompatibility ()
{
m_bDVDHighCompatibility = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetRecursive() const
{
return m_bRecursiveSearch;
}
COMMAND_LINE_ERRORS PARAMETERS::SetRecursive()
{
m_bRecursiveSearch = true;
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImageBurnType(int &argc, char **&argv)
{
COMMAND_LINE_ERRORS ecl = SetBurnType(BURNTYPE_IMAGE);
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
if (argc <= 0)
{
return CLE_MISSING_IMAGE_PARAMETER;
}
argc--;
argv++;
return SetImageFileName(*argv);
}
COMMAND_LINE_ERRORS PARAMETERS::SetFreestyleBurnType(int &argc, char **&argv)
{
// make sure that the burn type has not been
// specified already
if (GetBurnType() != BURNTYPE_UNKNOWN && GetBurnType() != BURNTYPE_FREESTYLE)
{
return CLE_BURN_TYPE_ALREADY_SPECIFIED;
}
// set the track mode
COMMAND_LINE_ERRORS ecl;
if (!stricmp (*argv, "--freestyle_mode1"))
{
ecl = SetTrackMode(GetNumberOfTracks(), NERO_TRACKMODE_MODE1);
}
else if (!stricmp (*argv, "--freestyle_mode2"))
{
ecl = SetTrackMode(GetNumberOfTracks(), NERO_TRACKMODE_MODE2_FORM1);
}
else if (!stricmp (*argv, "--freestyle_audio"))
{
ecl = SetTrackMode(GetNumberOfTracks(), NERO_TRACKMODE_AUDIO);
}
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
// the file name must be specified after the track mode
if (argc <= 0)
{
return CLE_MISSING_IMAGE_PARAMETER;
}
// make sure that we can add another track
if (!StillTrackSpaceLeft())
{
return CLE_MAXIMUM_NUMBER_OF_TRACKS_REACHED;
}
// Get the track filename
argc--;
argv++;
ecl = SetTrackFileName(GetNumberOfTracks(), *argv);
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
ecl = IncrementNumberOfTracks();
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
// finally, set the burn type
return SetBurnType(BURNTYPE_FREESTYLE);
}
COMMAND_LINE_ERRORS PARAMETERS::AddAudioReadTrack(int &argc, char **&argv)
{
bool bOK = false;
if (strlen (*argv) <= 4 &&
'0' <= (*argv)[2] && (*argv)[2] <= '9' &&
'0' <= (*argv)[3] && (*argv)[3] <= '9')
{
if (!StillTrackSpaceLeft())
{
return CLE_MAXIMUM_NUMBER_OF_TRACKS_REACHED;
}
int iTrackNumber;
if (!ATOI (&(*argv)[2], iTrackNumber))
{
return CLE_INVALID_PARAMETER;
}
COMMAND_LINE_ERRORS ecl = SetTrackNumber(GetNumberOfTracks(), iTrackNumber);
if (GetTrackNumber(GetNumberOfTracks()) > 0)
{
if (argc <= 0)
{
return CLE_MISSING_TRACK_PARAMETER;
}
argc--;
argv++;
ecl = SetTrackFileName(GetNumberOfTracks(), *argv);
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
ecl = IncrementNumberOfTracks();
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
bOK = true;
}
}
if (!bOK)
{
return CLE_INVALID_PARAMETER;
}
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::AddAudioIsoFreestyleWriteTrack(int &argc, char **&argv)
{
if (!GetVolumeNameSupplied() && GetBurnType() != BURNTYPE_FREESTYLE)
{
// If volume name was not yet supplied, the parameter is an audio file.
if (!StillTrackSpaceLeft())
{
return CLE_MAXIMUM_NUMBER_OF_TRACKS_REACHED;
}
COMMAND_LINE_ERRORS ecl = SetTrackFileName(GetNumberOfTracks(), *argv);
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
ecl = IncrementNumberOfTracks();
if (CLE_NO_ERROR != ecl)
{
return ecl;
}
}
else
{
// This is a data file so simply add it to the back of the array.
GetFileList().Add (*argv);
}
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetNeroLogTimestamp() const
{
return m_bNeroLogTimestamp;
}
COMMAND_LINE_ERRORS PARAMETERS::SetNeroLogTimestamp()
{
m_bNeroLogTimestamp = true;
return CLE_NO_ERROR;
}
COMMAND_LINE_ERRORS PARAMETERS::SetForceEraseCDRW()
{
m_bForceEraseCDRW = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetForceEraseCDRW() const
{
return m_bForceEraseCDRW;
}
COMMAND_LINE_ERRORS PARAMETERS::SetTempPath (int& argc, char**& argv)
{
if (argc <= 0)
{
return CLE_MISSING_TEMP_PATH_PARAMETER;
}
argc--;
argv++;
m_psTempPath = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetTempPath () const
{
return m_psTempPath;
}
const NERO_MEDIA_SET PARAMETERS::GetMediaType() const
{
return m_MediaSet;
}
void ParseMediaTypeArgument (CSimpleStringArray & ssa, LPCSTR psArg)
{
// A plus sign is a separator between media constants.
//
for (;;)
{
LPCSTR psPlus = strchr (psArg, '+');
if (psPlus == NULL)
{
// No more plus signs found. This is the last media constant.
//
LPSTR psMediaType = new char [strlen (psArg) + 1];
strcpy (psMediaType, psArg);
ssa.Add (psMediaType);
// We have reached the end. Break the endless for loop.
//
break;
}
else
{
// We found a plus sign so there are more constants.
//
LPSTR psMediaType = new char [psPlus - psArg + 1];
strncpy (psMediaType, psArg, psPlus - psArg);
psMediaType[psPlus - psArg] = 0;
ssa.Add (psMediaType);
// Advance the pointer to the position beyond a plus sign.
//
psArg = psPlus + 1;
}
}
}
COMMAND_LINE_ERRORS PARAMETERS::SetMediaType(int& argc, char**& argv)
{
if (argc <= 0)
{
return CLE_MISSING_MEDIA_TYPE_PARAMETER;
}
argc--;
argv++;
CSimpleStringArray ssa;
ParseMediaTypeArgument (ssa, *argv);
m_MediaSet = MEDIA_NONE;
for (int i = 0; i < ssa.vect.size (); i ++)
{
LPCSTR psMediaType = ssa.vect[i];
if (0 == stricmp (psMediaType, "media_cd"))
{
m_MediaSet |= MEDIA_CD;
}
else if (0 == stricmp (psMediaType, "media_ddcd"))
{
m_MediaSet |= MEDIA_DDCD;
}
else if (0 == stricmp (psMediaType, "media_dvd_m"))
{
m_MediaSet |= MEDIA_DVD_M;
}
else if (0 == stricmp (psMediaType, "media_dvd_p"))
{
m_MediaSet |= MEDIA_DVD_P;
}
else if (0 == stricmp (psMediaType, "media_dvd_any"))
{
m_MediaSet |= MEDIA_DVD_ANY;
}
else if (0 == stricmp (psMediaType, "media_dvd_ram"))
{
m_MediaSet |= MEDIA_DVD_RAM;
}
else if (0 == stricmp (psMediaType, "media_ml"))
{
m_MediaSet |= MEDIA_ML;
}
else if (0 == stricmp (psMediaType, "media_mrw"))
{
m_MediaSet |= MEDIA_MRW;
}
else if (0 == stricmp (psMediaType, "media_no_cdr"))
{
m_MediaSet |= MEDIA_NO_CDR;
}
else if (0 == stricmp (psMediaType, "media_no_cdrw"))
{
m_MediaSet |= MEDIA_NO_CDRW;
}
else if (0 == stricmp (psMediaType, "media_cdrw"))
{
m_MediaSet |= MEDIA_CDRW;
}
else if (0 == stricmp (psMediaType, "media_cdr"))
{
m_MediaSet |= MEDIA_CDR;
}
else if (0 == stricmp (psMediaType, "media_dvd_rom"))
{
m_MediaSet |= MEDIA_DVD_ROM;
}
else if (0 == stricmp (psMediaType, "media_cdrom"))
{
m_MediaSet |= MEDIA_CDROM;
}
else if (0 == stricmp (psMediaType, "media_no_dvd_m_rw"))
{
m_MediaSet |= MEDIA_NO_DVD_M_RW;
}
else if (0 == stricmp (psMediaType, "media_no_dvd_m_r"))
{
m_MediaSet |= MEDIA_NO_DVD_M_R;
}
else if (0 == stricmp (psMediaType, "media_no_dvd_p_rw"))
{
m_MediaSet |= MEDIA_NO_DVD_P_RW;
}
else if (0 == stricmp (psMediaType, "media_no_dvd_p_r"))
{
m_MediaSet |= MEDIA_NO_DVD_P_R;
}
else if (0 == stricmp (psMediaType, "media_dvd_m_r"))
{
m_MediaSet |= MEDIA_DVD_M_R;
}
else if (0 == stricmp (psMediaType, "media_dvd_m_rw"))
{
m_MediaSet |= MEDIA_DVD_M_RW;
}
else if (0 == stricmp (psMediaType, "media_dvd_p_r"))
{
m_MediaSet |= MEDIA_DVD_P_R;
}
else if (0 == stricmp (psMediaType, "media_dvd_p_rw"))
{
m_MediaSet |= MEDIA_DVD_P_RW;
}
else if (0 == stricmp (psMediaType, "media_fpacket"))
{
m_MediaSet |= MEDIA_FPACKET;
}
else if (0 == stricmp (psMediaType, "media_vpacket"))
{
m_MediaSet |= MEDIA_VPACKET;
}
else if (0 == stricmp (psMediaType, "media_packetw"))
{
m_MediaSet |= MEDIA_PACKETW;
}
else if (0 == stricmp (psMediaType, "media_hdb"))
{
m_MediaSet |= MEDIA_HDB;
}
}
return CLE_NO_ERROR;
}
bool PARAMETERS::ATOI (LPCSTR psString, int & iVal)
{
char * pchStopChar;
iVal = strtol (psString, &pchStopChar, 10);
// C run-time function "strtol" sets internal error to non-null
// if error occurs on conversion. This error value is retrieved by
// accessing errno global variable. We will also consider it an error
// if the stop char is not the actual end of string.
//
return errno == 0 && *pchStopChar == '\0';
}
int PARAMETERS::GetSpeedToNeroBurn (void) const
{
int iSpeed;
// There are two variants of specifying the burning speed. One is
// to specify it in X and the other in kb/s. If speed in kb/s is
// used, a flag NBF_SPEED_IN_KBS must be used to NeroBurn().
// GetBurnFlags() function will take care of that.
//
if (GetSpeedInKbps () >= 0)
{
// If speed is specified as kb/s, the use this setting.
//
iSpeed = GetSpeedInKbps ();
}
else if (GetSpeed () >= 0)
{
// If the speed is specified in X, the use this setting.
//
iSpeed = GetSpeed ();
}
else
{
// If none is specified, use the default speed of 0. NeroAPI
// will choose the appropriate speed.
//
iSpeed = 0;
}
return iSpeed;
}
const bool PARAMETERS::GetUserInteraction () const
{
return m_bUserInteraction;
}
COMMAND_LINE_ERRORS PARAMETERS::SetNoUserInteraction ()
{
m_bUserInteraction = false;
// Use default responses to questions if no user interaction is
// specified.
//
CResponse::SetUseDefaultResponse (!m_bUserInteraction);
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetUseAllSpace() const
{
return m_bUseAllSpace;
}
COMMAND_LINE_ERRORS PARAMETERS::SetUseAllSpace()
{
m_bUseAllSpace = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetRelaxJoliet() const
{
return m_bRelaxJoliet;
}
COMMAND_LINE_ERRORS PARAMETERS::SetRelaxJoliet()
{
m_bRelaxJoliet = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetJapaneseCDText() const
{
return m_bJapaneseCDText;
}
COMMAND_LINE_ERRORS PARAMETERS::SetJapaneseCDText()
{
m_bJapaneseCDText = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetBooktypeDVDROM() const
{
return m_bBooktypeDVDROM;
}
COMMAND_LINE_ERRORS PARAMETERS::SetBooktypeDVDROM()
{
m_bBooktypeDVDROM = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetNoBooktypeChange() const
{
return m_bNoBooktypeChange;
}
COMMAND_LINE_ERRORS PARAMETERS::SetNoBooktypeChange()
{
m_bNoBooktypeChange = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetDisableEjectAfterErase() const
{
return m_bDisableEjectAfterErase;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDisableEjectAfterErase()
{
m_bDisableEjectAfterErase = true;
return CLE_NO_ERROR;
}
const bool PARAMETERS::GetForceEjectAfterErase() const
{
return m_bForceEjectAfterErase;
}
COMMAND_LINE_ERRORS PARAMETERS::SetForceEjectAfterErase()
{
m_bForceEjectAfterErase = true;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetImageInfoFileName() const
{
return m_psImageInfoFilename;
}
COMMAND_LINE_ERRORS PARAMETERS::SetImageInfoFileName(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_IMAGE_INFO_FILENAME_PARAMETER;
}
m_psImageInfoFilename = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetSystemIdentifier () const
{
return m_psSystemIdentifier;
}
COMMAND_LINE_ERRORS PARAMETERS::SetSystemIdentifier(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_SYSTEM_IDENTIFIER_PARAMETER;
}
m_psSystemIdentifier = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetVolumeSet () const
{
return m_psVolumeSet;
}
COMMAND_LINE_ERRORS PARAMETERS::SetVolumeSet(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_VOLUME_SET_PARAMETER;
}
m_psVolumeSet = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetPublisher () const
{
return m_psPublisher;
}
COMMAND_LINE_ERRORS PARAMETERS::SetPublisher(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_PUBLISHER_PARAMETER;
}
m_psPublisher = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetDataPreparer () const
{
return m_psDataPreparer;
}
COMMAND_LINE_ERRORS PARAMETERS::SetDataPreparer(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_DATA_PREPARER_PARAMETER;
}
m_psDataPreparer = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetApplication () const
{
return m_psApplication;
}
COMMAND_LINE_ERRORS PARAMETERS::SetApplication(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_APPLICATION_PARAMETER;
}
m_psApplication = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetCopyright () const
{
return m_psCopyright;
}
COMMAND_LINE_ERRORS PARAMETERS::SetCopyright(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_COPYRIGHT_PARAMETER;
}
m_psCopyright = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetAbstract () const
{
return m_psAbstract;
}
COMMAND_LINE_ERRORS PARAMETERS::SetAbstract(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_ABSTRACT_PARAMETER;
}
m_psAbstract = *argv;
return CLE_NO_ERROR;
}
const LPCSTR PARAMETERS::GetBibliographic () const
{
return m_psBibliographic;
}
COMMAND_LINE_ERRORS PARAMETERS::SetBibliographic(int& argc, char**& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_BIBLIOGRAPHIC_PARAMETER;
}
m_psBibliographic = *argv;
return CLE_NO_ERROR;
}
bool PARAMETERS::GetBackup () const
{
return m_bBackup;
}
COMMAND_LINE_ERRORS PARAMETERS::SetBackup (void)
{
m_bBackup = true;
return CLE_NO_ERROR;
}
NERO_VIDEO_RESOLUTION PARAMETERS::GetVideoResolution (void) const
{
return m_VideoResolution;
}
COMMAND_LINE_ERRORS PARAMETERS::SetVideoResolution (int & argc, char **& argv)
{
argc--;
argv++;
if (argc <= 0)
{
return CLE_MISSING_VIDEO_RESOLUTION_PARAMETER;
}
if (0 == stricmp (*argv, "pal"))
{
m_VideoResolution = NERO_VIDEO_RESOLUTION_PAL;
}
else if (0 == stricmp (*argv, "ntsc"))
{
m_VideoResolution = NERO_VIDEO_RESOLUTION_NTSC;
}
else
{
return CLE_BAD_VIDEO_RESOLUTION_PARAMETER;
}
return CLE_NO_ERROR;
}
bool PARAMETERS::GetEstimateNoFSOverhead () const
{
return m_bEstimateFSOverhead;
}
COMMAND_LINE_ERRORS PARAMETERS::SetEstimateNoFSOverhead (void)
{
m_bEstimateFSOverhead = true;
return CLE_NO_ERROR;
}
bool PARAMETERS::GetEstimateNoData () const
{
return m_bEstimateData;
}
COMMAND_LINE_ERRORS PARAMETERS::SetEstimateNoData (void)
{
m_bEstimateData = true;
return CLE_NO_ERROR;
}
bool PARAMETERS::GetEstimateNoExactSize () const
{
return m_bEstimateExactSize;
}
COMMAND_LINE_ERRORS PARAMETERS::SetEstimateNoExactSize (void)
{
m_bEstimateExactSize = true;
return CLE_NO_ERROR;
}