void _HYPlatformGraphicPane::_SavePicture (_String prompt)
{
InitializeQTExporters ();
if (graphicsFormats.lLength)
{
_String filePath;
long menuChoice = SaveFileWithPopUp (filePath,
savePicPrompt,prompt,savePicAs,graphicsFormats);
if (menuChoice>=0)
{
ComponentInstance grexc = OpenComponent ((Component)qtGrexComponents(menuChoice));
GraphicsExportSetInputGWorld (grexc,thePane);
FSSpec fs;
Str255 buff;
StringToStr255 (filePath,buff);
FSMakeFSSpec(0,0,buff,&fs);
GraphicsExportSetOutputFile (grexc,&fs);
GraphicsExportRequestSettings (grexc,nil,nil);
unsigned long dummy;
OSType t,c;
GraphicsExportGetDefaultFileTypeAndCreator (grexc,&t,&c);
GraphicsExportSetOutputFileTypeAndCreator (grexc,t,c);
GraphicsExportDoExport (grexc,&dummy);
CloseComponent (grexc);
}
}
}
//------------------------------------------------------------------------
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;
}
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;
}
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);
}
}
