neroapi.h

用VC开发的nero刻录程序

		{
			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. Of course there should be at least 1 audio track,
												else this flag will be ignored. */
	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_RESERVED3				(1<<29) /* Reserved */
#define NBF_RESERVED2				(1<<30) /* Reserved */
#define NBF_RESERVED				(1<<31) /* Reserved */


typedef struct tag_NERO_FILESYSTEMTRACK_OPTIONS
{
    DWORD				netsStructureSize;		/* fill this with sizeof(NERO_FILESYSTEMTRACK_OPTIONS) */

	/*
     * The following three entries need to be filled out whenever the file system size is to be calculated
	 * accurately.
	 */

	void *				netspCDStamp;			/* Point on a CDStamp object when appending to an existing medium, otherwise NULL */	
	NERO_MEDIA_TYPE		netsMediaType;			/* The media type the file system is to be written to */
	NERO_DEVICEHANDLE	netsDeviceHandle;		/* device handle representing the drive the file system is to be written to */
	DWORD				netsFlags;				/* NBF_XXXX that will be used for the recording process */
#ifdef __cplusplus
FileSystemContent::
#else //__cplusplus
struct
#endif//__cplusplus
    IFileSystemDescContainer *netsFSContainer;	/* if not NULL, the file system will be created from this 
												 * object instead of the passed CNeroIsoTrack object. pIsoTrack must be NULL in this case */
	DWORD				netsFSContainerFlags;	/* NCITEF_XXXX flags to be used for filesystem creation. Used only when netsFSContainer 
												 * is used to create the file system */
	DWORD netsReserved[32];						/* Should be zero */
} NERO_FILESYSTEMTRACK_OPTIONS;



/* NeroAPI >= 6.0.0.14: Estimate the total size of a track including data and overhead
 * for the filesystem. The method returns the size in blocks.
 * Use the flags below to specify what exactly has to be taken into account for the
 * calculation.
 *
 * Warning: Depending on the parameters passed, the returned size might only be an estimation!
 */
NEROAPI_API unsigned int NADLL_ATTR NeroEstimateTrackSize(struct CNeroIsoTrack *pIsoTrack // the iso track for which to calculate the size
															   , DWORD dwFlags // combination of the flags below
															   , NERO_FILESYSTEMTRACK_OPTIONS *pOptions);

#define NETS_FILESYSTEM_OVERHEAD	(1<<0) /* calculate filesystem overhead */
#define NETS_DATA					(1<<1) /* calculate size of the data */
#define NETS_EXACT_SIZE				(1<<2) /* Nero >= 6.0.0.21 calculate exactly. 
											* If this option is specified, filesystem overhead as well as file data is taken into account 
											* the optional fields of the NERO_ESTIMATETRACKSIZE_OPTIONS structure need to be filled out */

/*
// Digital Audio Extraction functions:
// - aborting will not be reported by NeroGetLastError()
// - incomplete target files are not deleted
// - the function will return 0 for success, else error
*/

NEROAPI_API
int NADLL_ATTR NeroDAE(NERO_DEVICEHANDLE aDeviceHandle,
			DWORD             dwTrackStartBlk,
			DWORD             dwTrackLengthInBlks,
            const NERO_DATA_EXCHANGE *pDestDataExchg,
            DWORD             iSpeedInX,				// speed of extraction, 0 means maximum speed
            NERO_CALLBACK*    pNeroProgressCallback); /* has to be a NERO_PROGRESS_CALLBACK */


//
// Utility functions:
//
NEROAPI_API int NADLL_ATTR NeroIsDeviceReady(NERO_DEVICEHANDLE aDeviceHandle); // returns a value of NERO_DRIVE_ERROR
NEROAPI_API int NADLL_ATTR NeroEjectLoadCD(NERO_DEVICEHANDLE aDeviceHandle,BOOL eject);	// returns a value of NERO_DRIVE_ERROR

// NeroAPI >= 6.6.0.2: waits dwTimeOut milliseconds until a drive is ready. returns a value of NERO_DRIVE_ERROR
NEROAPI_API int NADLL_ATTR NeroWaitForDeviceReady(NERO_DEVICEHANDLE aDeviceHandle, DWORD dwTimeOut, void *reserved);

// NeroAPI >= 6.0.0.25:
// Set the image file for the image recorder. This can be used to initialize
// the image recorder for packet writing.
// If imageFilePath is NULL, the