30#if defined(_CARBON_) || defined(__APPLE__)
31# if defined (__GNUC__) && (__GNUC__ >= 4)
40#if defined(_CARBON_) || defined(__APPLE__)
44#include <IOKit/IOKitLib.h>
45#include <IOKit/IOBSD.h>
46#include <IOKit/storage/IOMediaBSDClient.h>
47#include <IOKit/storage/IOMedia.h>
48#include <IOKit/storage/IOCDMedia.h>
49#include <IOKit/storage/IOCDTypes.h>
50#include <CoreFoundation/CoreFoundation.h>
53#if defined(_CARBON_) || defined(__APPLE__)
65#define MSF_TO_LBA(msf) \
66 (((((msf).minute * 60UL) + (msf).second) * 75UL) + (msf).frame - 150)
73 struct _CDMSF address;
82 struct _CDTOC_Desc trackdesc[1];
92static kern_return_t FindEjectableCDMedia(io_iterator_t *mediaIterator) {
93 kern_return_t kernResult;
94 CFMutableDictionaryRef classesToMatch;
97 classesToMatch = IOServiceMatching(kIOCDMediaClass);
98 if (classesToMatch == NULL) {
99 printf(
"IOServiceMatching returned a NULL dictionary.\n");
101 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey), kCFBooleanTrue);
106 kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, mediaIterator);
113static kern_return_t GetBSDPath(io_iterator_t mediaIterator,
char *bsdPath, CFIndex maxPathSize) {
114 io_object_t nextMedia;
115 kern_return_t kernResult = KERN_FAILURE;
119 nextMedia = IOIteratorNext(mediaIterator);
121 CFTypeRef bsdPathAsCFString;
123 bsdPathAsCFString = IORegistryEntryCreateCFProperty(nextMedia,
124 CFSTR(kIOBSDNameKey),
127 if (bsdPathAsCFString) {
128 strlcpy(bsdPath, _PATH_DEV, maxPathSize);
134 strlcat(bsdPath,
"r", maxPathSize);
136 size_t devPathLength = strlen(bsdPath);
138 if (CFStringGetCString((CFStringRef)bsdPathAsCFString,
139 bsdPath + devPathLength,
140 maxPathSize - devPathLength,
141 kCFStringEncodingUTF8)) {
142 printf(
"BSD path: %s\n", bsdPath);
143 kernResult = KERN_SUCCESS;
146 CFRelease(bsdPathAsCFString);
149 IOObjectRelease(nextMedia);
214static struct _CDTOC * ReadTOC(
const char *devpath) {
215 struct _CDTOC * toc_p = NULL;
216 io_iterator_t iterator = 0;
217 io_registry_entry_t service = 0;
218 CFDictionaryRef properties = 0;
220 mach_port_t port = 0;
223 if ((devname = strrchr(devpath,
'/')) != NULL) {
226 devname = (
char *) devpath;
229 if (IOMasterPort(bootstrap_port, &port) != KERN_SUCCESS) {
230 fprintf(stderr,
"IOMasterPort failed\n");
234 if (IOServiceGetMatchingServices(port, IOBSDNameMatching(port, 0, devname),
235 &iterator) != KERN_SUCCESS) {
236 fprintf(stderr,
"IOServiceGetMatchingServices failed\n");
240 service = IOIteratorNext(iterator);
242 IOObjectRelease(iterator);
246 while (service && !IOObjectConformsTo(service,
"IOCDMedia")) {
247 if (IORegistryEntryGetParentIterator(service, kIOServicePlane,
248 &iterator) != KERN_SUCCESS)
250 fprintf(stderr,
"IORegistryEntryGetParentIterator failed\n");
254 IOObjectRelease(service);
255 service = IOIteratorNext(iterator);
256 IOObjectRelease(iterator);
260 fprintf(stderr,
"CD media not found\n");
264 if (IORegistryEntryCreateCFProperties(service, (__CFDictionary **) &properties,
266 kNilOptions) != KERN_SUCCESS)
268 fprintf(stderr,
"IORegistryEntryGetParentIterator failed\n");
272 data = (CFDataRef) CFDictionaryGetValue(properties, CFSTR(kIOCDMediaTOCKey));
274 fprintf(stderr,
"CFDictionaryGetValue failed\n");
280 buflen = CFDataGetLength(data) + 1;
281 range = CFRangeMake(0, buflen);
282 toc_p = (
struct _CDTOC *) malloc(buflen);
284 fprintf(stderr,
"Out of memory\n");
287 CFDataGetBytes(data, range, (
unsigned char *) toc_p);
295 CFRelease(properties);
301 IOObjectRelease(service);
312 : AkaiDiskElement(pDisk->GetPos())
316 mDirEntry = DirEntry;
325AkaiSample::~AkaiSample()
331AkaiDirEntry AkaiSample::GetDirEntry()
336bool AkaiSample::LoadSampleData()
343 mpDisk->SetPos(mImageOffset);
344 mpSamples = (int16_t*) malloc(mNumberOfSamples *
sizeof(int16_t));
348 mpDisk->ReadInt16((uint16_t*)mpSamples, mNumberOfSamples);
352void AkaiSample::ReleaseSampleData()
360int AkaiSample::SetPos(
int Where, akai_stream_whence_t Whence)
362 if (!mHeaderOK)
return -1;
366 case akai_stream_start:
371 case akai_stream_curpos:
374 case akai_stream_end:
375 mPos = mNumberOfSamples - w;
378 if (mPos > mNumberOfSamples) mPos = mNumberOfSamples;
379 if (mPos < 0) mPos = 0;
383int AkaiSample::Read(
void* pBuffer, uint SampleCount)
385 if (!mHeaderOK)
return 0;
387 if (mPos + SampleCount > mNumberOfSamples) SampleCount = mNumberOfSamples - mPos;
389 mpDisk->SetPos(mImageOffset + mPos * 2);
390 mpDisk->ReadInt16((uint16_t*)pBuffer, SampleCount);
394bool AkaiSample::LoadHeader()
399 mpDisk->SetPos(mpParent->GetParent()->GetOffset() + mDirEntry.mStart * AKAI_BLOCK_SIZE );
404 if (mpDisk->ReadInt8() != AKAI_SAMPLE_ID)
409 mMidiRootNote = mpDisk->ReadInt8();
412 mpDisk->Read(buffer, 12, 1);
413 AkaiToAscii(buffer, 12);
419 mActiveLoops = mpDisk->ReadInt8();
421 mFirstActiveLoop = mpDisk->ReadInt8();
426 mLoopMode = mpDisk->ReadInt8();
428 mTuneCents = mpDisk->ReadInt8();
430 mTuneSemitones = mpDisk->ReadInt8();
438 mNumberOfSamples = mpDisk->ReadInt32();
440 mStartMarker = mpDisk->ReadInt32();
442 mEndMarker = mpDisk->ReadInt32();
453 mLoops[i].Load(mpDisk);
457 mSamplingFrequency = mpDisk->ReadInt16();
459 mLoopTuneOffset = mpDisk->ReadInt8();
461 const int headerSize =
462 (mpParent->GetDirEntry().mType == AKAI_TYPE_DIR_S3000) ? 192 : 150;
464 mImageOffset = mpParent->GetParent()->GetOffset() + mDirEntry.mStart * AKAI_BLOCK_SIZE + headerSize;
467 return (mHeaderOK =
true);
470bool AkaiSampleLoop::Load(
DiskImage* pDisk)
473 mMarker = pDisk->ReadInt32();
475 mFineLength = pDisk->ReadInt16();
477 mCoarseLength = pDisk->ReadInt32();
479 mTime = pDisk->ReadInt16();
485AkaiProgram::AkaiProgram(
DiskImage* pDisk,
AkaiVolume* pParent,
const AkaiDirEntry& DirEntry)
486 : AkaiDiskElement(pDisk->GetPos())
490 mDirEntry = DirEntry;
495AkaiProgram::~AkaiProgram()
498 delete[] mpKeygroups;
501AkaiDirEntry AkaiProgram::GetDirEntry()
506bool AkaiProgram::Load()
509 uint temppos = mpDisk->GetPos();
510 mpDisk->SetPos(mpParent->GetParent()->GetOffset() + mDirEntry.mStart * AKAI_BLOCK_SIZE );
514 uint8_t ProgID = mpDisk->ReadInt8();
515 if (ProgID != AKAI_PROGRAM_ID)
517 mpDisk->SetPos(temppos);
524 mpDisk->Read(buffer, 12, 1);
525 AkaiToAscii(buffer, 12);
528 mMidiProgramNumber = mpDisk->ReadInt8();
530 mMidiChannel = mpDisk->ReadInt8();
532 mPolyphony = mpDisk->ReadInt8();
534 mPriority = mpDisk->ReadInt8();
536 mLowKey = mpDisk->ReadInt8();
538 mHighKey = mpDisk->ReadInt8();
540 mOctaveShift = mpDisk->ReadInt8();
542 mAuxOutputSelect = mpDisk->ReadInt8();
544 mMixOutputSelect = mpDisk->ReadInt8();
546 mMixPan = mpDisk->ReadInt8();
548 mVolume = mpDisk->ReadInt8();
550 mVelocityToVolume = mpDisk->ReadInt8();
552 mKeyToVolume = mpDisk->ReadInt8();
554 mPressureToVolume = mpDisk->ReadInt8();
556 mPanLFORate = mpDisk->ReadInt8();
558 mPanLFODepth = mpDisk->ReadInt8();
560 mPanLFODelay = mpDisk->ReadInt8();
562 mKeyToPan = mpDisk->ReadInt8();
564 mLFORate = mpDisk->ReadInt8();
566 mLFODepth = mpDisk->ReadInt8();
568 mLFODelay = mpDisk->ReadInt8();
570 mModulationToLFODepth = mpDisk->ReadInt8();
572 mPressureToLFODepth = mpDisk->ReadInt8();
574 mVelocityToLFODepth = mpDisk->ReadInt8();
576 mBendToPitch = mpDisk->ReadInt8();
578 mPressureToPitch = mpDisk->ReadInt8();
580 mKeygroupCrossfade = mpDisk->ReadInt8()?
true:
false;
582 mNumberOfKeygroups = mpDisk->ReadInt8();
587 for (i = 0; i<11; i++)
588 mKeyTemperament[i] = mpDisk->ReadInt8();
590 mFXOutput = mpDisk->ReadInt8()?
true:
false;
592 mModulationToPan = mpDisk->ReadInt8();
594 mStereoCoherence = mpDisk->ReadInt8()?
true:
false;
596 mLFODesync = mpDisk->ReadInt8()?
true:
false;
598 mPitchLaw = mpDisk->ReadInt8();
600 mVoiceReassign = mpDisk->ReadInt8();
602 mSoftpedToVolume = mpDisk->ReadInt8();
604 mSoftpedToAttack = mpDisk->ReadInt8();
606 mSoftpedToFilter = mpDisk->ReadInt8();
608 mSoftpedToTuneCents = mpDisk->ReadInt8();
610 mSoftpedToTuneSemitones = mpDisk->ReadInt8();
612 mKeyToLFORate = mpDisk->ReadInt8();
614 mKeyToLFODepth = mpDisk->ReadInt8();
616 mKeyToLFODelay = mpDisk->ReadInt8();
618 mVoiceOutputScale = mpDisk->ReadInt8();
620 mStereoOutputScale = mpDisk->ReadInt8();
625 delete[] mpKeygroups;
627 const int entrySize =
628 (mpParent->GetDirEntry().mType == AKAI_TYPE_DIR_S3000) ? 192 : 150;
630 mpKeygroups =
new AkaiKeygroup[mNumberOfKeygroups];
631 for (i = 0; i < mNumberOfKeygroups; i++)
634 mpDisk->SetPos(mpParent->GetParent()->GetOffset() + mDirEntry.mStart * AKAI_BLOCK_SIZE + entrySize * (i+1));
635 if (!mpKeygroups[i].Load(mpDisk))
637 mpDisk->SetPos(temppos);
642 mpDisk->SetPos(temppos);
646uint AkaiProgram::ListSamples(std::list<String>& )
651AkaiSample* AkaiProgram::GetSample(uint )
656AkaiSample* AkaiProgram::GetSample(
const String& )
668 if (pDisk->ReadInt8() != AKAI_KEYGROUP_ID)
673 mLowKey = pDisk->ReadInt8();
675 mHighKey = pDisk->ReadInt8();
677 mTuneCents = pDisk->ReadInt8();
679 mTuneSemitones = pDisk->ReadInt8();
681 mFilter = pDisk->ReadInt8();
683 mKeyToFilter = pDisk->ReadInt8();
685 mVelocityToFilter = pDisk->ReadInt8();
687 mPressureToFilter = pDisk->ReadInt8();
689 mEnveloppe2ToFilter = pDisk->ReadInt8();
708 mEnveloppes[i].Load(pDisk);
711 mVelocityToEnveloppe2ToFilter = pDisk->ReadInt8();
713 mEnveloppe2ToPitch = pDisk->ReadInt8();
715 mVelocityZoneCrossfade = pDisk->ReadInt8()?
true:
false;
717 mVelocityZoneUsed = pDisk->ReadInt8();
746 mSamples[i].Load(pDisk);
749 mBeatDetune = pDisk->ReadInt8();
751 mHoldAttackUntilLoop = pDisk->ReadInt8()?
true:
false;
754 mSampleKeyTracking[i] = pDisk->ReadInt8()?
true:
false;
757 mSampleAuxOutOffset[i] = pDisk->ReadInt8();
760 mVelocityToSampleStart[i] = pDisk->ReadInt8();
763 mVelocityToVolumeOffset[i] = pDisk->ReadInt8();
769bool AkaiEnveloppe::Load(
DiskImage* pDisk)
772 mAttack = pDisk->ReadInt8();
774 mDecay = pDisk->ReadInt8();
776 mSustain = pDisk->ReadInt8();
778 mRelease = pDisk->ReadInt8();
780 mVelocityToAttack = pDisk->ReadInt8();
782 mVelocityToRelease = pDisk->ReadInt8();
784 mOffVelocityToRelease = pDisk->ReadInt8();
786 mKeyToDecayAndRelease = pDisk->ReadInt8();
790bool AkaiKeygroupSample::Load(
DiskImage* pDisk)
794 pDisk->
Read(buffer, 12, 1);
795 AkaiToAscii(buffer, 12);
799 mLowLevel = pDisk->ReadInt8();
834 mDirEntry = DirEntry;
836 if (mDirEntry.mType != AKAI_TYPE_DIR_S1000 && mDirEntry.mType != AKAI_TYPE_DIR_S3000)
838 printf(
"Creating Unknown Volume type! %d\n",mDirEntry.mType);
840 OutputDebugString(
"Creating Unknown Volume type!\n");
845AkaiVolume::~AkaiVolume()
848 std::list<AkaiProgram*>::iterator it;
849 std::list<AkaiProgram*>::iterator end = mpPrograms.end();
850 for (it = mpPrograms.begin(); it != end; it++)
856 std::list<AkaiSample*>::iterator it;
857 std::list<AkaiSample*>::iterator end = mpSamples.end();
858 for (it = mpSamples.begin(); it != end; it++)
864uint AkaiVolume::ReadDir()
867 if (mpPrograms.empty())
869 uint maxfiles = (mDirEntry.mType == AKAI_TYPE_DIR_S3000) ? AKAI_MAX_FILE_ENTRIES_S3000 : AKAI_MAX_FILE_ENTRIES_S1000;
870 for (i = 0; i < maxfiles; i++)
872 AkaiDirEntry DirEntry;
873 ReadDirEntry(mpDisk, mpParent, DirEntry, mDirEntry.mStart, i);
875 if (DirEntry.mType ==
'p')
877 AkaiProgram* pProgram =
new AkaiProgram(mpDisk,
this, DirEntry);
879 mpPrograms.push_back(pProgram);
881 else if (DirEntry.mType ==
's')
883 AkaiSample* pSample =
new AkaiSample(mpDisk,
this, DirEntry);
885 mpSamples.push_back(pSample);
889 return (uint)(mpPrograms.size() + mpSamples.size());
892uint AkaiVolume::ListPrograms(std::list<AkaiDirEntry>& rPrograms)
897 std::list<AkaiProgram*>::iterator it;
898 std::list<AkaiProgram*>::iterator end = mpPrograms.end();
899 for (it = mpPrograms.begin(); it != end; it++)
901 rPrograms.push_back((*it)->GetDirEntry());
902 return (uint)rPrograms.size();
909 if (mpPrograms.empty())
911 std::list<AkaiDirEntry> dummy;
915 std::list<AkaiProgram*>::iterator it;
916 std::list<AkaiProgram*>::iterator end = mpPrograms.end();
917 for (it = mpPrograms.begin(); it != end; it++)
919 if (*it && i == Index)
929AkaiProgram* AkaiVolume::GetProgram(
const String& rName)
931 if (mpPrograms.empty())
933 std::list<AkaiDirEntry> dummy;
937 std::list<AkaiProgram*>::iterator it;
938 std::list<AkaiProgram*>::iterator end = mpPrograms.end();
939 for (it = mpPrograms.begin(); it != end; it++)
941 if (*it && rName == (*it)->GetDirEntry().mName)
950uint AkaiVolume::ListSamples(std::list<AkaiDirEntry>& rSamples)
955 std::list<AkaiSample*>::iterator it;
956 std::list<AkaiSample*>::iterator end = mpSamples.end();
957 for (it = mpSamples.begin(); it != end; it++)
959 rSamples.push_back((*it)->GetDirEntry());
960 return (uint)rSamples.size();
963AkaiSample* AkaiVolume::GetSample(uint Index)
967 if (mpSamples.empty())
969 std::list<AkaiDirEntry> dummy;
973 std::list<AkaiSample*>::iterator it;
974 std::list<AkaiSample*>::iterator end = mpSamples.end();
975 for (it = mpSamples.begin(); it != end; it++)
977 if (*it && i == Index)
987AkaiSample* AkaiVolume::GetSample(
const String& rName)
989 if (mpSamples.empty())
991 std::list<AkaiDirEntry> dummy;
995 std::list<AkaiSample*>::iterator it;
996 std::list<AkaiSample*>::iterator end = mpSamples.end();
997 for (it = mpSamples.begin(); it != end; it++)
999 if (*it && rName == (*it)->GetDirEntry().mName)
1008AkaiDirEntry AkaiVolume::GetDirEntry()
1013bool AkaiVolume::IsEmpty()
1015 return ReadDir() == 0;
1027AkaiPartition::~AkaiPartition()
1029 std::list<AkaiVolume*>::iterator it;
1030 std::list<AkaiVolume*>::iterator end = mpVolumes.end();
1031 for (it = mpVolumes.begin(); it != end; it++)
1036uint AkaiPartition::ListVolumes(std::list<AkaiDirEntry>& rVolumes)
1040 if (mpVolumes.empty())
1042 for (i = 0; i < AKAI_MAX_DIR_ENTRIES; i++)
1044 AkaiDirEntry DirEntry;
1045 ReadDirEntry(mpDisk,
this, DirEntry, AKAI_ROOT_ENTRY_OFFSET, i);
1046 DirEntry.mIndex = i;
1047 if (DirEntry.mType == AKAI_TYPE_DIR_S1000 || DirEntry.mType == AKAI_TYPE_DIR_S3000)
1049 AkaiVolume* pVolume =
new AkaiVolume(mpDisk,
this, DirEntry);
1051 if (!pVolume->IsEmpty())
1053 mpVolumes.push_back(pVolume);
1054 rVolumes.push_back(DirEntry);
1063 std::list<AkaiVolume*>::iterator it;
1064 std::list<AkaiVolume*>::iterator end = mpVolumes.end();
1065 for (it = mpVolumes.begin(); it != end; it++)
1067 rVolumes.push_back((*it)->GetDirEntry());
1069 return (uint)rVolumes.size();
1072AkaiVolume* AkaiPartition::GetVolume(uint Index)
1076 if (mpVolumes.empty())
1078 std::list<AkaiDirEntry> dummy;
1082 std::list<AkaiVolume*>::iterator it;
1083 std::list<AkaiVolume*>::iterator end = mpVolumes.end();
1084 for (it = mpVolumes.begin(); it != end; it++)
1086 if (*it && i == Index)
1096AkaiVolume* AkaiPartition::GetVolume(
const String& rName)
1098 if (mpVolumes.empty())
1100 std::list<AkaiDirEntry> dummy;
1104 std::list<AkaiVolume*>::iterator it;
1105 std::list<AkaiVolume*>::iterator end = mpVolumes.end();
1106 for (it = mpVolumes.begin(); it != end; it++)
1108 if (*it && rName == (*it)->GetDirEntry().mName)
1117bool AkaiPartition::IsEmpty()
1119 std::list<AkaiDirEntry> Volumes;
1120 return ListVolumes(Volumes) == 0;
1131AkaiDisk::~AkaiDisk()
1133 std::list<AkaiPartition*>::iterator it;
1134 std::list<AkaiPartition*>::iterator end = mpPartitions.end();
1135 for (it = mpPartitions.begin(); it != end ; it++)
1140uint AkaiDisk::GetPartitionCount()
1142 if (!mpPartitions.empty())
1143 return (uint)mpPartitions.size();
1147 while (size != AKAI_PARTITION_END_MARK && size != 0x0fff && size != 0xffff
1148 && size<30720 && mpPartitions.size()<9)
1151 AkaiPartition* pPartition =
new AkaiPartition(mpDisk,
this);
1152 pPartition->Acquire();
1153 pPartition->SetOffset(offset);
1155 if (!pPartition->IsEmpty())
1157 mpPartitions.push_back(pPartition);
1160 mpDisk->SetPos(offset);
1161 if (!mpDisk->ReadInt16(&size))
1162 return (uint)mpPartitions.size();
1164 offset += AKAI_BLOCK_SIZE * t;
1168 return (uint)mpPartitions.size();
1173 std::list<AkaiPartition*>::iterator it;
1174 std::list<AkaiPartition*>::iterator end = mpPartitions.end();
1176 for (i = 0, it = mpPartitions.begin(); it != end && i != count; i++) it++;
1178 if (i != count || it == end)
1191 pDisk->SetPos(pPartition->GetOffset()+AKAI_FAT_OFFSET + block*2);
1192 pDisk->ReadInt16(&value);
1197bool AkaiDiskElement::ReadDirEntry(
DiskImage* pDisk,
AkaiPartition* pPartition, AkaiDirEntry& rEntry,
int block,
int pos)
1201 if (block == AKAI_ROOT_ENTRY_OFFSET)
1203 pDisk->SetPos(pPartition->GetOffset()+AKAI_DIR_ENTRY_OFFSET + pos * AKAI_DIR_ENTRY_SIZE);
1204 pDisk->
Read(buffer, 12, 1);
1205 AkaiToAscii(buffer, 12);
1206 rEntry.mName = buffer;
1208 pDisk->ReadInt16(&rEntry.mType);
1209 pDisk->ReadInt16(&rEntry.mStart);
1217 pDisk->SetPos(block * AKAI_BLOCK_SIZE + pos * AKAI_FILE_ENTRY_SIZE + pPartition->GetOffset());
1222 temp = ReadFAT(pDisk, pPartition, block);
1223 pDisk->SetPos(pPartition->GetOffset()+temp * AKAI_BLOCK_SIZE + (pos - 341) * AKAI_FILE_ENTRY_SIZE);
1226 pDisk->
Read(buffer, 12, 1);
1227 AkaiToAscii(buffer, 12);
1228 rEntry.mName = buffer;
1231 pDisk->SetPos(4,akai_stream_curpos);
1232 pDisk->
Read(&t1, 1,1);
1237 rEntry.mType = t1 & 0x7f;
1239 pDisk->
Read(&t1, 1,1);
1240 pDisk->
Read(&t2, 1,1);
1241 pDisk->
Read(&t3, 1,1);
1242 rEntry.mSize = (
unsigned char)t1 | ((
unsigned char)t2 <<8) | ((
unsigned char)t3<<16);
1244 pDisk->ReadInt16(&rEntry.mStart,1);
1249void AkaiDiskElement::AkaiToAscii(
char * buffer,
int length)
1253 for (i = 0; i < length; i++)
1255 if (buffer[i]>=0 && buffer[i]<=9)
1257 else if (buffer[i]==10)
1259 else if (buffer[i]>=11 && buffer[i]<=36)
1260 buffer[i] = 64+(buffer[i]-10);
1264 buffer[length] =
'\0';
1265 while (length-- > 0 && buffer[length] == 32)
1269 buffer[length+1] =
'\0';
1283kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
1285 kern_return_t kernResult;
1286 mach_port_t masterPort;
1287 CFMutableDictionaryRef classesToMatch;
1289 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
1290 if ( KERN_SUCCESS != kernResult )
1292 printf(
"IOMasterPort returned %d\n", kernResult );
1295 classesToMatch = IOServiceMatching( kIOCDMediaClass );
1296 if ( classesToMatch == NULL )
1298 printf(
"IOServiceMatching returned a NULL dictionary.\n" );
1302 CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
1305 kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
1306 if ( KERN_SUCCESS != kernResult )
1308 printf(
"IOServiceGetMatchingServices returned %d\n", kernResult );
1314kern_return_t GetBSDPath( io_iterator_t mediaIterator,
char *bsdPath, CFIndex maxPathSize )
1316 io_object_t nextMedia;
1317 kern_return_t kernResult = KERN_FAILURE;
1321 nextMedia = IOIteratorNext( mediaIterator );
1324 CFTypeRef bsdPathAsCFString;
1326 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia,
1327 CFSTR( kIOBSDNameKey ),
1328 kCFAllocatorDefault,
1330 if ( bsdPathAsCFString )
1332 size_t devPathLength;
1334 strcpy( bsdPath, _PATH_DEV );
1335 strcat( bsdPath,
"r" );
1337 devPathLength = strlen( bsdPath );
1339 if ( CFStringGetCString( (__CFString*)bsdPathAsCFString,
1340 bsdPath + devPathLength,
1341 maxPathSize - devPathLength,
1342 kCFStringEncodingASCII ) )
1344 printf(
"BSD path: %s\n", bsdPath );
1345 kernResult = KERN_SUCCESS;
1348 CFRelease( bsdPathAsCFString );
1350 IOObjectRelease( nextMedia );
1364#define MSF_TO_LBA(msf) (((((msf).minute * 60UL) + (msf).second) * 75UL) + (msf).frame - 150)
1372 struct _CDMSF address;
1380 u_char first_session;
1381 u_char last_session;
1382 struct _CDTOC_Desc trackdesc[1];
1385static struct _CDTOC * ReadTOC (
const char * devpath )
1387 struct _CDTOC * toc_p = NULL;
1388 io_iterator_t iterator = 0;
1389 io_registry_entry_t service = 0;
1390 CFDictionaryRef properties = 0;
1392 mach_port_t port = 0;
1394 if (( devname = strrchr( devpath,
'/' )) != NULL )
1400 devname = (
char *) devpath;
1403 if ( IOMasterPort(bootstrap_port, &port ) != KERN_SUCCESS )
1405 printf(
"IOMasterPort failed\n" );
goto Exit ;
1407 if ( IOServiceGetMatchingServices( port, IOBSDNameMatching( port, 0, devname ),
1408 &iterator ) != KERN_SUCCESS )
1410 printf(
"IOServiceGetMatchingServices failed\n" );
goto Exit ;
1414 IOObjectGetClass(iterator,buffer);
1415 printf(
"Service: %s\n",buffer);
1418 IOIteratorReset (iterator);
1419 service = IOIteratorNext( iterator );
1421 IOObjectRelease( iterator );
1424 while ( service && !IOObjectConformsTo( service,
"IOCDMedia" ))
1427 IOObjectGetClass(service,buffer);
1428 printf(
"Service: %s\n",buffer);
1430 if ( IORegistryEntryGetParentIterator( service, kIOServicePlane, &iterator ) != KERN_SUCCESS )
1432 printf(
"IORegistryEntryGetParentIterator failed\n" );
1436 IOObjectRelease( service );
1437 service = IOIteratorNext( iterator );
1438 IOObjectRelease( iterator );
1441 if ( service == NULL )
1443 printf(
"CD media not found\n" );
goto Exit ;
1445 if ( IORegistryEntryCreateCFProperties( service, (__CFDictionary **) &properties,
1446 kCFAllocatorDefault,
1447 kNilOptions ) != KERN_SUCCESS )
1449 printf(
"IORegistryEntryGetParentIterator failed\n" );
goto Exit ;
1452 data = (CFDataRef) CFDictionaryGetValue( properties, CFSTR(
"TOC" ) );
1455 printf(
"CFDictionaryGetValue failed\n" );
goto Exit ;
1463 buflen = CFDataGetLength( data ) + 1;
1464 range = CFRangeMake( 0, buflen );
1465 toc_p = (
struct _CDTOC *) malloc( buflen );
1466 if ( toc_p == NULL )
1468 printf(
"Out of memory\n" );
goto Exit ;
1472 CFDataGetBytes( data, range, (
unsigned char *) toc_p );
1480 CFRelease( properties );
1486 IOObjectRelease( service );
1498 sprintf(buffer,
"%c:\\",
'A'+disk);
1499 mSize = GetFileSize(buffer,NULL);
1501 sprintf(buffer,
"\\\\.\\%c:",
'a'+disk);
1502 mFile = CreateFile(buffer, GENERIC_READ,0,NULL,OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS,NULL);
1506 DISK_GEOMETRY* pdg = &dg;
1507 BOOL res = DeviceIoControl(mFile,
1508 IOCTL_DISK_GET_DRIVE_GEOMETRY,
1516 mSize = dg.BytesPerSector * dg.SectorsPerTrack * dg.TracksPerCylinder * dg.Cylinders.LowPart;
1517 mClusterSize = dg.BytesPerSector;
1519#elif defined(_CARBON_) || defined(__APPLE__)
1520 kern_return_t kernResult;
1521 io_iterator_t mediaIterator;
1522 char bsdPath[ MAXPATHLEN ];
1523 kernResult = FindEjectableCDMedia( &mediaIterator );
1524 kernResult = GetBSDPath( mediaIterator, bsdPath,
sizeof( bsdPath ) );
1525 if ( bsdPath[ 0 ] !=
'\0' )
1527 strcpy(bsdPath,
"/dev/rdisk1s0");
1529 struct _CDTOC * toc = ReadTOC( bsdPath );
1532 size_t toc_entries = ( toc->length - 2 ) /
sizeof (
struct _CDTOC_Desc );
1534 int start_sector = -1;
1535 int data_track = -1;
1540 for (ssize_t i=toc_entries - 1; i>=0; i-- )
1542 if ( start_sector != -1 )
1544 start_sector = MSF_TO_LBA(toc->trackdesc[i].p) - start_sector;
1548 if (( toc->trackdesc[i].ctrl_adr >> 4) != 1 )
1550 if ( toc->trackdesc[i].ctrl_adr & 0x04 )
1552 data_track = toc->trackdesc[i].point;
1553 start_sector = MSF_TO_LBA(toc->trackdesc[i].p);
1558 if ( start_sector == -1 )
1567 mFile = open(bsdPath,O_RDONLY);
1569 printf(
"Error while opening file: %s\n",bsdPath);
1572 printf(
"opened file: %s\n",bsdPath);
1574 mSize = (int) lseek(mFile,1000000000,SEEK_SET);
1575 printf(
"size %d\n",mSize);
1576 lseek(mFile,0,SEEK_SET);
1578 mSize = 700 * 1024 * 1024;
1582 if ( mediaIterator )
1584 IOObjectRelease( mediaIterator );
1587 OpenStream(
"/dev/cdrom");
1591void DiskImage::Init()
1595 mCluster = (uint)-1;
1599 mpCache = (
char*) VirtualAlloc(NULL,mClusterSize,MEM_COMMIT,PAGE_READWRITE);
1605DiskImage::~DiskImage()
1608 if (mFile != INVALID_HANDLE_VALUE)
1612#elif defined _CARBON_ || defined(__APPLE__) || LINUX
1621 VirtualFree(mpCache, 0, MEM_RELEASE);
1622#elif defined(_CARBON_) || defined(__APPLE__) || LINUX
1628akai_stream_state_t DiskImage::GetState()
const
1630 if (!mFile)
return akai_stream_closed;
1631 if (mPos > mSize)
return akai_stream_end_reached;
1632 return akai_stream_ready;
1635int DiskImage::GetPos()
const
1640int DiskImage::SetPos(
int Where, akai_stream_whence_t Whence)
1646 case akai_stream_start:
1651 case akai_stream_curpos:
1654 case akai_stream_end:
1665int DiskImage::Available (uint WordSize)
1667 return (mSize-mPos)/WordSize;
1673 int sizetoread = WordCount * WordSize;
1675 while (sizetoread > 0) {
1676 if (mSize <= mPos)
return readbytes / WordSize;
1677 int requestedCluster = (mRegularFile) ? mPos / mClusterSize
1678 : mPos / mClusterSize + mStartFrame;
1679 if (mCluster != requestedCluster) {
1680 mCluster = requestedCluster;
1682 if (mCluster * mClusterSize != SetFilePointer(mFile, mCluster * mClusterSize, NULL, FILE_BEGIN)) {
1683 printf(
"ERROR: couldn't seek device!\n");
1685 if ((readbytes > 0) && (mEndian != eEndianNative)) {
1687 case 2: bswap_16_s ((uint16*)pData, readbytes);
break;
1688 case 4: bswap_32_s ((uint32*)pData, readbytes);
break;
1689 case 8: bswap_64_s ((uint64*)pData, readbytes);
break;
1693 return readbytes / WordSize;
1696 ReadFile(mFile, mpCache, mClusterSize, &size, NULL);
1697#elif defined(_CARBON_) || defined(__APPLE__) || LINUX
1698 if (mCluster * mClusterSize != lseek(mFile, mCluster * mClusterSize, SEEK_SET))
1699 return readbytes / WordSize;
1701 read(mFile, mpCache, mClusterSize);
1707 int currentReadSize = sizetoread;
1708 int posInCluster = mPos % mClusterSize;
1709 if (currentReadSize > mClusterSize - posInCluster)
1710 currentReadSize = mClusterSize - posInCluster;
1712 memcpy((uint8_t*)pData + readbytes, mpCache + posInCluster, currentReadSize);
1714 mPos += currentReadSize;
1715 readbytes += currentReadSize;
1716 sizetoread -= currentReadSize;
1721 if ((readbytes > 0) && (mEndian != eEndianNative))
1724 case 2: bswap_16_s ((uint16_t*)pData, readbytes);
break;
1725 case 4: bswap_32_s ((uint32_t*)pData, readbytes);
break;
1726 case 8: bswap_64_s ((uint64_t*)pData, readbytes);
break;
1730 return readbytes / WordSize;
1733void DiskImage::ReadInt8(uint8_t* pData, uint WordCount) {
1734 Read(pData, WordCount, 1);
1737void DiskImage::ReadInt16(uint16_t* pData, uint WordCount) {
1739 for (i = 0; i < WordCount; i++) {
1740 *(pData + i) = ReadInt16();
1744void DiskImage::ReadInt32(uint32_t* pData, uint WordCount) {
1746 for (i = 0; i < WordCount; i++) {
1747 *(pData + i) = ReadInt32();
1751int DiskImage::ReadInt8(uint8_t* pData) {
1752 return Read(pData, 1, 1);
1755int DiskImage::ReadInt16(uint16_t* pData) {
1756 int result =
Read(pData, 1, 2);
1758 swapBytes_16(pData);
1763int DiskImage::ReadInt32(uint32_t* pData) {
1764 int result =
Read(pData, 1, 4);
1766 swapBytes_32(pData);
1771uint8_t DiskImage::ReadInt8()
1778uint16_t DiskImage::ReadInt16()
1783 swapBytes_16(&word);
1788uint32_t DiskImage::ReadInt32()
1793 swapBytes_32(&word);
1798void DiskImage::OpenStream(
const char* path) {
1800 mFile = CreateFile(path, GENERIC_READ,0,NULL,OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS,NULL);
1801 BY_HANDLE_FILE_INFORMATION FileInfo;
1802 GetFileInformationByHandle(mFile,&FileInfo);
1803 mSize = FileInfo.nFileSizeLow;
1804#elif defined(_CARBON_) || defined(__APPLE__) || LINUX
1805 struct stat filestat;
1806 stat(path,&filestat);
1807 mFile = open(path, O_RDONLY | O_NONBLOCK);
1809 printf(
"Can't open %s\n", path);
1814 if (S_ISREG(filestat.st_mode)) {
1815 printf(
"Using regular Akai image file.\n");
1816 mRegularFile =
true;
1817 mSize = (int) filestat.st_size;
1818 mClusterSize = DISK_CLUSTER_SIZE;
1819 mpCache = (
char*) malloc(mClusterSize);
1821#if defined(_CARBON_) || defined(__APPLE__)
1822 printf(
"Can't open %s: not a regular file\n", path);
1823#elif HAVE_LINUX_CDROM
1824 mRegularFile =
false;
1825 mClusterSize = CD_FRAMESIZE;
1826 mpCache = (
char*) malloc(mClusterSize);
1828 struct cdrom_tochdr tochdr;
1829 struct cdrom_tocentry tocentry;
1831 if (ioctl(mFile, CDROMREADTOCHDR, (
unsigned long)&tochdr) < 0) {
1832 printf(
"Trying to read TOC of %s failed\n", path);
1837 printf(
"Total tracks: %d\n", tochdr.cdth_trk1);
1840 tocentry.cdte_format = CDROM_LBA;
1842 int firstDataTrack = -1;
1843 int start, end, length;
1846 for (
int t = tochdr.cdth_trk1; t >= 0; t--) {
1847 tocentry.cdte_track = (t == tochdr.cdth_trk1) ? CDROM_LEADOUT : t + 1;
1848 if (ioctl(mFile, CDROMREADTOCENTRY, (
unsigned long)&tocentry) < 0){
1849 printf(
"Failed to read TOC entry for track %d\n", tocentry.cdte_track);
1854 if (tocentry.cdte_track == CDROM_LEADOUT) {
1855 printf(
"Lead Out: Start(LBA)=%d\n", tocentry.cdte_addr.lba);
1858 printf(
"Track %d: Start(LBA)=%d End(LBA)=%d Length(Blocks)=%d ",
1859 tocentry.cdte_track, tocentry.cdte_addr.lba, prev_addr - 1, prev_addr - tocentry.cdte_addr.lba);
1860 if (tocentry.cdte_ctrl & CDROM_DATA_TRACK) {
1861 printf(
"Type: Data\n");
1862 firstDataTrack = tocentry.cdte_track;
1863 start = tocentry.cdte_addr.lba;
1864 end = prev_addr - 1;
1865 length = prev_addr - tocentry.cdte_addr.lba;
1867 else printf(
"Type: Audio\n");
1869 prev_addr = tocentry.cdte_addr.lba;
1872 if (firstDataTrack == -1) {
1873 printf(
"Sorry, no data track found on %s\n", path);
1879 printf(
"Ok, I'll pick track %d\n", firstDataTrack);
1880 mStartFrame = start;
1882 mSize = length * CD_FRAMESIZE;
1884 printf(
"Can't open %s: raw CD-ROM access is not supported on this platform\n", path);
1894#if defined(_CARBON_) || defined(__APPLE__) || LINUX
1895 const uint bufferSize = 524288;
1896 int fOut = open(path, O_WRONLY | O_NONBLOCK | O_CREAT | O_TRUNC,
1897 S_IRUSR | S_IWUSR | S_IRGRP);
1899 printf(
"Can't open output file %s\n", path);
1902 uint8_t* pBuffer =
new uint8_t[bufferSize];
1904 while (Available() > 0) {
1905 int readBytes =
Read(pBuffer,bufferSize,1);
1906 if (readBytes > 0) write(fOut,pBuffer,readBytes);
1915inline void DiskImage::swapBytes_16(
void* Word) {
1917 byteCache = *((uint8_t*) Word);
1918 *((uint8_t*) Word) = *((uint8_t*) Word + 1);
1919 *((uint8_t*) Word + 1) = byteCache;
1922inline void DiskImage::swapBytes_32(
void* Word) {
1924 byteCache = *((uint8_t*) Word);
1925 *((uint8_t*) Word) = *((uint8_t*) Word + 3);
1926 *((uint8_t*) Word + 3) = byteCache;
1927 byteCache = *((uint8_t*) Word + 1);
1928 *((uint8_t*) Word + 1) = *((uint8_t*) Word + 2);
1929 *((uint8_t*) Word + 2) = byteCache;
Toplevel AKAI image interpreter.
Encapsulates one disk partition of an AKAI disk.
AKAI instrument definition.
Subdivision of an AKAI disk partition.
Accessing AKAI image either from file or a drive (i.e.
bool WriteImage(const char *path)
Extract Akai data track and write it into a regular file.
virtual int Read(void *pData, uint WordCount, uint WordSize)
Returns number of successfully read words.
DiskImage(const char *path)
Open an image from a file.