neroapi.h

用VC开发的nero刻录程序

									NERO_DEVICEOPTION aOption,
									void *value);

/*
// Get an option from a device. The returned value must be freed with NeroFreeMem
// by the caller
*/
NEROAPI_API void* NADLL_ATTR NeroGetDeviceOption(NERO_DEVICEHANDLE aDeviceHandle,
									NERO_DEVICEOPTION aOption, void* reserved);


/*
// CD-Information:
*/

typedef enum
{
	NTT_UNKNOWN,
	NTT_DATA,
	NTT_AUDIO
} NERO_TRACK_TYPE;


/* NeroAPI > 6.6.0.3
 * Define the type of file system present in the particular track.
 */
typedef enum
{
	NTFST_UNKNOWN	= 0,
	NTFST_ISO		= (1<<0),
	NTFST_UDF		= (1<<1),		
	NTFST_HFS		= (1<<2),
	NTFST_FAT         = (1<<3),
	NTFST_DATA        = (1<<4),
	NTFST_AUDIO       = (1<<5),
	NTFST_CDRFS       = (1<<6),
	NTFST_DIRECTCD    = (1<<7),
	NTFST_PACKETCD    = (1<<8),
	NTFST_JOLIET      = (1<<9),
	NTFST_BOOTABLE    = (1<<10),
	NTFST_DATA_MODE_1 = (1<<11),
	NTFST_DATA_MODE_2 = (1<<12),
}
NERO_TRACK_FS_TYPE;

typedef struct tag_NERO_TRACK_INFO
{
	DWORD			ntiSessionNumber;
	DWORD			ntiTrackNumber;
	NERO_TRACK_TYPE	ntiTrackType;
	DWORD			ntiTrackStartBlk;
	DWORD			ntiTrackLengthInBlks;
	char			ntiArtist[65];
	char			ntiTitle[65];
	char			ntiISRC[13];			/* NeroAPI > 5.5.8.3: if NGCDI_READ_ISRC is present: 12 chars ISRC code + terminator */
	DWORD			ntiBlockSize;           /* NeroAPI >= 6.0.0.0: size of one block in bytes */
	DWORD			ntiFSType;				/* NeroAPI > 6.6.0.3 type of tracks file system. Can be combination of multiple file systems. */			
	DWORD			ntiReserved[27];        /* Should be zero */
} NERO_TRACK_INFO;

typedef enum
{
	NMT_UNKNOWN,
	NMT_CD_ROM,
	NMT_CD_RECORDABLE,
	NMT_CD_REWRITEABLE
} NERO_MEDIUM_TYPE;

/** Book types the inserted disc have. In seldom cases, beside DVD-ROM, it may differ from the
 * physical disc type. */
typedef enum 
{
	NBT_UNKNOWN,		// Unknown
	NBT_DVD_ROM,		// DVD-ROM	
	NBT_DVD_RAM,		// DVD-RAM	
	NBT_DVD_M_R,		// DVD-R	
	NBT_DVD_P_R,		// DVD+R
	NBT_DVD_M_RW,		// DVD-RW
	NBT_DVD_P_RW,		// DVD+RW
	NBT_DVD_P_R_DL,		// DVD+R Dual Layer
} 
NERO_BOOK_TYPE;


typedef struct tag_NERO_CD_INFO
{
	DWORD            ncdiFreeCapacityInBlocks;
	BOOL             ncdiIsWriteable;       /* A disc can be non-writeable */
	NERO_MEDIUM_TYPE ncdiMediumType;        /* Old media type description, ncdiMediaType should be used instead */
	char             ncdiArtist[65];
	char             ncdiTitle[65];
	DWORD			 ncdiAvailableEraseModes;/* This bitfield can be decoded using the NCDI_IS_ERASE_MODE_AVAILABLE macro */
	DWORD			 ncdiUnusedBlocks;		/* difference beetween Lead-Out position and last possible Lead-Out position */
	NERO_MEDIA_TYPE	 ncdiMediaType;			/* NeroAPI>=5.5.9.4: type of media */
	DWORD			 ncdiMediumFlags;		/* NeroAPI>6.0.0.10: various medium flags (Virtual multisession, ...)  */
/* The medium is a virtual multisession medium, use VMS API to retrieve session information.
   NOTE: This flag only tells you, that if multisession is written, VMS is used. But not
         that this medium contains multisessions.
*/
#define NCDIMF_VIRTUALMULTISESSION	(1<<0)
#define NCDIMF_HDB_SUPPORTED		(1<<1)  /* The medium supports HD-BURN */
#define NCDIMF_FINALIZED_DISC		(1<<2)  /* NeroAPI >= 6.6.0.12: Disc is finalized. No further writing possible */

	DWORD            ncdiLayer0MaxBlocks;   /* NeroAPI>6.0.0.19: If this value is set, the medium is a double layer medium whereby 
	                                         * layer 0 can not be bigger than the given number of blocks.
                                             */
	DWORD            ncdiTotalCapacity;		/* NeroAPI>=6.3.0.5: The total capacity of this medium */
	NERO_BOOK_TYPE	 ncdiBookType;			/* NeroAPI>=6.6.0.11: Book type of current disc or NBT_UNKNOWN, if could not be read. */
	DWORD            ncdiReserved[25];      /* Should be zero */
	DWORD            ncdiNumTracks;
	NERO_TRACK_INFO  ncdiTrackInfos[1];
} NERO_CD_INFO;

#define NCDI_IS_ERASE_MODE_AVAILABLE(cdInfo,eraseMode)	((cdInfo).ncdiAvailableEraseModes & (1<<(eraseMode)))



// NeroAPI >= 6.6.1.0
// Get the actual medium type inside the recorder.
// Returns MEDIA_NONE if no media is inside.
//
NEROAPI_API NERO_MEDIA_TYPE NADLL_ATTR NeroGetCurrentMediumType(NERO_DEVICEHANDLE aDeviceHandle);


/*
// Get information about a CD. Free result with NeroFreeMem().
//
// aDeviceHandle: result of NeroOpenDevice()
//         flags: see below
//
// Returns NULL in case of error.
*/
NEROAPI_API NERO_CD_INFO * NADLL_ATTR NeroGetCDInfo(NERO_DEVICEHANDLE aDeviceHandle, DWORD dwFlags);
#define NGCDI_READ_CD_TEXT      (1<<0)		/* also try to fill in */
#define NGCDI_READ_ISRC			(1<<1)		/* NeroAPI>=5.5.8.4 */
/* NeroAPI>=6.0.0.25: 
 * If the recorder and the current medium support HD-BURN, give the capacity and 
 * the unused blocks for the HD-BURN mode 
 * Note, that if the medium is already written in HD-BURN mode, this flag is not necessary.
 */
#define NGCDI_USE_HDB			(1<<2)
/* NeroAPI > 6.6.0.3
 * Get extended disc info, e.g. file system type of particular track.
 * This can take a little bit more time, therefore set it only if such
 * information is really required.  */
#define NGCDI_EXTENDED			(1<<3)
	

typedef struct tag_NERO_VMSSESSION
{
	char		nvmssSessionName[256];		/* The name of the session (volume name) */
	struct tm	nvmssCreationTime;			/* The creation time of the session */
	DWORD		nvmssNextWritableAddress;	/* The first block that is not occupied by this session */
	DWORD		nvmssReserved[32];			/* Should be zero */
} NERO_VMSSESSION;

typedef struct tag_NERO_VMS_INFO
{
	DWORD			nvmsiNextWritableAddress;	/* The next writable address of the medium, may be used for free space calculation */
	DWORD			nvmsiNumSessions;			/* Number of sessions stored on the VMS medium */
	DWORD			nvmsiReserved[32];			/* Should be zero */
	NERO_VMSSESSION	nvmsiSessionInfo[1];		/* One entry per session */
} NERO_VMS_INFO;


/*
// NeroAPI>6.0.0.10: Retrieve virtual multisession information for media supporting it.
// This function may be called for media having the NCDIMF_VIRTUALMULTISESSION flag
// set in their NERO_CD_INFO structure. Free result with NeroFreeMem()
//
// aDeviceHandle: result of NeroOpenDevice()
//         flags: currently unused, reserved for future extensions
//
// Returns NULL in case of error (e.g. non-VMS medium inserted)
//
// Virtual multisession is a technique to allow writing multisession discs on
// medium types that does not support normal multisession, e.g. DVD-+RW.
*/
NEROAPI_API NERO_VMS_INFO * NADLL_ATTR NeroGetVMSInfo(NERO_DEVICEHANDLE aDeviceHandle, DWORD dwFlags);


/*
// NeroAPI>=5.5.9.16: Get information about a disc image. Result must be released using NeroFreeMem().
//
// imagePath: path to the image file
// reserved: reserved for future usage
// 
// Returns NULL in case of error.
*/
NEROAPI_API NERO_CD_INFO * NADLL_ATTR NeroGetDiscImageInfo(const char *imagePath, void *reserved);

/*
// A progress display could look like this:
//
// +------------------------------------------------------+
// | Log of Operation:                                    |
// | +--------------------------------------------------+ |
// | | [icon] text                                      | |
// | | ...........                                      | |
// | |                                                  | |
// | +--------------------------------------------------+ |
// | Current Phase: text                                  |
// |      Progress: ********............................  |
// |                                                      |
// |                       ABORT                          |
// +------------------------------------------------------+
//
// The application may provide callback functions to set
// the different parts of this display. All of them may
// be NULL.
*/
typedef BOOL  (NERO_CALLBACK_ATTR *NERO_PROGRESS_CALLBACK)(void *pUserData, DWORD dwProgressInPercent); /* Will return TRUE if the user wants to abort */
typedef BOOL  (NERO_CALLBACK_ATTR *NERO_ABORTED_CALLBACK)(void *pUserData);                             /*  "     "     "    "  "    "    "    "   "   */
typedef enum
{
	NERO_TEXT_INFO,        /* informative text                     */
	NERO_TEXT_STOP,        /* some operation stopped prematurely   */
	NERO_TEXT_EXCLAMATION, /* important information                */
	NERO_TEXT_QUESTION,    /* a question which requires an answer  */
	NERO_TEXT_DRIVE,       /* a message concerning a CD-ROM drive or recorder */
	NERO_TEXT_FILE,        /* a message concerning a file          */
	NERO_TEXT_UNSPECIFIED  /* no type specified                    */
} NERO_TEXT_TYPE;       

typedef enum
{
	NERO_PHASE_UNSPECIFIED					=-1,
	NERO_PHASE_START_CACHE					=24,
	NERO_PHASE_DONE_CACHE					=25,
	NERO_PHASE_FAIL_CACHE					= 26,
	NERO_PHASE_ABORT_CACHE					= 27,
	NERO_PHASE_START_TEST					=28,
	NERO_PHASE_DONE_TEST					=29,
	NERO_PHASE_FAIL_TEST					= 30,
	NERO_PHASE_ABORT_TEST					= 31,
	NERO_PHASE_START_SIMULATE				=32,
	NERO_PHASE_DONE_SIMULATE				=33,
	NERO_PHASE_FAIL_SIMULATE				= 34,
	NERO_PHASE_ABORT_SIMULATE				= 35,
	NERO_PHASE_START_WRITE					=36,
	NERO_PHASE_DONE_WRITE					=37,
	NERO_PHASE_FAIL_WRITE					= 38,
	NERO_PHASE_ABORT_WRITE					= 39,
	NERO_PHASE_START_SIMULATE_NOSPD			=61,
	NERO_PHASE_DONE_SIMULATE_NOSPD			=62,
	NERO_PHASE_FAIL_SIMULATE_NOSPD			= 63,
	NERO_PHASE_ABORT_SIMULATE_NOSPD			= 64,
	NERO_PHASE_START_WRITE_NOSPD			=65,
	NERO_PHASE_DONE_WRITE_NOSPD				=66,
	NERO_PHASE_FAIL_WRITE_NOSPD				= 67,
	NERO_PHASE_ABORT_WRITE_NOSPD			= 68,
	NERO_PHASE_PREPARE_ITEMS				= 73,
	NERO_PHASE_VERIFY_COMPILATION			= 78,
	NERO_PHASE_VERIFY_ABORTED				= 79,
	NERO_PHASE_VERIFY_END_OK				= 80,
	NERO_PHASE_VERIFY_END_FAIL				= 81,
	NERO_PHASE_ENCODE_VIDEO					=82,
	NERO_PHASE_SEAMLESSLINK_ACTIVATED      = 87,  // deprecated, use NERO_PHASE_BUP_ACTIVATED below
	NERO_PHASE_BUP_ACTIVATED				=90,  // Generic: Buffer underun protection activated
	NERO_PHASE_START_FORMATTING				= 98, 
	NERO_PHASE_CONTINUE_FORMATTING			=99,
	NERO_PHASE_FORMATTING_SUCCESSFUL		=100,
	NERO_PHASE_FORMATTING_FAILED            =101,
	NERO_PHASE_PREPARE_CD					=105,
	NERO_PHASE_DONE_PREPARE_CD				=106,
	NERO_PHASE_FAIL_PREPARE_CD				=107,
	NERO_PHASE_ABORT_PREPARE_CD				=108,
	NERO_PHASE_DVDVIDEO_DETECTED			=111,
	NERO_PHASE_DVDVIDEO_REALLOC_STARTED		=112,
	NERO_PHASE_DVDVIDEO_REALLOC_COMPLETED	=113,
	NERO_PHASE_DVDVIDEO_REALLOC_NOTNEEDED	=114, // NeroAPI > 5.5.9.3
	NERO_PHASE_DVDVIDEO_REALLOC_FAILED		=115,  // NeroAPI > 5.5.9.3
	NERO_PHASE_DRM_CHECK_FAILURE			=169,  // NeroAPI >= 6.3.0.6
	/** Start Burn-at-once phases **/
	NERO_PHASE_START_WRITE_DATAFILES		=171,	// Writing data files started
	NERO_PHASE_DONE_WRITE_DATAFILES			=172,   // Writing data files completed successfully
	NERO_PHASE_FAIL_WRITE_DATAFILES			=173,	// Writing data files failed
	NERO_PHASE_WARN_WRITE_DATAFILES			=174,	// Writing data files completed with warnings
	NERO_PHASE_START_BAO_FINALIZE			=175,	// Finalizing disc started
	NERO_PHASE_FAIL_BAO_FINALIZE			=176,	// Finalizing the disc failed
	NERO_PHASE_DONE_BAO_FINALIZE			=177,	// Disc finalized successfully
	NERO_PHASE_FAIL_BAO_PREPARE				=178,	// Preparing the disc failed
	NERO_PHASE_FAIL_BAO_WRITEFILE			=179,	// Writing file to disc failed
	/** End Burn-at-once phases **/
	NERO_PHASE_BURN_LAYER_1					=180,	// Starting writing on layer 1 of a double layer disc
	NERO_PHASE_BURN_LAYER_2					=181,	// Starting writing on layer 2 of a double layer disc
} NERO_MAJOR_PHASE;

/* a one-line text to be displayed; text pointer becomes invalid after returning from this function */
typedef void  (NERO_CALLBACK_ATTR *NERO_ADD_LOG_LINE_CALLBACK)(void *pUserData, NERO_TEXT_TYPE type, const char *text); 

/* set the phase line; text pointer becomes invalid after returning from this function */
typedef void  (NERO_CALLBACK_ATTR *NERO_SET_PHASE_CALLBACK)(void *pUserData, const char *text);                         

/* Tell the main program whether the burn process can be interrupted or not */
typedef void (NERO_CALLBACK_ATTR *NERO_DISABLE_ABORT_CALLBACK)(void *pUserData,BOOL abortEnabled);

/* Let the application knows in which part of the burn process NeroAPI is */
typedef void (NERO_CALLBACK_ATTR *NERO_SET_MAJOR_PHASE_CALLBACK)(void *pUserData,NERO_MAJOR_PHASE phase,void *reserved);

typedef struct tag_NERO_PROGRESS
{
	NERO_PROGRESS_CALLBACK npProgressCallback;
	NERO_ABORTED_CALLBACK npAbortedCallback;