steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Input/in_cdda/windac/Dac32.h

775 lines
22 KiB
C
Raw Permalink Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
// ----------------------------------------------
// - DAC32.DLL Header Datei -
// - Written 1996-1998 by Christoph Schmelnik -
// ----------------------------------------------
// Changes
// ===========
// Version 1.2 :
// -CMapDrive supports now up to 34 Host Adapters, because now it could access the drives under
// NT with the DeviceControl Interface
// The required information for this is coded as:
// Drives accessed over the new Interface have a HostAdapterNumber above or equal to the
// NumberOfHostAdapters (global Information).
// The ID consists of the good old drive number, like in DOS.
// The LUN is not used for the configuration, but it is used to hold the open handle to the device
// The Burstmodus couldn't be used with the new access mode, so the default setting for those
// drives is the Normal-mode. (For those drives is no difference between Burst- and Normal-mode)
// -LoadASPI checks now the Windows Version and hold this result global in the DLL
// -The Constructor of CSCSCD opens the handles to the new devices
// -The destructor closes those handles
// Interface changes are not required but some values must be handled differnt to avoid
// misconfiguring, e.g. it is not allowed to configure the new drives ID, LUN, and HostAdapterNumber
// -A bug in CWaveSave regarding conversion to mixed mono has been fixed.
//
// Version 1.33 : 18.01.1998
// Changes:
// Added speed selection support for all current Plextor drives
//
// Version 1.40 : 24.02.1998
// Changes:
// Set correct direction flags, to work with NT device IO interface and ATAPI drives
// Changed main CD detection to TestUnitReady
// Removed CD detection from Audio Status Info
// Added hopefully correct read command for Matsushita/Panasonic drives
// Added Parameters to CDAC class to allow the disabling of the audio test and to spin up the drive for a specified time
// in seconds to avoid spin up problems on some drives. Both parameters have default values so it behaves like the old version
// without the additional parameters
// Added Parameter to the constructor of CWaveSave to disable writing any Headers. Also this parameter has a default to work like
// before.
// Added virtual function in CDAC to report buffer underruns in Burst Copy Mode
// For the last feature an immediate parameter in WaitCDDA is added
// GetLastSense function added to return the sense information for the last read audio command
// Configuration in CMapDrive extended by new features
// Fixed GetRedBook operator in CCDAdress
// Added function to CD Class to read Media Cataloge Number
//
// Version 1.41 : 28.04.1998
// Changes:
// New GetInfoEx() function in CMapDrive, to allow a better result checking.
//
// Version 1.42 : 02.08.1998
// Changes:
// Added GetLastReadableAddress function to get the last readable Sektor of a session.
// Added a flag in the drive properties for the function.
// Added this function to the CDAC object.
//
// Version 1.43 : 23.12.1998
// Changes:
// Added Wave and DAC classes are now available in a MT version, the old versions will not longer be updated.
//
// Version 1.44 : 10.03.1999
// Changes:
// Added Support for current Plextor CDROM drives and CD-Writers.
// Added Support for Jukeboxes
// Changed Handling of the Ringbuffer
//
// Version 1.45 : 15.08.1999
// Changes:
// Added Enhanced error detection for Plextor drives.
// Several Bugfixes (initialising under NT and Ringbuffer specific)
//
// Version 1.45-Build 11 : 11.11.1999
// Changes:
// Added a check for the MaxSektor parameter in CBaseWaveMT to avoid Program failures even if the applications provides an invalid value.
// Changed source to comile with Borland compiler
// Added MMC-2 Type which will be default for Sony CD-Writers 140 and 928
// Skip Virtual CD devices in Bus scan
// Fixed Array out of bound bug in drive detection.
#ifndef _DAC32_H
#define _DAC32_H
#ifndef STRICT
#define STRICT // Use strct typechecking
#define WIN32_LEAN_AND_MEAN // compile only important Headerfiles
#endif
#include <windows.h>
#include <stdio.h>
#include "aspifunc.h"
/*#ifdef DLL
#define DACDLL __declspec(dllexport)
#else
#define DACDLL __declspec(dllimport)
#endif*/
#define DACDLL
#ifdef _DEBUG
#define DBGOUT(sz) OutputDebugString(sz)
#else
#define DBGOUT(sz)
#endif
//The Errormessages for the CD and DAC Classes
#define CDOK 0x000
#define CDUnknownDrive 0x001
#define CDDriveNotReady 0x002
#define CDUnknownCommand 0x003
#define CDSeekError 0x006
#define CDSectorNotFound 0x008
#define CDReadError 0x00B
#define CDGeneralError 0x00C
#define CDNoCD 0x00E
#define CDIllegalCDChange 0x00F
#define CDDriveNotFound 0x100
#define CDNoMemory 0x101
#define CDDACUnable 0x102
#define CDASPIError 0x103
#define CDUserBreak 0x104
#define CDTimeOut 0x105
//The Errormessage for the wave classes
#define WAVEFileOpenError 0x200
#define WAVEFileWriteError 0x201
#define WAVEChannelError 0x202
#define WAVEBitsError 0x203
#define WAVEFreqError 0x204
#define WAVENameError 0x205
#define WAVEMemoryError 0x206
//The supported base drive types
#define CDTYPE_TOSHIBA 0
#define CDTYPE_SONY 1
#define CDTYPE_NEC 2
#define CDTYPE_PHILIPS 3
#define CDTYPE_ATAPI 4
#define CDTYPE_TOSHNEW 5
#define CDTYPE_RICOH 6
#define CDTYPE_MATSHITA 7
#define CDTYPE_PLEXTOR 8
#define CDTYPE_CYBERDRV 9
#define JUKETYPE_SONY 0
#define JUKETYPE_PIONEER 1
//Amount of predefined drive mappings (relationship between real drives and base drive types)
#define MaxMappings 22 // pgo
//Amount of predefined jukebox mappings (relationship between real jukeboxes and base jukebox types)
#define MaxMappingsJuke 2
//The possible Copy modes
#define ModeNormal 0
#define ModeSynch 1
#define ModeBurst 2
//The possible Values for the DA Test
#define DATEST_ALLWAYS 0
#define DATEST_FIRSTTRACK 1
#define DATEST_NEVER 2
//The possible SpinUp modes
#define SPINUP_ALLWAYS 0
#define SPINUP_FIRSTTRACK 1
#define SPINUP_NEVER 2
// Amount of DWORD for the synchronisation
#define SynLen 512
// The Class for the Addressformats
class DACDLL CCDAdress
{
public:
void SetRedbook(long Value);
void SetHSG(long Value)
{
Adresse=Value;
};
long GetHSG()
{
return Adresse;
};
long GetRedbook()
{
long t;
t=(Adresse % 75)<<24;
t+=((Adresse / 75) % 60)<<16;
t+=((Adresse / 75) / 60)<<8;
return t;
};
CCDAdress &operator = (const CCDAdress &other)
{
Adresse=other.Adresse;
return (*this);
};
CCDAdress &operator + (const long Value)
{
Adresse+=Value;
return (*this);
};
CCDAdress &operator - (const long Value)
{
Adresse-=Value;
return (*this);
};
CCDAdress &operator += (const long Value)
{
Adresse+=Value;
return (*this);
};
CCDAdress &operator -= (const long Value)
{
Adresse-=Value;
return (*this);
};
private:
long Adresse;
};
// Typendeclarations
struct TDriveStatus
{
int DoorOpen; //Door open/closed
int DoorLocked; //Door locked/unlocked
int Cooked_RAW; //supports Cooked and RAW or Cooked
int Read_Write; //supports read and write
int Data_Audio_Video; //supports Data/Audio/Video or only Data
int Interleave; //supports Interleave regarding ISO
int CommandPrefetch; //supports Command Prefetching
int AudioChannelManipulation; //supports Audio-Channel Manipulation
int HSG_Redbook; //supports HSG and Redbook Addressing or only HSG
int CDPresent; //CD inserted or not
int RWSupport; //supports R-W-Sub Channels
};
struct TAudioStatus
{
BOOL Pause; //Play is paused
BOOL IsPlaying; //CD is playing
BOOL IsDone; //Play is stopped
BOOL PlayError; //Play completed with error
int TrackNummer; //Number of actual track
CCDAdress AbsSektor,RelSektor; //Startsector and Endsector of last/next Play
};
struct TTrackFlag
{
BYTE AudioChannels; //Amount of Audio Channels (2/4)
BOOL PreEmphasis; //Audio Channel with or without...
BOOL DataTrack; //Data track or Audio track
BOOL CopyProhibeted; //Digital copy prohibited
};
struct TTrackList
{
BYTE TrackNummer; //Number of Track
CCDAdress StartSektor; //First sector in HSG Format
long Laenge; //Amount of Sectors
TTrackFlag Flags;
};
struct TTrackListeMem
{
TTrackList Info;
TTrackListeMem *Prev,*Next;
};
struct TDriveInfo
{
int ID;
int LUN;
int HostAdapterNumber;
int Type;
int MaxSektors;
int SynchSektors;
int Mode;
char VendorID[9];
char ProductID[17];
int Speed;
int PerformDATest;
int SpinUpMode;
DWORD dwSpinUpTime;
BOOL bUseLastReadableAddress;
BOOL bUseC2ErrorInfo;
BOOL bSpinDown;
};
struct TJukeInfo
{
int ID;
int LUN;
int HostAdapterNumber;
int Type;
int MaxDrives;
int *pConnectedDrives;
int MaxDiscs;
char VendorID[9];
char ProductID[17];
};
// The class with the infos for the type mapping
class DACDLL CMapInfo
{
public:
CMapInfo();
char *GetTypName(int Index);
int GetTypMapping(int Index);
int GetTypMappingRev(int CDType);
private:
char TypNamen[MaxMappings][9];
int TypMapping[MaxMappings];
};
// The class with the infos for the type mapping
class DACDLL CMapInfoJuke
{
public:
CMapInfoJuke();
char *GetTypName(int Index);
int GetTypMapping(int Index);
int GetTypMappingRev(int JukeType);
private:
char TypNamen[MaxMappingsJuke][9];
int TypMapping[MaxMappingsJuke];
};
// The base class (pure virtual) for the CD access
class DACDLL CBaseCD
{
public:
int Lasterror();
virtual void PrepareCDDA()=0;
virtual void ReadCDDA(CCDAdress StartSektor,long Sektoranzahl,void *Buffer,BOOL bUseC2ErrorInfo=FALSE)=0;
virtual BOOL WaitCDDA(BOOL bImmediate=FALSE)=0;
virtual void FinishCDDA()=0;
virtual void SortWaveData(DWORD *Data,int Samples)=0;
virtual CCDAdress GetErrorAdress()=0;
virtual void Play_Audio(CCDAdress StartSektor,long Sektoranzahl)=0;
virtual void Stop_Audio()=0;
virtual void Pause_Audio()=0;
virtual void Resume_Audio()=0;
virtual TDriveStatus Get_DriveStatus()=0;
virtual BOOL MediaChanged()=0;
virtual void Get_MediaCatalogNumber(char szUPC[16])=0;
virtual void EjectDisk()=0;
virtual void LockDoor(int Lock)=0;
virtual void CloseTray()=0;
virtual void ReRead()=0;
virtual CCDAdress GetLastReadableAddress(CCDAdress StartSektor)=0;
virtual int GetMaxSektors()=0;
virtual int GetSynchSektors()=0;
virtual int GetMode()=0;
virtual int GetSpeed()=0;
virtual void InitSpeedTable()=0;
virtual BYTE GetSupportedSpeeds()=0;
virtual int GetCurrentSpeed()=0;
virtual void SetCurrentSpeed(int Speed)=0;
virtual int GetSpeed(BYTE Index)=0;
int ReadFirstTrackInfo(TTrackList &Infos);
int ReadNextTrackInfo(TTrackList &Infos);
int ReadPrevTrackInfo(TTrackList &Infos);
int ReadTrackInfo(TTrackList &Infos);
int ReadMaxTracks();
protected:
int Error,BusyFlag,DoneFlag;
TTrackListeMem *FirstTrack,*AktTrack;
void DeleteTrackList();
private:
CBaseCD& operator = (const CBaseCD &other);
};
// The class for the access to SCSI drives
class DACDLL CSCSICD:public CBaseCD
{
public:
CSCSICD (char drive, TDriveInfo &xInfo);
~CSCSICD();
virtual void PrepareCDDA();
virtual void ReadCDDA(CCDAdress StartSektor,long Sektoranzahl,void *Buffer,BOOL bUseC2ErrorInfo=FALSE);
virtual BOOL WaitCDDA(BOOL bImmediate=FALSE);
virtual void FinishCDDA();
virtual void SortWaveData(DWORD *Data,int Samples);
virtual CCDAdress GetErrorAdress();
virtual void Play_Audio(CCDAdress StartSektor,long Sektoranzahl);
virtual void Stop_Audio();
virtual void Pause_Audio();
virtual void Resume_Audio();
virtual TDriveStatus Get_DriveStatus();
virtual BOOL MediaChanged();
virtual TAudioStatus Get_AudioStatus_Info();
virtual void Get_MediaCatalogNumber(char szUPC[16]);
virtual void EjectDisk();
virtual void LockDoor(int Lock);
virtual void CloseTray();
virtual void ReRead();
virtual CCDAdress GetLastReadableAddress(CCDAdress StartSektor);
virtual int GetMaxSektors();
virtual int GetSynchSektors();
virtual int GetMode();
virtual int GetSpeed();
virtual void InitSpeedTable();
virtual BYTE GetSupportedSpeeds();
virtual int GetCurrentSpeed();
virtual void SetCurrentSpeed(int Speed);
virtual int GetSpeed(BYTE Index);
TDriveInfo &GetInfo()
{
return Config;
};
TSenseInfo GetSense();
TSenseInfo GetLastSenseInfo();
private:
CSCSICD& operator = (const CSCSICD &other);
TDriveInfo &Config; // Drive Configuration
BOOL CDPresentLast,Changed; // Helpvariables for the MediaChanged function
SRB_ExecSCSICmd ReadSRB; // SCSI Commando Block
TDriveMode ModeData;
BYTE NECRotationSpeed;
CMapInfo MapInfo;
DWORD StartReadTime;
int SpeedTable[256];
BYTE SupportedSpeeds;
HANDLE m_hDriveEvent;
TSenseInfo m_SenseInfo;
BOOL m_bSpeedTableInitialized;
};
// The base class for saving/converting the audio data
class DACDLL CBaseWave
{
public:
int Lasterror();
virtual void WritePuffer(long Samples,DWORD *Buffer)=0;
protected:
int Error; //last occured error
private:
CBaseWave& operator = (const CBaseWave &other);
};
typedef struct
{
BOOL bIsUsed; //Is Buffer used?
BOOL bReady; //Is Nuffer ready to write?
int nSamples; //Number of Samples in Buffer.
int nZeroSamples; //Number of Silence Samples to insert before the buffer
DWORD *dwBuffer; //Buffer for Audio Data
} WAVEBUFFER, *PWAVEBUFFER;
typedef struct _WAVEBUFFERLIST
{
PWAVEBUFFER pWaveBuffer;
_WAVEBUFFERLIST *pNext;
} WAVEBUFFERLIST, *PWAVEBUFFERLIST;
typedef struct
{
HANDLE hEvent;
LPVOID pData;
} TWAVEMTSTRUCT;
// The base class for saving/converting the audio data as its own thread
class DACDLL CBaseWaveMT
{
public:
CBaseWaveMT(DWORD dwBufferSize,BOOL bUseHighPriority=FALSE,int MaxSektors=27,DWORD dwExtraBytes=0);
~CBaseWaveMT();
void SetFadeInOut(int dwTotalSamples,int dwFadeSamples);
PWAVEBUFFER GetBuffer(); //returns NULL if no Buffer is available
void SignalBuffer(); //signal if a buffer is filled;
int Lasterror();
double GetBufferFullRatio();
DWORD GetBytesInBuffer();
virtual void WritePuffer(long Samples,DWORD *Buffer)=0;
friend unsigned _stdcall WaveThreadProc(LPVOID pUserData);
protected:
int Error; //last occured error
void StartThread(); //call this from your own initialisation function
BOOL WriteData();
void StopThread(BOOL bImmediate=FALSE); //call this from your own cleanup function
private:
CBaseWaveMT& operator = (const CBaseWaveMT &other);
DWORD m_Nullen[256];
PWAVEBUFFERLIST m_pFirstBuffer, m_pReadBuffer, m_pWriteBuffer;
TWAVEMTSTRUCT m_WaveInfo;
BOOL m_bStopThread,m_bAbortThread,m_bIsWorking;
HANDLE m_hWaveThread;
BOOL m_bUseHighPriority;
int m_dwTotalSamples,m_dwFadeSamples,m_dwCurrentSample;
int m_nBufferNum,m_nReadBufferNum,m_nWriteBufferNum;
int m_nMaxSektors;
};
// The class for saving audio data in a wave file
class DACDLL CWaveSave:public CBaseWave
{
public:
CWaveSave(const char *DateiName,BYTE Freq,BYTE Channels,BYTE Bits,BOOL bWriteHeaders=TRUE);
~CWaveSave();
virtual void WritePuffer(long Samples,DWORD *Buffer);
private:
void WMono8(long Samples,DWORD *Buffer);
void WStereo8(long Samples,DWORD *Buffer);
void WMono16(long Samples,DWORD *Buffer);
void WStereo16(long Samples,DWORD *Buffer);
void WLR8(long Samples,int Mode,DWORD *Buffer);
void WLR16(long Samples,int Mode,DWORD *Buffer);
CWaveSave& operator = (const CWaveSave &other);
BYTE ConvertType; //CodeNumber of the conversion type
FILE *Datei; //file variable to access the wave file
WORD *DPM16; //Pointer to the file data buffer
BYTE *DPM8; //Pointer to the file data buffer
DWORD *DPS16; //Pointer to the file data buffer
BYTE *DPS8; //Pointer to the file data buffer
int DatenCount; //Counter of data in buffer
long WaveBytes; //Counts all written bytes
BYTE SAdd; //Value to increment the source counter
BOOL m_bWriteHeaders; //Write Headers of Wave file
};
// The class for saving audio data in a wave file in its own thread
class DACDLL CWaveSaveMT:public CBaseWaveMT
{
public:
CWaveSaveMT(DWORD dwBufferSize,BOOL bUseHighPriority=FALSE,int MaxSektors=27,DWORD dwExtraBytes=0):CBaseWaveMT(dwBufferSize,bUseHighPriority,MaxSektors,dwExtraBytes)
{
};
void Init(const char *DateiName,BYTE Freq,BYTE Channels,BYTE Bits,BOOL bWriteHeaders=TRUE);
void Done(BOOL bImmediate=FALSE);
virtual void WritePuffer(long Samples,DWORD *Buffer);
private:
void WMono8(long Samples,DWORD *Buffer);
void WStereo8(long Samples,DWORD *Buffer);
void WMono16(long Samples,DWORD *Buffer);
void WStereo16(long Samples,DWORD *Buffer);
void WLR8(long Samples,int Mode,DWORD *Buffer);
void WLR16(long Samples,int Mode,DWORD *Buffer);
CWaveSave& operator = (const CWaveSave &other);
BYTE ConvertType; //CodeNumber of the conversion type
FILE *Datei; //file variable to access the wave file
WORD *DPM16; //Pointer to the file data buffer
BYTE *DPM8; //Pointer to the file data buffer
DWORD *DPS16; //Pointer to the file data buffer
BYTE *DPS8; //Pointer to the file data buffer
int DatenCount; //Counter of data in buffer
long WaveBytes; //Counts all written bytes
BYTE SAdd; //Value to increment the source counter
BOOL m_bWriteHeaders; //Write Headers of Wave file
};
// The class for copying the audio data from CD.
class DACDLL CDAC
{
public:
CDAC(CBaseCD *pDrive,CBaseWave *pWave,
CCDAdress Start,long Laenge,BOOL xKillZeros,BOOL bPerformDATest=TRUE,DWORD dwSpinUpTime=0,BOOL bUseLastReadableAddress=FALSE);
~CDAC();
int Lasterror();
void Copy();
int Errors();
void StopCopy();
// The following member functions are declared as virtual. They could be used to display
// information to the user. They do nothing by default.
virtual void WriteInit();
virtual void WritePercent(float Percent);
virtual void WriteReading();
virtual void WriteReadingEnd();
virtual void WriteSynch();
virtual void WriteSynchEnd();
virtual void WriteFlushing();
virtual void WriteFlushingEnd();
virtual void WriteSynchError();
virtual void WriteBufferUnderrun(CCDAdress Start);
virtual void WriteReRead(CCDAdress Start,long Laenge);
virtual void WriteSektorsSkipped(CCDAdress Start,long Laenge);
virtual void WriteDone();
virtual void OnIdle();
protected:
CCDAdress StartSektor,StartOld;
int SynchErrors,Error;
long Anzahl,AnzahlOld,Remain;
private:
CBaseCD *m_pCD;
BOOL RunCopy,KillFirst,KillLast,KillZero,Found;
DWORD m_dwSpinUpTime;
CBaseWave *m_pWaveSave;
long SektorAnzahl,Retries,SynchDiff,ZeroCount;
DWORD *MemBlocks[2];
int BlockCount,S_Offset;
int SpeedSave;
DWORD m_Nullen[256];
void ReadCDDA(CCDAdress Start,long Sektoranzahl,void *Buffer);
void FlushWave();
void FlushSynch(int Samples,DWORD *Data);
void MakeTable(DWORD *Werte,DWORD *Table);
int SynchSearch(DWORD *String1,DWORD *String2,DWORD *Table);
void SynchWave();
CDAC& operator = (const CDAC &other);
};
// The class for copying the audio data from CD.
class DACDLL CDACMT
{
public:
CDACMT(CBaseCD *pDrive,CBaseWaveMT *pWave,
CCDAdress Start,long Laenge,BOOL xKillZeros,BOOL bPerformDATest=TRUE,DWORD dwSpinUpTime=0,BOOL bUseHighPriority=FALSE,BOOL bUseC2ErrorInfo=FALSE,BOOL bSpinDown=FALSE,BOOL bUseLastReadableAddress=FALSE);
~CDACMT();
int Lasterror();
void Copy();
int Errors();
void StopCopy();
// The following member functions are declared as virtual. They could be used to display
// information to the user. They do nothing by default.
virtual void WriteInit();
virtual void WritePercent(float Percent);
virtual void WriteReading();
virtual void WriteReadingEnd();
virtual void WriteSynch();
virtual void WriteSynchEnd();
virtual void WriteFlushing();
virtual void WriteFlushingEnd();
virtual void WriteSynchError();
virtual void WriteBufferUnderrun(CCDAdress Start);
virtual void WriteReRead(CCDAdress Start,long Laenge);
virtual void WriteSektorsSkipped(CCDAdress Start,long Laenge);
virtual void WriteDone();
virtual void OnIdle(BOOL bReturnFast=TRUE);
friend unsigned _stdcall DACThreadProc(LPVOID pUserData);
protected:
CCDAdress StartSektor,StartOld;
int SynchErrors,Error;
long Anzahl,AnzahlOld,Remain;
void CopyMT();
private:
CBaseCD *m_pCD;
BOOL RunCopy,KillFirst,KillLast,KillZero,Found;
DWORD m_dwSpinUpTime;
CBaseWaveMT *m_pWaveSave;
BOOL m_bUseC2ErrorInfo;
BOOL m_bSpinDown;
long SektorAnzahl,Retries,SynchDiff,ZeroCount;
PWAVEBUFFER MemBlocks[2];
int BlockCount,S_Offset;
int SpeedSave;
int m_MaxSektors;
int m_SynchSektors;
void ReadCDDA(CCDAdress Start,long Sektoranzahl,void *Buffer);
void FlushWave(int nMax=2);
void FlushSynch(int Samples,PWAVEBUFFER Data);
void MakeTable(DWORD *Werte,DWORD *Table);
int SynchSearch(DWORD *String1,DWORD *String2,DWORD *Table);
void SynchWave();
CDACMT& operator = (const CDACMT &other);
HANDLE m_hDACThread;
BOOL m_bUseHighPriority;
};
// The class for configuring the SCSI CDROM drives
class DACDLL CMapDrive
{
public:
CMapDrive(BOOL bDoReset=TRUE);
~CMapDrive();
void Reset();
int GetMaxDrives();
TDriveInfo &GetInfo(int index);
BOOL GetInfoEx(int index, TDriveInfo *&pInfo);
void DeleteInfo(int index);
int GetMaxHostAdapters();
int GetSupportedHostAdapterMemory(int index);
void SetSupportedHostAdapterMemory(int index,int Memory);
int GetMaxSektors(int HostAdapterNumber);
protected:
void DeleteAll();
private:
struct TDriveInfoMem
{
TDriveInfo Info;
TDriveInfoMem *Next;
};
TDriveInfoMem *First;
int HostAdapterMemory[34];
HANDLE m_hDriveEvent;
};
// The class for configuring the SCSI Jukeboxes
class DACDLL CMapJuke
{
public:
CMapJuke(BOOL bDoReset=TRUE);
~CMapJuke();
void Reset();
int GetMaxJukes();
TJukeInfo &GetInfo(int index);
BOOL IsWorking(int index);
void SetWorking(int index,BOOL bIsWorking);
void DeleteInfo(int index);
protected:
void DeleteAll();
private:
struct TJukeInfoMem
{
TJukeInfo Info;
BOOL bIsWorking;
TJukeInfoMem *Next;
};
TJukeInfoMem *First;
HANDLE m_hJukeEvent;
};
//The class to access Jukeboxes
class DACDLL CJukeBox
{
public:
CJukeBox (TJukeInfo &xInfo);
~CJukeBox();
//use following defines to address an item in the jukebox:
//drive0..x : 0x4000...0x400x
//storage1..xxx : 0x0001...0x0xxx
BOOL MoveMedium(int Source,int Destination);
TJukeInfo &GetInfo()
{
return Config;
};
private:
TJukeInfo &Config; // Drive Configuration
CMapInfoJuke MapInfo;
HANDLE m_hJukeEvent;
};
// ----------------------
// function declarations
// ----------------------
// initialize and deinatialize the WNASPI32.DLL and some internal flags
int DACDLL LoadASPI();
int DACDLL FreeASPI();
int DACDLL CheckASPI();
#endif //_DAC32_H