QList<QByteArray> QMacPasteboardMimePict::convertFromMime(const QString &mime, QVariant variant,
QString flav)
{
QList<QByteArray> ret;
if (!resolveMimeQuickTimeSymbols())
return ret;
if (!canConvert(mime, flav))
return ret;
QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(qvariant_cast<QImage>(variant));
Handle pic = NewHandle(0);
GraphicsExportComponent graphicsExporter;
ComponentResult result = OpenADefaultComponent(GraphicsExporterComponentType,
kQTFileTypePicture, &graphicsExporter);
if (!result) {
unsigned long sizeWritten;
result = ptrGraphicsExportSetInputCGImage(graphicsExporter, cgimage);
if (!result)
result = ptrGraphicsExportSetOutputHandle(graphicsExporter, pic);
if (!result)
result = ptrGraphicsExportDoExport(graphicsExporter, &sizeWritten);
CloseComponent(graphicsExporter);
}
int size = GetHandleSize((Handle)pic);
// Skip the Picture File header (512 bytes) and feed the raw data
QByteArray ar(reinterpret_cast<char *>(*pic + 512), size - 512);
ret.append(ar);
DisposeHandle(pic);
return ret;
}
// Component Open Request - Required
pascal ComponentResult ExampleIPB_DOpen(ExampleIPBDecompressorGlobals glob, ComponentInstance self)
{
ComponentResult err;
// Allocate memory for our globals, set them up and inform the component manager that we've done so
glob = calloc( sizeof( ExampleIPBDecompressorGlobalsRecord ), 1 );
if( ! glob ) {
err = memFullErr;
goto bail;
}
SetComponentInstanceStorage(self, (Handle)glob);
glob->self = self;
glob->target = self;
// Open and target an instance of the base decompressor as we delegate
// most of our calls to the base decompressor instance
err = OpenADefaultComponent(decompressorComponentType, kBaseCodecType, &glob->delegateComponent);
if( err )
goto bail;
ComponentSetTarget(glob->delegateComponent, self);
bail:
return err;
}
// Component Open Request - Required
pascal ComponentResult TextSubCodecOpen(TextSubGlobals glob, ComponentInstance self)
{
ComponentResult err;
// Allocate memory for our globals, set them up and inform the component manager that we've done so
glob = (TextSubGlobals)NewPtrClear(sizeof(TextSubGlobalsRecord));
if (err = MemError()) goto bail;
SetComponentInstanceStorage(self, (Handle)glob);
glob->self = self;
glob->target = self;
glob->wantedDestinationPixelTypeH = (OSType **)NewHandleClear((kNumPixelFormatsSupportedTextSub+1) * sizeof(OSType));
if (err = MemError()) goto bail;
glob->drawBandUPP = NULL;
glob->ssa = NULL;
glob->colorSpace = NULL;
glob->translateSRT = true;
// Open and target an instance of the base decompressor as we delegate
// most of our calls to the base decompressor instance
err = OpenADefaultComponent(decompressorComponentType, kBaseCodecType, &glob->delegateComponent);
if (err) goto bail;
ComponentSetTarget(glob->delegateComponent, self);
bail:
return err;
}
//------------------------------------------------------------------------
bool pixel_map::save_as_qt(const char *filename) const
{
FSSpec fss;
OSErr err;
// get file specification to application directory
err = HGetVol(nil, &fss.vRefNum, &fss.parID);
if (err == noErr)
{
GraphicsExportComponent ge;
CopyCStringToPascal(filename, fss.name);
// I decided to use PNG as output image file type.
// There are a number of other available formats.
// Should I check the file suffix to choose the image file format?
err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePNG, &ge);
if (err == noErr)
{
err = GraphicsExportSetInputGWorld(ge, m_pmap);
if (err == noErr)
{
err = GraphicsExportSetOutputFile (ge, &fss);
if (err == noErr)
{
GraphicsExportDoExport(ge, nil);
}
}
CloseComponent(ge);
}
}
return err == noErr;
}
pascal ComponentResult Theora_ImageCodecOpen(Theora_Globals glob, ComponentInstance self)
{
ComponentResult err;
glob = (Theora_Globals)NewPtrClear(sizeof(Theora_GlobalsRecord));
dbg_printf("\n--:Theora:- CodecOpen(%08lx) called\n", (long)glob);
if (err = MemError()) goto bail;
SetComponentInstanceStorage(self, (Handle)glob);
glob->self = self;
glob->target = self;
glob->wantedDestinationPixelTypeH = (OSType **)NewHandle(sizeof(OSType) * (kNumPixelFormatsSupported + 1));
if (err = MemError()) goto bail;
glob->drawBandUPP = NULL;
glob->info_initialised = false;
glob->last_frame = -1;
glob->p_buffer = NewPtr(kPacketBufferAllocIncrement);
glob->p_buffer_len = kPacketBufferAllocIncrement;
glob->p_buffer_used = 0;
// many of the functions are delegated actually
err = OpenADefaultComponent(decompressorComponentType, kBaseCodecType, &glob->delegateComponent);
if (err) goto bail;
ComponentSetTarget(glob->delegateComponent, self);
bail:
return err;
}
QVariant QMacPasteboardMimePict::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
{
if(data.count() > 1)
qWarning("QMacPasteboardMimePict: Cannot handle multiple member data");
QVariant ret;
if (!resolveMimeQuickTimeSymbols())
return ret;
if(!canConvert(mime, flav))
return ret;
const QByteArray &a = data.first();
// This function expects the 512 header (just to skip it, so create the extra space for it).
Handle pic = NewHandle(a.size() + 512);
memcpy(*pic + 512, a.constData(), a.size());
GraphicsImportComponent graphicsImporter;
ComponentResult result = OpenADefaultComponent(GraphicsImporterComponentType,
kQTFileTypePicture, &graphicsImporter);
QCFType<CGImageRef> cgImage;
if (!result)
result = ptrGraphicsImportSetDataHandle(graphicsImporter, pic);
if (!result)
result = ptrGraphicsImportCreateCGImage(graphicsImporter, &cgImage,
kGraphicsImportCreateCGImageUsingCurrentSettings);
if (!result)
ret = QVariant(QPixmap::fromMacCGImageRef(cgImage).toImage());
CloseComponent(graphicsImporter);
DisposeHandle(pic);
return ret;
}
void wxBitmapDataObject::SetBitmap( const wxBitmap& rBitmap )
{
Clear();
wxBitmapDataObjectBase::SetBitmap( rBitmap );
if (m_bitmap.Ok())
{
#if wxMAC_USE_CORE_GRAPHICS
CGImageRef cgImageRef = (CGImageRef) m_bitmap.CGImageCreate();
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
if ( UMAGetSystemVersion() >= 0x1040 )
{
CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, 0);
CGImageDestinationRef destination = CGImageDestinationCreateWithData( data , kUTTypeTIFF , 1 , NULL );
if ( destination )
{
CGImageDestinationAddImage( destination, cgImageRef, NULL );
CGImageDestinationFinalize( destination );
CFRelease( destination );
}
m_pictHandle = NewHandle(CFDataGetLength(data));
if ( m_pictHandle )
{
memcpy( *(Handle)m_pictHandle, (const char *)CFDataGetBytePtr(data), CFDataGetLength(data) );
}
CFRelease( data );
}
else
#endif
#ifndef __LP64__
{
// export as TIFF
GraphicsExportComponent exporter = 0;
OSStatus err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypeTIFF, &exporter);
if (noErr == err)
{
m_pictHandle = NewHandle(0);
if ( m_pictHandle )
{
err = GraphicsExportSetInputCGImage( exporter, cgImageRef);
err = GraphicsExportSetOutputHandle(exporter, (Handle)m_pictHandle);
err = GraphicsExportDoExport(exporter, NULL);
}
CloseComponent( exporter );
}
}
#endif
CGImageRelease(cgImageRef);
#else
m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle();
m_pictCreated = false;
#endif
}
}
static void exportCGImageToFileWithQT(CGImageRef image, CFURLRef url,
CFStringRef outputFormat,
float dpi)
{
Handle dataRef = NULL;
OSType dataRefType;
GraphicsExportComponent graphicsExporter;
unsigned long sizeWritten;
ComponentResult result;
OSType imageExportType;
if(CFStringCompare(outputFormat, kUTTypeTIFF, kCFCompareCaseInsensitive) == kCFCompareEqualTo){
imageExportType = kQTFileTypeTIFF;
}else if(CFStringCompare(outputFormat, kUTTypePNG, kCFCompareCaseInsensitive) == kCFCompareEqualTo){
imageExportType = kQTFileTypePNG;
}else if(CFStringCompare(outputFormat, kUTTypeJPEG, kCFCompareCaseInsensitive) == kCFCompareEqualTo){
imageExportType = kQTFileTypeJPEG;
}else{
fprintf(stderr, "Requested image export format %@s unsupported\n", outputFormat);
return;
}
result = QTNewDataReferenceFromCFURL(url, 0, &dataRef, &dataRefType);
if(!result){
result = OpenADefaultComponent(GraphicsExporterComponentType,
imageExportType, &graphicsExporter);
if(!result){
result = GraphicsExportSetInputCGImage(graphicsExporter,
image);
if(!result)
result = GraphicsExportSetResolution(graphicsExporter,
FloatToFixed(dpi), FloatToFixed(dpi));
if(!result)
result = GraphicsExportSetOutputDataReference(
graphicsExporter, dataRef, dataRefType);
if(!result)
result = GraphicsExportDoExport(
graphicsExporter, &sizeWritten);
CloseComponent(graphicsExporter);
}
}
if(dataRef)
DisposeHandle(dataRef);
if(result)
fprintf(stderr, "QT export got bad result = %d!\n", (int)result);
return;
}
ComponentResult initVorbisComponent(WebMExportGlobalsPtr globals, GenericStreamPtr as)
{
dbg_printf("[WebM] enter initVorbisComponent\n");
ComponentResult err = noErr;
if (globals->audioSettingsAtom == NULL)
getDefaultVorbisAtom(globals);
//This chunk initializes the Component instance that will be used for decompression : TODO put this in its own function
err = OpenADefaultComponent(StandardCompressionType, StandardCompressionSubTypeAudio, &as->aud.vorbisComponentInstance);
if (err) goto bail;
AudioStreamBasicDescription *inFormat = NULL;
inFormat = calloc(1, sizeof(AudioStreamBasicDescription));
if (inFormat == NULL) goto bail;
err = getInputBasicDescription(as, inFormat);
if (err) goto bail;
getInputBasicDescription(as, inFormat);
err = SCSetSettingsFromAtomContainer(as->aud.vorbisComponentInstance, globals->audioSettingsAtom);
if (err) goto bail;
err = QTGetComponentProperty(as->aud.vorbisComponentInstance, kQTPropertyClass_SCAudio,
kQTSCAudioPropertyID_BasicDescription,
sizeof(AudioStreamBasicDescription), &as->aud.asbd, NULL);
if (err) goto bail;
err = QTSetComponentProperty(as->aud.vorbisComponentInstance, kQTPropertyClass_SCAudio, kQTSCAudioPropertyID_InputBasicDescription,
sizeof(AudioStreamBasicDescription), inFormat);
bail:
if (inFormat != NULL)
free(inFormat);
dbg_printf("[WebM]initVorbisComponent return %d\n", err);
return err;
}
QVariant QMacPasteboardMimeTiff::convertToMime(const QString &mime, QList<QByteArray> data, QString flav)
{
if(data.count() > 1)
qWarning("QMacPasteboardMimeTiff: Cannot handle multiple member data");
QVariant ret;
if (!canConvert(mime, flav))
return ret;
const QByteArray &a = data.first();
QCFType<CGImageRef> image;
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
QCFType<CFDataRef> data = CFDataCreateWithBytesNoCopy(0,
reinterpret_cast<const UInt8 *>(a.constData()),
a.size(), kCFAllocatorNull);
QCFType<CGImageSourceRef> imageSource = CGImageSourceCreateWithData(data, 0);
image = CGImageSourceCreateImageAtIndex(imageSource, 0, 0);
} else
#endif
{
#ifdef Q_WS_MAC32
if (resolveMimeQuickTimeSymbols()) {
Handle tiff = NewHandle(a.size());
memcpy(*tiff, a.constData(), a.size());
GraphicsImportComponent graphicsImporter;
ComponentResult result = OpenADefaultComponent(GraphicsImporterComponentType,
kQTFileTypeTIFF, &graphicsImporter);
if (!result)
result = ptrGraphicsImportSetDataHandle(graphicsImporter, tiff);
if (!result)
result = ptrGraphicsImportCreateCGImage(graphicsImporter, &image,
kGraphicsImportCreateCGImageUsingCurrentSettings);
CloseComponent(graphicsImporter);
DisposeHandle(tiff);
}
#endif
}
if (image != 0)
ret = QVariant(QPixmap::fromMacCGImageRef(image).toImage());
return ret;
}
RTPMPComponentVideo_Open(
RTPMPComponentVideoInstanceData ** inGlobals,
ComponentInstance self )
{
ComponentResult theResult = noErr;
RTPMediaPacketizer theBase;
inGlobals =
REINTERPRET_CAST( RTPMPComponentVideoInstanceData ** )(
NewHandleClear( sizeof( **inGlobals ) ) );
if( inGlobals )
{
( **inGlobals ).itself = self;
( **inGlobals ).itsFinalDerivation = self;
( **inGlobals ).itsInitialized = false;
SetComponentInstanceStorage( self, REINTERPRET_CAST( Handle )( inGlobals ) );
theResult =
OpenADefaultComponent(
kRTPMediaPacketizerType, kRTPBaseMediaPacketizerType, &theBase );
if( theResult == noErr )
{
( **inGlobals ).itsBase = theBase;
theResult = CallComponentTarget( ( **inGlobals ).itsBase, self );
}
}
else
{
theResult = MemError();
if( theResult == noErr )
theResult = memFullErr;
}
return( theResult );
}
int macosx_audio_open(audio_desc_t ad, audio_format* ifmt, audio_format *ofmt)
{
OSStatus err = noErr;
UInt32 propertySize;
Boolean writable;
obtained_ = false;
add = ad;
//dev[0] = devices[ad];
UNUSED(ofmt);
// Get the default input device ID.
err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &writable);
if (err != noErr) {
return 0;
}
err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &propertySize, &(devices[ad].inputDeviceID_));
if (err != noErr) {
debug_msg("error kAudioHardwarePropertyDefaultInputDevice");
return 0;
}
if (devices[ad].inputDeviceID_ == kAudioDeviceUnknown) {
debug_msg("error kAudioDeviceUnknown");
return 0;
}
// Get the input stream description.
err = AudioDeviceGetPropertyInfo(devices[ad].inputDeviceID_, 0, true, kAudioDevicePropertyStreamFormat, &propertySize, &writable);
if (err != noErr) {
debug_msg("error AudioDeviceGetPropertyInfo");
return 0;
}
err = AudioDeviceGetProperty(devices[ad].inputDeviceID_, 0, true, kAudioDevicePropertyStreamFormat, &propertySize, &(devices[ad].inputStreamBasicDescription_));
//printf("inputStreamBasicDescription_.mBytesPerFrame %d\n", devices[add].inputStreamBasicDescription_);
if (err != noErr) {
debug_msg("error AudioDeviceGetProperty");
return 0;
}
// nastavime maly endian
devices[ad].inputStreamBasicDescription_.mFormatFlags &= (kAudioFormatFlagIsBigEndian & 0);
if (writable) {
err = AudioDeviceSetProperty(devices[ad].inputDeviceID_, NULL, 0, true, kAudioDevicePropertyStreamFormat, sizeof(AudioStreamBasicDescription), &(devices[ad].inputStreamBasicDescription_));
if (err != noErr) printf("err: AudioDeviceSetProperty: kAudioDevicePropertyStreamFormat\n");
}
/* set the buffer size of the device */
/*
int bufferByteSize = 8192;
propertySize = sizeof(bufferByteSize);
err = AudioDeviceSetProperty(devices[ad].inputDeviceID_, NULL, 0, true, kAudioDevicePropertyBufferSize, propertySize, &bufferByteSize);
if (err != noErr) debug_msg("err: Set kAudioDevicePropertyBufferSize to %d\n", bufferByteSize);
else debug_msg("sucessfully set kAudioDevicePropertyBufferSize to %d\n", bufferByteSize);
*/
// Set the device sample rate -- a temporary fix for the G5's
// built-in audio and possibly other audio devices.
Boolean IsInput = 0;
int inChannel = 0;
Float64 theAnswer = 44100;
UInt32 theSize = sizeof(theAnswer);
err = AudioDeviceSetProperty(devices[ad].inputDeviceID_, NULL, inChannel, IsInput,
kAudioDevicePropertyNominalSampleRate, theSize, &theAnswer);
if (err != noErr) {
debug_msg("error AudioDeviceSetProperty\n");
return 0;
}
debug_msg("Sample rate, %f\n", theAnswer);
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
err = AudioDeviceCreateIOProcID(devices[ad].inputDeviceID_, audioIOProc, (void*)NULL, &devices[ad].inputDeviceProcID_);
if (err != noErr) {
debug_msg("error AudioDeviceCreateIOProcID, %s\n", GetMacOSStatusCommentString(err));
return 0;
}
err = OpenADefaultComponent(kAudioUnitType_Output, kAudioUnitSubType_DefaultOutput, &(devices[ad].outputUnit_));
// The HAL AU maybe a better way to in the future...
//err = OpenADefaultComponent(kAudioUnitType_Output, kAudioUnitSubType_HALOutput, &(devices[ad].outputUnit_));
if (err != noErr) {
debug_msg("error OpenADefaultComponent\n");
return 0;
}
#else
// Register the AudioDeviceIOProc.
err = AudioDeviceAddIOProc(devices[ad].inputDeviceID_, audioIOProc, NULL);
if (err != noErr) {
debug_msg("error AudioDeviceAddIOProc\n");
return 0;
}
err = OpenDefaultAudioOutput(&(devices[ad].outputUnit_));
if (err != noErr) {
debug_msg("error OpenDefaultAudioOutput\n");
return 0;
}
#endif
// Register a callback function to provide output data to the unit.
devices[ad].input.inputProc = outputRenderer;
devices[ad].input.inputProcRefCon = 0;
/* These would be needed if HAL used
* UInt32 enableIO =1;
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, (const void*)&enableIO, sizeof(UInt32));
enableIO=0;
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, (const void*)&enableIO, sizeof(UInt32));
if (err != noErr) {
debug_msg("error AudioUnitSetProperty EnableIO with error %ld: %s\n", err, GetMacOSStatusErrorString(err));
return 0;
}*/
#if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, 0, &(devices[ad].input), sizeof(AURenderCallbackStruct));
#else
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &(devices[ad].input), sizeof(AURenderCallbackStruct));
#endif
if (err != noErr) {
debug_msg("error AudioUnitSetProperty1 with error %ld: %s\n", err, GetMacOSStatusErrorString(err));
return 0;
}
// Define the Mash stream description. Mash puts 20ms of data into each read
// and write call. 20ms at 8000Hz equals 160 samples. Each sample is a u_char,
// so that's 160 bytes. Mash uses 8-bit mu-law internally, so we need to convert
// to 16-bit linear before using the audio data.
devices[ad].mashStreamBasicDescription_.mSampleRate = 8000.0;
//devices[ad].mashStreamBasicDescription_.mSampleRate = ifmt->sample_rate;
devices[ad].mashStreamBasicDescription_.mFormatID = kAudioFormatLinearPCM;
#ifdef WORDS_BIGENDIAN
devices[ad].mashStreamBasicDescription_.mFormatFlags =kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsBigEndian |kLinearPCMFormatFlagIsPacked;
#else
devices[ad].mashStreamBasicDescription_.mFormatFlags =kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
#endif
devices[ad].mashStreamBasicDescription_.mBytesPerPacket = 2;
devices[ad].mashStreamBasicDescription_.mFramesPerPacket = 1;
devices[ad].mashStreamBasicDescription_.mBytesPerFrame = 2;
devices[ad].mashStreamBasicDescription_.mChannelsPerFrame = 1;
devices[ad].mashStreamBasicDescription_.mBitsPerChannel = 16;
// Inform the default output unit of our source format.
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &(devices[ad].mashStreamBasicDescription_), sizeof(AudioStreamBasicDescription));
if (err != noErr) {
debug_msg("error AudioUnitSetProperty2");
printf("error setting output unit source format\n");
return 0;
}
// check the stream format
err = AudioUnitGetPropertyInfo(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &propertySize, &writable);
if (err != noErr) debug_msg("err getting propert info for kAudioUnitProperty_StreamFormat\n");
err = AudioUnitGetProperty(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &streamdesc_, &propertySize);
if (err != noErr) debug_msg("err getting values for kAudioUnitProperty_StreamFormat\n");
char name[128];
audio_format_name(ifmt, name, 128);
debug_msg("Requested ifmt %s\n",name);
debug_msg("ifmt bytes pre block: %d\n",ifmt->bytes_per_block);
// handle the requested format
if (ifmt->encoding != DEV_S16) {
audio_format_change_encoding(ifmt, DEV_S16);
debug_msg("Requested ifmt changed to %s\n",name);
debug_msg("ifmt bytes pre block: %d\n",ifmt->bytes_per_block);
}
audio_format_name(ofmt, name, 128);
debug_msg("Requested ofmt %s\n",name);
debug_msg("ofmt bytes pre block: %d\n",ofmt->bytes_per_block);
// Allocate the read buffer and Z delay line.
//readBufferSize_ = 8192;
readBufferSize_ = ifmt->bytes_per_block * ringBufferFactor_;
//readBufferSize_ = 320;
//printf("readBufferSize_ %d\n", readBufferSize_);
readBuffer_ = malloc(sizeof(u_char)*readBufferSize_);
bzero(readBuffer_, readBufferSize_ * sizeof(u_char));
//memset(readBuffer_, PCMU_AUDIO_ZERO, readBufferSize_);
//inputReadIndex_ = -1;
inputReadIndex_ = 0; inputWriteIndex_ = 0;
zLine_ = malloc(sizeof(double)*DECIM441_LENGTH / 80);
availableInput_ = 0;
// Allocate the write buffer.
//writeBufferSize_ = 8000;
writeBufferSize_ = ofmt->bytes_per_block * ringBufferFactor_;
writeBuffer_ = malloc(sizeof(SInt16)*writeBufferSize_);
bzero(writeBuffer_, writeBufferSize_ * sizeof(SInt16));
outputReadIndex_ = 0; outputWriteIndex_ = 0;
//outputWriteIndex_ = -1;
// Start audio processing.
err = AudioUnitInitialize(devices[ad].outputUnit_);
if (err != noErr) {
debug_msg("error AudioUnitInitialize\n");
return 0;
}
err = AudioDeviceStart(devices[ad].inputDeviceID_, audioIOProc);
if (err != noErr) {
fprintf(stderr, "Input device error: AudioDeviceStart\n");
return 0;
}
err = AudioOutputUnitStart(devices[ad].outputUnit_);
if (err != noErr) {
fprintf(stderr, "Output device error: AudioOutputUnitStart\n");
return 0;
}
// Inform the default output unit of our source format.
/*
err = AudioUnitSetProperty(devices[ad].outputUnit_, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &(devices[ad].mashStreamBasicDescription_), sizeof(AudioStreamBasicDescription));
if (err != noErr) {
debug_msg("error AudioUnitSetProperty3");
return 0;
}
*/
return 1;
};
void QuicktimeImportExport::writeToStream(std::ostream& outStream, osg::Image* image, const std::string& fileTypeHint)
{
std::string ext = osgDB::getFileExtension(fileTypeHint);
//Build map of extension <-> osFileTypes
static std::map<std::string, OSType> extmap;
if (extmap.size() == 0) {
extmap["jpg"] = kQTFileTypeJPEG;
extmap["jpeg"] = kQTFileTypeJPEG;
extmap["bmp"] = kQTFileTypeBMP;
extmap["tif"] = kQTFileTypeTIFF;
extmap["tiff"] = kQTFileTypeTIFF;
extmap["png"] = kQTFileTypePNG;
extmap["gif"] = kQTFileTypeGIF;
extmap["psd"] = kQTFileTypePhotoShop;
extmap["sgi"] = kQTFileTypeSGIImage;
extmap["rgb"] = kQTFileTypeSGIImage;
extmap["rgba"] = kQTFileTypeSGIImage;
}
std::map<std::string, OSType>::iterator cur = extmap.find(ext);
// can not handle this type of file, perhaps a movie?
if (cur == extmap.end())
return;
unsigned int numBytes = image->computeNumComponents(image->getPixelFormat());
unsigned char* pixels = prepareBufferForQuicktime(
image->data(),
image->getPixelFormat(),
numBytes,
image->s(),
image->t()
);
OSType desiredType = cur->second;
GraphicsExportComponent geComp = NULL;
GWorldPtr gw = 0;
Handle dataHandle;
dataHandle = NewHandle(0);
try {
OSErr err = OpenADefaultComponent(GraphicsExporterComponentType, desiredType, &geComp);
Rect bounds = {0,0, image->t(), image->s()};
err = QTNewGWorldFromPtr(&gw, k32ARGBPixelFormat, &bounds, 0,0,0, pixels, image->s()*4);
if (err != noErr) {
throw QTImportExportException(err, "could not create gworld for type " + ext);
}
err = GraphicsExportSetInputGWorld(geComp, gw);
if (err != noErr) {
throw QTImportExportException(err, "could not set input gworld for type " + ext);
}
err = GraphicsExportSetOutputHandle( geComp, dataHandle);
if (err != noErr) {
throw QTImportExportException(err, "could not set output file for type " + ext);
}
// Set the compression quality (needed for JPEG, not necessarily for other formats)
if (desiredType == kQTFileTypeJPEG) {
err = GraphicsExportSetCompressionQuality(geComp, codecLosslessQuality);
if (err != noErr) {
throw QTImportExportException(err, "could not set compression for type " + ext);
}
}
if(4 == numBytes)
{
err = GraphicsExportSetDepth( geComp, k32ARGBPixelFormat ); // depth
}
// else k24RGBPixelFormat???
// do the export
err = GraphicsExportDoExport(geComp, NULL);
if (err != noErr) {
throw QTImportExportException(err, "could not do the export for type " + ext);
}
if (geComp != NULL)
CloseComponent(geComp);
if (gw) DisposeGWorld (gw);
if (pixels) free(pixels);
outStream.write(*dataHandle, GetHandleSize(dataHandle));
DisposeHandle(dataHandle);
}
catch (QTImportExportException& e)
{
setError(e.what());
if (geComp != NULL) CloseComponent(geComp);
if (gw != NULL) DisposeGWorld (gw);
if (pixels) free(pixels);
DisposeHandle(dataHandle);
}
}
int convertToMP4PathThrough(CFStringRef inFile, CFStringRef outFile)
{
OSStatus error;
MovieExportComponent movieExporter = NULL;
Handle inDataRef=0, outDataRef=0;
OSType inDataRefType, outDataRefType;
short inResID = 0;
Movie theMovie=0;
int ret = -1;
error = OpenADefaultComponent(MovieExportType, kQTFileTypeMP4, &movieExporter);
if(error) {
fprintf(stderr,"OpenADefaultComponent error: cannot find the QuickTime conponent\n");
goto last;
}
error = QTNewDataReferenceFromFullPathCFString(inFile, kQTNativeDefaultPathStyle, 0, &inDataRef, &inDataRefType);
if(error) {
fprintf(stderr,"QTNewDataReferenceFromFullPathCFString error: input file path is invalid\n");
goto last;
}
error = QTNewDataReferenceFromFullPathCFString(outFile, kQTNativeDefaultPathStyle, 0, &outDataRef, &outDataRefType);
if(error) {
fprintf(stderr,"QTNewDataReferenceFromFullPathCFString error: output file path is invalid\n");
goto last;
}
error = NewMovieFromDataRef(&theMovie, newMovieActive, &inResID, inDataRef, inDataRefType);
if(error) {
fprintf(stderr,"NewMovieFromDataRef error: cannot open the input file\n");
goto last;
}
Track theTrack = getSoundTrack(theMovie);
Media theMedia = GetTrackMedia(theTrack);
DeleteTrackSegment(theTrack, 0, GetTrackDuration(theTrack));
SetMovieTimeScale(theMovie, GetMediaTimeScale(theMedia));
InsertMediaIntoTrack(theTrack, 0, 0, GetMediaDuration(theMedia), fixed1);
Boolean useHighResolutionAudio = true;
QTSetComponentProperty(
movieExporter,
kQTPropertyClass_MovieExporter,
kQTMovieExporterPropertyID_EnableHighResolutionAudioFeatures,
sizeof(Boolean),
&useHighResolutionAudio
);
UInt32 ftyp = 'mp42';
QTSetComponentProperty(
movieExporter,
kQTPropertyClass_MovieExporter,
'ftyp',
4,
&ftyp
);
QTAtomContainer ac;
MovieExportGetSettingsAsAtomContainer(movieExporter, &ac);
QTAtom ensoAtom = QTFindChildByID(ac, kParentAtomIsContainer, kQTSettingsMovieExportEnableSound, 1, NULL);
if(ensoAtom) {
long size, *data;
QTGetAtomDataPtr(ac,ensoAtom,&size,(Ptr *)&data);
data[0] = EndianS32_NtoB('past');
QTSetAtomData(ac, ensoAtom, size, data);
MovieExportSetSettingsFromAtomContainer(movieExporter, ac);
}
DisposeHandle(ac);
/*Boolean cancelled;
error = MovieExportDoUserDialog(movieExporter, theMovie, NULL, 0, GetMovieDuration(theMovie), &cancelled);
if(cancelled) goto last;
if(error) {
printf("MovieExportDoUserDialog error\n");
goto last;
}*/
error = ConvertMovieToDataRef(theMovie, 0, outDataRef, outDataRefType, kQTFileTypeMP4, FOUR_CHAR_CODE('TVOD'), createMovieFileDeleteCurFile|createMovieFileDontCreateResFile, movieExporter);
if(error) {
fprintf(stderr,"ConvertMovieToDataRef error: cannot translate .mov into .m4a (%d)\n",error);
goto last;
}
ret = 0;
last:
if(movieExporter) CloseComponent(movieExporter);
if(theMovie) DisposeMovie(theMovie);
if(inDataRef) DisposeHandle(inDataRef);
if(outDataRef) DisposeHandle(outDataRef);
return ret;
}
bool wxBitmapDataObject::SetData( const wxDataFormat& format, size_t nSize, const void *pBuf )
{
Clear();
if ((pBuf == NULL) || (nSize == 0))
return false;
#if wxMAC_USE_CORE_GRAPHICS
Handle picHandle = NULL ;
m_pictHandle = NewHandle( nSize );
memcpy( *(Handle) m_pictHandle, pBuf, nSize );
if ( format == s_pict )
{
// pict for IO expects a 512 byte header
picHandle = NewHandle( nSize + 512 );
memset( *picHandle , 0 , 512 );
memcpy( *picHandle+512, pBuf, nSize );
}
else
{
picHandle = (Handle) m_pictHandle;
}
CGImageRef cgImageRef = 0;
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
if ( UMAGetSystemVersion() >= 0x1040 )
{
CFDataRef data = NULL;
HLock( picHandle );
data = CFDataCreateWithBytesNoCopy( kCFAllocatorDefault, (const UInt8*) *picHandle, GetHandleSize(picHandle), kCFAllocatorNull);
CGImageSourceRef source = CGImageSourceCreateWithData( data, NULL );
if ( source )
{
cgImageRef = CGImageSourceCreateImageAtIndex(source, 0, NULL);
}
CFRelease( source );
CFRelease( data );
HUnlock( picHandle );
}
else
#endif
#ifndef __LP64__
{
// import from TIFF
GraphicsImportComponent importer = 0;
OSStatus err = OpenADefaultComponent(GraphicsImporterComponentType, s_pict == format ? kQTFileTypePicture : kQTFileTypeTIFF, &importer);
if (noErr == err)
{
if ( picHandle )
{
ComponentResult result = GraphicsImportSetDataHandle(importer, picHandle);
if ( result == noErr )
{
Rect frame;
GraphicsImportGetNaturalBounds( importer, &frame );
GraphicsImportCreateCGImage( importer, &cgImageRef, kGraphicsImportCreateCGImageUsingCurrentSettings );
}
}
CloseComponent( importer );
}
}
#endif
if ( format == s_pict )
{
DisposeHandle( picHandle );
}
if ( cgImageRef )
{
m_bitmap.Create( CGImageGetWidth(cgImageRef) , CGImageGetHeight(cgImageRef) );
CGRect r = CGRectMake( 0 , 0 , CGImageGetWidth(cgImageRef) , CGImageGetHeight(cgImageRef) );
// since our context is upside down we dont use CGContextDrawImage
HIViewDrawCGImage( (CGContextRef) m_bitmap.GetHBITMAP() , &r, cgImageRef ) ;
CGImageRelease(cgImageRef);
cgImageRef = NULL;
}
#else
PicHandle picHandle = (PicHandle)NewHandle( nSize );
memcpy( *picHandle, pBuf, nSize );
m_pictHandle = picHandle;
// ownership is transferred to the bitmap
m_pictCreated = false;
#ifndef __LP64__
Rect frame;
wxMacGetPictureBounds( picHandle, &frame );
#if wxUSE_METAFILE
wxMetafile mf;
mf.SetHMETAFILE( (WXHMETAFILE)m_pictHandle );
#endif
wxMemoryDC mdc;
m_bitmap.Create( frame.right - frame.left, frame.bottom - frame.top );
mdc.SelectObject( m_bitmap );
#if wxUSE_METAFILE
mf.Play( &mdc );
#endif
mdc.SelectObject( wxNullBitmap );
#endif
#endif
return m_bitmap.Ok();
}
OSErr SpriteUtils_AddCompressedSpriteSampleToMedia (Media theMedia, QTAtomContainer theSample, TimeValue theDuration, Boolean isKeyFrame, OSType theDataCompressorType, TimeValue *theSampleTime)
{
SpriteDescriptionHandle mySampleDesc = NULL;
Handle myCompressedSample = NULL;
ComponentInstance myComponent = NULL;
OSErr myErr = noErr;
myErr = OpenADefaultComponent(DataCompressorComponentType, theDataCompressorType, &myComponent);
if (myErr != noErr)
goto bail;
mySampleDesc = (SpriteDescriptionHandle)NewHandleClear(sizeof(SpriteDescription));
if (mySampleDesc == NULL) {
myErr = MemError();
goto bail;
}
if (myComponent != NULL) {
UInt32 myCompressBufferSize, myActualCompressedSize, myDecompressSlop = 0;
UInt32 myUncompressedSize;
SignedByte mySaveState = HGetState(theSample);
myErr = (OSErr)DataCodecGetCompressBufferSize(myComponent, GetHandleSize(theSample), &myCompressBufferSize);
if (myErr != noErr)
goto bail;
myCompressedSample = NewHandle(sizeof(UInt32) + myCompressBufferSize);
myErr = MemError();
if (myErr != noErr)
goto bail;
HLockHi(theSample);
HLockHi(myCompressedSample);
myErr = (OSErr)DataCodecCompress(myComponent,
*theSample,
GetHandleSize(theSample),
*myCompressedSample + sizeof(UInt32), // room for size at beginning
myCompressBufferSize,
&myActualCompressedSize,
&myDecompressSlop);
HSetState(theSample, mySaveState);
HUnlock(myCompressedSample);
if (myErr != noErr)
goto bail;
SetHandleSize(myCompressedSample, sizeof(UInt32) + myActualCompressedSize);
myErr = MemError();
if (myErr != noErr)
goto bail;
(**mySampleDesc).decompressorType = EndianU32_NtoB(theDataCompressorType);
myUncompressedSize = GetHandleSize(theSample);
(*(UInt32*) *myCompressedSample) = EndianU32_NtoB(myUncompressedSize); // add uncompressed size at beginning
myErr = AddMediaSample(theMedia,
(Handle)myCompressedSample,
0,
GetHandleSize(myCompressedSample),
theDuration,
(SampleDescriptionHandle)mySampleDesc,
1,
(short)(isKeyFrame ? 0 : mediaSampleNotSync),
theSampleTime);
} else {
myErr = AddMediaSample(theMedia,
(Handle)theSample,
0,
GetHandleSize(theSample),
theDuration,
(SampleDescriptionHandle)mySampleDesc,
1,
(short)(isKeyFrame ? 0 : mediaSampleNotSync),
theSampleTime);
}
bail:
if (myCompressedSample != NULL)
DisposeHandle(myCompressedSample);
if (mySampleDesc != NULL)
DisposeHandle((Handle)mySampleDesc);
if (myComponent != NULL)
CloseComponent(myComponent);
return(myErr);
}
QList<QByteArray> QMacPasteboardMimeTiff::convertFromMime(const QString &mime, QVariant variant, QString flav)
{
QList<QByteArray> ret;
if (!canConvert(mime, flav))
return ret;
QImage img = qvariant_cast<QImage>(variant);
QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(img);
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
QCFType<CFMutableDataRef> data = CFDataCreateMutable(0, 0);
QCFType<CGImageDestinationRef> imageDestination = CGImageDestinationCreateWithData(data, kUTTypeTIFF, 1, 0);
if (imageDestination != 0) {
CFTypeRef keys[2];
QCFType<CFTypeRef> values[2];
QCFType<CFDictionaryRef> options;
keys[0] = kCGImagePropertyPixelWidth;
keys[1] = kCGImagePropertyPixelHeight;
int width = img.width();
int height = img.height();
values[0] = CFNumberCreate(0, kCFNumberIntType, &width);
values[1] = CFNumberCreate(0, kCFNumberIntType, &height);
options = CFDictionaryCreate(0, reinterpret_cast<const void **>(keys),
reinterpret_cast<const void **>(values), 2,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CGImageDestinationAddImage(imageDestination, cgimage, options);
CGImageDestinationFinalize(imageDestination);
}
QByteArray ar(CFDataGetLength(data), 0);
CFDataGetBytes(data,
CFRangeMake(0, ar.size()),
reinterpret_cast<UInt8 *>(ar.data()));
ret.append(ar);
} else
#endif
{
#ifdef Q_WS_MAC32
Handle tiff = NewHandle(0);
if (resolveMimeQuickTimeSymbols()) {
GraphicsExportComponent graphicsExporter;
ComponentResult result = OpenADefaultComponent(GraphicsExporterComponentType,
kQTFileTypeTIFF, &graphicsExporter);
if (!result) {
unsigned long sizeWritten;
result = ptrGraphicsExportSetInputCGImage(graphicsExporter, cgimage);
if (!result)
result = ptrGraphicsExportSetOutputHandle(graphicsExporter, tiff);
if (!result)
result = ptrGraphicsExportDoExport(graphicsExporter, &sizeWritten);
CloseComponent(graphicsExporter);
}
}
int size = GetHandleSize((Handle)tiff);
QByteArray ar(reinterpret_cast<char *>(*tiff), size);
ret.append(ar);
DisposeHandle(tiff);
#endif
}
return ret;
}
void TLevelWriter3gp::save(const TImageP &img, int frameIndex)
{
if (m_cancelled)
return;
TRasterImageP image(img);
int lx = image->getRaster()->getLx();
int ly = image->getRaster()->getLy();
//void *buffer = image->getRaster()->getRawData();
int pixSize = image->getRaster()->getPixelSize();
if (pixSize != 4)
throw TImageException(getFilePath(), "Unsupported pixel type");
QMutexLocker sl(&m_mutex);
if (!m_properties)
m_properties = new Tiio::MovWriterProperties();
Tiio::MovWriterProperties *prop = (Tiio::MovWriterProperties *)(m_properties);
//CodecType compression = StandardCompressionType; prop->getCurrentCodec();
//CodecQ quality = StandardQualityType; prop->getCurrentQuality();
if (!m_initDone) {
//FSSpec fspec;
Rect frame;
long max_compressed_size;
QDErr err;
m_videoTrack = NewMovieTrack(m_movie, FixRatio((short)lx, 1), FixRatio((short)ly, 1), kNoVolume);
if ((err = GetMoviesError() != noErr))
throw TImageException(getFilePath(), "can't create video track");
m_dataRef = nil;
m_hMovieData = NewHandle(0);
// Construct the Handle data reference
err = PtrToHand(&m_hMovieData, &m_dataRef, sizeof(Handle));
if ((err = GetMoviesError() != noErr))
throw TImageException(getFilePath(), "can't create Data Ref");
m_videoMedia = NewTrackMedia(m_videoTrack, VideoMediaType, (TINT32)m_frameRate, m_dataRef, HandleDataHandlerSubType);
OpenADefaultComponent(MovieExportType, '3gpp', &m_myExporter);
// err = (short)MovieExportDoUserDialog(m_myExporter, m_movie, 0, 0, 0, &m_cancelled);
// if (m_cancelled)
// throw TImageException(getFilePath(), "User abort of 3GP render");
if ((err = GetMoviesError() != noErr))
throw TImageException(getFilePath(), "can't create video media");
if ((err = BeginMediaEdits(m_videoMedia)) != noErr)
throw TImageException(getFilePath(), "can't begin edit video media");
frame.left = 0;
frame.top = 0;
frame.right = lx;
frame.bottom = ly;
#if 0
if ((err = NewGWorld(&(m_gworld), pixSize * 8, &frame, 0, 0, 0))!=noErr)
#else /* Mac OSX 10.7 later */
if ((err = QTNewGWorld(&(m_gworld), pixSize * 8, &frame, 0, 0, 0)) != noErr)
#endif
throw TImageException(getFilePath(), "can't create movie buffer");
#ifdef WIN32
LockPixels(m_gworld->portPixMap);
if ((err = GetMaxCompressionSize(m_gworld->portPixMap, &frame, 0,
quality, compression, anyCodec,
&max_compressed_size)) != noErr)
throw TImageException(getFilePath(), "can't get max compression size");
#else
#if 0
PixMapHandle pixmapH = GetPortPixMap (m_gworld);
LockPixels(pixmapH);
#else
PixMapHandle pixmapH = NULL;
#endif
max_compressed_size = lx * ly * 4 * 20;
/*if ((err = GetMaxCompressionSize(pixmapH, &frame, 0,
quality, compression,anyCodec,
&max_compressed_size))!=noErr)
throw TImageException(getFilePath(), "can't get max compression size");*/
#endif
m_compressedData = NewHandle(max_compressed_size);
if ((err = MemError()) != noErr)
throw TImageException(getFilePath(), "can't allocate compressed data for movie");
MoveHHi(m_compressedData);
HLock(m_compressedData);
if ((err = MemError()) != noErr)
throw TImageException(getFilePath(), "can't allocate img handle");
#if 0
m_pixmap = GetGWorldPixMap(m_gworld);
if (!LockPixels(m_pixmap))
throw TImageException(getFilePath(), "can't lock pixels");
buf = (PixelXRGB*) GetPixBaseAddr(m_pixmap);
#else
m_pixmap = NULL;
buf = NULL;
#endif
buf_lx = lx;
buf_ly = ly;
m_initDone = true;
}
unsigned short rowBytes = (unsigned short)(((short)(*(m_pixmap))->rowBytes & ~(3 << 14)));
Rect frame;
ImageDescriptionHandle img_descr;
Ptr compressed_data_ptr;
QDErr err;
frame.left = 0;
frame.top = 0;
frame.right = lx;
frame.bottom = ly;
TRasterP ras = image->getRaster();
#ifdef WIN32
compressed_data_ptr = StripAddress(*(m_compressedData));
copy(ras, buf, buf_lx, buf_ly);
#else
compressed_data_ptr = *m_compressedData;
copy(ras, buf, buf_lx, buf_ly, rowBytes);
#endif
img_descr = (ImageDescriptionHandle)NewHandle(4);
#ifdef WIN32
if ((err = CompressImage(m_gworld->portPixMap,
&frame,
quality, compression,
img_descr, compressed_data_ptr)) != noErr)
throw TImageException(getFilePath(), "can't compress image");
#else
#if 0
PixMapHandle pixmapH = GetPortPixMap (m_gworld);
if ((err = CompressImage(pixmapH,
&frame,
codecNormalQuality, kJPEGCodecType,
img_descr, compressed_data_ptr))!=noErr)
{
throw TImageException(getFilePath(), "can't compress image");
}
#endif
#endif
if ((err = AddMediaSample(m_videoMedia, m_compressedData, 0,
(*img_descr)->dataSize, 1,
(SampleDescriptionHandle)img_descr,
1, 0, 0)) != noErr)
throw TImageException(getFilePath(), "can't add image to movie media");
DisposeHandle((Handle)img_descr);
}
static void QTDR_DrawFrame (short theTrackWidth, short theTrackHeight, long theNumSample, GWorldPtr theGWorld)
{
Handle myHandle = NULL;
char myData[kPICTFileHeaderSize];
static PicHandle myPicture = NULL;
static GWorldPtr myGWorld = NULL;
static GraphicsImportComponent myImporter = NULL;
Rect myRect;
RGBColor myColor;
ComponentResult myErr = noErr;
MacSetRect(&myRect, 0, 0, theTrackWidth, theTrackHeight);
if (myPicture == NULL) {
myErr = NewGWorld(&myGWorld, kPixelDepth, &myRect, NULL, NULL, (GWorldFlags)0);
if (myErr != noErr)
goto bail;
// read a picture from our resource file
myPicture = GetPicture(kPictureID);
if (myPicture == NULL)
goto bail;
// use Munger to prepend a 512-byte header onto the picture data; this converts the PICT
// resource data into in-memory PICT file data (see Ice Floe 14 for an explanation of this)
myHandle = (Handle)myPicture;
Munger(myHandle, 0, NULL, 0, myData, kPICTFileHeaderSize);
// get a graphics importer for the picture
myErr = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypePicture, &myImporter);
if (myErr != noErr)
goto bail;
// configure the graphics importer
myErr = GraphicsImportSetGWorld(myImporter, myGWorld, NULL);
if (myErr != noErr)
goto bail;
myErr = GraphicsImportSetDataHandle(myImporter, myHandle);
if (myErr != noErr)
goto bail;
myErr = GraphicsImportSetBoundsRect(myImporter, &myRect);
if (myErr != noErr)
goto bail;
// draw the picture into the source GWorld
myErr = GraphicsImportDraw(myImporter);
if (myErr != noErr)
goto bail;
}
// set the blend amount (0 = fully transparent; 0xffff = fully opaque)
myColor.red = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
myColor.green = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
myColor.blue = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
OpColor(&myColor);
// blend the picture (in the source GWorld) into the empty rectangle (in the destination GWorld)
CopyBits((BitMapPtr)*GetGWorldPixMap(myGWorld),
(BitMapPtr)*GetGWorldPixMap(theGWorld),
&myRect,
&myRect,
blend,
NULL);
if (theNumSample == kNumVideoFrames)
goto bail;
return;
bail:
if (myHandle != NULL)
DisposeHandle(myHandle);
if (myPicture != NULL)
ReleaseResource((Handle)myPicture);
if (myImporter != NULL)
CloseComponent(myImporter);
}
