neroapitest.cpp

Nero刻录工具的插件编程SDK

			}
	
			/* read needs track number */
			if (read && !tracks[i]) {
				Usage ("no track number specified for file %s", files[i]);
			}
		}

	}

	/* initialize */
	signal (SIGINT, SigCtrlC);

	if (!NeroAPIGlueConnect(NULL)) 
	{
		puts ("Cannot connect to NeroAPI");
		Exit (10);
	}
	
	WORD ver1, ver2, ver3, ver4;
	if (!NeroGetAPIVersionEx(&ver1,&ver2,&ver3,&ver4,NULL))
	{
		puts("Could not get NeroAPI version number");
		Exit(10);
	}
	printf ("Nero API version %d.%d.%d.%d\n\n",ver1,ver2,ver3,ver4);

	NEROAPI_INIT_ERROR initErr=NeroInit (&NeroSettings,NULL);
	switch (initErr) 
	{
	case NEROAPI_INIT_OK:
		break;
	case NEROAPI_INIT_INVALID_ARGS:
		NeroError ("NeroInit() : invalid args");
		break;
	case NEROAPI_INIT_INVALID_SERIAL_NUM:
		NeroError ("NeroInit() : invalid serial number");
		break;
	case NEROAPI_INIT_DEMOVERSION_EXPIRED:
		NeroError ("NeroInit() : demo version has expired");
		break;
	case NEROAPI_INIT_CANNOT_LOCK:
		NeroError ("NeroInit() : cannot lock");
		break;
	default:
	case NEROAPI_INIT_UNSPECIFIED_ERROR:
		NeroError ("NeroInit() : unspecified error");
	}

	if (writebuffersize!=0)
	{
		NeroSetOption(NEROAPI_OPTION_WRITE_BUFFER_SIZE,&writebuffersize);
	}

	NeroDeviceInfos = NeroGetAvailableDrivesEx (dvd ? MEDIA_DVD_ANY : MEDIA_CD,NULL);
	if (!NeroDeviceInfos) {
		NeroError ("NeroGetAvailableDrives()");
	}

	NERO_SCSI_DEVICE_INFO *pSelectedDeviceInfo;

	if (drivename) {
		for (i = 0; i < NeroDeviceInfos->nsdisNumDevInfos; i++) 
		{
			char driveLetter=NeroDeviceInfos->nsdisDevInfos[i].nsdiDriveLetter ? NeroDeviceInfos->nsdisDevInfos[i].nsdiDriveLetter : '?';

			if (!stricmp(drivename, NeroDeviceInfos->nsdisDevInfos[i].nsdiDeviceName)
				|| (strlen(drivename)==1 && toupper(drivename[0])==toupper(driveLetter)))
			{
				NeroDeviceHandle = NeroOpenDevice (&NeroDeviceInfos->nsdisDevInfos[i]);
				pSelectedDeviceInfo=&NeroDeviceInfos->nsdisDevInfos[i];
				if (!NeroDeviceHandle) 
				{
					NeroError (drivename);
				}
				break;
			}
		}
		if (!NeroDeviceHandle) {
			printf ("Drive %s not found, available are:\n", drivename);
			listdrives = TRUE;
		}
	}

	if (listdrives) 
	{
		printf ("Drive: adapter # (type), ID\n"
			    "-------------------------\n");
		for (i = 0; i < NeroDeviceInfos->nsdisNumDevInfos; i++) 
		{
			char bufUnderrunProtName[128]="";
			char *str;
			if (NeroDeviceInfos->nsdisDevInfos[i].nsdiCapabilities&NSDI_BUF_UNDERRUN_PROT)
			{
				sprintf(bufUnderrunProtName," (%s)",NeroDeviceInfos->nsdisDevInfos[i].nsdiBufUnderrunProtName);
				if (NeroDeviceInfos->nsdisDevInfos[i].nsdiMandatoryBUPSpeed)
					sprintf(bufUnderrunProtName+strlen(bufUnderrunProtName)," (recommanded when burning at %dX or faster)",NeroDeviceInfos->nsdisDevInfos[i].nsdiMandatoryBUPSpeed);
			}

			printf ("%c. %s: %d (%s), %d, %s%s (%s) (%d KB buffer)\n",
				NeroDeviceInfos->nsdisDevInfos[i].nsdiDriveLetter ? NeroDeviceInfos->nsdisDevInfos[i].nsdiDriveLetter : '?',
				NeroDeviceInfos->nsdisDevInfos[i].nsdiDeviceName,
				NeroDeviceInfos->nsdisDevInfos[i].nsdiHostAdapterNo,
				NeroDeviceInfos->nsdisDevInfos[i].nsdiHostAdapterName,
				NeroDeviceInfos->nsdisDevInfos[i].nsdiDeviceID,
				NeroDeviceInfos->nsdisDevInfos[i].nsdiCapabilities&NSDI_ALLOWED ? "" : "(Not allowed) ",
				bufUnderrunProtName,
				str=NeroGetTypeNameOfMedia(NeroDeviceInfos->nsdisDevInfos[i].nsdiMediaSupport,","),
				NeroDeviceInfos->nsdisDevInfos[i].nsdiDriveBufferSize);
			NeroFreeMem(str);
		}
		puts ("");
		Exit(0);
	}

	if (!NeroDeviceHandle)
	{
		Usage ("drive name required", 0);
		Exit (0);
	}
	if (listspeed)
	{
		printf("List of possible speed:\n");
		for(int i=0;i<pSelectedDeviceInfo->nsdiWriteSpeeds.nsiNumSupportedSpeeds;i++)
			printf("%.1fX (%d KB/s)\n",(float)pSelectedDeviceInfo->nsdiWriteSpeeds.nsiSupportedSpeedsKBs[i]/pSelectedDeviceInfo->nsdiWriteSpeeds.nsiBaseSpeedKBs
					,pSelectedDeviceInfo->nsdiWriteSpeeds.nsiSupportedSpeedsKBs[i]);
		
	}
	if (load)
	{
		NeroEjectLoadCD(NeroDeviceHandle,FALSE);
	}
	if (erase)
	{	// Erase CDRW
		NEROAPI_CDRW_ERASE_MODE mode=NEROAPI_ERASE_QUICK;	// Default is quickly
		int time;
		
		if (entire)	mode=NEROAPI_ERASE_ENTIRE;
		time=NeroGetCDRWErasingTime(NeroDeviceHandle,mode);
		if (time==-1)
			NeroError("No CD inserted");
		else if (time==-2)
			NeroError("This CD recorder doesn't support CDRW");
		else if (time==-3)
			NeroError("This media is not rewritable");
		printf("Erasing CDRW. This will take %d seconds.\n",time);
		int err=NeroEraseCDRW(NeroDeviceHandle,mode);
		if (err)
			NeroError("Error erasing the CDRW");
	}
	if (eject)
	{
		NeroEjectLoadCD(NeroDeviceHandle,TRUE);
	}
	if (cdinfo || read) {
		NeroCDInfo = NeroGetCDInfo (NeroDeviceHandle, NGCDI_READ_CD_TEXT|NGCDI_READ_ISRC);
		if (!NeroCDInfo) {
			NeroError ("NeroGetCDInfo()");
		}

		if (cdinfo) {
			switch (NeroCDInfo->ncdiMediumType) {
			case NMT_CD_ROM:
				printf ("Read-only media, ");
				break;
			case NMT_CD_RECORDABLE:
				printf ("Recordable media, ");
				break;
			case NMT_CD_REWRITEABLE:
				printf ("Rewriteable media, ");
				break;
			default:
				printf ("unknown media, ");
				break;
			}
			
			char *mediatypename=NeroGetTypeNameOfMedia(NeroCDInfo->ncdiMediaType,NULL);
			printf("%s ",mediatypename);
			NeroFreeMem(mediatypename);

			printf ("%s, %d blocks free\n",
				NeroCDInfo->ncdiIsWriteable ? "writeable" : "not writable",
				NeroCDInfo->ncdiFreeCapacityInBlocks);
			printf ("Artist %s, Title %s\n",
				NeroCDInfo->ncdiArtist[0] ? NeroCDInfo->ncdiArtist : "unknown",
				NeroCDInfo->ncdiTitle[0] ? NeroCDInfo->ncdiTitle : "unknown");

			for (i = 0; i < NeroCDInfo->ncdiNumTracks; i++) {
				NERO_TRACK_INFO *pTrackInfo = &NeroCDInfo->ncdiTrackInfos[i];
				printf ("%02d. %6s %6d - %6d = %6d blocks, session %d",
					pTrackInfo->ntiTrackNumber,
					pTrackInfo->ntiTrackType == NTT_AUDIO ? "audio" :
					pTrackInfo->ntiTrackType == NTT_DATA ? "data" :
					"unknown",
					pTrackInfo->ntiTrackStartBlk,
					pTrackInfo->ntiTrackStartBlk + pTrackInfo->ntiTrackLengthInBlks,
					pTrackInfo->ntiTrackLengthInBlks,
					pTrackInfo->ntiSessionNumber);
				if (pTrackInfo->ntiArtist[0] || pTrackInfo->ntiTitle[0])
					printf (" (%s %s)\n", pTrackInfo->ntiArtist, pTrackInfo->ntiTitle);
				else
					puts("");

				if (pTrackInfo->ntiISRC[0])
					printf("\tISRC: %s\n",pTrackInfo->ntiISRC);
			}
		}

		if (read) {
			for (i = 0; (int)i < num_files; i++) {
				NERO_TRACK_INFO *pTrackInfo = NULL;
				unsigned int e;
				NERO_CALLBACK callback;
				NERO_DATA_EXCHANGE exchange;
				
				/* tracks may start with a number higher than 1, so search for track */
				for (e = 0; e < NeroCDInfo->ncdiNumTracks; e++) {
					if (NeroCDInfo->ncdiTrackInfos[e].ntiTrackNumber == tracks[i]) {
						pTrackInfo = &NeroCDInfo->ncdiTrackInfos[e];
						break;
					}
				}
				if (!pTrackInfo) {
					printf ("track %d for file '%s' not found on CD\n", tracks[i], files[i]);
					Exit (10);
				}

				/* extract audio */
				callback.ncCallbackFunction = ProgressCallback;
				callback.ncUserData = DUMMY_USER_DATA;
				switch (type[i]) {
				case WAV:
					exchange.ndeType = NERO_ET_FILE;
					strncpy(exchange.ndeData.ndeFileName, files[i], sizeof(exchange.ndeData.ndeFileName));
					exchange.ndeData.ndeFileName[sizeof(exchange.ndeData.ndeFileName) - 1] = 0;
					break;
				case PCM:
					exchange.ndeType = NERO_ET_IO_CALLBACK;
					exchange.ndeData.ndeIO.nioIOCallback = WriteIOCallback;
					exchange.ndeData.ndeIO.nioEOFCallback = EOFCallback;
					exchange.ndeData.ndeIO.nioErrorCallback = ErrorCallback;
					exchange.ndeData.ndeIO.nioUserData = fopen (files[i], "wb");
					if (!exchange.ndeData.ndeIO.nioUserData) {
						printf ("Cannot open target file %s\n", files[i]);
						Exit (10);
					/* We are lazy - closing the file will be done by resource tracking. */
					}
					break;
				
				default:
					/* unknown */
					printf ("unknown file type for writing of %s\n", files[i]);
					Exit (10);
					break;
				}
				printf ("%02d. '%s':\n", tracks[i], files[i]);
				if (NeroDAE (NeroDeviceHandle, pTrackInfo->ntiTrackStartBlk, pTrackInfo->ntiTrackLengthInBlks,
					&exchange, 0, &callback)) {
					NeroError ("NeroDAE()");
				}
				puts ("");
			}
		}
	}

	if (write) 
	{
		int res=0;

		if (!videocd && !svideocd && !image)
		{
			// Burn ISO/Audio CD

			int size = sizeof (NERO_WRITE_CD) + (num_files - 1) * sizeof (NERO_AUDIO_TRACK);
			NERO_WRITE_CD *pWriteCD = (NERO_WRITE_CD *)malloc (size);

			if (!pWriteCD) {
				puts ("no mem");
				Exit (10);
			}
			memset (pWriteCD, 0, size);
			pWriteCD->nwcdMediaType = dvd ? MEDIA_DVD_ANY : MEDIA_CD;
			pWriteCD->nwcdNumTracks = num_files;
			pWriteCD->nwcdArtist = artist;
			pWriteCD->nwcdTitle = title;
			if (data) 
			{
				pWriteCD->nwcdIsoTrack = &IsoTrack;
				pWriteCD->nwcdCDExtra = CDExtra;
			}

			for (i = 0; i < num_files; i++)
			{
				pWriteCD->nwcdTracks [i].natPauseInBlksBeforeThisTrack = ((i==0) ? 2*75 : iPauseLength);	/* Write continously; first track requires minimal pause of 2 seconds (2*75)	*/
				pWriteCD->nwcdTracks [i].natIndex0ContainsData = ((i==0) ? FALSE : bAudioInIndex0);			/* The first track may never contain data in index 0							*/
				/* no indices, artist or title: these values are already NULL */
				switch (type [i]) {
				case WAV:
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeType = NERO_ET_FILE;
					strncpy (pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName, files[i], sizeof(pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName));
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName[sizeof(pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName) - 1] = 0;
					break;
				case MP3:
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeType = NERO_ET_FILE_MP3;
					strncpy (pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName, files[i], sizeof(pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName));
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName[sizeof(pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName) - 1] = 0;
					break;
				case WMA:
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeType = NERO_ET_FILE_WMA;
					strncpy (pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName, files[i], sizeof(pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName));
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName[sizeof(pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeFileName) - 1] = 0;
					break;
				case PCM: {
					struct _stat buf;

					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeType = NERO_ET_IO_CALLBACK;
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeIO.nioIOCallback = ReadIOCallback;
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeIO.nioEOFCallback = EOFCallback;
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeIO.nioErrorCallback = ErrorCallback;
					if (_stat (files[i], &buf)) {
						printf ("Cannot determine length of file %s\n", files[i]);
						Exit (10);
					}
					pWriteCD->nwcdTracks [i].natLengthInBlocks = buf.st_size / 2352;
					pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeIO.nioUserData = fopen (files[i], "rb");
					if (!pWriteCD->nwcdTracks [i].natSourceDataExchg.ndeData.ndeIO.nioUserData) {
						printf ("Cannot open source file %s\n", files[i]);
						Exit (10);
					}
					/* We are lazy - closing the file will be done by resource tracking. */
					break;
				}
				default:
					/* unknown */
					printf ("unknown file type for writing of %s\n", files[i]);
					Exit (10);
					break;
				}
			}
			
			/* burn, baby, burn... */
			res = NeroBurn (NeroDeviceHandle,NERO_ISO_AUDIO_CD ,pWriteCD,
				(real ? NBF_WRITE : NBF_SIMULATE) // Write and simulate are not mutually exclusive, we just use either one or the other here.
				| (TAO ? 0 : NBF_DAO) | NBF_DISABLE_ABORT | NBF_DETECT_NON_EMPTY_CDRW | NBF_SPEED_IN_KBS
				| (speedtest ? NBF_SPEED_TEST : 0)
				| NBF_CLOSE_SESSION
				| NBF_CD_TEXT
				| (bup ? NBF_BUF_UNDERRUN_PROT : 0)
				| (verify ? NBF_VERIFY : 0)
				| (no_eject ? NBF_DISABLE_EJECT : 0),
				speed*pSelectedDeviceInfo->nsdiWriteSpeeds.nsiBaseSpeedKBs
				, &NeroProgress);

			free (pWriteCD);
			pWriteCD = NULL;
		} else if (videocd || svideocd)
		{
			// Burn Video CD or Super Video CD

			int size = sizeof (NERO_WRITE_VIDEO_CD) + (num_files - 1) * sizeof (NERO_VIDEO_ITEM);
			NERO_WRITE_VIDEO_CD *pWriteCD = (NERO_WRITE_VIDEO_CD *)malloc (size);

			if (!pWriteCD) {
				puts ("no mem");
				Exit (10);
			}
			memset (pWriteCD, 0, size);
		
			pWriteCD->nwvcdSVCD=svideocd;
			pWriteCD->nwvcdNumItems=num_files;
			pWriteCD->nwvcdIsoTrack=&IsoTrack;

			if (tempdir)
			{
				strncpy(pWriteCD->nwvcdTempPath,tempdir,sizeof(pWriteCD->nwvcdTempPath));
				pWriteCD->nwvcdTempPath[sizeof(pWriteCD->nwvcdTempPath)-1]=0;
			}

			for (i=0;i<num_files;i++)
			{
				NERO_VIDEO_ITEM *item=&pWriteCD->nwvcdItems[i];
				strncpy (item->nviSourceFileName, files[i], sizeof(pWriteCD->nwvcdItems[i].nviSourceFileName));
				pWriteCD->nwvcdItems[i].nviSourceFileName[sizeof(pWriteCD->nwvcdItems[i].nviSourceFileName)-1]=0;

				if (type[i]==JPEG)
				{
					item->nviItemType=NERO_JPEG_ITEM;
					item->nviPauseAfterItem=-1;
				} else 
				if (type[i]==AVI)
				{
					item->nviItemType=NERO_NONENCODED_VIDEO_ITEM;
					item->nviPauseAfterItem=0;
				} else
				{
					item->nviItemType=NERO_MPEG_ITEM;
					item->nviPauseAfterItem=0;
				}
			}

			/* burn, baby, burn... */
			res = NeroBurn (NeroDeviceHandle,NERO_VIDEO_CD ,pWriteCD,
				(real ? NBF_WRITE : NBF_SIMULATE) 
				| (TAO ? 0 : NBF_DAO) 
				| NBF_DETECT_NON_EMPTY_CDRW 
				| NBF_DISABLE_ABORT 
				| (speedtest ? NBF_SPEED_TEST : 0)/*| NBF_CLOSE_SESSION*/ /* Write and simulate are not mutually exclusive, we just use either one or the other here. */
				| (no_eject ? NBF_DISABLE_EJECT : 0), 
				speed, &NeroProgress);

			free (pWriteCD);
		} else if (image)
		{
			// Burn image
			NERO_WRITE_IMAGE pWriteCD;

			if (num_files<1)
			{
				puts("Image file not specified");
				Exit(10);
			}
			
			strncpy(pWriteCD.nwiImageFileName,files[0],sizeof(pWriteCD.nwiImageFileName));
			pWriteCD.nwiImageFileName[sizeof(pWriteCD.nwiImageFileName)-1]=0;

			/* burn, baby, burn... */
			res = NeroBurn (NeroDeviceHandle,NERO_BURN_IMAGE_CD ,&pWriteCD,
				(real ? NBF_WRITE : NBF_SIMULATE)