int process_first_packet__flac(StreamInfo *si, ogg_page *op, ogg_packet *opckt)
{
unsigned long serialnoatom[3] = { EndianU32_NtoB(sizeof(serialnoatom)), EndianU32_NtoB(kCookieTypeOggSerialNo),
EndianS32_NtoB(ogg_page_serialno(op)) };
unsigned long atomhead[2] = { EndianU32_NtoB(opckt->bytes + sizeof(atomhead) - 13), EndianU32_NtoB(kCookieTypeFLACStreaminfo) };
UInt32 sib = EndianU32_BtoN(* (UInt32 *) (((char *)opckt->packet) + 27));
si->si_flac.metablocks = (SInt32) EndianU16_BtoN(* (UInt16 *) (((char *)opckt->packet) + 7));
sib >>= 4;
si->si_flac.bps = (sib & 0x1f) + 1;
sib >>= 5;
si->numChannels = (sib & 0x07) + 1;
si->rate = (sib >> 3) & 0xfffff;
//si->lastMediaInserted = 0;
si->mediaLength = 0;
dbg_printf("! -- - flac_first_packet: ch: %d, rate: %ld, bps: %ld\n", si->numChannels, si->rate, si->si_flac.bps);
PtrAndHand(serialnoatom, si->soundDescExtension, sizeof(serialnoatom)); //check errors?
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead)); //check errors?
PtrAndHand((((char *)opckt->packet) + 13), si->soundDescExtension, opckt->bytes - 13); //check errors?
si->si_flac.state = kFStateReadingComments;
return 0;
};
Handle QTDR_MakeResourceDataRef (FSSpecPtr theFile, OSType theResType, SInt16 theResID)
{
Handle myDataRef = NULL;
OSType myResType;
SInt16 myResID;
OSErr myErr = noErr;
myDataRef = QTDR_MakeFileDataRef(theFile);
if (myDataRef == NULL)
goto bail;
// append the resource type and ID to the data reference
myResType = EndianU32_NtoB(theResType);
myResID = EndianS16_NtoB(theResID);
myErr = PtrAndHand(&myResType, myDataRef, sizeof(myResType));
if (myErr == noErr)
myErr = PtrAndHand(&myResID, myDataRef, sizeof(myResID));
bail:
if (myErr != noErr) {
if (myDataRef != NULL)
DisposeHandle(myDataRef);
myDataRef = NULL;
}
return(myDataRef);
}
OSErr QTDR_AddFilenamingExtension (Handle theDataRef, StringPtr theFileName)
{
unsigned char myChar = 0;
OSErr myErr = noErr;
if (theFileName == NULL)
myErr = PtrAndHand(&myChar, theDataRef, sizeof(myChar));
else
myErr = PtrAndHand(theFileName, theDataRef, theFileName[0] + 1);
return(myErr);
}
static int
AddCStringToHandle( // Concatenates C string to handle.
char *theStr,
Handle theHand)
{
return PtrAndHand(theStr, theHand, strlen(theStr));
}
OSErr QTDR_AddMIMETypeDataRefExtension (Handle theDataRef, StringPtr theMIMEType)
{
unsigned long myAtomHeader[2];
OSErr myErr = noErr;
if (theMIMEType == NULL)
return(paramErr);
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + theMIMEType[0] + 1);
myAtomHeader[1] = EndianU32_NtoB(kDataRefExtensionMIMEType);
myErr = PtrAndHand(myAtomHeader, theDataRef, sizeof(myAtomHeader));
if (myErr == noErr)
myErr = PtrAndHand(theMIMEType, theDataRef, theMIMEType[0] + 1);
return(myErr);
}
OSErr QTDR_AddInitDataDataRefExtension (Handle theDataRef, Ptr theInitDataPtr)
{
unsigned long myAtomHeader[2];
OSErr myErr = noErr;
if (theInitDataPtr == NULL)
return(paramErr);
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + GetPtrSize(theInitDataPtr));
myAtomHeader[1] = EndianU32_NtoB(kDataRefExtensionInitializationData);
myErr = PtrAndHand(myAtomHeader, theDataRef, sizeof(myAtomHeader));
if (myErr == noErr)
myErr = PtrAndHand(theInitDataPtr, theDataRef, GetPtrSize(theInitDataPtr));
return(myErr);
}
OSErr QTDR_AddMacOSFileTypeDataRefExtension (Handle theDataRef, OSType theType)
{
unsigned long myAtomHeader[2];
OSType myType;
OSErr myErr = noErr;
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader) + sizeof(theType));
myAtomHeader[1] = EndianU32_NtoB(kDataRefExtensionMacOSFileType);
myType = EndianU32_NtoB(theType);
myErr = PtrAndHand(myAtomHeader, theDataRef, sizeof(myAtomHeader));
if (myErr == noErr)
myErr = PtrAndHand(&myType, theDataRef, sizeof(myType));
return(myErr);
}
OSErr QTDR_CreateTrackInRAM (Movie theMovie)
{
Track myTrack = NULL;
Media myMedia = NULL;
Handle myDataRef = NULL;
unsigned long myAtomHeader[2];
OSErr myErr = noErr;
if (theMovie == NULL)
return(paramErr);
myDataRef = NewHandleClear(sizeof(Handle) + sizeof(char));
if (myDataRef == NULL)
return(MemError());
myAtomHeader[0] = EndianU32_NtoB(sizeof(myAtomHeader));
myAtomHeader[1] = EndianU32_NtoB(kDataRefExtensionInitializationData);
myErr = PtrAndHand(myAtomHeader, myDataRef, sizeof(myAtomHeader));
if (myErr != noErr)
goto bail;
// create the movie track and media
myTrack = NewMovieTrack(theMovie, FixRatio(kVideoTrackWidth, 1), FixRatio(kVideoTrackHeight, 1), kNoVolume);
myErr = GetMoviesError();
if (myErr != noErr)
goto bail;
myMedia = NewTrackMedia(myTrack, VideoMediaType, kVideoTimeScale, myDataRef, HandleDataHandlerSubType);
myErr = GetMoviesError();
if (myErr != noErr)
goto bail;
// create the media samples
myErr = BeginMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
myErr = QTDR_AddVideoSamplesToMedia(myMedia, kVideoTrackWidth, kVideoTrackHeight);
if (myErr != noErr)
goto bail;
myErr = EndMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
// add the media to the track
myErr = InsertMediaIntoTrack(myTrack, 0, 0, GetMediaDuration(myMedia), fixed1);
bail:
if (myDataRef != NULL)
DisposeHandle(myDataRef);
return(myErr);
}
pascal OSErr MoreFEGetCommentCFString(const FSRefPtr pFSRefPtr, CFStringRef* pCommentStr,const AEIdleUPP pIdleProcUPP)
{
AppleEvent tAppleEvent = {typeNull,NULL}; // If you always init AEDescs, it's always safe to dispose of them.
AEDesc tAEDesc = {typeNull,NULL};
OSErr anErr = noErr;
if (NULL == pIdleProcUPP) // the idle proc is required
return paramErr;
anErr = MoreAEOCreateObjSpecifierFromFSRef(pFSRefPtr,&tAEDesc);
if (noErr == anErr)
{
AEBuildError tAEBuildError;
anErr = AEBuildAppleEvent(
kAECoreSuite,kAEGetData,
typeApplSignature,&gFinderSignature,sizeof(OSType),
kAutoGenerateReturnID,kAnyTransactionID,
&tAppleEvent,&tAEBuildError,
"'----':obj {form:prop,want:type(prop),seld:type(comt),from:(@)}",&tAEDesc);
// always dispose of AEDescs when you are finished with them
(void) MoreAEDisposeDesc(&tAEDesc);
if (noErr == anErr)
{
#if 0 // Set this true to printf the Apple Event before you send it.
Handle strHdl;
anErr = AEPrintDescToHandle(&tAppleEvent,&strHdl);
if (noErr == anErr)
{
char nul = '\0';
PtrAndHand(&nul,strHdl,1);
printf("\n-MoreFEGetCommentCFString: tAppleEvent=%s.",*strHdl); fflush(stdout);
DisposeHandle(strHdl);
}
#endif
// Send the event.
anErr = MoreAESendEventReturnAEDesc(pIdleProcUPP,&tAppleEvent,typeUnicodeText,&tAEDesc);
// always dispose of AEDescs when you are finished with them
(void) MoreAEDisposeDesc(&tAppleEvent);
if (noErr == anErr)
{
anErr = MoreAEGetCFStringFromDescriptor(&tAEDesc,pCommentStr);
// always dispose of AEDescs when you are finished with them
(void) MoreAEDisposeDesc(&tAEDesc);
}
}
}
return anErr;
} // end MoreFEGetCommentCFString
int process_first_packet__speex(StreamInfo *si, ogg_page *op, ogg_packet *opckt)
{
unsigned long serialnoatom[3] = { EndianU32_NtoB(sizeof(serialnoatom)), EndianU32_NtoB(kCookieTypeOggSerialNo),
EndianS32_NtoB(ogg_page_serialno(op)) };
unsigned long atomhead[2] = { EndianU32_NtoB(opckt->bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeSpeexHeader) };
SpeexHeader *inheader = (SpeexHeader *) opckt->packet;
si->si_speex.header.bitrate = EndianS32_LtoN(inheader->bitrate);
si->si_speex.header.extra_headers = EndianS32_LtoN(inheader->extra_headers);
si->si_speex.header.frame_size = EndianS32_LtoN(inheader->frame_size);
si->si_speex.header.frames_per_packet = EndianS32_LtoN(inheader->frames_per_packet);
si->si_speex.header.header_size = EndianS32_LtoN(inheader->header_size);
si->si_speex.header.mode = EndianS32_LtoN(inheader->mode);
si->si_speex.header.mode_bitstream_version = EndianS32_LtoN(inheader->mode_bitstream_version);
si->si_speex.header.nb_channels = EndianS32_LtoN(inheader->nb_channels);
si->si_speex.header.rate = EndianS32_LtoN(inheader->rate);
si->si_speex.header.reserved1 = EndianS32_LtoN(inheader->reserved1);
si->si_speex.header.reserved2 = EndianS32_LtoN(inheader->reserved2);
si->si_speex.header.speex_version_id = EndianS32_LtoN(inheader->speex_version_id);
si->si_speex.header.vbr = EndianS32_LtoN(inheader->vbr);
//si->si_speex.header. = EndianS32_LtoN(inheader->);
dbg_printf("! -- - speex_first_packet: ch: %d, rate: %ld\n", si->si_speex.header.nb_channels, si->si_speex.header.rate);
si->numChannels = si->si_speex.header.nb_channels;
si->rate = si->si_speex.header.rate;
//si->lastMediaInserted = 0;
si->mediaLength = 0;
PtrAndHand(serialnoatom, si->soundDescExtension, sizeof(serialnoatom)); //check errors?
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead)); //check errors?
PtrAndHand(opckt->packet, si->soundDescExtension, opckt->bytes); //check errors?
si->si_speex.state = kSStateReadingComments;
return 0;
};
P3(PUBLIC pascal trap, LONGINT, PutScrap, LONGINT, len, ResType, rest, Ptr, p)
{
OSErr retval;
LONGINT l, swappedlen;
INTEGER f;
LONGINT *lp;
if (Cx(ScrapState) < 0) {
retval = ZeroScrap();
if (retval != noErr)
/*-->*/ return(retval);
}
#if defined(X) || defined(NEXTSTEP) || defined (SDL)
PutScrapX(rest, len, (char *) p, CW (ScrapCount));
#endif /* defined(X) */
if (Cx(ScrapState) == 0) {
retval = FSOpen(MR(ScrapName), CW (BootDrive), &f);
if (retval != noErr)
/*-->*/ return(retval);
SetFPos(f, fsFromStart, (LONGINT)Cx(ScrapSize));
l = 4;
rest = CL(rest);
FSWriteAll(f, &l, (Ptr) &rest);
l = 4;
swappedlen = CL(len);
FSWriteAll(f, &l, (Ptr) &swappedlen);
l = len = (len + 1) & -2L;
FSWriteAll(f, &len, p);
FSClose(f);
} else {
SetHandleSize(MR(ScrapHandle), (Size)Cx(ScrapSize) + 8);
if (MemErr != noErr)
/*-->*/ return CW(MemErr);
/* alignment stuff */
lp = (LONGINT *)((char *)STARH(MR(ScrapHandle)) + Cx(ScrapSize));
*lp++ = CL(rest);
*lp++ = CL(len);
len = (len + 1) & -2L;
PtrAndHand(p, MR(ScrapHandle), (Size)len);
}
ScrapSize = CL(CL(ScrapSize) + 8 + len);
return noErr;
}
extern pascal OSStatus InsertSystemMenu(MenuRef theMenu,
SystemMenuCallbackProc callback,
void *refcon)
// See comment in interface part.
{
long oldA4;
OSStatus err;
RootSysMenuEntry newEntry;
oldA4 = SetUpA4();
assert(ValidateSystemMenuRef(theMenu));
assert(callback != NULL);
// If either of these fire, you're too late to call this routine,
// either because system startup is complete or because someone
// has already inserted a system menu.
assert( IsSystemStartup() );
assert( ! gHaveInsertedRootSysMenus );
// Fill out the new entry.
newEntry.theMenu = theMenu;
newEntry.callback = callback;
newEntry.refcon = refcon;
// Add the entry on to the system menu list. Later on, in the
// InsertMenuPatch, we'll add it to the menu bar.
if (theMenu == NULL || callback == NULL) {
err = paramErr;
} else {
err = PtrAndHand(&newEntry, (Handle) gRootSysMenus, sizeof(newEntry));
}
(void) SetA4(oldA4);
return err;
}
OSErr SpriteUtils_AddCompressedImageToKeyFrameSample (QTAtomContainer theKeySample, ImageDescriptionHandle theImageDesc, long theDataSize, Ptr theCompressedDataPtr, QTAtomID theImageID, FixedPoint *theRegistrationPoint, StringPtr theImageName)
{
Handle myImageData = NULL;
QTAtom myDefaultsAtom, myImagesContainerAtom, myImageAtom;
ImageDescriptionHandle myImageDesc = NULL;
OSErr myErr = noErr;
#if TARGET_RT_LITTLE_ENDIAN
myImageDesc = (ImageDescriptionHandle)NewHandle(GetHandleSize((Handle)theImageDesc));
BlockMoveData(*theImageDesc, *myImageDesc, GetHandleSize((Handle)theImageDesc));
EndianUtils_ImageDescription_NtoB(myImageDesc);
#else
myImageDesc = theImageDesc; // already is big endian
#endif
// append compressed picture data to myImageDesc to obtain sprite image data
myImageData = NewHandle(0);
myErr = MemError();
if (myErr != noErr)
goto bail;
myErr = HandAndHand((Handle)myImageDesc, myImageData);
if (myErr != noErr)
goto bail;
myErr = PtrAndHand(theCompressedDataPtr, myImageData, theDataSize);
if (myErr != noErr)
goto bail;
myDefaultsAtom = QTFindChildByIndex(theKeySample, 0, kSpriteSharedDataAtomType, 1, NULL);
if (myDefaultsAtom == 0) {
myErr = QTInsertChild(theKeySample, kParentAtomIsContainer, kSpriteSharedDataAtomType, 1, 0, 0, NULL, &myDefaultsAtom);
if (myErr != noErr)
goto bail;
}
myImagesContainerAtom = QTFindChildByIndex(theKeySample, myDefaultsAtom, kSpriteImagesContainerAtomType, 1, NULL);
if (myImagesContainerAtom == 0) {
myErr = QTInsertChild(theKeySample, myDefaultsAtom, kSpriteImagesContainerAtomType, 1, 0, 0, NULL, &myImagesContainerAtom);
if (myErr != noErr)
goto bail;
}
myErr = QTInsertChild(theKeySample, myImagesContainerAtom, kSpriteImageAtomType, theImageID, 0, 0, NULL, &myImageAtom);
if (myErr != noErr)
goto bail;
HLock(myImageData);
myErr = QTInsertChild(theKeySample, myImageAtom, kSpriteImageDataAtomType, 1, 0, GetHandleSize(myImageData), *myImageData, NULL);
if (myErr != noErr)
goto bail;
HUnlock(myImageData);
if (theRegistrationPoint != NULL) {
FixedPoint myRegistrationPoint;
myRegistrationPoint.x = EndianS32_NtoB(theRegistrationPoint->x);
myRegistrationPoint.y = EndianS32_NtoB(theRegistrationPoint->y);
myErr = QTInsertChild(theKeySample, myImageAtom, kSpriteImageRegistrationAtomType, 1, 0, sizeof(myRegistrationPoint), &myRegistrationPoint, NULL);
if (myErr != noErr)
goto bail;
} else {
FixedPoint myRegistrationPoint = { 0, 0 }; // flipping {0,0} doesn't change anything so we don't flip
myErr = QTInsertChild(theKeySample, myImageAtom, kSpriteImageRegistrationAtomType, 1, 0, sizeof(myRegistrationPoint), &myRegistrationPoint, NULL);
if (myErr != noErr)
goto bail;
}
if (theImageName != NULL) {
myErr = QTInsertChild(theKeySample, myImageAtom, kSpriteImageNameAtomType, 1, 0, theImageName[0], &theImageName[1], NULL);
if (myErr != noErr)
goto bail;
}
bail:
#if TARGET_RT_LITTLE_ENDIAN
if (myImageDesc != NULL)
DisposeHandle((Handle)myImageDesc);
#else
// myImageDesc is still theImageDesc, so don't dispose of it
#endif
if (myImageData != NULL)
DisposeHandle(myImageData);
return(myErr);
}
void DisplayJPEGAndDisposeHandle( Handle imageData )
{
OSErr err;
Rect naturalBounds;
MatrixRecord matrix;
SInt32 gapH, gapV;
Fixed scaleH, scaleV;
Rect boundsRect;
GraphicsImportComponent grip;
Rect windowPortRect;
static char gifSentinel[] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
static char jpegSentinel[] = {0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9};
Ptr sentinel;
Size sentinelSize;
if( !imageData )
{
ofLogNotice() << "NO IMAGE DATA" << endl;
} else {
ofImage image;
//ofPixels pixels();
//pixels = imageData;
//image.setFromPixels((const unsigned char *)imageData);
//string image
//image.saveImage(ofToDataPath(ofGetTimestampString()+".jpg", OF_IMAGE_QUALITY_BEST));
ofLogError() << "WE HAVE DATA!" << endl;
}
return;
again:
ofLogError() << "Again called";
if( 'G' == **imageData ) {
grip = gripG;
// for GIF:
// FF FF FF FF will ensure that the bit parser aborts, since you can't
// have two consecutive all-ones symbols in the LZW codestream --
// you can sometimes have one (say, a 9-bit code), but after consuming
// it the code width increases (so we're now using 10-bit codes)
// and the all-ones code won't be valid for a while yet.
sentinel = gifSentinel;
sentinelSize = sizeof(gifSentinel);
}
else {
grip = gripJ;
// for JPEG:
// FF D9 FF D9 will ensure (a) that the bit-parser aborts, since FF D9
// is an "unstuffed" FF and hence illegal in the entropy-coded datastream,
// and (b) be long enough to stop overreads.
sentinel = jpegSentinel;
sentinelSize = sizeof(jpegSentinel);
}
//•• add sentinel pattern to the end of the handle.
err = PtrAndHand( sentinel, imageData, sentinelSize );
err = GraphicsImportSetDataHandle( grip, imageData );
if( err )
{
ofLogNotice() << "GraphicsImportSetDataHandle Error" << endl;
goto bail;
}
err = GraphicsImportGetNaturalBounds( grip, &naturalBounds );
if( err )
{
ofLogNotice() << "GraphicsImportGetNaturalBounds Error" << endl;
goto bail;
}
//GetPortBounds( GetWindowPort( window ), &windowPortRect );
gapH = windowPortRect.right - naturalBounds.right;
gapV = windowPortRect.bottom - naturalBounds.bottom;
if( gapH >= 0 ) {
gapH = ((UInt16)Random()) % gapH;
scaleH = fixed1;
}
else {
gapH = 0;
scaleH = FixDiv( windowPortRect.right, naturalBounds.right );
}
if( gapV >= 0 ) {
gapV = ((UInt16)Random()) % gapV;
scaleV = fixed1;
}
else {
gapV = 0;
scaleV = FixDiv( windowPortRect.bottom, naturalBounds.bottom );
}
// need to use smaller scale of the two, and then recalc the other gap.
if( scaleH > scaleV ) {
scaleH = scaleV;
gapH = windowPortRect.right - FixMul(scaleH, naturalBounds.right);
gapH = ((UInt16)Random()) % gapH;
} else if( scaleH < scaleV ) {
scaleV = scaleH;
gapV = windowPortRect.bottom - FixMul(scaleV, naturalBounds.bottom);
gapV = ((UInt16)Random()) % gapV;
}
SetIdentityMatrix( &matrix );
ScaleMatrix( &matrix, scaleH, scaleV, 0, 0 );
TranslateMatrix( &matrix, gapH<<16, gapV<<16 );
err = GraphicsImportSetMatrix( grip, &matrix );
if( err ) goto bail;
err = GraphicsImportDraw( grip );
if( err ) goto bail;
err = GraphicsImportGetBoundsRect( grip, &boundsRect );
if( err ) goto bail;
InsetRect( &boundsRect, -1, -1 );
//SetPortWindowPort( window );
FrameRect( &boundsRect );
if( scanForAnotherImageMarker(imageData))
{
ofLogError() << "again: scanForAnotherImageMarker" << endl;
goto again;
}
bail:
DisposeHandle( imageData );
//gDrewJPEG = true;
}
pascal ComponentResult BIMGetScriptLangSupport( Handle inSessionHandle,
ScriptLanguageSupportHandle *outScriptHandle )
{
#pragma unused (inSessionHandle)
OSStatus result;
ScriptLanguageRecord scriptLanguageRecord;
result = noErr;
// Allocate a handle to store our script/language records.
if( *outScriptHandle == NULL ) {
*outScriptHandle = (ScriptLanguageSupportHandle) NewHandle ( sizeof( SInt16 ) );
if( *outScriptHandle == NULL )
result = memFullErr;
}
// Set up the handle so that it is empty.
if( result == noErr ) {
SetHandleSize( (Handle) *outScriptHandle, sizeof( SInt16 ) );
result = MemError();
if( result == noErr )
( **outScriptHandle )->fScriptLanguageCount = 0;
}
// Add a script/language record to tell TSM that we are a type 3 input method (we
// work with Unicode but only send back Unicode characters that are part of some
// Macintosh script encoding). We put our Macintosh script into our 'thng' resource
// component flags (as always), and return kTextEncodingUnicodeDefault from this
// routine.
//
// Input Component ScriptLanguage- xCHR Resource
// Method Description Support ('KCHR' or 'uchr')
// Type componentFlags fScript (chosen from KB Menu)
// ------ -------------- ------------------- ---------------------
// type 1 Mac Script Mac Script (or err) KCHR
// type 2 Mac Script 0x7E KCHR and uchr
// type 3 Mac Script 0x100 uchr
// type 4 0x7E 0x100 uchr (negative ID)
// ------ -------------- ------------------- ---------------------
//
if( result == noErr ) {
scriptLanguageRecord.fScript = kTextEncodingUnicodeDefault;
scriptLanguageRecord.fLanguage = kBIMLanguage;
result = PtrAndHand( &scriptLanguageRecord, (Handle) *outScriptHandle,
sizeof( ScriptLanguageRecord ) );
if( result == noErr )
(**outScriptHandle)->fScriptLanguageCount++;
}
// If an error occurred, dispose of everything.
if( result ){
if( *outScriptHandle ) {
DisposeHandle( (Handle) *outScriptHandle );
*outScriptHandle = NULL;
}
}
return result;
}
ComponentResult process_stream_page__speex(OggImportGlobals *globals, StreamInfo *si, ogg_page *opg)
{
ComponentResult ret = noErr;
int ovret = 0;
Boolean loop = true;
Boolean movie_changed = false;
TimeValue movieTS = GetMovieTimeScale(globals->theMovie);
TimeValue mediaTS = 0;
TimeValue mediaTS_fl = 0.0;
ogg_packet op;
switch(si->si_speex.state) {
case kSStateReadingComments:
case kSStateReadingAdditionalHeaders:
ogg_stream_pagein(&si->os, opg);
break;
default:
break;
}
do {
switch(si->si_speex.state) {
case kSStateReadingComments:
ovret = ogg_stream_packetout(&si->os, &op);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeSpeexComments) };
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
ret = CreateTrackAndMedia(globals, si, opg);
if (ret != noErr) {
dbg_printf("??? -- CreateTrackAndMedia failed?: %ld\n", (long)ret);
}
unpack_vorbis_comments(&si->si_speex.vc, op.packet, op.bytes);
/*err =*/ DecodeCommentsQT(globals, si, &si->si_speex.vc);
//NotifyMovieChanged(globals);
si->si_speex.state = kSStateReadingAdditionalHeaders;
}
break;
case kSStateReadingAdditionalHeaders:
if (si->si_speex.skipped_headers >= si->si_speex.header.extra_headers) {
unsigned long endAtom[2] = { EndianU32_NtoB(sizeof(endAtom)), EndianU32_NtoB(kAudioTerminatorAtomType) };
ret = PtrAndHand(endAtom, si->soundDescExtension, sizeof(endAtom));
if (ret == noErr) {
ret = AddSoundDescriptionExtension((SoundDescriptionHandle) si->sampleDesc,
si->soundDescExtension, siDecompressionParams);
//dbg_printf("??? -- Adding extension: %ld\n", ret);
} else {
//dbg_printf("??? -- Hmm, something went wrong: %ld\n", ret);
}
si->insertTime = 0;
si->streamOffset = globals->currentGroupOffset;
mediaTS = GetMediaTimeScale(si->theMedia);
mediaTS_fl = (Float64) mediaTS;
si->streamOffsetSamples = (TimeValue) (mediaTS_fl * globals->currentGroupOffsetSubSecond) -
((globals->currentGroupOffset % movieTS) * mediaTS / movieTS);
dbg_printf("---/ / streamOffset: [%ld, %ld], %lg\n", si->streamOffset, si->streamOffsetSamples, globals->currentGroupOffsetSubSecond);
si->incompleteCompensation = 0;
si->si_speex.state = kSStateReadingFirstPacket;
loop = false; // ??!
break;
}
ovret = ogg_stream_packetout(&si->os, &op);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
// not much here so far, basically just skip the extra header packet
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeSpeexExtraHeader) };
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
si->si_speex.skipped_headers += 1;
}
break;
case kSStateReadingFirstPacket:
if (ogg_page_pageno(opg) > 2) {
si->lastGranulePos = ogg_page_granulepos(opg);
dbg_printf("----==< skipping: %llx, %lx\n", si->lastGranulePos, ogg_page_pageno(opg));
loop = false;
if (si->lastGranulePos < 0)
si->lastGranulePos = 0;
}
si->si_speex.state = kSStateReadingPackets;
break;
case kVStateReadingPackets:
{
ogg_int64_t pos = ogg_page_granulepos(opg);
int len = opg->header_len + opg->body_len;
TimeValue duration = pos - si->lastGranulePos;
short smp_flags = 0;
if (ogg_page_continued(opg) || si->incompleteCompensation != 0)
smp_flags |= mediaSampleNotSync;
if (duration <= 0) {
duration = INCOMPLETE_PAGE_DURATION;
si->incompleteCompensation -= INCOMPLETE_PAGE_DURATION;
} else if (si->incompleteCompensation != 0) {
duration += si->incompleteCompensation;
si->incompleteCompensation = 0;
if (duration <= 0) {
ret = badFileFormat;
loop = false;
break;
}
}
if (si->insertTime == 0 && si->streamOffsetSamples > 0) {
dbg_printf(" - :++: increasing duration (%ld) by sampleOffset: %ld\n", duration, si->streamOffsetSamples);
duration += si->streamOffsetSamples;
}
ret = _store_sample_reference(si, &globals->dataOffset, len, duration, smp_flags);
if (ret != noErr) {
loop = false;
break;
}
if (!globals->usingIdle) {
if (si->sample_refs_count >= kSSRefsInitial)
ret = _commit_srefs(globals, si, &movie_changed);
}
if (pos != -1)
si->lastGranulePos = pos;
}
loop = false;
break;
default:
loop = false;
}
} while(loop);
if (movie_changed)
NotifyMovieChanged(globals, false);
return ret;
};
extern pascal OSStatus InsertSystemSubMenu(MenuRef rootMenu,
MenuRef parentMenu, UInt16 itemInParent, MenuRef childMenu)
// See comment in interface part.
{
long oldA4;
OSStatus err;
SubSysMenuEntry newEntry;
SInt16 newIDForChildMenu;
oldA4 = SetUpA4();
assert(ValidateSystemMenuRef(rootMenu ));
assert(ValidateSystemMenuRef(parentMenu));
assert(ValidateSystemMenuRef(childMenu ));
assert(gMenuSelectState = kMenuSelectStatePre);
// Validate parameters
err = noErr;
if ((rootMenu == NULL) || (parentMenu == NULL) || (childMenu == NULL)) {
err = paramErr;
}
if (err == noErr && ((itemInParent == 0) || (itemInParent > CountMenuItems(parentMenu)))) {
err = paramErr;
}
// Make sure rootMenu references a current system menu.
// If it does, record the index of the root menu for
// later use by HandleMenuSelect. Also fill out the rest
// of the fields of the sub-menu entry.
if (err == noErr) {
newEntry.rootMenuIndex = FindRootMenuByRef(rootMenu);
newEntry.parentMenu = parentMenu;
newEntry.itemInParent = itemInParent;
newEntry.childMenu = childMenu;
if (newEntry.rootMenuIndex == kRootMenuNotFound) {
err = paramErr;
}
}
// Add newEntry to the sub-menu list, creating the sub-menu list if necessary.
if (err == noErr) {
if (gSubSysMenus == NULL) {
gSubSysMenus = (SubSysMenuHandle) NewHandleSys(0);
err = MemError();
}
}
if (err == noErr) {
err = PtrAndHand(&newEntry, (Handle) gSubSysMenus, sizeof(newEntry));
}
// Finally, insert the menu with a unique ID into the menu bar,
// and set the parent item to reference its ID.
if (err == noErr) {
newIDForChildMenu = FindUniqueSubMenuID();
(**childMenu).menuID = newIDForChildMenu;
InsertMenu(childMenu, hierMenu);
SetItemCmd(parentMenu, itemInParent, hMenuCmd);
SetItemMark(parentMenu, itemInParent, newIDForChildMenu);
// I added this after testing revealed that adding a sub-menu didn't
// force the menu size to be recalculated, so the item text of the
// hierarchical item in the sub-menu was being truncated. This
// only appears to happen on Mac OS 8.5, but the fix is sufficiently
// benign to be employed on all systems.
CalcMenuSize(parentMenu);
}
(void) SetA4(oldA4);
return err;
}
ComponentResult process_stream_page__flac(OggImportGlobals *globals, StreamInfo *si, ogg_page *opg)
{
ComponentResult ret = noErr;
int ovret = 0;
Boolean loop = true;
Boolean movie_changed = false;
TimeValue movieTS = GetMovieTimeScale(globals->theMovie);
TimeValue mediaTS = 0;
TimeValue mediaTS_fl = 0.0;
ogg_packet op;
switch(si->si_flac.state) {
case kFStateReadingComments:
case kFStateReadingAdditionalMDBlocks:
ogg_stream_pagein(&si->os, opg);
break;
default:
break;
}
do {
switch(si->si_flac.state) {
case kFStateReadingComments:
ovret = ogg_stream_packetout(&si->os, &op);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
ret = CreateTrackAndMedia(globals, si, opg);
if (ret != noErr) {
dbg_printf("??? -- CreateTrackAndMedia failed?: %ld\n", (long)ret);
loop = false;
break;
}
if (si->si_flac.metablocks == 0 && (*((unsigned char*) op.packet) == 0xff)) {
si->si_flac.metablocks = si->si_flac.skipped;
si->si_flac.state = kFStateReadingAdditionalMDBlocks;
break;
}
{
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeFLACMetadata) };
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
}
if (((* (char *) op.packet) & 0x7f) == 4) {
dbg_printf("! > - flac_stream_page - mb: %ld, skipped: %ld, h: %02x\n", si->si_flac.metablocks, si->si_flac.skipped,
(*(char *) op.packet) & 0x7f);
unpack_vorbis_comments(&si->si_flac.vc, ((char *) op.packet) + 4, op.bytes - 4);
/*err =*/ DecodeCommentsQT(globals, si, &si->si_flac.vc);
//NotifyMovieChanged(globals);
}
si->si_flac.skipped += 1;
si->si_flac.state = kFStateReadingAdditionalMDBlocks;
}
break;
case kFStateReadingAdditionalMDBlocks:
dbg_printf("! -- - flac_stream_page - mb: %ld, skipped: %ld\n", si->si_flac.metablocks, si->si_flac.skipped);
if (si->si_flac.metablocks > 0 && si->si_flac.skipped >= si->si_flac.metablocks) {
unsigned long endAtom[2] = { EndianU32_NtoB(sizeof(endAtom)), EndianU32_NtoB(kAudioTerminatorAtomType) };
ret = PtrAndHand(endAtom, si->soundDescExtension, sizeof(endAtom));
if (ret == noErr) {
ret = AddSoundDescriptionExtension((SoundDescriptionHandle) si->sampleDesc,
si->soundDescExtension, siDecompressionParams);
//dbg_printf("??? -- Adding extension: %ld\n", ret);
} else {
//dbg_printf("??? -- Hmm, something went wrong: %ld\n", ret);
}
si->insertTime = 0;
si->streamOffset = globals->currentGroupOffset;
mediaTS = GetMediaTimeScale(si->theMedia);
mediaTS_fl = (Float64) mediaTS;
si->streamOffsetSamples = (TimeValue) (mediaTS_fl * globals->currentGroupOffsetSubSecond) -
((globals->currentGroupOffset % movieTS) * mediaTS / movieTS);
dbg_printf("---/ / streamOffset: [%ld, %ld], %lg\n", si->streamOffset, si->streamOffsetSamples, globals->currentGroupOffsetSubSecond);
si->incompleteCompensation = 0;
si->si_flac.state = kFStateReadingFirstPacket;
loop = false; // the audio data is supposed to start on a fresh page
break;
}
ovret = ogg_stream_packetout(&si->os, &op);
dbg_printf("! -- - flac_stream_page - ovret: %d\n", ovret);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
// not much here so far, basically just skip the extra header packet
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeFLACMetadata) };
if (si->si_flac.metablocks == 0 && (* (unsigned char*) op.packet) == 0xff) {
si->si_flac.metablocks = si->si_flac.skipped;
break;
}
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
if (((* (unsigned char *) op.packet) & 0x7f) == 4) {
dbg_printf("! > - flac_stream_page - mb: %ld, skipped: %ld, h: %02x\n", si->si_flac.metablocks, si->si_flac.skipped,
(*(char *) op.packet) & 0x7f);
unpack_vorbis_comments(&si->si_flac.vc, ((char *) op.packet) + 4, op.bytes - 4);
/*err =*/ DecodeCommentsQT(globals, si, &si->si_flac.vc);
//NotifyMovieChanged(globals);
}
si->si_flac.skipped += 1;
}
break;
case kFStateReadingFirstPacket:
// what to do with this one? is it needed at all??
if (ogg_page_pageno(opg) > 2 && false) {
si->lastGranulePos = ogg_page_granulepos(opg);
dbg_printf("----==< skipping: %llx, %lx\n", si->lastGranulePos, ogg_page_pageno(opg));
loop = false;
if (si->lastGranulePos < 0)
si->lastGranulePos = 0;
}
si->si_flac.state = kFStateReadingPackets;
break;
case kFStateReadingPackets:
{
ogg_int64_t pos = ogg_page_granulepos(opg);
int len = opg->header_len + opg->body_len;
TimeValue duration = pos - si->lastGranulePos;
short smp_flags = 0;
if (ogg_page_continued(opg) || si->incompleteCompensation != 0)
smp_flags |= mediaSampleNotSync;
if (duration <= 0) {
duration = INCOMPLETE_PAGE_DURATION;
si->incompleteCompensation -= INCOMPLETE_PAGE_DURATION;
} else if (si->incompleteCompensation != 0) {
duration += si->incompleteCompensation;
si->incompleteCompensation = 0;
if (duration <= 0) {
ret = badFileFormat;
loop = false;
break;
}
}
if (si->insertTime == 0 && si->streamOffsetSamples > 0) {
dbg_printf(" - :++: increasing duration (%ld) by sampleOffset: %ld\n", duration, si->streamOffsetSamples);
duration += si->streamOffsetSamples;
}
ret = _store_sample_reference(si, &globals->dataOffset, len, duration, smp_flags);
if (ret != noErr) {
loop = false;
break;
}
if (!globals->usingIdle) {
#if !defined(XIPHQT_FORCE_SINGLE_SAMPLE_REF)
if (si->sample_refs_count >= si->sample_refs_size)
//if (si->sample_refs_count >= kFSRefsInitial)
#endif
{
ret = _commit_srefs(globals, si, &movie_changed);
}
}
if (pos != -1)
si->lastGranulePos = pos;
}
loop = false;
break;
default:
loop = false;
}
} while(loop);
if (movie_changed)
NotifyMovieChanged(globals, false);
return ret;
};
