333 lines
10 KiB
ObjectPascal
333 lines
10 KiB
ObjectPascal
unit akrip32;
|
|
{*
|
|
* akrip32.h - copyright (c) 1999 jay a. key
|
|
*
|
|
* api for akrip32.dll (v0.93)
|
|
*
|
|
* modified for acs (dynamic loading ...) y christian ulrich (mail@z0m3ie.de)
|
|
* translated for borland delphi by holger dors (holger@dors.de)
|
|
*
|
|
* history of delphi version:
|
|
*
|
|
* 09. january 2000: first released version
|
|
* 05. February 2000: Updated for new function "CDDBGetServerList"
|
|
* in V.093 of akrip32.dll
|
|
*
|
|
**********************************************************************
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published
|
|
* by the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*}
|
|
|
|
interface
|
|
|
|
uses windows;
|
|
|
|
const
|
|
|
|
TRACK_AUDIO = $00;
|
|
TRACK_DATA = $01;
|
|
|
|
MAXIDLEN = 64;
|
|
MAXCDLIST = 8;
|
|
|
|
{*
|
|
* TRACKBUF
|
|
*
|
|
* This structure should not be allocated directly. If a buffer containing
|
|
* 27 * 2353 bytes is desired, a buffer should be allocated containing
|
|
* the desired amount + 24 bytes. The allocated memory can then be
|
|
* typecast to a LPTRACKBUF. It is the program's responsibility to guard
|
|
* against reading/writing past the end of allocated memory.
|
|
*
|
|
* The following must always apply:
|
|
* (len + startOffset) <= (numFrames * 2352) <= maxLen
|
|
*}
|
|
|
|
type
|
|
PTRACKBUF = ^TRACKBUF;
|
|
TRACKBUF = record
|
|
startFrame: DWord; {* 00: starting frame number *}
|
|
numFrames: DWord; {* 04: number of frames read *}
|
|
maxLen: DWord; {* 08: length of buffer itself *}
|
|
len: DWord; {* 0C: length of data actually in buf *}
|
|
status: DWord; {* 10: status of last read operation *}
|
|
startOffset: Integer; {* 14: offset of valid data in buf *}
|
|
buf: array[0..1024 * 1024 - 1] of Byte; {* 18: the data itself *}
|
|
end;
|
|
|
|
TRACKBUFDUMMY = record
|
|
startFrame: DWord; {* 00: starting frame number *}
|
|
numFrames: DWord; {* 04: number of frames read *}
|
|
maxLen: DWord; {* 08: length of buffer itself *}
|
|
len: DWord; {* 0C: length of data actually in buf *}
|
|
status: DWord; {* 10: status of last read operation *}
|
|
startOffset: Integer; {* 14: offset of valid data in buf *}
|
|
end;
|
|
|
|
const
|
|
TRACKBUFEXTRA = SizeOf(TRACKBUFDUMMY);
|
|
|
|
type
|
|
PCDINFO = ^CDINFO;
|
|
CDINFO = record
|
|
vendor: array[0..8] of Char;
|
|
prodId: array[0..16] of Char;
|
|
rev: array[0..4] of Char;
|
|
vendSpec: array[0..20] of Char;
|
|
end;
|
|
|
|
PCDREC = ^CDREC;
|
|
CDREC = record
|
|
ha: Byte;
|
|
tgt: Byte;
|
|
lun: Byte;
|
|
pad: Byte;
|
|
id: array[0..MAXIDLEN] of Char;
|
|
info: CDINFO;
|
|
end;
|
|
|
|
PCDLIST = ^CDLIST;
|
|
CDLIST = record
|
|
max: Byte;
|
|
num: Byte;
|
|
cd: array[0..MAXCDLIST - 1] of CDREC;
|
|
end;
|
|
|
|
{*
|
|
* TOCTRACK and TOC must be byte-aligned. If you're not using Mingw32,
|
|
* CygWin, or some other compiler that understands the PACKED keyword,
|
|
* you need to ensure that these structures are byte aligned. Usually,
|
|
* this is done using a
|
|
* #pragma pack(1)
|
|
* See your compiler's documentation for details
|
|
*}
|
|
|
|
TOCTRACK = packed record
|
|
rsvd: Byte;
|
|
ADR: Byte;
|
|
trackNumber: Byte;
|
|
rsvd2: Byte;
|
|
addr: array[0..3] of Byte;
|
|
end;
|
|
|
|
PTOC = ^TOC;
|
|
TOC = packed record
|
|
tocLen: Word;
|
|
firstTrack: Byte;
|
|
lastTrack: Byte;
|
|
tracks: array[0..99] of TOCTRACK;
|
|
end;
|
|
|
|
PTRACK = ^TRACK;
|
|
TRACK = packed record
|
|
trackNo: Integer;
|
|
startLBA: DWord;
|
|
trackLen: DWord;
|
|
_type: Byte;
|
|
pad: array[0..3] of Byte;
|
|
name: ShortString;//array[0..255] of Char;
|
|
end;
|
|
|
|
PREADMSF = ^READMSF;
|
|
READMSF = record
|
|
sm: Byte;
|
|
ss: Byte;
|
|
sf: Byte;
|
|
em: Byte;
|
|
es: Byte;
|
|
ef: Byte;
|
|
end;
|
|
|
|
const
|
|
{*
|
|
* Error codes set by functions in ASPILIB.C
|
|
*}
|
|
|
|
ALERR_NOERROR = 0;
|
|
ALERR_NOWNASPI = 1;
|
|
ALERR_NOGETASPI32SUPP = 2;
|
|
ALERR_NOSENDASPICMD = 3;
|
|
ALERR_ASPI = 4;
|
|
ALERR_NOCDSELECTED = 5;
|
|
ALERR_BUFTOOSMALL = 6;
|
|
ALERR_INVHANDLE = 7;
|
|
ALERR_NOMOREHAND = 8;
|
|
ALERR_BUFPTR = 9;
|
|
ALERR_NOTACD = 10;
|
|
ALERR_LOCK = 11;
|
|
ALERR_DUPHAND = 12;
|
|
ALERR_INVPTR = 13;
|
|
ALERR_INVPARM = 14;
|
|
ALERR_JITTER = 15;
|
|
|
|
{*
|
|
* constants used for queryCDParms()
|
|
*}
|
|
|
|
CDP_READCDR = $0001; // can read CD-R
|
|
CDP_READCDE = $0002; // can read CD-E
|
|
CDP_METHOD2 = $0003; // can read CD-R wriiten via method 2
|
|
CDP_WRITECDR = $0004; // can write CD-R
|
|
CDP_WRITECDE = $0005; // can write CD-E
|
|
CDP_AUDIOPLAY = $0006; // can play audio
|
|
CDP_COMPOSITE = $0007; // composite audio/video stream
|
|
CDP_DIGITAL1 = $0008; // digital output (IEC958) on port 1
|
|
CDP_DIGITAL2 = $0009; // digital output (IEC958) on port 2
|
|
CDP_M2FORM1 = $000A; // reads Mode 2 Form 1 (XA) format
|
|
CDP_M2FORM2 = $000B; // reads Mode 2 Form 2 format
|
|
CDP_MULTISES = $000C; // reads multi-session or Photo-CD
|
|
CDP_CDDA = $000D; // supports cd-da
|
|
CDP_STREAMACC = $000E; // supports "stream is accurate"
|
|
CDP_RW = $000F; // can return R-W info
|
|
CDP_RWCORR = $0010; // returns R-W de-interleaved and err.
|
|
// corrected
|
|
CDP_C2SUPP = $0011; // C2 error pointers
|
|
CDP_ISRC = $0012; // can return the ISRC info
|
|
CDP_UPC = $0013; // can return the Media Catalog Number
|
|
CDP_CANLOCK = $0014; // prevent/allow cmd. can lock the media
|
|
CDP_LOCKED = $0015; // current lock state (TRUE = LOCKED)
|
|
CDP_PREVJUMP = $0016; // prevent/allow jumper state
|
|
CDP_CANEJECT = $0017; // drive can eject disk
|
|
CDP_MECHTYPE = $0018; // type of disk loading supported
|
|
CDP_SEPVOL = $0019; // independent audio level for channels
|
|
CDP_SEPMUTE = $001A; // independent mute for channels
|
|
CDP_SDP = $001B; // supports disk present (SDP)
|
|
CDP_SSS = $001C; // Software Slot Selection
|
|
CDP_MAXSPEED = $001D; // maximum supported speed of drive
|
|
CDP_NUMVOL = $001E; // number of volume levels
|
|
CDP_BUFSIZE = $001F; // size of output buffer
|
|
CDP_CURRSPEED = $0020; // current speed of drive
|
|
CDP_SPM = $0021; // "S" units per "M" (MSF format)
|
|
CDP_FPS = $0022; // "F" units per "S" (MSF format)
|
|
CDP_INACTMULT = $0023; // inactivity multiplier ( x 125 ms)
|
|
CDP_MSF = $0024; // use MSF format for READ TOC cmd
|
|
CDP_OVERLAP = $0025; // number of overlap frames for jitter
|
|
CDP_JITTER = $0026; // number of frames to check for jitter
|
|
CDP_READMODE = $0027; // mode to attempt jitter corr.
|
|
|
|
{*
|
|
* defines for GETCDHAND readType
|
|
*
|
|
*}
|
|
CDR_ANY = $00; // unknown
|
|
CDR_ATAPI1 = $01; // ATAPI per spec
|
|
CDR_ATAPI2 = $02; // alternate ATAPI
|
|
CDR_READ6 = $03; // using SCSI READ(6)
|
|
CDR_READ10 = $04; // using SCSI READ(10)
|
|
CDR_READ_D8 = $05; // using command 0xD8 (Plextor?)
|
|
CDR_READ_D4 = $06; // using command 0xD4 (NEC?)
|
|
CDR_READ_D4_1 = $07; // 0xD4 with a mode select
|
|
CDR_READ10_2 = $08; // different mode select w/ READ(10)
|
|
|
|
{*
|
|
* defines for the read mode (CDP_READMODE)
|
|
*}
|
|
CDRM_NOJITTER = $00; // never jitter correct
|
|
CDRM_JITTER = $01; // always jitter correct
|
|
CDRM_JITTERONERR = $02; // jitter correct only after a read error
|
|
|
|
type
|
|
HCDROM = THandle;
|
|
|
|
PGETCDHAND = ^GETCDHAND;
|
|
GETCDHAND = packed record
|
|
size: Byte; {* set to sizeof(GETCDHAND) *}
|
|
ver: Byte; {* set to AKRIPVER *}
|
|
ha: Byte; {* host adapter *}
|
|
tgt: Byte; {* target id *}
|
|
lun: Byte; {* LUN *}
|
|
readType: Byte; {* read function to use *}
|
|
jitterCorr: Bool; {* use built-in jitter correction? *}
|
|
numJitter: Byte; {* number of frames to try to match *}
|
|
numOverlap: Byte; {* number of frames to overlap *}
|
|
end;
|
|
|
|
const
|
|
akriplib = 'akrip32.dll';
|
|
|
|
var
|
|
LibHandle : Integer;
|
|
CDRipLoaded : Boolean;
|
|
|
|
type
|
|
GetNumAdapters_t = function : Integer; cdecl;
|
|
GetCDList_t = function (var cd: CDLIST): Integer; cdecl;
|
|
GetAspiLibError_t = function : Integer; cdecl;
|
|
GetAspiLibAspiError_t = function : Byte; cdecl;
|
|
|
|
GetCDId_t = function (hCD: HCDROM; buf: PChar; maxBuf: Integer): DWord; cdecl;
|
|
GetDriveInfo_t = function (ha, tgt, lun: byte; var cdrec: CDREC): DWord; cdecl;
|
|
ReadTOC_t = function (hCD: HCDROM; var MyToc: TOC): DWord; cdecl;
|
|
ReadCDAudioLBA_t = function (hCD: HCDROM; TrackBuf: PTRACKBUF): DWord; cdecl;
|
|
QueryCDParms_t = function (hCD: HCDROM; which: Integer; var Num: DWord): Bool; cdecl;
|
|
ModifyCDParms_t = function (hCD: HCDROM; which: Integer; val: DWord): Bool; cdecl;
|
|
GetCDHandle_t = function (var cd: GETCDHAND): HCDROM; cdecl;
|
|
CloseCDHandle_t = function (hCD: HCDROM): Bool; cdecl;
|
|
ReadCDAudioLBAEx_t = function (hCD: HCDROM; TrackBuf, Overlap: PTRACKBUF): DWord; cdecl;
|
|
|
|
var
|
|
GetNumAdapters : GetNumAdapters_t;
|
|
GetCDList : GetCDList_t;
|
|
GetAspiLibError : GetAspiLibError_t;
|
|
GetAspiLibAspiError : GetAspiLibAspiError_t;
|
|
|
|
GetCDId : GetCDId_t;
|
|
GetDriveInfo : GetDriveInfo_t;
|
|
ReadTOC : ReadTOC_t;
|
|
ReadCDAudioLBA : ReadCDAudioLBA_t;
|
|
QueryCDParms : QueryCDParms_t;
|
|
ModifyCDParms : ModifyCDParms_t;
|
|
GetCDHandle : GetCDHandle_t;
|
|
CloseCDHandle : CloseCDHandle_t;
|
|
ReadCDAudioLBAEx : ReadCDAudioLBAEx_t;
|
|
|
|
procedure CDRIPInit(FilePath:String);
|
|
|
|
implementation
|
|
|
|
procedure CDRIPInit(FilePath:String);
|
|
begin
|
|
Libhandle := LoadLibraryEx(akriplib, 0, 0);
|
|
if Libhandle <> 0 then
|
|
begin
|
|
CDRipLoaded := True;
|
|
GetNumAdapters := GetProcAddress(Libhandle, 'GetNumAdapters');
|
|
GetCDList := GetProcAddress(Libhandle, 'GetCDList');
|
|
GetAspiLibError := GetProcAddress(Libhandle, 'GetAspiLibError');
|
|
GetAspiLibAspiError := GetProcAddress(Libhandle, 'GetAspiLibAspiError');
|
|
GetCDId := GetProcAddress(Libhandle, 'GetCDId');
|
|
GetDriveInfo := GetProcAddress(Libhandle, 'GetCDDriveInfo');
|
|
ReadTOC := GetProcAddress(Libhandle, 'ReadTOC');
|
|
ReadCDAudioLBA := GetProcAddress(Libhandle, 'ReadCDAudioLBA');
|
|
QueryCDParms := GetProcAddress(Libhandle, 'QueryCDParams');
|
|
ModifyCDParms := GetProcAddress(Libhandle, 'ModifyCDParms');
|
|
GetCDHandle := GetProcAddress(Libhandle, 'GetCDHandle');
|
|
CloseCDHandle := GetProcAddress(Libhandle, 'CloseCDHandle');
|
|
ReadCDAudioLBAEx := GetProcAddress(Libhandle, 'ReadCDAudioLBAEx');
|
|
end;
|
|
end;
|
|
|
|
initialization
|
|
|
|
finalization
|
|
if Libhandle <> 0 then
|
|
begin
|
|
FreeLibrary(Libhandle);
|
|
end;
|
|
|
|
end.
|
|
|