neroapi.h

本源码是通过调用NeroAPI实现刻录功能

/*
// Create a NERO_ISO_ITEM tree from an already existing ISO track in order to create a new session
// with reference to files from older sessions
// *ppCDStamp will be filled with a pointer on a CDStamp object which will have to be freed later
// *pInfo will be filled with information about the imported track
// *result will contain a result flag, may be NULL
// (NeroAPI>=6.0.0.0)
*/
NEROAPI_API NERO_ISO_ITEM *NADLL_ATTR NeroImportDataTrack(	NERO_DEVICEHANDLE pRecorder,
												DWORD trackNumber,
												void **ppCDStamp,
												NERO_IMPORT_DATA_TRACK_INFO *pInfo,
												DWORD flags,
												NERO_IMPORT_DATA_TRACK_RESULT *result,
												void *reserved);		// Must be NULL
#define NIITEF_IMPORT_ROCKRIDGE		(1<<0) // Will be ignored, RockRidge is now always imported if present
#define NIITEF_IMPORT_ISO_ONLY		(1<<1)
#define NIITEF_PREFER_ROCKRIDGE		(1<<2) // Will be ignored
#define NIITEF_IMPORT_UDF			(1<<3) // Import UDF Session
#define NIITEF_IMPORT_VMS_SESSION	(1<<4) // treat trackNumber as the virtual multisession session specifier

// Free a CD stamp allocated by NeroImportIsoTrackEx

NEROAPI_API void NADLL_ATTR NeroFreeCDStamp(void *pCDStamp);

// Create a file system container for the NERO_FILE_SYSTEM_CONTAINER_MEDIA compilation type

#ifdef __cplusplus
namespace FileSystemContent
{
	struct IFileSystemDescContainer;
};
#else //__cplusplus
struct IFileSystemDescContainer;
#endif//__cplusplus

NEROAPI_API 
#ifdef __cplusplus
FileSystemContent::
#else //__cplusplus
struct
#endif//__cplusplus
IFileSystemDescContainer *NADLL_ATTR NeroCreateFileSystemContainer(void *reserved);


/*
// Recording functions:
*/

typedef enum
{
	NERO_ET_FILE,			/* read/write to/from WAV file. */
	NERO_ET_IO_CALLBACK,	/* exchange data with application directly */
	NERO_ET_FILE_MP3,		/* read from MP3 file (not for DAE) */
	NERO_ET_FILE_WMA,		/* read from MS audio file (not for DAE) */
    NERO_ET_FILE_RAW,        /* for a Freestyle compilation,
					 * this and NERO_ET_IO_CALLBACK
					 * are the only types allowed
					 * at the moment.
					 * It will expect files 
					 * to be in the format
					 * as to be written to the disc.
					 * This exchange type is valid
					 * for freestyle compilations only */

	NERO_ET_AUDIO_FILE	/* NeroAPI > 5.5.9.8: audio file created with the plugin manager*/

} NERO_DATA_EXCHANGE_TYPE;

typedef void * NERO_AUDIO_ITEM_HANDLE;

typedef struct tagNERO_AUDIO_ITEM_INFO
{
	NERO_AUDIO_ITEM_HANDLE	naiiAudioItem;
	const char				*naiiFileName;
} NERO_AUDIO_ITEM_INFO;

/* use PCM, 44.1kHz, Stereo (left channel first), 16 bits per channel, LSB,
   when exchanging data with the NeroAPI */
typedef	struct tag_NERO_DATA_EXCHANGE
{
	NERO_DATA_EXCHANGE_TYPE ndeType;
	union
	{
		char			ndeFileName[256];      // Deprecated, use ndeLongFileName.ptr instead
		struct
		{
			DWORD	reserved;				   /* must be 0	*/
			const char 	*ptr;				   
		} ndeLongFileName;
		NERO_IO			ndeIO;                 // NERO_IO/EOF/ERROR_CALLBACK

		NERO_AUDIO_ITEM_INFO	ndeAudioItemInfo; // NeroAPI > 5.5.9.8
	} ndeData;
} NERO_DATA_EXCHANGE;
		
typedef struct tag_NERO_AUDIO_TRACK
{
	DWORD natPauseInBlksBeforeThisTrack;
	DWORD natNumIndexPositions;
	/* NOTE: values of index positions has to be given in bytes,
	 * whereby the values have to be a multiple of 2352
	 */
	DWORD natRelativeIndexBlkPositions[98];  /* offsets between one index position and the next one */
	const char *natTitle, *natArtist;        /* set to NULL if unknown or to be taken from source */
	NERO_DATA_EXCHANGE natSourceDataExchg;
	DWORD natLengthInBlocks;                 /* only used for NERO_IO_CALLBACK */
	BOOL  natIndex0ContainsData;			 /* NeroAPI 5.5.9.8: TRUE, if audio data shall be written into index 
												0. Data for index 0 must be provided. */
	DWORD natReserved[31];                   /* Should be zero */
} NERO_AUDIO_TRACK;

typedef enum
{
   NERO_TRACKMODE_MODE1,         /* 2048 Bytes per sector data track */
   NERO_TRACKMODE_MODE2_FORM1,   /* 2048 Bytes per sector, used for multisession */
   NERO_TRACKMODE_AUDIO          /* 2352 Bytes per sector, standard audio track */
} NERO_TRACKMODE_TYPE;
   
typedef struct tag_NERO_FREESTYLE_TRACK
{
    DWORD nftStructureSize;                     /* size of this structure, to ensure binary compatibility */
	DWORD nftPauseInBlksBeforeThisTrack;
	DWORD nftNumIndexPositions;
	DWORD nftRelativeIndexBlkPositions[98];  /* offsets between one index position and the next one */
	const char *nftTitle, *nftArtist;        /* set to NULL if unknown or to be taken from source */
	NERO_DATA_EXCHANGE nftSourceDataExchg;   /* source for raw track data */
	DWORD nftLengthInBlocks;                 /* only used for NERO_IO_CALLBACK */
    NERO_TRACKMODE_TYPE nftTracktype;           /* specifies track type to be written */
} NERO_FREESTYLE_TRACK;
      
typedef enum
{
	NERO_MPEG_ITEM,
	NERO_JPEG_ITEM,
	NERO_NONENCODED_VIDEO_ITEM,	// The source file name will be an AVI file which will be encoded into MPG by NeroAPI
} NERO_VIDEO_ITEM_TYPE;

typedef struct tag_NERO_VIDEO_ITEM
{
	DWORD nviPauseAfterItem;			// value is number of blocks (75 blocks = 1 second)
	char nviSourceFileName[250];		// Deprecated, use nviLongSourceFileName instead
	const char *nviLongSourceFileName;	// MPG, JPG or AVI file
	NERO_VIDEO_ITEM_TYPE nviItemType;
} NERO_VIDEO_ITEM;

typedef enum
{
	NERO_ISO_AUDIO_MEDIA			=0,	// Burn either a CD or a DVD, depending on the nwcdMediaType member
	NERO_VIDEO_CD					=1,
	NERO_BURN_IMAGE_MEDIA			=2,	// Burn either a CD or a DVD from an image
    NERO_FREESTYLE_CD				=3,
	NERO_FILE_SYSTEM_CONTAINER_MEDIA=4,	// Burn an IFileSystemDescContainer (see NeroFileSystemContainer.h) 

	// For compatibility
	NERO_ISO_AUDIO_CD				=0,
	NERO_BURN_IMAGE_CD				=2
} NERO_CD_FORMAT;

typedef struct tag_NERO_WRITE_CD
{
	/* both may be NULL: */
	const char *nwcdArtist;
	const char *nwcdTitle;

	struct CNeroIsoTrack *nwcdIsoTrack;      /* if not NULL, then the disc will have an ISO track - please refer to "NeroIsoTrack.h" */
	BOOL nwcdCDExtra;                        /* if TRUE and nwcdIsoTrack not NULL, then the resulting CD will have audio in the first session
											    and the data track in the second, however, currently the NeroAPI does not add any of the
												special CD Extra files to the data track */
	void *nwcdpCDStamp;						// Point on a CDStamp object if a particular CD is requested, otherwise NULL
	DWORD nwcdNumTracks;

	NERO_MEDIA_TYPE	nwcdMediaType;			/* Media on which the data should be written */
	DWORD nwcdReserved[32];					/* Should be zero */

	NERO_AUDIO_TRACK nwcdTracks[1];
} NERO_WRITE_CD;

#ifdef __cplusplus
namespace VCDEngine
{
	struct IVCDFSContentGenerator;
	struct IVCDMediaDescription;
};
#endif


typedef enum
{
	NERO_VIDEO_RESOLUTION_PAL = 0,
	NERO_VIDEO_RESOLUTION_NTSC = 1
} NERO_VIDEO_RESOLUTION;


typedef struct tag_NERO_WRITE_VIDEO_CD
{
	BOOL nwvcdSVCD;							// If TRUE, write a SVCD
	DWORD nwvcdNumItems;
	struct CNeroIsoTrack *nwvcdIsoTrack;
	char nwvcdTempPath[252];				/* Deprecated, use nwvcdLongTempPath instead */
	const char *nwvcdLongTempPath;			/* NeroAPI>=5.5.5.3: where the encoded files will be temporary stored */
#ifdef __cplusplus							/* NeroAPI>=5.5.7.6 */
	VCDEngine::IVCDFSContentGenerator *(*nwvcdCustomVCDEngine)(VCDEngine::IVCDMediaDescription *desc,FileSystemContent::IFileSystemDescContainer *pFSDC);
#else
	void *nwvcdCustomVCDEngine;
#endif
	NERO_VIDEO_RESOLUTION nwvcdEncodingResolution; /* NeroAPI >= 6.0.0.17: select the encoding resolution for the video. 
                                                    * This option only has effects for video items of type NERO_NONENCODED_VIDEO_ITEM. */
	DWORD nwvcdReserved[31];				/* Should be zero */
	NERO_VIDEO_ITEM nwvcdItems[1];
} NERO_WRITE_VIDEO_CD;

typedef struct tag_NERO_WRITE_IMAGE
{
	char nwiImageFileName[252];				/* Deprecated, use nwiLongImageFileName instead */
	const char *nwiLongImageFileName;		/* Name of the NRG file to burn
											   ISO and CUE files can also be burnt this way */
	NERO_MEDIA_TYPE	nwiMediaType;			/* NeroAPI >= 6.3.0.6: Media on which the image should be written. If set to MEDIA_NONE the default media type of the image will be used. */
	DWORD nwiReserved[32];
} NERO_WRITE_IMAGE;

/* This structure will allow you to write any type of 
 * CD Layout, e.g. containing a raw data track at the beginning of the
 * disc instead of a self-made ISO/UDF filesystem.
 * This is good for writing .iso images as they can be downloaded everywhere
 * on the net */
typedef struct tag_NERO_WRITE_FREESTYLE_CD
{
    DWORD nwfcdStructureSize;                   /* fill this with sizeof(NERO_FREESTYLEWRITE_CD) */
	/* both may be NULL: */
	const char *nwfcdArtist;
	const char *nwfcdTitle;

	struct CNeroIsoTrack *nwfcdIsoTrack;		/* if not NULL, then the disc will have an ISO track - please refer to "NeroIsoTrack.h" */
	BOOL nwfcdCDExtra;							/* if TRUE and nwfcdIsoTrack not NULL, then the resulting CD will have audio in the first session
											       and the data track in the second, however, currently the NeroAPI does not add any of the
												   special CD Extra files to the data track */
	void *nwfcdpCDStamp;						/* Point on a CDStamp object if a particular CD is requested, otherwise NULL */
	
	DWORD nwfcdNumTracks;

	DWORD nwfcdBurnOptions;						/* NeroAPI>=5.5.9.1: Combination of NCITEF flags (ignored if nwfcdFSContainer is NULL) */
#ifdef __cplusplus
FileSystemContent::
#else //__cplusplus
struct
#endif//__cplusplus
    IFileSystemDescContainer *nwfcdFSContainer;	/* NeroAPI>=5.5.9.1: if not NULL, then the disc will have an ISO track described by 
												   this container. nwfcdIsoTrack must be NULL, otherwise the container will be ignored */
	NERO_MEDIA_TYPE	nwfcdMediaType;				/* NeroAPI >=5.5.9.1: Media on which the data should be written */
	DWORD nwfcdReserved[32];					/* Should be zero */

	NERO_FREESTYLE_TRACK nwfcdTracks[1];
} NERO_WRITE_FREESTYLE_CD;


// To burn an IFileSystemDescContainer object

typedef struct tag_NERO_WRITE_FILE_SYSTEM_CONTAINER
{
	DWORD nwfscSize;						/* fill this with sizeof(NERO_WRITE_FILE_SYSTEM_CONTENT) */
#ifdef __cplusplus
FileSystemContent::
#else //__cplusplus
struct
#endif//__cplusplus
    IFileSystemDescContainer *nwfscFSContainer;
	NERO_MEDIA_TYPE	nwfscMediaType;			/* Media on which the data should be written */
	DWORD nwfscBurnOptions;					/* Combination of NCITEF flags */
	DWORD nwfscReserved[32];				/* Should be zero */
} NERO_WRITE_FILE_SYSTEM_CONTENT;
	
typedef enum
{
	NEROAPI_BURN_OK=0,
	NEROAPI_BURN_UNKNOWN_CD_FORMAT,
	NEROAPI_BURN_INVALID_DRIVE,
	NEROAPI_BURN_FAILED,
	NEROAPI_BURN_FUNCTION_NOT_ALLOWED,
	NEROAPI_BURN_DRIVE_NOT_ALLOWED,
	NEROAPI_BURN_USER_ABORT,
	NEROAPI_BURN_BAD_MESSAGE_FILE		// message file invalid or missing
} NEROAPI_BURN_ERROR;

NEROAPI_API
NEROAPI_BURN_ERROR NADLL_ATTR NeroBurn(NERO_DEVICEHANDLE    aDeviceHandle,
			 NERO_CD_FORMAT		  CDFormat,
             const void*		  pWriteCD, // Must point on a NERO_WRITE_CD or a NERO_WRITE_VIDEO_CD structure
 			 DWORD                dwFlags,
             DWORD                dwSpeed,  // In KB/s if NBF_SPEED_IN_KBS is present, in multiple of 150 KB/s otherwise
             NERO_PROGRESS*       pNeroProgress);
/* NeroBurn() flags: */
#define NBF_SPEED_TEST				(1<<0)  /* test speed of source first */
#define NBF_SIMULATE				(1<<1)  /* simulate writing before actually writing */
#define NBF_WRITE					(1<<2)  /* really write at the end */
#define NBF_DAO						(1<<3)  /* write in DAO */
#define NBF_CLOSE_SESSION			(1<<4)  /* only close the session and not the whole disc */
#define NBF_CD_TEXT					(1<<5)  /* write CD text - will be ignore if not supported by drive */
#define NBF_BUF_UNDERRUN_PROT		(1<<6)	/* enable saver burn mode  */
#define NBF_DISABLE_ABORT			(1<<7)  /* The disable abort callback will be called */
#define NBF_DETECT_NON_EMPTY_CDRW	(1<<8)	/* The DLG_NON_EMPTY_CDRW user callback will be called when trying to burn onto a non empty CDRW */
#define NBF_DISABLE_EJECT			(1<<9)	/* CD will not be ejected at the end of the burn process */
#define NBF_VERIFY                  (1<<10) /* Verify Filesystem after writing. Works for ISO only */
#define NBF_SPEED_IN_KBS			(1<<11)	/* NeroAPI>=5.5.5.5: Interpret the dwSpeed as KB/s instead of multiple of 150 KB/s */
#define NBF_DVDP_BURN_30MM_AT_LEAST	(1<<12)	/* NeroAPI>=5.5.8.0: DVD+R/RW high compability mode (at least 1GB will be written) */
#define NBF_CD_TEXT_IS_JAPANESE		(1<<13) /* NeroApi>=5.5.9.17: If NBF_CD_TEXT and NBF_CD_TEXT_IS_JAPANESE are set, then the CD Text is treated as japanese CD Text */
#define NBF_BOOKTYPE_DVDROM         (1<<14) /* NeroAPI>5.5.10.7: If NBF_BOOKTYPE_DVDROM the booktype of a burned DVD will be set to DVD-ROM */
#define NBF_NO_BOOKTYPE_CHANGE		(1<<15) /* NeroAPI>=6.0.0.24: Don't change the booktype of DVD, even if the default setting of NeroAPI is to change the booktype to DVD-ROM*/
#define NBF_RESERVED2				(1<<30) /* Reserved */
#define NBF_RESERVED				(1<<31) /* Reserved */