LFA_FileRef LFA_Open ( const char * filePath, char mode )
{
if ( (mode != 'r') && (mode != 'w') )
LFA_Throw ( "LFA_Open: invalid mode", kLFAErr_ExternalFailure );;
FSRef fileRef;
SInt8 perm = ( (mode == 'r') ? fsRdPerm : fsRdWrPerm );
HFSUniStr255 dataForkName;
#if __LP64__
FSIORefNum refNum;
#else
SInt16 refNum;
#endif
OSErr err = FSGetDataForkName ( &dataForkName );
if ( err != noErr ) LFA_Throw ( "LFA_Open: FSGetDataForkName failure", kLFAErr_ExternalFailure );
err = FSPathMakeRef ( (XMP_Uns8*)filePath, &fileRef, 0 );
if ( err != noErr ) LFA_Throw ( "LFA_Open: FSPathMakeRef failure", kLFAErr_ExternalFailure );
err = FSOpenFork ( &fileRef, dataForkName.length, dataForkName.unicode, perm, &refNum );
if ( err != noErr ) LFA_Throw ( "LFA_Open: FSOpenFork failure", kLFAErr_ExternalFailure );
return (LFA_FileRef)refNum;
} // LFA_Open
static OSErr FSOpenDFCompat(FSRef *ref, char permission, short *refNum)
{
HFSUniStr255 forkName;
OSErr theErr;
Boolean isFolder, wasChanged;
theErr = FSResolveAliasFile(ref, TRUE, &isFolder, &wasChanged);
if (theErr != noErr)
{
return theErr;
}
FSGetDataForkName(&forkName);
#ifdef PLATFORM_64BIT
theErr = FSOpenFork(ref, forkName.length, forkName.unicode, permission, (FSIORefNum *)refNum);
#else
theErr = FSOpenFork(ref, forkName.length, forkName.unicode, permission, refNum);
#endif
return theErr;
}
SMACsdec::SMACsdec(ComponentInstance inSelf)
:
mSelf(inSelf),
mSourceComponent(NULL),
mDecoder(NULL),
mSourceID(0),
mSourceData(NULL),
mPacketFrameSize(0),
mFloatBuffer(NULL),
mOutputBuffer(NULL)
#if CaptureDataToFile
,mOutputFileRefNum(-1)
#endif
{
memset(&mOutputData, 0, sizeof(SoundComponentData));
mOutputData.format = k16BitNativeEndianFormat;
mOutputData.sampleSize = 16;
#if TARGET_API_MAC_OSX && TARGET_CPU_PPC
mHasAltiVec = SMACSCDUtility::HasAltiVec();
#else
mHasAltiVec = false;
#endif
#if TARGET_API_MAC_OSX
mThreadStateMutex = new CAMutex("SMACsdec::mThreadStateMutex");
#endif
#if CaptureDataToFile
FSRef theFSRef;
FSRef theParentRef;
UniChar theFileName[] = { 'o', 'u', 't', 'p', 'u', 't', '.', 's', 'd', '2' };
OSStatus theError = FSPathMakeRef((const UInt8*)"/Volumes/Annex/Users/moorf/output.sd2", &theFSRef, NULL);
if(theError != fnfErr)
{
FSDeleteObject(&theFSRef);
}
theError = FSPathMakeRef((const UInt8*)"/Volumes/Annex/Users/moorf", &theParentRef, NULL);
theError = FSCreateFileUnicode(&theParentRef, 10, theFileName, kFSCatInfoNone, NULL, &theFSRef, NULL);
theError = FSOpenFork(&theFSRef, 0, NULL, fsRdWrPerm, &mOutputFileRefNum);
if(theError != 0)
{
mOutputFileRefNum = -1;
}
#endif
}
bool
XMLMacCarbonFile::openWithPermission(const XMLCh* const fileName, int macPermission)
{
OSErr err = noErr;
if (mFileValid)
ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, fileName);
if (gHasHFSPlusAPIs)
{
FSRef ref;
if (!XMLParsePathToFSRef(fileName, ref))
err = fnfErr;
HFSUniStr255 forkName;
if (err == noErr)
err = FSGetDataForkName(&forkName);
if (err == noErr)
err = FSOpenFork(&ref, forkName.length, forkName.unicode, macPermission, &mFileRefNum);
}
else
{
FSSpec spec;
if (!XMLParsePathToFSSpec(fileName, spec))
err = fnfErr;
if (err == noErr)
err = FSpOpenDF(&spec, macPermission, &mFileRefNum);
}
if (err != noErr)
ThrowXML1(XMLPlatformUtilsException, XMLExcepts::File_CouldNotOpenFile, fileName);
mFileValid = true;
return mFileValid;
}
prMALError
SDKOpenFile8(
imStdParms *stdParms,
imFileRef *SDKfileRef,
imFileOpenRec8 *SDKfileOpenRec8)
{
prMALError result = malNoError;
ImporterLocalRec8H localRecH = NULL;
ImporterLocalRec8Ptr localRecP = NULL;
if(SDKfileOpenRec8->privatedata)
{
localRecH = (ImporterLocalRec8H)SDKfileOpenRec8->privatedata;
stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(localRecH));
localRecP = reinterpret_cast<ImporterLocalRec8Ptr>( *localRecH );
}
else
{
localRecH = (ImporterLocalRec8H)stdParms->piSuites->memFuncs->newHandle(sizeof(ImporterLocalRec8));
SDKfileOpenRec8->privatedata = (PrivateDataPtr)localRecH;
stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(localRecH));
localRecP = reinterpret_cast<ImporterLocalRec8Ptr>( *localRecH );
localRecP->vf = NULL;
localRecP->opus = NULL;
localRecP->flac = NULL;
localRecP->importerID = SDKfileOpenRec8->inImporterID;
localRecP->fileType = SDKfileOpenRec8->fileinfo.filetype;
}
SDKfileOpenRec8->fileinfo.fileref = *SDKfileRef = reinterpret_cast<imFileRef>(imInvalidHandleValue);
if(localRecP)
{
const prUTF16Char *path = SDKfileOpenRec8->fileinfo.filepath;
#ifdef PRWIN_ENV
HANDLE fileH = CreateFileW(path,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(fileH != imInvalidHandleValue)
{
SDKfileOpenRec8->fileinfo.fileref = *SDKfileRef = fileH;
}
else
result = imFileOpenFailed;
#else
FSIORefNum refNum = CAST_REFNUM(imInvalidHandleValue);
CFStringRef filePathCFSR = CFStringCreateWithCharacters(NULL, path, prUTF16CharLength(path));
CFURLRef filePathURL = CFURLCreateWithFileSystemPath(NULL, filePathCFSR, kCFURLPOSIXPathStyle, false);
if(filePathURL != NULL)
{
FSRef fileRef;
Boolean success = CFURLGetFSRef(filePathURL, &fileRef);
if(success)
{
HFSUniStr255 dataForkName;
FSGetDataForkName(&dataForkName);
OSErr err = FSOpenFork( &fileRef,
dataForkName.length,
dataForkName.unicode,
fsRdWrPerm,
&refNum);
}
CFRelease(filePathURL);
}
CFRelease(filePathCFSR);
if(CAST_FILEREF(refNum) != imInvalidHandleValue)
{
SDKfileOpenRec8->fileinfo.fileref = *SDKfileRef = CAST_FILEREF(refNum);
}
else
result = imFileOpenFailed;
#endif
}
if(result == malNoError)
{
localRecP->fileType = SDKfileOpenRec8->fileinfo.filetype;
assert(0 == ogg_tell_func(static_cast<void *>(*SDKfileRef)));
if(localRecP->fileType == Ogg_filetype)
{
localRecP->vf = new OggVorbis_File;
OggVorbis_File &vf = *localRecP->vf;
int ogg_err = ov_open_callbacks(static_cast<void *>(*SDKfileRef), &vf, NULL, 0, g_ov_callbacks);
if(ogg_err == OV_OK)
{
if( ov_streams(&vf) == 0 )
{
result = imFileHasNoImportableStreams;
ov_clear(&vf);
}
else if( !ov_seekable(&vf) )
{
result = imBadFile;
}
}
else
result = imBadHeader;
}
else if(localRecP->fileType == Opus_filetype)
{
int _error = 0;
localRecP->opus = op_open_callbacks(static_cast<void *>(*SDKfileRef), &g_opusfile_callbacks, NULL, 0, &_error);
if(localRecP->opus != NULL && _error == 0)
{
assert(op_link_count(localRecP->opus) == 1); // we're not really handling multi-link scenarios
}
else
result = imBadHeader;
}
else if(localRecP->fileType == FLAC_filetype)
{
try
{
localRecP->flac = new OurDecoder(*SDKfileRef);
localRecP->flac->set_md5_checking(true);
FLAC__StreamDecoderInitStatus init_status = localRecP->flac->init();
assert(init_status == FLAC__STREAM_DECODER_INIT_STATUS_OK && localRecP->flac->is_valid());
bool ok = localRecP->flac->process_until_end_of_metadata();
assert(ok);
}
catch(...)
{
result = imBadHeader;
}
}
}
// close file and delete private data if we got a bad file
if(result != malNoError)
{
if(SDKfileOpenRec8->privatedata)
{
stdParms->piSuites->memFuncs->disposeHandle(reinterpret_cast<PrMemoryHandle>(SDKfileOpenRec8->privatedata));
SDKfileOpenRec8->privatedata = NULL;
}
}
else
{
stdParms->piSuites->memFuncs->unlockHandle(reinterpret_cast<char**>(SDKfileOpenRec8->privatedata));
}
return result;
}
prMALError
SDKOpenFile8(
imStdParms *stdParms,
imFileRef *SDKfileRef,
imFileOpenRec8 *SDKfileOpenRec8)
{
prMALError result = malNoError;
ImporterLocalRec8H localRecH = NULL;
ImporterLocalRec8Ptr localRecP = NULL;
if(SDKfileOpenRec8->privatedata)
{
localRecH = (ImporterLocalRec8H)SDKfileOpenRec8->privatedata;
stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(localRecH));
localRecP = reinterpret_cast<ImporterLocalRec8Ptr>( *localRecH );
}
else
{
localRecH = (ImporterLocalRec8H)stdParms->piSuites->memFuncs->newHandle(sizeof(ImporterLocalRec8));
SDKfileOpenRec8->privatedata = (PrivateDataPtr)localRecH;
stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(localRecH));
localRecP = reinterpret_cast<ImporterLocalRec8Ptr>( *localRecH );
localRecP->reader = NULL;
localRecP->file = NULL;
localRecP->audio_track = NULL;
localRecP->alac = NULL;
localRecP->importerID = SDKfileOpenRec8->inImporterID;
localRecP->fileType = SDKfileOpenRec8->fileinfo.filetype;
}
SDKfileOpenRec8->fileinfo.fileref = *SDKfileRef = reinterpret_cast<imFileRef>(imInvalidHandleValue);
if(localRecP)
{
const prUTF16Char *path = SDKfileOpenRec8->fileinfo.filepath;
#ifdef PRWIN_ENV
HANDLE fileH = CreateFileW(path,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(fileH != imInvalidHandleValue)
{
SDKfileOpenRec8->fileinfo.fileref = *SDKfileRef = fileH;
}
else
result = imFileOpenFailed;
#else
FSIORefNum refNum = CAST_REFNUM(imInvalidHandleValue);
CFStringRef filePathCFSR = CFStringCreateWithCharacters(NULL, path, prUTF16CharLength(path));
CFURLRef filePathURL = CFURLCreateWithFileSystemPath(NULL, filePathCFSR, kCFURLPOSIXPathStyle, false);
if(filePathURL != NULL)
{
FSRef fileRef;
Boolean success = CFURLGetFSRef(filePathURL, &fileRef);
if(success)
{
HFSUniStr255 dataForkName;
FSGetDataForkName(&dataForkName);
OSErr err = FSOpenFork( &fileRef,
dataForkName.length,
dataForkName.unicode,
fsRdPerm,
&refNum);
}
CFRelease(filePathURL);
}
CFRelease(filePathCFSR);
if(CAST_FILEREF(refNum) != imInvalidHandleValue)
{
SDKfileOpenRec8->fileinfo.fileref = *SDKfileRef = CAST_FILEREF(refNum);
}
else
result = imFileOpenFailed;
#endif
}
if(result == malNoError)
{
localRecP->fileType = SDKfileOpenRec8->fileinfo.filetype;
try
{
localRecP->reader = new My_ByteStream(*SDKfileRef);
localRecP->file = new AP4_File(*localRecP->reader);
AP4_Track *audio_track = localRecP->file->GetMovie()->GetTrack(AP4_Track::TYPE_AUDIO);
if(audio_track != NULL)
{
assert(audio_track->GetSampleDescriptionCount() == 1);
AP4_SampleDescription *desc = audio_track->GetSampleDescription(0);
AP4_AudioSampleDescription *audio_desc = AP4_DYNAMIC_CAST(AP4_AudioSampleDescription, desc);
if(desc != NULL && desc->GetFormat() == AP4_SAMPLE_FORMAT_ALAC)
{
localRecP->audio_track = audio_track;
ALAC_Atom *alac_atom = AP4_DYNAMIC_CAST(ALAC_Atom, desc->GetDetails().GetChild(AP4_SAMPLE_FORMAT_ALAC));
if(alac_atom != NULL)
{
size_t magic_cookie_size = 0;
void *magic_cookie = alac_atom->GetMagicCookie(magic_cookie_size);
if(magic_cookie != NULL && magic_cookie_size > 0)
{
localRecP->alac = new ALACDecoder();
int32_t alac_result = localRecP->alac->Init(magic_cookie, magic_cookie_size);
if(alac_result != 0)
{
result = imBadHeader;
}
}
else
result = imBadHeader;
}
else
result = imBadHeader;
}
else
result = imUnsupportedCompression;
}
else
result = imFileHasNoImportableStreams;
}
catch(...)
{
result = imBadFile;
}
}
// close file and delete private data if we got a bad file
if(result != malNoError)
{
if(SDKfileOpenRec8->privatedata)
{
stdParms->piSuites->memFuncs->disposeHandle(reinterpret_cast<PrMemoryHandle>(SDKfileOpenRec8->privatedata));
SDKfileOpenRec8->privatedata = NULL;
}
}
else
{
stdParms->piSuites->memFuncs->unlockHandle(reinterpret_cast<char**>(SDKfileOpenRec8->privatedata));
}
return result;
}
OSErr SplitFileIfNeeded(FSRef * inFileReference,FSRef * inParentReference,FSCatalogInfo * inFileCatalogInfo,HFSUniStr255 * inFileName)
{
OSErr tErr;
Boolean splitNeeded=FALSE;
SInt16 tForkRefNum;
UInt32 tResourceForkSize=0;
static HFSUniStr255 sResourceForkName={0,{}};
Boolean hasResourceFork=FALSE;
static UInt8 tPOSIXPath[PATH_MAX*2+1];
static UInt32 tPOSIXPathMaxLength=PATH_MAX*2;
struct stat tFileStat;
SInt16 tNewFileRefNum;
if (sResourceForkName.length==0)
{
tErr=FSGetResourceForkName(&sResourceForkName);
if (tErr!=noErr)
{
logerror("An error occurred when obtaining the ResourceFork name\n");
return -1;
}
}
// 1. Check for the presence of a resource fork
tErr=FSOpenFork(inFileReference,sResourceForkName.length,sResourceForkName.unicode,fsRdPerm,&tForkRefNum);
if (tErr==noErr)
{
SInt64 tForkSize;
// Get the size of the resource fork
tErr=FSGetForkSize(tForkRefNum,&tForkSize);
if (tErr!=noErr)
{
logerror("An error occurred on getting the resource fork size of a file or director\n");
FSCloseFork(tForkRefNum);
return -1;
}
if (tForkSize>0xFFFFFFFF)
{
FSCloseFork(tForkRefNum);
// AppleDouble File format does not support forks bigger than 2GB
logerror("AppleDouble file format does not support forks bigger than 2 GB\n");
return -1;
}
tResourceForkSize=tForkSize;
if (tForkSize>0)
{
hasResourceFork=TRUE;
splitNeeded=TRUE;
}
else
{
FSCloseFork(tForkRefNum);
}
}
else
{
switch(tErr)
{
case errFSForkNotFound:
case eofErr:
// No resource Fork
tErr=noErr;
break;
default:
logerror("Unable to open fork\n");
return -1;
break;
}
}
// 2. Check for the presence of FinderInfo or ExtFinderInfo
if (splitNeeded==FALSE)
{
UInt32 * tUnsignedInt32Ptr;
int i;
// 1. We need to save the Folder(Ext) Info in the ._ file if there are any folder/finder or extend folder/finder info
tUnsignedInt32Ptr= (UInt32 *) inFileCatalogInfo->finderInfo;
for(i=0;i<4;i++)
{
if (tUnsignedInt32Ptr[i]!=0)
{
// We need to create a ._file
splitNeeded=TRUE;
break;
}
}
if (splitNeeded==TRUE) // 01/02/07: Symbolic link looks like this
{
UInt32 tSymbolicLink;
tSymbolicLink='s';
tSymbolicLink='l'+(tSymbolicLink<<8);
tSymbolicLink='n'+(tSymbolicLink<<8);
tSymbolicLink='k'+(tSymbolicLink<<8);
if (tUnsignedInt32Ptr[0]==tSymbolicLink)
{
splitNeeded=FALSE;
}
}
else
{
tUnsignedInt32Ptr= (UInt32 *) inFileCatalogInfo->extFinderInfo;
for(i=0;i<4;i++)
{
if (tUnsignedInt32Ptr[i]!=0)
{
// We need to create a ._file
splitNeeded=TRUE;
break;
}
}
}
}
// 3. Split if needed
if (splitNeeded==TRUE)
{
FSRef tNewFileReference;
HFSUniStr255 tNewFileName;
// Get the absolute Posix Path Name
tErr=FSRefMakePath(inFileReference,tPOSIXPath,tPOSIXPathMaxLength);
if (tErr==noErr)
{
if (lstat((char *) tPOSIXPath,&tFileStat)==-1)
{
switch(errno)
{
case ENOENT:
// A COMPLETER
break;
default:
// A COMPLETER
break;
}
tErr=-1;
goto byebye;
}
}
else
{
logerror("An error occurred when trying to get the absolute path of a file or directory\n");
tErr=-1;
goto byebye;
}
if (gVerboseMode==TRUE)
{
printf(" splitting %s...\n",tPOSIXPath);
}
// Check that we do not explode the current limit for file names
if (inFileName->length>gMaxFileNameLength)
{
// We do not have enough space to add the ._ prefix
// The file name is too long
// Write the error
logerror("File name is too long. The maximum length allowed is %ld characters\n",gMaxFileNameLength+2);
return -1;
}
tNewFileName.length=inFileName->length+2;
tNewFileName.unicode[0]='.';
tNewFileName.unicode[1]='_';
BlockMoveData(inFileName->unicode,tNewFileName.unicode+2,inFileName->length*sizeof(UniChar));
// We need to create a ._file
tryagain:
tErr=FSCreateFileUnicode(inParentReference,tNewFileName.length,tNewFileName.unicode,0,NULL,&tNewFileReference,NULL);
if (tErr!=noErr)
{
switch(tErr)
{
case bdNamErr:
case fsmBadFFSNameErr:
case errFSNameTooLong:
// The file name is too long
// Write the error
logerror("File name is too long. The maximum length allowed is %ld characters\n",gMaxFileNameLength+2);
break;
case dskFulErr:
logerror("Disk is full\n");
break;
case errFSQuotaExceeded:
logerror("Your quota are exceeded\n");
break;
case dupFNErr:
// The file already exists, we need to try to delete it before recreating it
tErr=FSMakeFSRefUnicode(inParentReference,tNewFileName.length,tNewFileName.unicode,kTextEncodingDefaultFormat,&tNewFileReference);
if (tErr==noErr)
{
// Delete the current ._file
tErr=FSDeleteObject(&tNewFileReference);
if (tErr==noErr)
{
goto tryagain;
}
else
{
// A COMPLETER
}
}
else
{
// A COMPLETER
}
break;
case afpVolLocked:
// A COMPLETER
break;
default:
// A COMPLETER
break;
}
return -1;
}
tErr=FSOpenFork(&tNewFileReference,0,NULL,fsWrPerm,&tNewFileRefNum);
if (tErr==noErr)
{
unsigned char tAppleDoubleMagicNumber[4]= {0x00,0x05,0x16,0x07};
unsigned char tAppleDoubleVersionNumber[4]={0x00,0x02,0x00,0x00};
unsigned char tAppleDoubleFiller[16]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
ByteCount tRequestCount;
UInt16 tNumberOfEntries;
UInt16 tSwappedNumberOfEntries;
UInt32 tEntryID;
UInt32 tEntryOffset;
UInt32 tEntryLength;
// Write the Magic Number
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,tAppleDoubleMagicNumber,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Version Number
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,tAppleDoubleVersionNumber,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Filler
tRequestCount=16;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,tAppleDoubleFiller,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Compute the Number of Entries
tNumberOfEntries=0x0002;
tSwappedNumberOfEntries=tNumberOfEntries;
#ifdef __LITTLE_ENDIAN__
// Swap for Intel processor
tSwappedNumberOfEntries=CFSwapInt16(tSwappedNumberOfEntries);
#endif
tRequestCount=2;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tSwappedNumberOfEntries,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Entries Descriptor
// **** Finder Info
tEntryID=0x00000009; // Finder Info ID
tEntryOffset=0x0000001A+tNumberOfEntries*12;
tEntryLength=0x00000020; // 32 bytes
#ifdef __LITTLE_ENDIAN__
// Swap for Intel processor
tEntryID=CFSwapInt32(tEntryID);
tEntryOffset=CFSwapInt32(tEntryOffset);
tEntryLength=CFSwapInt32(tEntryLength);
#endif
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryID,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryOffset,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryLength,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tEntryID=0x00000002; // Resource Fork ID
tEntryOffset=0x00000052;
if (hasResourceFork==TRUE)
{
// **** Finder Info
tEntryLength=tResourceForkSize; // As you can see the AppleDouble format file is not ready for forks bigger than 2 GB
}
else
{
tEntryLength=0;
}
#ifdef __LITTLE_ENDIAN__
// Swap for Intel processor
tEntryID=CFSwapInt32(tEntryID);
tEntryOffset=CFSwapInt32(tEntryOffset);
tEntryLength=CFSwapInt32(tEntryLength);
#endif
tRequestCount=4;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryID,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryOffset,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,&tEntryLength,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// Write the Entries
// **** Write Finder Info
#ifdef __LITTLE_ENDIAN__
// Intel Processors
// Even though it's referenced as a bytes field in the File API, this is actually a structure we need to swap...
if (inFileCatalogInfo->nodeFlags & kFSNodeIsDirectoryMask)
{
// It's a fragging folder
FolderInfo * tFolderInfoStruct;
ExtendedFolderInfo * tExtendedFolderInfoStruct;
// Swap FolderInfo Structure
tFolderInfoStruct=(FolderInfo *) inFileCatalogInfo->finderInfo;
SWAP_RECT(tFolderInfoStruct->windowBounds);
tFolderInfoStruct->finderFlags=CFSwapInt16(tFolderInfoStruct->finderFlags);
SWAP_POINT(tFolderInfoStruct->location);
tFolderInfoStruct->reservedField=CFSwapInt16(tFolderInfoStruct->reservedField);
// Swap ExtendedFolderInfo Info Structure
tExtendedFolderInfoStruct=(ExtendedFolderInfo *) inFileCatalogInfo->extFinderInfo;
SWAP_POINT(tExtendedFolderInfoStruct->scrollPosition);
tExtendedFolderInfoStruct->reserved1=CFSwapInt32(tExtendedFolderInfoStruct->reserved1);
tExtendedFolderInfoStruct->extendedFinderFlags=CFSwapInt16(tExtendedFolderInfoStruct->extendedFinderFlags);
tExtendedFolderInfoStruct->reserved2=CFSwapInt16(tExtendedFolderInfoStruct->reserved2);
tExtendedFolderInfoStruct->putAwayFolderID=CFSwapInt32(tExtendedFolderInfoStruct->putAwayFolderID);
}
else
{
// I'm just a file, you know
FileInfo * tFileInfoStruct;
ExtendedFileInfo * tExtendedFileInfoStruct;
// Swap FileInfo Structure
tFileInfoStruct=(FileInfo *) inFileCatalogInfo->finderInfo;
tFileInfoStruct->fileType=CFSwapInt32(tFileInfoStruct->fileType);
tFileInfoStruct->fileCreator=CFSwapInt32(tFileInfoStruct->fileCreator);
tFileInfoStruct->finderFlags=CFSwapInt16(tFileInfoStruct->finderFlags);
SWAP_POINT(tFileInfoStruct->location);
tFileInfoStruct->reservedField=CFSwapInt16(tFileInfoStruct->reservedField);
// Swap ExtendedFileInfo Structure
tExtendedFileInfoStruct=(ExtendedFileInfo *) inFileCatalogInfo->extFinderInfo;
tExtendedFileInfoStruct->reserved1[0]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[0]);
tExtendedFileInfoStruct->reserved1[1]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[1]);
tExtendedFileInfoStruct->reserved1[2]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[2]);
tExtendedFileInfoStruct->reserved1[3]=CFSwapInt16(tExtendedFileInfoStruct->reserved1[3]);
tExtendedFileInfoStruct->extendedFinderFlags=CFSwapInt16(tExtendedFileInfoStruct->extendedFinderFlags);
tExtendedFileInfoStruct->reserved2=CFSwapInt16(tExtendedFileInfoStruct->reserved2);
tExtendedFileInfoStruct->putAwayFolderID=CFSwapInt32(tExtendedFileInfoStruct->putAwayFolderID);
}
#endif
tRequestCount=16;
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,inFileCatalogInfo->finderInfo,NULL);
if (tErr!=noErr)
{
goto writebail;
}
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tRequestCount,inFileCatalogInfo->extFinderInfo,NULL);
if (tErr!=noErr)
{
goto writebail;
}
// **** Write Resource Fork?
if (hasResourceFork==TRUE)
{
// We need to be clever and copy the Resource Fork by chunks to avoid using too much memory
static UInt8 * tBuffer=NULL;
static ByteCount tReadRequestCount=0;
ByteCount tReadActualCount;
OSErr tReadErr;
#define GOLDIN_BUFFER_ONE_MEGABYTE_SIZE 1048576
if (tBuffer==NULL)
{
tReadRequestCount=GOLDIN_BUFFER_ONE_MEGABYTE_SIZE;
do
{
tBuffer=(UInt8 *) malloc(tReadRequestCount*sizeof(UInt8));
tReadRequestCount/=2;
}
while (tBuffer==NULL && tReadRequestCount>1);
if (tBuffer!=NULL && tReadRequestCount>1)
{
tReadRequestCount*=2;
}
else
{
// A COMPLETER
}
}
do
{
tReadErr=FSReadFork(tForkRefNum, fsAtMark,0, tReadRequestCount, tBuffer, &tReadActualCount);
if (tReadErr==noErr || tReadErr==eofErr)
{
tErr=FSWriteFork(tNewFileRefNum,fsAtMark,0,tReadActualCount,tBuffer,NULL);
if (tErr!=noErr)
{
break;
}
}
else
{
break;
}
}
while (tReadErr!=eofErr);
if (tReadErr!=eofErr)
{
// A problem occurred while reading the Resource Fork
goto writebail;
}
else
if (tErr!=noErr)
{
// A problem occurred while writing the Resource Fork Data to the AppleDouble file
goto writebail;
}
}
tErr=FSCloseFork(tNewFileRefNum);
tErr=noErr;
// Set the owner
tErr=FSSetCatalogInfo(&tNewFileReference,kFSCatInfoPermissions,inFileCatalogInfo);
if (tErr!=noErr)
{
//logerror("Permissions, owner and group could not be set for the AppleDouble file of %s\n",tPOSIXPath);
tErr=-1;
goto byebye;
}
}
else
{
// A COMPLETER
}
// Close the Resource Fork if needed
if (hasResourceFork==TRUE)
{
tErr=FSCloseFork(tForkRefNum);
if (gStripResourceForks==TRUE && tErr==noErr)
{
// Strip the resource fork
tErr=FSDeleteFork(inFileReference,sResourceForkName.length,sResourceForkName.unicode);
if (tErr!=noErr)
{
switch(tErr)
{
case errFSForkNotFound:
// This is not important
tErr=noErr;
break;
default:
// A COMPLETER
break;
}
}
}
else
{
if (gStripResourceForks==TRUE && tErr!=noErr)
{
logerror("Resource Fork could not be stripped from %s\n",tPOSIXPath);
// A COMPLETER
}
}
}
}
return tErr;
writebail:
switch(tErr)
{
case dskFulErr:
logerror("Disk is full\n");
break;
case errFSQuotaExceeded:
logerror("Your quota are exceeded\n");
break;
default:
logerror("An unknown error occurred while writing the AppleDouble file of %s\n",tPOSIXPath);
break;
}
FSCloseFork(tNewFileRefNum);
byebye:
if (hasResourceFork==TRUE)
{
FSCloseFork(tForkRefNum);
}
return tErr;
}
static int AudioFilePlayer_OpenFile (AudioFilePlayer *afp, const FSRef *inRef, SInt64 *outFileDataSize)
{
ContainerChunk chunkHeader;
ChunkHeader chunk;
SSNDData ssndData;
OSErr result;
HFSUniStr255 dfName;
ByteCount actual;
SInt64 offset;
/* Open the data fork of the input file */
result = FSGetDataForkName(&dfName);
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSGetDataForkName")*/
result = FSOpenFork(inRef, dfName.length, dfName.unicode, fsRdPerm, &afp->mForkRefNum);
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSOpenFork")*/
/* Read the file header, and check if it's indeed an AIFC file */
result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(chunkHeader), &chunkHeader, &actual);
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/
if (SDL_SwapBE32(chunkHeader.ckID) != 'FORM') {
result = -1;
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): chunk id is not 'FORM'");*/
}
if (SDL_SwapBE32(chunkHeader.formType) != 'AIFC') {
result = -1;
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): file format is not 'AIFC'");*/
}
/* Search for the SSND chunk. We ignore all compression etc. information
in other chunks. Of course that is kind of evil, but for now we are lazy
and rely on the cdfs to always give us the same fixed format.
TODO: Parse the COMM chunk we currently skip to fill in mFileDescription.
*/
offset = 0;
do {
result = FSReadFork(afp->mForkRefNum, fsFromMark, offset, sizeof(chunk), &chunk, &actual);
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/
chunk.ckID = SDL_SwapBE32(chunk.ckID);
chunk.ckSize = SDL_SwapBE32(chunk.ckSize);
/* Skip the chunk data */
offset = chunk.ckSize;
} while (chunk.ckID != 'SSND');
/* Read the header of the SSND chunk. After this, we are positioned right
at the start of the audio data. */
result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(ssndData), &ssndData, &actual);
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/
ssndData.offset = SDL_SwapBE32(ssndData.offset);
result = FSSetForkPosition(afp->mForkRefNum, fsFromMark, ssndData.offset);
if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSSetForkPosition")*/
/* Data size */
*outFileDataSize = chunk.ckSize - ssndData.offset - 8;
/* File format */
afp->mFileDescription.mSampleRate = 44100;
afp->mFileDescription.mFormatID = kAudioFormatLinearPCM;
afp->mFileDescription.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger;
afp->mFileDescription.mBytesPerPacket = 4;
afp->mFileDescription.mFramesPerPacket = 1;
afp->mFileDescription.mBytesPerFrame = 4;
afp->mFileDescription.mChannelsPerFrame = 2;
afp->mFileDescription.mBitsPerChannel = 16;
return 1;
}
static PyObject *
MacOS_WMAvailable(PyObject *self, PyObject *args)
{
static PyObject *rv = NULL;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if (!rv) {
ProcessSerialNumber psn;
/*
** This is a fairly innocuous call to make if we don't have a window
** manager, or if we have no permission to talk to it. It will print
** a message on stderr, but at least it won't abort the process.
** It appears the function caches the result itself, and it's cheap, so
** no need for us to cache.
*/
#ifdef kCGNullDirectDisplay
/* On 10.1 CGMainDisplayID() isn't available, and
** kCGNullDirectDisplay isn't defined.
*/
if (CGMainDisplayID() == 0) {
rv = Py_False;
} else {
#else
{
#endif
if (GetCurrentProcess(&psn) < 0 ||
SetFrontProcess(&psn) < 0) {
rv = Py_False;
} else {
rv = Py_True;
}
}
}
Py_INCREF(rv);
return rv;
}
static char GetTicks_doc[] = "Return number of ticks since bootup";
static PyObject *
MacOS_GetTicks(PyObject *self, PyObject *args)
{
return Py_BuildValue("i", (int)TickCount());
}
static char openrf_doc[] = "Open resource fork of a file";
static PyObject *
MacOS_openrf(PyObject *self, PyObject *args)
{
OSErr err;
char *mode = "r";
FSRef ref;
SInt8 permission = fsRdPerm;
rfobject *fp;
HFSUniStr255 name;
if (!PyArg_ParseTuple(args, "O&|s", PyMac_GetFSRef, &ref, &mode))
return NULL;
while (*mode) {
switch (*mode++) {
case '*': break;
case 'r': permission = fsRdPerm; break;
case 'w': permission = fsWrPerm; break;
case 'b': break;
default:
PyErr_BadArgument();
return NULL;
}
}
err = FSGetResourceForkName(&name);
if (err != noErr) {
PyMac_Error(err);
return NULL;
}
if ( (fp = newrfobject()) == NULL )
return NULL;
err = FSOpenFork(&ref, name.length, name.unicode, permission, &fp->fRefNum);
if (err != noErr) {
Py_DECREF(fp);
PyMac_Error(err);
return NULL;
}
fp->isclosed = 0;
return (PyObject *)fp;
}
int ReadTOCData (FSVolumeRefNum theVolume, SDL_CD *theCD)
{
HFSUniStr255 dataForkName;
OSStatus theErr;
FSIORefNum forkRefNum;
SInt64 forkSize;
Ptr forkData = 0;
ByteCount actualRead;
CFDataRef dataRef = 0;
CFPropertyListRef propertyListRef = 0;
FSRefParam fsRefPB;
FSRef tocPlistFSRef;
FSRef rootRef;
const char* error = "Unspecified Error";
const UniChar uniName[] = { '.','T','O','C','.','p','l','i','s','t' };
theErr = FSGetVolumeInfo(theVolume, 0, 0, kFSVolInfoNone, 0, 0, &rootRef);
if(theErr != noErr) {
error = "FSGetVolumeInfo";
goto bail;
}
SDL_memset(&fsRefPB, '\0', sizeof (fsRefPB));
fsRefPB.ref = &rootRef;
fsRefPB.newRef = &tocPlistFSRef;
fsRefPB.nameLength = sizeof (uniName) / sizeof (uniName[0]);
fsRefPB.name = uniName;
fsRefPB.textEncodingHint = kTextEncodingUnknown;
theErr = PBMakeFSRefUnicodeSync (&fsRefPB);
if(theErr != noErr) {
error = "PBMakeFSRefUnicodeSync";
goto bail;
}
theErr = FSGetDataForkName (&dataForkName);
if (theErr != noErr) {
error = "FSGetDataForkName";
goto bail;
}
theErr = FSOpenFork (&tocPlistFSRef, dataForkName.length, dataForkName.unicode, fsRdPerm, &forkRefNum);
if (theErr != noErr) {
error = "FSOpenFork";
goto bail;
}
theErr = FSGetForkSize (forkRefNum, &forkSize);
if (theErr != noErr) {
error = "FSGetForkSize";
goto bail;
}
forkData = NewPtr (forkSize);
if(forkData == NULL) {
error = "NewPtr";
goto bail;
}
theErr = FSReadFork (forkRefNum, fsFromStart, 0 , forkSize, forkData, &actualRead);
if(theErr != noErr) {
error = "FSReadFork";
goto bail;
}
dataRef = CFDataCreate (kCFAllocatorDefault, (UInt8 *)forkData, forkSize);
if(dataRef == 0) {
error = "CFDataCreate";
goto bail;
}
propertyListRef = CFPropertyListCreateFromXMLData (kCFAllocatorDefault,
dataRef,
kCFPropertyListImmutable,
NULL);
if (propertyListRef == NULL) {
error = "CFPropertyListCreateFromXMLData";
goto bail;
}
if(CFGetTypeID(propertyListRef)== CFDictionaryGetTypeID())
{
CFDictionaryRef dictRef = (CFDictionaryRef)propertyListRef;
CFDataRef theRawTOCDataRef;
CFArrayRef theSessionArrayRef;
CFIndex numSessions;
CFIndex index;
theRawTOCDataRef = (CFDataRef)CFDictionaryGetValue (dictRef, CFSTR(kRawTOCDataString));
theSessionArrayRef = (CFArrayRef)CFDictionaryGetValue (dictRef, CFSTR(kSessionsString));
numSessions = CFArrayGetCount (theSessionArrayRef);
theCD->numtracks = 0;
for(index = 0; index < numSessions; index++)
{
CFDictionaryRef theSessionDict;
CFNumberRef leadoutBlock;
CFArrayRef trackArray;
CFIndex numTracks;
CFIndex trackIndex;
UInt32 value = 0;
theSessionDict = (CFDictionaryRef) CFArrayGetValueAtIndex (theSessionArrayRef, index);
leadoutBlock = (CFNumberRef) CFDictionaryGetValue (theSessionDict, CFSTR(kLeadoutBlockString));
trackArray = (CFArrayRef)CFDictionaryGetValue (theSessionDict, CFSTR(kTrackArrayString));
numTracks = CFArrayGetCount (trackArray);
for(trackIndex = 0; trackIndex < numTracks; trackIndex++) {
CFDictionaryRef theTrackDict;
CFNumberRef trackNumber;
CFNumberRef sessionNumber;
CFNumberRef startBlock;
CFBooleanRef isDataTrack;
UInt32 value;
theTrackDict = (CFDictionaryRef) CFArrayGetValueAtIndex (trackArray, trackIndex);
trackNumber = (CFNumberRef) CFDictionaryGetValue (theTrackDict, CFSTR(kPointKeyString));
sessionNumber = (CFNumberRef) CFDictionaryGetValue (theTrackDict, CFSTR(kSessionNumberKeyString));
startBlock = (CFNumberRef) CFDictionaryGetValue (theTrackDict, CFSTR(kStartBlockKeyString));
isDataTrack = (CFBooleanRef) CFDictionaryGetValue (theTrackDict, CFSTR(kDataKeyString));
int idx = theCD->numtracks++;
CFNumberGetValue (trackNumber, kCFNumberSInt32Type, &value);
theCD->track[idx].id = value;
CFNumberGetValue (startBlock, kCFNumberSInt32Type, &value);
theCD->track[idx].offset = value;
theCD->track[idx].type = (isDataTrack == kCFBooleanTrue) ? SDL_DATA_TRACK : SDL_AUDIO_TRACK;
if (trackIndex > 0) {
theCD->track[idx-1].length = theCD->track[idx].offset - theCD->track[idx-1].offset;
}
}
CFNumberGetValue (leadoutBlock, kCFNumberSInt32Type, &value);
theCD->track[theCD->numtracks-1].length =
value - theCD->track[theCD->numtracks-1].offset;
theCD->track[theCD->numtracks].offset = value;
}
}
theErr = 0;
goto cleanup;
bail:
SDL_SetError ("ReadTOCData: %s returned %d", error, theErr);
theErr = -1;
cleanup:
if (propertyListRef != NULL)
CFRelease(propertyListRef);
if (dataRef != NULL)
CFRelease(dataRef);
if (forkData != NULL)
DisposePtr(forkData);
FSCloseFork (forkRefNum);
return theErr;
}
