1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:

unit UNeroAPI;

interface

uses Windows, Messages, SysUtils, Forms;

type NEROAPI_INIT_ERROR = (
   NEROAPI_INIT_OK=0,
   NEROAPI_INIT_INVALID_ARGS,
   NEROAPI_INIT_UNSPECIFIED_ERROR,
   NEROAPI_INIT_INVALID_SERIAL_NUM,
   NEROAPI_INIT_DEMOVERSION_EXPIRED,
   NEROAPI_INIT_ALREADY_INITIALISED,
   NEROAPI_INIT_CANNOT_LOCK
   );
type NERO_MEDIUM_TYPE = (
   NMT_UNKNOWN,
   NMT_CD_ROM,
   NMT_CD_RECORDABLE,
   NMT_CD_REWRITEABLE
   );

type  NERO_MEDIA_TYPE = (
   MEDIA_NONE     = $00000000,
   MEDIA_CD       = $00000001,
   MEDIA_DDCD     = $00000002,
   MEDIA_DVD_M    = $00000004,
   MEDIA_DVD_P    = $00000008,
   MEDIA_DVD_ANY  = MEDIA_DVD_M OR MEDIA_DVD_P,
   MEDIA_DVD_RAM  = $00000010,
   MEDIA_ML       = $00000020,
   MEDIA_MRW      = $00000040,
   MEDIA_NO_CDR   = $00000080,
   MEDIA_NO_CDRW  = $00000100,
   MEDIA_CDRW = MEDIA_CD OR MEDIA_NO_CDR,
   MEDIA_CDR = MEDIA_CD OR MEDIA_NO_CDRW,
   MEDIA_DVD_ROM  = $00000200,
   MEDIA_CDROM    = $00000400,
   MEDIA_NO_DVD_M_RW = $00000800,
   //NeroAPI v5.5.10.15
   MEDIA_NO_DVD_M_R  = $00001000,
   MEDIA_NO_DVD_P_RW = $00002000,
   MEDIA_NO_DVD_P_R  = $00004000,
   MEDIA_DVD_M_R = MEDIA_DVD_M OR MEDIA_NO_DVD_M_RW,
   MEDIA_DVD_M_RW = MEDIA_DVD_M OR MEDIA_NO_DVD_M_R,
   MEDIA_DVD_P_R = MEDIA_DVD_P OR MEDIA_NO_DVD_P_RW,
   MEDIA_DVD_P_RW = MEDIA_DVD_P OR MEDIA_NO_DVD_P_R,
   MEDIA_FPACKET     = $00008000,
   MEDIA_VPACKET     = $00010000,
   MEDIA_PACKETW = MEDIA_MRW OR MEDIA_FPACKET OR MEDIA_VPACKET,
   MEDIA_HDB         = $00020000
   );

type NERO_TRACK_TYPE = (
   NTT_UNKNOWN,
   NTT_DATA,
   NTT_AUDIO
   );

type NEROAPI_OPTION = (
  NEROAPI_OPTION_MSG_FILE_NAME,    // Set the language file. The value points to a string containing the file name. This adress will be kept.
  NEROAPI_OPTION_WRITE_BUFFER_SIZE  // Set write buffer size. Value points onto an integer containing the size in byte
   );

type NEROAPI_SCSI_DEVTYPE = (
   NEA_SCSI_DEVTYPE_UNKNOWN,
  NEA_SCSI_DEVTYPE_WORM,      // can write
  NEA_SCSI_DEVTYPE_CDROM,     // can only read
  NEA_SCSI_DEVTYPE_UNSUPPORTED_WORM  // can write but is not supported by NeroAPI
   );

type NERO_MEDIA_SET = DWORD;

type NERO_CAPABILITIES = (
   NSDI_ALLOWED = 1, // the drive can only be used if this bit is set
   NSDI_DAO = 2,  //can write in DAO.
   NSDI_READ_CD_TEXT = 4, //can read CD text
   NSDI_VARIABLE_PAUSES_IN_TAO = 8, //see natPauseInBlksBeforeThisTrack below
   NSDI_DAO_WRITE_CD_TEXT = 16, //writes CD text in DAO (see natArtist/Title); never supported in TAO
   NSDI_IMAGE_RECORDER =64, //drive is the image recorder
   NSDI_UNDETECTED = 128,
   NSDI_IDE_BUS = 256,
   NSDI_SCSI_BUS = 512,
   NSDI_BUF_UNDERRUN_PROT = 1024, //drive has a buffer underrun protection feature (not necessary Burn Proof)
   NSDI_RESERVED = 2048, //Must not be used
   NSDI_RESERVED2 = 4096, //Must not be used
   NSDI_ALLOW_CHANGE_BOOKTYPE = 8192 //NeroAPI >5.5.10.7: DVD recorder can change booktype of burned medium
   );

type NERO_CALLBACK = record
   ncCallbackFunction, ncUserData : Pointer;
end;

type NERO_SETTINGS = record
   nstNeroFilesPath, nstVendor, nstSoftware, nstLanguageFile : PChar;
   nstIdle, nstUserDialog : NERO_CALLBACK;
   nstEnableOverburn : LongBool;
   nstOverburnSize : DWORD;
end;

type NERO_TRACK_INFO = record
   ntiSessionNumber, ntiTrackNumber : DWORD;
   ntiTrackType : NERO_TRACK_TYPE;
   ntiTrackStartBlk, ntiTrackLengthInBlks: DWORD ;
   ntiArtist, ntiTitle : Array[0..64] of char;
   ntiISRC: Array[0..12] of char;
   ntiReserved: array [0..28] of DWORD;
end;

type NERO_CD_INFO = record
   ncdiFreeCapacityInBlocks : DWORD;
   ncdiIsWriteable : LongBool;
   ncdiMediumType : NERO_MEDIUM_TYPE;
   ncdiArtist, ncdiTitle: array [0..64] of char;
   ncdiAvailableEraseModes, ncdiUnusedBlocks: DWORD;
   ncdiMediaType : NERO_MEDIA_TYPE ;
   ncdiReserved : array [0..28] of DWORD;
   ncdiNumTracks : DWORD;
   ncdiTrackInfos : array [0..0] of NERO_TRACK_INFO ;
end;

type NERO_SPEED_INFOS = record
   nsiNumSupportedSpeeds, nsiBaseSpeedKBs : DWORD;
   nsiSupportedSpeedsKBs, nsiSupportedSpeeds : array[0..63] of DWORD;
   nsiReserved : array[0..31] of DWORD;
end;

TProc = procedure;
type NERO_SCSI_DEVICE_INFO = record
   nsdiDeviceName : array[0..63] of char;
   nsdiHostAdapterName : array[0..7] of char;
   nsdiHostAdapterNo, nsdiDeviceID : DWORD;
   nsdiDevType : NEROAPI_SCSI_DEVTYPE;
   nsdiDriveLetter : char;
   //nsdiCapabilities : NERO_CAPABILITIES;
   nsdiCapabilities : DWORD;
   nsdiReadSpeeds, nsdiWriteSpeeds : NERO_SPEED_INFOS;
   nsdiDriver : TProc;
   NsdiBufUnderrunProtName : Array[0..63] of Char;
   nsdiMandatoryBUPSpeed : DWORD;
   nsdiMediaSupport : NERO_MEDIA_SET;
   nsdiDriveBufferSize : DWORD;
   nsdiReserved : array[0..62] of DWORD;
end;

type NERO_SCSI_DEVICE_INFOS = record
   nsdisNumDevInfos : DWORD;
   // nsdisDevInfos : ^NERO_SCSI_DEVICE_INFO; ///array[0..0] of
   nsdisDevInfos : array[0..0] of NERO_SCSI_DEVICE_INFO; ///
end;


type TNeroAPI = class
  private
    hndNero : THandle;
  public
    NeroSet : NERO_SETTINGS;
    constructor Create(Dir : String; var ErrMsg : String);
    destructor Destroy; override;
    function NeroInit(NeroSetting : NERO_SETTINGS) : String;
    procedure NeroClearErrors;
    procedure NeroDone;
    function GetAPIVersionEx(var MajHi, MajLo, MinHi, MinLo: Integer) : boolean;
    function NeroSetExpectedAPIVersionEx(MajHi, MajLo, MinHi, MinLo: Integer): Boolean;
    function NeroGetAvailableDrivesEx(
      MediaType: NERO_MEDIA_TYPE): NERO_SCSI_DEVICE_INFOS;
  published
  end;

implementation

uses
  Dialogs;

constructor TNeroApi.Create(Dir : String; var ErrMsg : String);
begin
   inherited Create;
   SetCurrentDir(Dir);
   ErrMsg := '';
   if FileExists('Neroapi.dll') then
   begin
      hndNero := LoadLibrary(PChar('Neroapi.dll'));
      if hndNero <> 0 then begin
         ErrMsg := NeroInit(NeroSet);
      end;
   end
   else
      errMsg := 'Error: Can''t find NeroAPI.dll';
end;

destructor TNeroAPI.Destroy;
begin
   if hndNero <> 0 then begin
      NeroDone;
      FreeLibrary(hndNero);
   end;
   inherited Destroy;
end;


function TNeroAPI.NeroInit(NeroSetting : NERO_SETTINGS) : String;
//NEROAPI_API NEROAPI_INIT_ERROR NADLL_ATTR NeroInit (const NERO_SETTINGS
//pNeroSettings, const char *reserved);
Type TF = function(const NeroSettings: NERO_SETTINGS; const Ch : Pointer) : NEROAPI_INIT_ERROR; cdecl;

var
   Rez : NEROAPI_INIT_ERROR;
   Fun : TF;
begin
   Result := '';
   if hndNero <> 0 then begin
      @Fun := GetProcAddress(hndNero, 'NeroInit');
      if @fun <> nil then
      try
         Rez := Fun(NeroSetting, nil);
         Application.ProcessMessages;
         if Rez <> (NEROAPI_INIT_OK) then
         begin
            case Rez of
               NEROAPI_INIT_INVALID_ARGS :
                  Result := 'Error: NeroInit unsuccesful. Invalid arguments.';
               NEROAPI_INIT_UNSPECIFIED_ERROR :
                  Result := 'Error: NeroInit unsuccesful. Unspecified error.';
               NEROAPI_INIT_INVALID_SERIAL_NUM :
                  Result := 'Error: NeroInit unsuccesful. Invalid serial number.';
               NEROAPI_INIT_DEMOVERSION_EXPIRED :
                  Result := 'Error: NeroInit unsuccesful. Demoversion has expired.';
               NEROAPI_INIT_ALREADY_INITIALISED :
                  Result := 'Error: NeroInit unsuccesful. Nero allready initialized.';
               NEROAPI_INIT_CANNOT_LOCK :
                  Result := 'Error: NeroInit unsuccesful. Can not lock the drive.';
            else
                  Result := 'Error: NeroInit unsuccesful. Unknown error.';
            end;
            hndNero := 0;
         end
         else
            Result := 'NeroInit OK';
      except
         on E : Exception do
            Result := E.message;
      end;
   end
   else
      Result := 'Error: DLL not found!';
end;

procedure TNeroAPI.NeroClearErrors();
//NEROAPI_API void NADLL_ATTR NeroClearErrors ();
type
   TF = function : Integer;
var
   fun : TF;
begin
   if hndNero <> 0 then begin
      @Fun := GetProcAddress(hndNero, 'NeroClearErrors');
      if @fun <> nil then Fun();
   end;
end;

procedure TNeroAPI.NeroDone();
//NEROAPI_API void NADLL_ATTR NeroDone ();
type TF = Function : integer;
var
   fun : TF;
begin
   if hndNero <> 0 then begin
      @Fun := GetProcAddress(hndNero, 'NeroDone');
      if @fun <> nil then Fun();
   end;
end;

function TNeroAPI.GetAPIVersionEx(var MajHi, MajLo, MinHi, MinLo : Integer) : Boolean;
//NEROAPI_API BOOL NADLL_ATTR NeroGetAPIVersionEx( WORD *majhi,WORD *majlo,WORD *minhi,WORD *minlo,void *reserved);
type
   TF = function (wMajHi, wMajLo, wMinHi, wMinLo, Res : Pointer) : Boolean; cdecl;

var Fun : TF;
   wMH, wML, wMiH, wMiL : word;
begin
   Result := False;
   wMH := 0;
   wML := 0;
   wMiH := 0;
   wMiL := 0;
   if hndNero <> 0 then begin
      @Fun := GetProcAddress(hndNero, 'NeroGetAPIVersionEx');
      if @fun <> nil then
      try
         Result := Fun(@wMH, @wML, @wMiH, @wMiL, nil);
         Application.ProcessMessages;
      except
         on E : Exception do
            MessageDlg(E.message, mtError, [mbOK], 0);
      end;
   end;

   MajHi := wMH;
   MajLo := wML;
   MinHi := wMiH;
   MinLo := wMiL;
end;

function TNeroAPI.NeroSetExpectedAPIVersionEx(MajHi, MajLo, MinHi, MinLo : Integer) : Boolean;
//NEROAPI_API BOOL NADLL_ATTR NeroSetExpectedAPIVersionEx(
//   WORD majhi, WORD majlo, WORD minhi, WORD minlo, void *reserved);  // Must be NULL

type
   TF = function (wMajHi, wMajLo, wMinHi, wMinLo : WORD; Res : Pointer) : Boolean; cdecl;

var Fun : TF;
   wMH, wML, wMiH, wMiL : word;
begin
   Result := False;
   wMH := MajHi;
   wML := MajLo;
   wMiH := MinHi;
   wMiL := MinLo;
   if hndNero <> 0 then begin
      @Fun := GetProcAddress(hndNero, 'NeroSetExpectedAPIVersionEx');
      if @fun <> nil then
      try
         Result := Fun(wMH, wML, wMiH, wMiL, nil);
         Application.ProcessMessages;
      except
         on E : Exception do
            MessageDlg(E.message, mtError, [mbOK], 0);
      end;
   end;
end;

function TNeroAPI.NeroGetAvailableDrivesEx(MediaType : NERO_MEDIA_TYPE): NERO_SCSI_DEVICE_INFOS;
//NEROAPI_API NERO_SCSI_DEVICE_INFOS * NADLL_ATTR
//NeroGetAvailableDrivesEx(NERO_MEDIA_TYPE mediaType, void *reserved);
   //NERO_SCSI_DEVICE_INFOS; cdecl;
type
   PDevInfos = ^NERO_SCSI_DEVICE_INFOS;
   TF = function (medType : NERO_MEDIA_TYPE; Reserved : Pointer) : PDevInfos ; cdecl;

var
   Fun : TF;
   //TDevInfos : NERO_SCSI_DEVICE_INFOS;
   vDevInfos : PDevInfos;
   //DevInfos : Pointer;
begin
   if hndNero <> 0 then begin
      @Fun := GetProcAddress(hndNero, 'NeroGetAvailableDrivesEx');
      if @fun <> nil then
      try
         //Result :=
         vDevInfos := nil;
         vDevInfos := Fun(MediaType, nil);
         if vDevInfos = nil then
            Result.nsdisNumDevInfos := 0;
         //else
         //   Result := NERO_SCSI_DEVICE_INFOS(DevInfos);
         Application.ProcessMessages;
      except
         on E : Exception do
            MessageDlg(E.message, mtError, [mbOK], 0);
      end;
   end
   //else
   //   Result := -1;

end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537:
538:
539:
540:
541:
542:
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603:
604:
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630:
631:
632:
633:
634:
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645:
646:
647:
648:
649:
650:
651:
652:
653:
654:
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674:
675:
676:
677:
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691:
692:
693:
694:
695:
696:
697:
698:
699:
700:
701:
702:
703:
704:
705:
706:
707:
708:
709:
710:
711:
712:
713:
714:
715:
716:
717:
718:
719:
720:
721:
722:
723:
724:
725:
726:
727:
728:
729:
730:
731:
732:
733:
734:
735:
736:
737:
738:
739:
740:
741:
742:
743:
744:
745:
746:
747:
748:
749:
750:
751:
752:
753:
754:
755:
756:
757:
758:
759:
760:
761:
762:
763:
764:
765:
766:
767:
768:
769:
770:
771:
772:
773:
774:
775:
776:
777:
778:
779:
780:
781:
782:
783:
784:
785:
786:
787:
788:
789:
790:
791:
792:
793:
794:
795:
796:
797:
798:
799:
800:
801:
802:
803:
804:
805:
806:
807:
808:
809:
810:
811:
812:
813:
814:
815:
816:
817:
818:
819:
820:
821:
822:
823:
824:
825:
826:
827:
828:
829:
830:
831:
832:
833:
834:
835:
836:
837:
838:
839:
840:
841:
842:
843:
844:
845:
846:
847:
848:
849:
850:
851:
852:
853:
854:
855:
856:
857:
858:
859:
860:
861:
862:
863:
864:

unit NeroApi;

{                                                         }
{ Unit: Nero API for Delphi                               }
{ Author: Thomas van Veen (Specialwork)                   }
{                                                         }
{ Copyrigth: Feel free to copy what ever you want, but if }
{   you add some featerues, or make some bugfixes, let me }
{   know at vanveen@specialwork.de                        }
{                                                         }

{$WEAKPACKAGEUNIT}

//{$DEFINE Complete}

interface

uses Windows;

{$HPPEMIT '#include <NeroApi.h>'}

const
  {library parameters}
  NeroApiLibraryPath      = 'C:\PROGRAMME\AHEAD\NERO\';
  NeroApiLibraryFile      = 'NEROAPI.DLL';

type
  {types not available in Delphi}
  Void                    = TObject;
  pVoid                   = ^Void;
  ppVoid                  = ^pVoid;
  ppChar                  = ^PChar;

  {simple declarations}
  NERO_AUDIO_ITEM_HANDLE  = THandle;
  NERO_DEVICEHANDLE       = ^TObject;
  NERO_MEDIA_SET          = Cardinal;

  {pointered declarations}
  pNeroAbortedCallback    = ^TNeroAbortedCallback;
  pNeroAccessType         = ^TNeroAccessType;
  pNeroConfigResult       = ^TNeroConfigResult;
  pNeroAudioFormatInfo    = ^TNeroAudioFormatInfo;
  pNeroCallback           = ^TNeroCallback;
  pNeroAudioItemHandle    = ^TNeroAudioItemHandle;
  pNeroApiBurnError       = ^TNeroApiBurnError;
  pNeroDeviceHandle       = ^TNeroDeviceHandle;
  pNeroCDFormat           = ^TNeroCDFormat;
  pNeroTextType           = ^TNeroTextType;
  pNeroAudioItemInfo      = ^TNeroAudioItemInfo;
  pNeroAddLogLineCallback = ^TNeroAddLogLineCallback;
  pNeroDataCallback       = ^TNeroDataCallback;
  pNeroIsoHandle          = ^TNeroIsoHandle;
  pNeroIsoEntry           = ^TNeroIsoEntry;
  pNeroIsoIterator        = ^TNeroIsoIterator;
  pNeroIsoTrack           = ^TNeroIsoTrack;
  pNeroIsoItem            = ^TNeroIsoItem;
  pImportInfo             = ^TImportInfo;
  pTimeInformation        = ^TTimeInformation;
  pNeroProgress           = ^TNeroProgress;
  pNeroDataExchange       = ^TNeroDataExchange;
  pNeroScsiDeviceInfos    = ^TNeroScsiDeviceInfos;
  pNeroMediaType          = ^TNeroMediaType;
  pNeroSpeedInfos         = ^TNeroSpeedInfos;
  pNeroCDInfo             = ^TNeroCDInfo;
  pNeroDeviceOption       = ^TNeroDeviceOption;
  pNeroMediaSet           = ^TNeroMediaSet;
  pNeroSettings           = ^TNeroSettings;
  pNeroApiOption          = ^TNeroApiOption;

  {enums}
  NERO_ACCESSTYPE         = ( ACCESSTYPE_WRITE,
                              ACCESSTYPE_READ );

  NERO_CONFIG_RESULT      = ( NCR_CANNOT_CONFIGURE,
                              NCR_CHANGED,
                              NCR_NOT_CHANGED );

  NEROAPI_BURN_ERROR      = ( 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 );

  NERO_CD_FORMAT          = ( NERO_ISO_AUDIO_MEDIA = 0,
                              NERO_ISO_AUDIO_CD = 0,
                              NERO_VIDEO_CD = 1,
                              NERO_BURN_IMAGE_MEDIA = 2,
                              NERO_BURN_IMAGE_CD = 2,
                              NERO_FREESTYLE_CD = 3,
                              NERO_FILE_SYSTEM_CONTAINER_MEDIA = 4 );

  NERO_TEXT_TYPE          = ( NERO_TEXT_INFO,
                              NERO_TEXT_STOP,
                              NERO_TEXT_EXCLAMATION,
                              NERO_TEXT_QUESTION,
                              NERO_TEXT_DRIVE,
                              NERO_TEXT_FILE,
                              NERO_TEXT_UNSPECIFIED );

  NERO_DATA_EXCHANGE_TYPE = ( NERO_ET_FILE,
                              NERO_ET_IO_CALLBACK,
                              NERO_ET_MP3,
                              NERO_ET_FILE_RAW,
                              NERO_ET_AUDIO_FILE );

  NERO_MEDIUM_TYPE        = ( NMT_UNKNOWN,
                              NMT_CD_ROM,
                              NMT_CD_RECORDABLE,
                              NMT_CD_REWRITEABLE );

  NERO_MEDIA_TYPE         = ( MEDIA_NONE = $00000,
                              MEDIA_CD = $00001,
                              MEDIA_DDCD = $00002,
                              MEDIA_DVD_M = $00004,
                              MEDIA_DVD_P = $00008,
                              MEDIA_DVD_ANY = $00012,
                              MEDIA_DVD_RAM = $00010,
                              MEDIA_ML = $00020,
                              MEDIA_MRW = $00040,
                              MEDIA_NO_CDR = $00080,
                              MEDIA_CDRW = $00081,
                              MEDIA_NO_CDRW = $00100,
                              MEDIA_CDR = $00101,
                              MEDIA_DVD_ROM = $00200,
                              MEDIA_CDROM = $00400,
                              MEDIA_NO_DVD_M_RW = $00800,
                              MEDIA_NO_DVD_M_R = $01000,
                              MEDIA_NO_DVD_P_RW = $02000,
                              MEDIA_NO_DVD_P_R = $04000,
                              MEDIA_DVD_M_R = $00804,
                              MEDIA_DVD_M_RW = $01004,
                              MEDIA_DVD_P_R = $02008,
                              MEDIA_DVD_P_RW = $04008,
                              MEDIA_FPACKET = $08000,
                              MEDIA_VPACKET = $10000,
                              MEDIA_PACKETW = $18040,
                              MEDIA_HDB = $20000 );

  NERO_TRACK_TYPE         = ( NTT_UNKNOWN,
                              NTT_DATA,
                              NTT_AUDIO );
                              
  NERO_DEVICEOPTION       = ( NERO_DEVICEOPTION_BOOKTYPE_DVDROM = 0 );

  NERO_TRACKMODE_TYPE     = ( NERO_TRACKMODE_MODE1,
                              NERO_TRACKMODE_MODE2_FORM1,
                              NERO_TRACKMODE_AUDIO );

  NERO_MAJOR_PHASE        = ( NERO_PHASE_UNSPECIFIED = -1,
                              NERO_PHASE_START_CACHE = 24,
                              NERO_PHASE_DONE_CACHE = 25,
                              NERO_PHASE_START_TEST = 28,
                              NERO_PHASE_DONE_TEST = 29,
                              NERO_PHASE_START_SIMULATE = 32,
                              NERO_PHASE_DONE_SIMULATE = 33,
                              NERO_PHASE_START_WRITE = 36,
                              NERO_PHASE_DONE_WRITE = 37,
                              NERO_PHASE_START_SIMULATE_NOSPD = 61,
                              NERO_PHASE_DONE_SIMULATE_NOSPD = 62,
                              NERO_PHASE_START_WRITE_NOSPD = 65,
                              NERO_PHASE_DONE_WRITE_NOSPD = 66,
                              NERO_PHASE_ENCODE_VIDEO = 82,
                              NERO_PHASE_SEAMLESSLINK_ACTIVATED = 87,
                              NERO_PHASE_BUP_ACTIVATED = 90,
                              NERO_PHASE_CONTINUE_FORMATTING = 99,
                              NERO_PHASE_FORMATTING_SUCCESSFUL = 100,
                              NERO_PHASE_DVDVIDEO_DETECTED = 111,
                              NERO_PHASE_DVDVIDEO_REALLOC_STARTED = 112,
                              NERO_PHASE_DVDVIDEO_REALLOC_COMPLETED = 113,
                              NERO_PHASE_DVDVIDEO_REALLOC_NOTNEEDED = 114,
                              NERO_PHASE_DVDVIDEO_REALLOC_FAILED = 115 );

  NEROAPI_SCSI_DEVTYPE    = ( NEA_SCSI_DEVTYPE_UNKNOWN,
                              NEA_SCSI_DEVTYPE_WORM,
                              NEA_SCSI_DEVTYPE_CDROM,
                              NEA_SCSI_DEVTYPE_UNSUPPORTED_WORM );

  NERO_VIDEO_ITEM_TYPE    = ( NERO_MPEG_ITEM,
                              NERO_JPEG_ITEM,
                              NERO_NONENCODED_VIDEO_ITEM,
                              NERO_DIB_ITEM );

  NEROAPI_OPTION          = ( NEROAPI_OPTION_MSG_FILE_NAME,
                              NEROAPI_OPTION_WRITE_BUFFER_SIZE );

  NEROAPI_INIT_ERROR      = ( NEROAPI_INIT_OK=0,
                              NEROAPI_INIT_INVALID_ARGS,
                              NEROAPI_INIT_UNSPECIFIED_ERROR,
                              NEROAPI_INIT_INVALID_SERIAL_NUM,
                              NEROAPI_INIT_DEMOVERSION_EXPIRED,
                              NEROAPI_INIT_ALREADY_INITIALISED,
                              NEROAPI_INIT_CANNOT_LOCK );

  {types initialized with callback functions}
  pNeroAbortetCallback            = function(pUserData: Pointer): LongBool; cdecl;
  pNERO_ADD_LOG_LINE_CALLBACK     = procedure(pUserData: Pointer; TextType: NERO_TEXT_TYPE; text: PChar); cdecl;
  pNERO_IO_CALLBACK               = function(pUserData: Pointer; pBuffer: PByte; dwLen: Cardinal): Cardinal; cdecl;
  pNERO_STATUS_CALLBACK           = function(pUserData: Pointer): LongBool; cdecl;
  pNERO_DISABLE_ABORT_CALLBACK    = procedure(pUserData: Pointer; abortEnabled: LongBool); cdecl;
  pNERO_IDLE_CALLBACK             = function(pUserData: Pointer): LongBool; cdecl;
  pNERO_SET_MAJOR_PHASE_CALLBACK  = procedure(pUserData: Pointer; phase: NERO_MAJOR_PHASE; Reserved: pVoid = nil); cdecl;
  pNERO_PROGRESS_CALLBACK         = function(pUserData: Pointer; dwProgressInPercent: Cardinal): LongBool; cdecl;
  pNERO_SET_PHASE_CALLBACK        = procedure(pUserData: Pointer; text: PChar); cdecl;

  NERO_ABORTED_CALLBACK           = pNeroAbortetCallback;
  NERO_ADD_LOG_LINE_CALLBACK      = pNERO_ADD_LOG_LINE_CALLBACK;
  NERO_IO_CALLBACK                = pNERO_IO_CALLBACK;
  NERO_STATUS_CALLBACK            = pNERO_STATUS_CALLBACK;
  NERO_DISABLE_ABORT_CALLBACK     = pNERO_DISABLE_ABORT_CALLBACK;
  NERO_IDLE_CALLBACK              = pNERO_IDLE_CALLBACK;
  NERO_SET_MAJOR_PHASE_CALLBACK   = pNERO_SET_MAJOR_PHASE_CALLBACK;
  NERO_PROGRESS_CALLBACK          = pNERO_PROGRESS_CALLBACK;
  NERO_SET_PHASE_CALLBACK         = pNERO_SET_PHASE_CALLBACK;

  {classes}
  TDestructorClass = class
  public
    procedure _Destroy; virtual; cdecl;
  end;

  TNeroDataCallback = class(TDestructorClass)
  public
    function IOCallback(pBuffer: PByte; dwLen: Cardinal): Cardinal; virtual; cdecl;
    function EOFCallback(): LongBool; virtual; cdecl;
    function ErrorCallback(): LongBool; virtual; cdecl;
  end;

  TNeroIsoHandle = class(TDestructorClass)
  public
    function Clone: pNeroIsoHandle; virtual; cdecl;
    function GetFileName (strBuffer: PChar; nBufferSize: UINT): Integer; virtual; cdecl;
    function Open: pNeroDataCallback; virtual; cdecl;
  end;

  TNeroIsoIterator = class(TDestructorClass)
  public
    function GetCurrentEntry: pNeroIsoEntry; virtual; cdecl;
    procedure Next; virtual; cdecl;
  end;

  TNeroIsoEntry = class(TDestructorClass)
  public
    function CreateDirectoryIterator: pNeroIsoIterator; virtual; cdecl;
    function GetName: PChar; virtual; cdecl;
    function GetLength: Int64; virtual; cdecl;
    function CreateHandle: pNeroIsoHandle; virtual; cdecl;
    function GetDataStartSec: Cardinal; virtual; cdecl;
    function IsDataFixed: LongBool; virtual; cdecl;
    function GetEntryTime(pTM: pTimeInformation): LongBool; virtual; cdecl;
    function GetImportInfo(): pImportInfo; virtual; cdecl;
    procedure GetPriorities(iPriority: Integer = 0; iDirPriority: Integer = 0); virtual; cdecl;
    function CreateDirectoryIteratorWrapper: pNeroIsoIterator; virtual; cdecl;
    function CreateResourceHandle: pNeroIsoHandle; virtual; cdecl;
  private
    {$Hints off}
    function reserved1: Integer; virtual; cdecl;
    {$Hints on}
  end;

  TNeroIsoTrack = class(TNeroIsoEntry)
  public
    function GetName: PChar; override; cdecl;
    function CreateDirectoryIterator: pNeroIsoIterator; override; cdecl;
    function UseJoliet: LongBool; virtual; cdecl;
    function UseMode2: LongBool; virtual; cdecl;
    function UseRockRidge: LongBool; virtual; cdecl;
    function BurnISO: LongBool; virtual; cdecl;
    function BurnUDF: LongBool; virtual; cdecl;
  protected
    {$Hints off}
    function GetLength: Int64; override; cdecl;
    function CreateHandle: pNeroIsoHandle; override; cdecl;
    function CreateResourceHandle: pNeroIsoHandle; override; cdecl;
    {$Hints on}
  public
    function BurnOptions: Cardinal; virtual; cdecl;
    function CreateDirectoryIteratorWrapper: pNeroIsoIterator; override; cdecl;
    function HasWrapper: LongBool; virtual; cdecl;
    function dummy: Pointer; virtual; cdecl;
    procedure GetVolumeDescriptor(systemIdentifier: ppChar = nil; volumeSet: ppChar = nil; dataPreparer: ppChar = nil; application: ppChar = nil;
                                  copyright: ppChar = nil; _Abstract: ppChar = nil; bibliographic: ppChar = nil); virtual; cdecl;
    function reserved1: Integer; override; cdecl;
    function reserved2: Integer; virtual; cdecl;
    function reserved3: Integer; virtual; cdecl;
    function reserved4: Integer; virtual; cdecl;
    function reserved5: Integer; virtual; cdecl;
    function reserved6: Integer; virtual; cdecl;
    function reserved7: Integer; virtual; cdecl;
    function reserved8: Integer; virtual; cdecl;
  end;

  {records or structs}
  TImportInfo = Record
  end;

  TTimeInformation = Record
    tm_sec: Integer;
    tm_min: Integer;
    tm_hour: Integer;
    tm_mday: Integer;
    tm_mon: Integer;
    tm_year: Integer;
    tm_wday: Integer;
    tm_yday: Integer;
    tm_isdst: Integer;
  end;

  NERO_AUDIO_FORMAT_INFO = Record
    Description: Array[0..256-1] of Char;
    ExtensionList: Array[0..256-1] of Char;
    IsTargetPlugIn: LongBool;
    Configurable: LongBool;
  end;

  NERO_AUDIO_ITEM_INFO = Record
    naiiAudioItem: NERO_AUDIO_ITEM_HANDLE;
    naiiFileName: PChar;
  end;

  NERO_CALLBACK = Record
    pCallbackFunction: Pointer;
    pUserData: Pointer;
  end;

  NERO_IO = Record
    nioUserData: Pointer;
    nioIOCallback: NERO_IO_CALLBACK;
    nioEOFCallback: NERO_STATUS_CALLBACK;
    nioErrorCallback: NERO_STATUS_CALLBACK;
  end;

  NERO_DATA_EXCHANGE = Record
    ndeType: NERO_DATA_EXCHANGE_TYPE;
    ndeData: Record
      case Integer of
        0: (ndeFileName: Array[0..256 - 1] of Char);
        1: (ndeIO: NERO_IO);
        2: (ndeAudioItemInfo: NERO_AUDIO_ITEM_INFO);
    end;
  end;

  NERO_AUDIO_TRACK = Record
    natPauseInBlksBeforeThisTrack: Cardinal;
    natNumIndexPositions: Cardinal;
    natRelativeIndexBlkPositions: Array[0..98 - 1] of Cardinal;
    natTitle: PChar;
    natArtist: PChar;
    natSourceDataExchg: NERO_DATA_EXCHANGE;
    natLengthInBlocks: Cardinal;
    natIndex0ContainsData: LongBool;
    natReserved: Array[0..31 - 1] of Cardinal;
  end;

  NERO_TRACK_INFO = Record
    ntiSessionNumber: Cardinal;
    ntiTrackNumber: Cardinal;
    ntiTrackType: NERO_TRACK_TYPE;
    ntiTrackStartBlk: Cardinal;
    ntiTrackLengthInBlks: Cardinal;
    ntiArtist: Array[0..65 - 1] of Char;
    ntiTitle: Array[0..65 - 1] of Char;
    ntiISRC: Array[0..13 - 1] of Char;
    ntiReserved: Array[0..29 - 1] of Cardinal;
  end;

  NERO_CD_INFO = Record
    ncdiFreeCapacityInBlocks: Cardinal;
    ncdiIsWriteable: LongBool;
    ncdiMediumType: NERO_MEDIUM_TYPE;
    ncdiArtist: Array [0..65-1] of Char;
    ncdiTitle: Array [0..65-1] of Char;
    ncdiAvailableEraseModes: Cardinal;
    ncdiUnusedBlocks: Cardinal;
    ncdiMediaType: NERO_MEDIA_TYPE;
    ncdiReserved: Array [0..29-1] of Cardinal;
    ncdiNumTracks: Cardinal;
    ncdiTrackInfos: Array [0..1-1] of NERO_TRACK_INFO;
  end;

  NERO_DLG_WAITCD_MEDIA_INFO = Record
    ndwmiSize: Cardinal;
    ndwmiLastDetectedMedia: NERO_MEDIA_TYPE;
    ndwmiRequestedMedia: NERO_MEDIA_SET;
    ndwmiLastDetectedMediaName: PChar;
    ndwmiRequestedMediaName: PChar;
  end;

  NERO_FREESTYLE_TRACK = Record
    nftStructureSize: Cardinal;
    nftPauseInBlksBeforeThisTrack: Cardinal;
    nftNumIndexPositions: Cardinal;
    nftRelativeIndexBlkPositions: Array [0..98-1] of Cardinal;
    nftTitle: PChar;
    nftArtist: PChar;
    nftSourceDataExchg: NERO_DATA_EXCHANGE;
    nftLengthInBlocks: Cardinal;
    nftTracktype: NERO_TRACKMODE_TYPE;
  end;

  NERO_PROGRESS = Record
    npProgressCallback: NERO_PROGRESS_CALLBACK;
    npAbortedCallback: NERO_ABORTED_CALLBACK;
    npAddLogLineCallback: NERO_ADD_LOG_LINE_CALLBACK;
    npSetPhaseCallback: NERO_SET_PHASE_CALLBACK;
    npDisableAbortCallback: NERO_DISABLE_ABORT_CALLBACK;
    npSetMajorPhaseCallback: NERO_SET_MAJOR_PHASE_CALLBACK;
    npSubTaskProgressCallback: NERO_PROGRESS_CALLBACK;
  end;

  NERO_SPEED_INFOS = Record
    nsiNumSupportedSpeeds: Cardinal;
    nsiBaseSpeedKBs: Cardinal;
    nsiSupportedSpeedsKBs: Array [0..64-1] of Cardinal;
    nsiSupportedSpeeds: Array [0..64-1] of Cardinal;
    nsiReserved: Array [0..32-1] of Cardinal;
  end;
  
  NERO_SCSI_DEVICE_INFO = Record
    nsdiDeviceName: Array [0..32-1] of Char;
    nsdiHostAdapterName: Array [0..8-1] of Char;
    nsdiHostAdapterNo: Cardinal;
    nsdiDeviceID: Cardinal;
    nsdiDevType: NEROAPI_SCSI_DEVTYPE;
    nsdiDriveLetter: Char;
    nsdiCapabilities: Cardinal;
    nsdiReadSpeeds: NERO_SPEED_INFOS;
    nsdiWriteSpeeds: NERO_SPEED_INFOS;
    nsdiDriver: Pointer;
    NsdiBufUnderrunProtName: Array [0..64-1] of PChar;
    nsdiMandatoryBUPSpeed: Cardinal;
    nsdiMediaSupport: NERO_MEDIA_SET;
    nsdiDriveBufferSize: Cardinal;
    nsdiReserved: Array [0..63-1] of Cardinal;
  end;

  NERO_SCSI_DEVICE_INFOS = Record
    nsdisNumDevInfos: Cardinal;
    nsdisDevInfos: Array [0..1-1] of NERO_SCSI_DEVICE_INFO;
  end;

  NERO_SETTINGS = Record
    nstNeroFilesPath: PChar;
    nstVendor: PChar;
    nstSoftware: PChar;
    nstLanguageFile: PChar;
    nstIdle: NERO_CALLBACK;
    nstUserDialog: NERO_CALLBACK;
    nstEnableOverburn: LongBool;
    nstOverburnSize: Cardinal;
  end;

  NERO_VIDEO_ITEM = Record
    nviPauseAfterItem: Cardinal;
    nviSourceFileName: Array [0..236-1] of Char;
    nviData: Record
      nviDib: Record
        case Integer of
          0: (pDIB: PBITMAPINFO);
          1: (size: Integer);
          2: (pixelRatio: Double);
      end;
    end;
    reserved: Cardinal;
    nviItemType: NERO_VIDEO_ITEM_TYPE;
  end;

  NERO_WRITE_CD = Record
    nwcdArtist: PChar;
    nwcdTitle: PChar;
    nwcdIsoTrack: pNeroIsoTrack;
    nwcdCDExtra: LongBool;
    nwcdpCDStamp: Pointer;
    nwcdNumTracks: Cardinal;
    nwcdMediaType: NERO_MEDIA_TYPE;
    nwcdAudioMaster: LongBool;
    nwcdReserved: Array [0..31-1] of Cardinal;
    nwcdTracks: Array [0..1-1] of NERO_AUDIO_TRACK;
  end;

  NERO_WRITE_FILE_SYSTEM_CONTENT = Record
    nwfscSize: Cardinal;
    {$IFDEF Complete}
    nwfscFSContainer: IFileSystemDescContainer*;
    {$ENDIF}
    nwfscMediaType: NERO_MEDIA_TYPE;
    nwfscBurnOptions: Cardinal;
    nwfscReserved: Array [0..32-1] of Cardinal;
  end;

  NERO_WRITE_FREESTYLE_CD = Record
    nwfcdStructureSize: Cardinal;
    nwfcdArtist: PChar;
    nwfcdTitle: PChar;
    nwfcdIsoTrack: pNeroIsoTrack;
    nwfcdCDExtra: LongBool;
    nwfcdpCDStamp: Pointer;
    nwfcdNumTracks: Cardinal;
    nwfcdBurnOptions: Cardinal;
    {$IFDEF Complete}
    nwfcdFSContainer: IFileSystemDescContainer*;
    {$ENDIF}
    nwfcdMediaType: NERO_MEDIA_TYPE;
    nwfcdReserved: Array [0..32-1] of Cardinal;
    nwfcdTracks: Array [0..1] of NERO_FREESTYLE_TRACK;
  end;

  NERO_WRITE_IMAGE = Record
    nwiImageFileName: Array [0..256-1] of Char;
  end;

  NERO_WRITE_VIDEO_CD = Record
    nwvcdSVCD: LongBool;
    nwvcdNumItems: Cardinal;
    nwvcdIsoTrack: pNeroIsoTrack;
    nwvcdTempPath: Array [0..256-1] of Char;
    nwvcdCustomVCDEngine: Pointer;
    nwvcdReserved: Array [0..31-1] of Cardinal;
    nwvcdItems: Array [0..1-1] of NERO_VIDEO_ITEM;
  end;

  NERO_ISO_ITEM = Record
    fileName: Array [0..256-1] of Char;
    isDirectory: LongBool;
    isReference: LongBool;
    sourceFilePath: Array [0..256-1] of Char;
    subDirFirstItem: pNeroIsoItem;
    nextItem: pNeroIsoItem;
    userData: Pointer;
    dataStartSec: LongInt;
    dataLength: Int64;
    entryTime: TTimeInformation;
    itemSize: Integer;
    importinfo: pImportInfo;
  end;

  NeroCITEArgs = Record
    size: Integer;
    firstRootItem: ^NERO_ISO_ITEM;
    firstRootItem_wrapper: ^NERO_ISO_ITEM;
    name: PChar;
    dwBurnOptions: Cardinal;
    systemIdentifier: PChar;
    volumeSet: PChar;
    publisher: PChar;
    dataPreparer: PChar;
    application: PChar;
    copyright: PChar;
    _Abstract: PChar;
    bibliographic: PChar;
  end;

  {renamed types}
  TNeroAbortedCallback          = NERO_ABORTED_CALLBACK;
  TNeroAccessType               = NERO_ACCESSTYPE;
  TNeroConfigResult             = NERO_CONFIG_RESULT;
  TNeroAudioFormatInfo          = NERO_AUDIO_FORMAT_INFO;
  TNeroAudioItemHandle          = NERO_AUDIO_ITEM_HANDLE;
  TNeroCallback                 = NERO_CALLBACK;
  TNeroApiBurnError             = NEROAPI_BURN_ERROR;
  TNeroDeviceHandle             = NERO_DEVICEHANDLE;
  TNeroCDFormat                 = NERO_CD_FORMAT;
  TNeroTextType                 = NERO_TEXT_TYPE;
  TNeroAudioItemInfo            = NERO_AUDIO_ITEM_INFO;
  TNeroAddLogLineCallback       = NERO_ADD_LOG_LINE_CALLBACK;
  TNeroIsoItem                  = NERO_ISO_ITEM;
  TNeroProgress                 = NERO_PROGRESS;
  TNeroDataExchange             = NERO_DATA_EXCHANGE;
  TNeroScsiDeviceInfos          = NERO_SCSI_DEVICE_INFOS;
  TNeroMediaType                = NERO_MEDIA_TYPE;
  TNeroSpeedInfos               = NERO_SPEED_INFOS;
  TNeroCDInfo                   = NERO_CD_INFO;
  TNeroDeviceOption             = NERO_DEVICEOPTION;
  TNeroMediaSet                 = NERO_MEDIA_SET;
  TNeroSettings                 = NERO_SETTINGS;
  TNeroApiOption                = NEROAPI_OPTION;

  {callback functions}
  var NeroAudioCreateTargetItem:      function(FormatIndexNumber: Integer): TNeroAudioItemHandle; cdecl;
  var NeroAudioCloseItem:             function(ItemHandle: TNeroAudioItemHandle): LongBool; cdecl;
  var NeroAudioGetFormatInfo:         function(FormatIndexNumber: Integer; pNAFI: pNeroAudioFormatInfo): LongBool; cdecl;
  var NeroAudioGUIConfigureItem:      function(pNAFI: pNeroAudioItemHandle; Num: Integer): TNeroConfigResult; cdecl;
  var NeroBurn:                       function(DeviceHandle: TNeroDeviceHandle; CDFormat: TNeroCDFormat; pWriteCD: Pointer;
                                               dwFlags: Cardinal; dwSpeed: Cardinal; pProgress: pNeroProgress): TNeroApiBurnError; cdecl;
  var NeroClearErrors:                procedure; cdecl;
  var NeroCloseDevice:                procedure(DeviceHandle: TNeroDeviceHandle); cdecl;
  var NeroCopyIsoItem:                function(iso_item: pNeroIsoItem): pNeroIsoItem; cdecl;
  function NeroCreateIsoItem(): pNeroIsoItem; cdecl;
  var NeroCreateIsoItemOfSize:        function(Undefined: Integer): pNeroIsoItem; cdecl;
  var NeroCreateIsoTrackEx:           function(root: pNeroIsoItem; name: PChar; flags: Cardinal): pNeroIsoTrack; cdecl;
  var NeroDAE:                        function(DeviceHandle: TNeroDeviceHandle; dwTrackStartBlk: Cardinal; dwTrackLengthInBlks:
                                               Cardinal; pDestDataExchg: pNeroDataExchange;iSpeedInX: Cardinal;
                                               pNeroProgressCallback: pNeroCallback): Integer;
  var NeroDone:                       procedure; cdecl;
  var NeroEjectLoadCD:                function(DeviceHandle: TNeroDeviceHandle; eject: LongBool): Integer; cdecl;
  var NeroEraseCDRW:                  function(DeviceHandle: TNeroDeviceHandle; mode: Integer): Integer; cdecl;
  var NeroFreeCDStamp:                procedure(pCDStamp: Pointer); cdecl;
  var NeroFreeIsoItem:                procedure(pUndefined: pNeroIsoItem);
  var NeroFreeIsoTrack:               procedure(track: pNeroIsoTrack);
  var NeroFreeMem:                    procedure(pMem: Pointer); cdecl;
  var NeroGetAPIVersion:              function: Cardinal; cdecl;
  var NeroGetAPIVersionEx:            function(majhi: PWORD; majlo: PWORD; minhi: PWORD; minlo: PWORD; Reserved: pVoid = nil): LongBool; cdecl;
  var NeroGetAvailableDrivesEx:       function(mediaType: TNeroMediaType; reserved: Pointer): pNeroScsiDeviceInfos; cdecl;
  var NeroGetAvailableSpeeds:         function(DeviceHandle: TNeroDeviceHandle; accessType: TNeroAccessType; mediaType: TNeroMediaType;
                                               reserved: Pointer): pNeroSpeedInfos; cdecl;
  var NeroGetCDInfo:                  function(DeviceHandle: TNeroDeviceHandle; dwFlags: Cardinal): pNeroCDInfo; cdecl;
  var NeroGetCDRWErasingTime:         function(DeviceHandle: TNeroDeviceHandle; mode: Integer): Integer;
  var NeroGetDeviceOption:            function(DeviceHandle: TNeroDeviceHandle; Option: TNeroDeviceOption; reserved: Pointer): Pointer; cdecl;
  var NeroGetDiscImageInfo:           function(imagePath: PChar; reserved: Pointer): pNeroCDInfo; cdecl;
  var NeroGetErrorLog:                function: PCHAR; cdecl;
  var NeroGetLastError:               function: PCHAR; cdecl;
  {$IFDEF Complete}
  var NeroGetLocalizedWaitCDTexts:    function(NERO_WAITCD_TYPE type): PChar; cdecl;
  {$ENDIF}
  var NeroGetTypeNameOfMedia:         function(media: TNeroMediaSet; reserved: Pointer): PChar; cdecl;
  var NeroImportIsoTrackEx:           function(Recorder: pNeroDeviceHandle; trackNumber: Cardinal; ppCDStamp: ppVoid; flags: Cardinal): pNeroIsoItem; cdecl;
  var NeroInit:                       function(pNeroSettings: pNeroSettings; reserved: PChar): NEROAPI_INIT_ERROR; cdecl;
  var NeroIsDeviceReady:              function(DeviceHandle: TNeroDeviceHandle): Integer; cdecl;
  var NeroOpenDevice:                 function(pDevInfo: pNeroScsiDeviceInfos): TNeroDeviceHandle; cdecl;
  var NeroSetDeviceOption:            function(DeviceHandle: TNeroDeviceHandle; Option: TNeroDeviceOption; value: Pointer): Integer; cdecl;
  var NeroSetExpectedAPIVersion:      procedure (UnNamed: Cardinal); cdecl;
  var NeroSetExpectedAPIVersionEx:    function (majhi: WORD; majlo: WORD; minhi: WORD; minlo: WORD; Reserved: Void = nil): LongBool; cdecl;
  var NeroSetOption:                  function(option: TNeroApiOption; value: Pointer): Integer; cdecl;
  var NeroWaitForMedia:               function(DeviceHandle: TNeroDeviceHandle; nms: TNeroMediaSet; dwFlags: Cardinal; pCDStamp: Pointer): LongBool; cdecl;

implementation

procedure TDestructorClass._Destroy;
begin
  inherited Destroy;
end;

function NeroCreateIsoItem(): pNeroIsoItem;
begin
  Result:=NeroCreateIsoItemOfSize(sizeof(TNeroIsoItem));
end;

function TNeroDataCallback.IOCallback(pBuffer: PByte; dwLen: Cardinal): Cardinal;
begin
  Result := 0;
end;

function TNeroDataCallback.EOFCallback(): LongBool;
begin
  Result := FALSE;
end;

function TNeroDataCallback.ErrorCallback(): LongBool;
begin
  Result := FALSE;
end;

function TNeroIsoHandle.Clone: pNeroIsoHandle;
begin
  Result := nil;
end;

function TNeroIsoHandle.GetFileName (strBuffer: PChar; nBufferSize: UINT): Integer;
begin
  Result := 0;
end;

function TNeroIsoHandle.Open: pNeroDataCallback;
begin
  Result := nil;
end;

function TNeroIsoIterator.GetCurrentEntry: pNeroIsoEntry;
begin
  Result := nil;
end;

procedure TNeroIsoIterator.Next;
begin

end;

function TNeroIsoEntry.CreateDirectoryIterator: pNeroIsoIterator;
begin
  Result := nil;
end;

function TNeroIsoEntry.GetName: PChar;
begin
  Result := nil;
end;

function TNeroIsoEntry.GetLength: Int64;
begin
  Result := 0;
end;

function TNeroIsoEntry.CreateHandle: pNeroIsoHandle;
begin
  Result := nil;
end;

function TNeroIsoEntry.GetDataStartSec: Cardinal;
begin
  Result := 0;
end;

function TNeroIsoEntry.IsDataFixed: LongBool;
begin
  Result := False;
end;

function TNeroIsoEntry.GetEntryTime(pTM: pTimeInformation): LongBool;
begin
  Result := False;
end;

function TNeroIsoEntry.GetImportInfo(): pImportInfo;
begin
  Result := nil;
end;

procedure TNeroIsoEntry.GetPriorities(iPriority: Integer = 0; iDirPriority: Integer = 0);
begin
  
end;

function TNeroIsoEntry.CreateDirectoryIteratorWrapper: pNeroIsoIterator;
begin
  Result := nil;
end;

function TNeroIsoEntry.CreateResourceHandle: pNeroIsoHandle;
begin
  Result := nil;
end;

function TNeroIsoEntry.reserved1: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.GetName: PChar;
begin
  Result := nil;
end;

function TNeroIsoTrack.CreateDirectoryIterator: pNeroIsoIterator;
begin
  Result := nil;
end;

function TNeroIsoTrack.UseJoliet: LongBool;
begin
  Result := True;
end;

function TNeroIsoTrack.UseMode2: LongBool;
begin
  Result := False;
end;

function TNeroIsoTrack.UseRockRidge: LongBool;
begin
  Result := False;
end;

function TNeroIsoTrack.BurnISO: LongBool;
begin
  Result := True;
end;

function TNeroIsoTrack.BurnUDF: LongBool;
begin
  Result := False;
end;

function TNeroIsoTrack.GetLength: Int64;
begin
  Result := -1;
end;

function TNeroIsoTrack.CreateHandle: pNeroIsoHandle;
begin
  Result := nil;
end;

function TNeroIsoTrack.CreateResourceHandle: pNeroIsoHandle;
begin
  Result := nil;
end;

function TNeroIsoTrack.BurnOptions: Cardinal;
begin
  Result := 0;

  {$IFDEF Complete}
  return (UseJoliet() ? NCITEF_USE_JOLIET : 0)
  |(UseMode2() ? NCITEF_USE_MODE2 : 0)
  |(UseRockRidge() ? NCITEF_USE_ROCKRIDGE : 0)
  |(BurnISO() ? NCITEF_CREATE_ISO_FS : 0)
  |(BurnUDF() ? NCITEF_CREATE_UDF_FS : 0);
  {$ENDIF}
end;

function TNeroIsoTrack.CreateDirectoryIteratorWrapper: pNeroIsoIterator;
begin
  Result := nil;
end;

function TNeroIsoTrack.HasWrapper: LongBool;
begin
  Result := False;
end;

function TNeroIsoTrack.dummy: Pointer;
begin
  Result := nil;
end;

procedure TNeroIsoTrack.GetVolumeDescriptor(systemIdentifier, volumeSet, dataPreparer, application, copyright,
_Abstract, bibliographic: ppChar);
begin

end;

function TNeroIsoTrack.reserved1: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved2: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved3: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved4: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved5: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved6: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved7: Integer;
begin
  Result := 0;
end;

function TNeroIsoTrack.reserved8: Integer;
begin
  Result := 0;
end;

end.