//////////

//

//  File:       QTGraphImp.c

//

//  Contains:   Sample code for using QuickTime's graphics import routines.

//

//  Written by: Tim Monroe

//              Based loosely on the SimpleGIExample.c code written by Apple DTS;

//              exporting code based heavily on Dispatch 14 from the Ice Floe by Sam Bushell.

//

//  Copyright:  © 1998 by Apple Computer, Inc., all rights reserved.

//

//  Change History (most recent first):

//

//     <3>      03/21/00    rtm     reworked functions to avoid calling Standard File Package

//     <2>      06/02/98    rtm     added QTGraphImp_ExportGWorldToFile and _GetAvailableExportTypes,

//                                  from Dispatch 14 from the Ice Floe; added QTGraphImp_ExportImageFile

//     <1>      04/14/98    rtm     first file

//     

//  This sample code illustrates how to use QuickTime's graphics importer routines

//  to open and display image files. The graphics importer routines were introduced

//  in QuickTime version 2.5 as a new way to draw still images. The graphics import

//  routines (for example, GetGraphicsImporterForFile) use graphics import components

//  (of component type 'grip') to open and perform other operations on image files.

//  Essentially, you can use the graphics import routines to insulate your application

//  from the nitty gritty details of the image file format and compression used in the

//  image.

//

//  This code also shows how to export images as picture files, and how to determine which

//  formats an image can be exported in. The QT functions that support these operations

//  were introduced in QuickTime version 3.

//

//  In this sample code, we allow the user to open an image file; then we draw it into

//  a window on the screen. Your application, of course, will probably want to do more

//  interesting things with the image. We also allow the user to save an image using JPEG

//  compression.

//

//////////

//////////

//

// header files

//

//////////

#include "QTGraphImp.h"

//////////

//

// global variables

//

//////////

WindowPtr                       gImageWindow = NULL;    // the window we display the image in

GraphicsImportComponent         gImporter = NULL;

//////////

//

// QTGraphImp_OpenImageFileAndDisplay

// Open an image file, then display the image in a window.

//

//////////

void QTGraphImp_OpenImageFileAndDisplay (FSSpecPtr theFSSpecPtr)

{

    Rect                        myRect;

    OSErr                       myErr = noErr;

    if (theFSSpecPtr == NULL)

        goto bail;

    //////////

    //

    // get a graphics importer for the image file and determine the natural size of the image

    //

    //////////

    myErr = GetGraphicsImporterForFile(theFSSpecPtr, &gImporter);

    if (myErr != noErr)

        goto bail;

    myErr = GraphicsImportGetNaturalBounds(gImporter, &myRect);

    if (myErr != noErr)

        goto bail;

    //////////

    //

    // create a window to display the image in; then draw into that window

    //

    //////////

    MacOffsetRect(&myRect, 50, 50);

    gImageWindow = NewCWindow(NULL, &myRect, theFSSpecPtr->name, true, movableDBoxProc, (WindowPtr)-1L, true, 0);

    if (gImageWindow == NULL)

        goto bail;

    // set the current port and draw

    GraphicsImportSetGWorld(gImporter, GetWindowPort(gImageWindow), NULL);

    GraphicsImportDraw(gImporter);

bail:

    if (myErr != noErr)

        if (gImporter != NULL)

            CloseComponent(gImporter);

}

//////////

//

// QTGraphImp_SaveCompressedImageIntoDiskFile

// Compress the current picture into the specified file.

//

//////////

void QTGraphImp_SaveCompressedImageIntoDiskFile (FSSpecPtr theFSSpecPtr)

{

    Rect                        myRect;

    GWorldPtr                   myGWorld;

    OSErr                       myErr = noErr;

    if (theFSSpecPtr == NULL)

        goto bail;

    // get the natural size of the image

    myErr = GraphicsImportGetNaturalBounds(gImporter, &myRect);

    if (myErr != noErr)

        goto bail;

    // create an offscreen graphics world to draw the image into

    myErr = NewGWorld(&myGWorld, 0, &myRect, NULL, NULL, 0);

    if (myErr == noErr) {

        GraphicsImportSetGWorld(gImporter, (CGrafPtr)myGWorld, NULL);

        GraphicsImportDraw(gImporter);

        // save the compressed image

        QTGraphImp_SaveCompressedImage(myGWorld, theFSSpecPtr);

        if (myGWorld != NULL)

            DisposeGWorld(myGWorld);

    }

bail:

    ;

}

//////////

//

// QTGraphImp_SaveCompressedImage

// Save the current image as a compressed file.

//

//////////

void QTGraphImp_SaveCompressedImage (GWorldPtr theWorld, FSSpec *theFile)

{

    ImageDescriptionHandle      myDesc;

    Handle                      myData;

    Rect                        myRect;

    PixMapHandle                myPixMap;   

    CTabHandle                  myCTab = NULL;

    ICMFlushProcRecord          myFlushProc;

    short                       myRefNum;

    short                       myDepth;

    OSErr                       myErr = noErr;

    if ((theWorld == NULL) || (theFile == NULL))

        goto bail;

    myDesc = (ImageDescriptionHandle)NewHandle(sizeof(ImageDescription));

    if (myDesc == NULL)

        goto bail;

#if TARGET_OS_MAC

    GetPortBounds(theWorld, &myRect);

#endif

#if TARGET_OS_WIN32

    myRect = theWorld->portRect;

#endif

    myPixMap = GetGWorldPixMap(theWorld);

    if (LockPixels(myPixMap)) {

        // if less than 16-bit, then get the color table of our GWorld

        myDepth = (**myPixMap).pixelSize;

        if (myDepth < 16)

            myCTab = (**myPixMap).pmTable;

        myData = NewHandle(kBufferSize);

        myErr = MemError();

        if ((myData != NULL) && (myErr == noErr)) {

            CodecType           myCodec = kJPEGCodecType;

            HLock(myData);

            myErr = FSpCreate(theFile, kImageFileCreator, kQTFileTypeJPEG, 0);

            if (myErr == noErr)

                myErr = FSpOpenDF(theFile, fsRdWrPerm, &myRefNum);

            if (myErr == noErr)

                myErr = SetFPos(myRefNum, fsFromStart, 0);

            if (myErr == noErr) {

                ICMFlushProcRecordPtr       myFlushProcPtr = NULL;

#if USE_FLUSH_PROC

                myFlushProc.flushProc = NewICMFlushProc(QTGraphImp_DataUnloadProc);

                myFlushProc.flushRefCon = myRefNum;

                myFlushProcPtr = &myFlushProc;

#else

                myFlushProcPtr = NULL;

#endif

                // compress the image

                myErr = FCompressImage( myPixMap,

                                        &myRect,

                                        myDepth,

                                        codecNormalQuality,

                                        myCodec,

                                        anyCodec,

                                        myCTab,

                                        codecFlagWasCompressed,

                                        kBufferSize,

                                        myFlushProcPtr,

                                        NULL,

                                        myDesc,

                                        *myData);

#if !USE_FLUSH_PROC

                if (myErr == noErr)

                    myErr = FSWrite(myRefNum, &(**myDesc).dataSize, *myData);

#endif

                if (myErr == noErr)

                    myErr = SetFPos(myRefNum, fsFromStart, (**myDesc).dataSize);

                if (myErr == noErr)

                    myErr = SetEOF(myRefNum, (**myDesc).dataSize);

                if (myErr == noErr)     

                    myErr = FSClose(myRefNum);

                HUnlock(myData);

                DisposeHandle(myData);

#if USE_FLUSH_PROC

                DisposeRoutineDescriptor(myFlushProc.flushProc);

#endif

            }

        }

    }

    UnlockPixels(myPixMap);

bail:   

    if (myDesc != NULL)

        DisposeHandle((Handle)myDesc);

}           

//////////

//

// QTGraphImp_DataUnloadProc

// A data unloading procedure: write the compressed data to disk.

//

// The theRefCon parameter is assumed to be a file reference number of an open file.

//

//////////

PASCAL_RTN OSErr QTGraphImp_DataUnloadProc (Ptr theData, long theBytesNeeded, long theRefCon)

{

    OSErr       myErr = noErr;

    if (theData == NULL) {

        // if data is NULL, set a new position in the file from the current mark, offset by bytesNeeded

        myErr = SetFPos(theRefCon, fsFromMark, theBytesNeeded);

    } else {

        // otherwise, write the specified data to disk

        myErr = FSWrite(theRefCon, &theBytesNeeded, theData);

    }

    return(myErr);

}

//////////

//

// QTGraphImp_ExportGWorldToFile

// Save the image in a graphics world to the specified file.

//

// Use this function when you've got an image that you want to export to a file

// but that image wasn't read in from a file (in which case you could just use

// the GetGraphicsImporterForFile function to open an appropriate graphics importer).

//

// Based on the function ExportGWorldToFile in Dispatch 14 from the Ice Floe.

//

//////////

OSErr QTGraphImp_ExportGWorldToFile (GWorldPtr theWorld, FSSpec *theFile, OSType theType)

{

    PicHandle                   myPicture = NULL;

    PixMapHandle                myPixMap = NULL;

    GraphicsImportComponent     myImporter = NULL;

    Handle                      myHandle = NULL;

    CGrafPtr                    mySavedGW;

    GDHandle                    mySavedGD;

    Rect                        myRect;

    OSErr                       myErr = noErr;

    // save the current graphics world, and set the specified graphics world as current

    GetGWorld(&mySavedGW, &mySavedGD);

    SetGWorld(theWorld, NULL);

    mySrcPixMap = GetGWorldPixMap(theWorld);

#if TARGET_OS_MAC

    GetPortBounds(theWorld, &myRect);

#endif

#if TARGET_OS_WIN32

    myRect = theWorld->portRect;

#endif

    // capture the contents of the specified graphics world in a picture handle

    myPicture = OpenPicture(&((GrafPtr)theWorld)->portRect);

    CopyBits(   (BitMapPtr)*myPixMap,

                (BitMapPtr)*myPixMap,

                &myRect,

                &myRect,

                srcCopy,

                NULL);

    ClosePicture();

    // convert the picture handle into a handle-based PICT file by adding a 512-byte header to the start;

    // picture files are just like picture handles, except that they have an extra 512-byte header at the

    // front; any data in this header is usually ignored but it must exist, for historical reasons

    myHandle = NewHandleClear(512);

    myErr = MemError();

    if (myErr != noErr)

        goto bail;

    myErr = HandAndHand((Handle)myPicture, myHandle);

    if (myErr != noErr)

        goto bail;

    // open an instance of the picture file graphics importer

    myErr = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypePicture, &myImporter);

    if (myErr != noErr)

        goto bail;

    myErr = GraphicsImportSetDataHandle(myImporter, myHandle);

    if (myErr != noErr)

        goto bail;

    // export the image to a file

    myErr = GraphicsImportExportImageFile(myImporter, theType, kImageFileCreator, theFile, smSystemScript);

bail:

    // restore the original graphics world

    SetGWorld(mySavedGW, mySavedGD);

    if (myPicture != NULL)

        KillPicture(myPicture);

    if (myImporter != NULL)

        CloseComponent(myImporter);

    if (myHandle != NULL)

        DisposeHandle(myHandle);

    return(myErr);

}

//////////

//

// QTGraphImp_GetAvailableExportTypes

// Get a list of the available image export file types.

//

// Based on a function in Dispatch 14 from the Ice Floe.

//

//////////

OSErr QTGraphImp_GetAvailableExportTypes (GraphicsImportComponent theImporter)

{

    QTAtomContainer             myContainer = NULL;

    short                       myCount, myIndex;

    OSErr                       myErr = noErr;

    // get an atom container that contains one or more kGraphicsExportGroup atoms;

    // each export group atom represents a single export format and has child atoms that indicate

    // the file type (kGraphicsExportFileType), a human-readable name (kGraphicsExportDescription),

    // a file extension (kGraphicsExportExtension) and a MIME type (kGraphicsExportMIMEType)

    myErr = GraphicsImportGetExportImageTypeList(theImporter, &myContainer);

    if (myErr != noErr)

        goto bail;

    myCount = QTCountChildrenOfType(myContainer, kParentAtomIsContainer, kGraphicsExportGroup);

    for (myIndex = 1; myIndex <= myCount; myIndex++) {

        QTAtom                  myGroupAtom;

        myGroupAtom = QTFindChildByIndex(myContainer, kParentAtomIsContainer, kGraphicsExportGroup, myIndex, NULL);

        if (myGroupAtom != 0) {

            QTAtom              myTypeAtom;

            myTypeAtom = QTFindChildByIndex(myContainer, myGroupAtom, kGraphicsExportFileType, 1, NULL);

            if (myTypeAtom != 0) {

                OSType          myType;

                myErr = QTCopyAtomDataToPtr(myContainer, myTypeAtom, false, sizeof(myType), &myType, NULL);

                // the data in QT atoms is always big-endian, so convert the file type to native format

                myType = EndianU32_BtoN(myType);

                // at this point, you probably want to do something interesting with the file type, eh?

                // this is left as an exercise for the reader

            } else {

                myErr = cannotFindAtomErr;

            }

        }

    }

bail:

    if (myContainer != NULL)

        QTDisposeAtomContainer(myContainer);

    return(myErr);

}

//////////

//

// QTGraphImp_ExportImageFile

// Let the user select a disk file, then export the current picture into that file.

//

//////////

OSErr QTGraphImp_ExportImageFile (GraphicsImportComponent theImporter)

{

    OSType                  myType;

    FSSpec                  myFSSpec;

    OSErr                   myErr = noErr;

    myErr = GraphicsImportDoExportImageFileDialog(

                            theImporter, 

                            NULL,           // no default name for the file

                            NULL,           // use the default prompt in the dialog box

                            NULL,           // no modal dialog filter procedure

                            &myType,        // return the type of the selected file

                            &myFSSpec,      // return the name (etc.) of the selected file

                            NULL);          // don't return the script code

    return(myErr);

}