quicktime.std.image
Class GraphicsExporter

java.lang.Object
  |
  +--quicktime.QTObject
        |
        +--quicktime.std.comp.ComponentIdentifier
              |
              +--quicktime.std.comp.Component
                    |
                    +--quicktime.std.image.GraphicsExporter
All Implemented Interfaces:
Errors, quicktime.jdirect.InterfaceLib, quicktime.jdirect.PrimitivesLib, quicktime.jdirect.QuickTimeLib, quicktime.jdirect.SharedLibrary, com.apple.jdirect.SharedLibrary

public final class GraphicsExporter
extends Component
implements quicktime.jdirect.QuickTimeLib, Errors

Graphics exporter components provide a standard interface for exporting graphics to image files in a variety of formats. QuickTime selects a graphic exporter component based on the desired output format, such as TIFF or PNG. Different image formats support a wide range of configurable features, such as depth, resolution and compression quality. This class implements methods for a corresponding QuickTime ComponentInstance structure. refer to GraphicsExportComponent in QuickTime The base exporter communicates with data handler components to negotiate access to image file data. If necessary, it calls the Image Compression Manager to perform compression operations. There are three modes that format-specific exporters can operate in: - Transcode. Data is transferred from one image file to another without decompressing and recompressing. (The data may be modified along the way, if appropriate.) - Using a Compressor. The graphics exporter provides an atom container identifying which compressor to use, and any settings to be passed to that compressor. - Standalone Export. The graphics exporter component does all the work itself, without using an image compressor.


Fields inherited from interface quicktime.jdirect.QuickTimeLib
JDirect_MacOSX, libraryInstance, name
 
Fields inherited from interface quicktime.Errors
AAPNotCreatedErr, AAPNotFoundErr, abortErr, addResFailed, afpAccessDenied, afpObjectTypeErr, ASDBadForkErr, ASDBadHeaderErr, ASDEntryNotFoundErr, atomIndexInvalidErr, atomsNotOfSameTypeErr, auxiliaryExportDataUnavailable, badCallOrderErr, badChannel, badComponentInstance, badComponentSelector, badComponentType, badControllerHeight, badDataRefIndex, badDepthErr, badEditIndex, badEditList, badFileFormat, badFormat, badImageDescription, badPublicMovieAtom, badSGChannel, badTrackIndex, badUnitErr, bdNamErr, buffersTooSmall, callNotSupportedByNodeErr, cannotBeLeafAtomErr, cannotFindAtomErr, cannotMoveAttachedController, cannotSetWidthOfAttachedController, cantCreateSingleForkFile, cantDoThatInCurrentMode, cantEnableTrack, cantFindHandler, cantOpenHandler, cantPutPublicMovieAtom, cantReceiveFromSynthesizerOSErr, cantSendToSynthesizerOSErr, cDepthErrInvalid, channelBusy, channelNotBusy, closErr, codecAbortErr, codecBadDataErr, codecCantQueueErr, codecCantWhenErr, codecConditionErr, codecDataVersErr, codecDisabledErr, codecDroppedFrameErr, codecErr, codecExtensionNotFoundErr, codecImageBufErr, codecNeedAccessKeyErr, codecNeedToFlushChainErr, codecNoMemoryPleaseWaitErr, codecNothingToBlitErr, codecOffscreenFailedErr, codecOpenErr, codecParameterDialogConfirm, codecScreenBufErr, codecSizeErr, codecSpoolErr, codecUnimpErr, codecWouldOffscreenErr, componentDllEntryNotFoundErr, componentDllLoadErr, componentDontRegister, componentNotCaptured, constraintReachedErr, controlErr, controllerBoundsNotExact, controllerHasFixedHeight, couldNotResolveDataRef, couldNotUseAnExistingSample, couldntGetRequiredComponent, dataAlreadyClosed, dataAlreadyOpenForWrite, dataNoDataRef, dataNotOpenForRead, dataNotOpenForWrite, destPortErr, deviceCantMeetRequest, digiUnimpErr, dInstErr, dirFulErr, dirNFErr, dRemovErr, dskFulErr, dupFNErr, duplicateAtomTypeAndIDErr, duplicateHandlerErr, editingNotAllowed, emptyPathErr, endOfDataReached, eofErr, fBsyErr, featureUnsupported, fileOffsetTooBigErr, fnfErr, grabTimeComplete, gWorldsNotSameDepthAndSizeErr, handlerNotFoundErr, illegalChannelOSErr, illegalControllerOSErr, illegalInstrumentOSErr, illegalKnobOSErr, illegalKnobValueOSErr, illegalNoteChannelOSErr, illegalPartOSErr, illegalVoiceAllocationOSErr, internalComponentErr, internalQuickTimeError, invalidAtomContainerErr, invalidAtomErr, invalidAtomTypeErr, invalidChunkCache, invalidChunkNum, invalidComponentID, invalidDataRef, invalidDataRefContainer, invalidDuration, invalidEditState, invalidHandler, invalidHotSpotIDErr, invalidImageIndexErr, invalidMedia, invalidMovie, invalidNodeFormatErr, invalidNodeIDErr, invalidRect, invalidSampleDescIndex, invalidSampleDescription, invalidSampleNum, invalidSampleTable, invalidSpriteIDErr, invalidSpriteIndexErr, invalidSpritePropertyErr, invalidSpriteWorldPropertyErr, invalidTime, invalidTrack, invalidViewStateErr, ioErr, kIllegalInstrumentErr, kInvalidPartNumberErr, kQ3ErrorAcceleratorAlreadySet, kQ3ErrorAccessRestricted, kQ3ErrorAlreadyInitialized, kQ3ErrorAlreadyRendering, kQ3ErrorAttributeInvalidType, kQ3ErrorAttributeNotContained, kQ3ErrorBadDrawContext, kQ3ErrorBadDrawContextFlag, kQ3ErrorBadDrawContextType, kQ3ErrorBadStringType, kQ3ErrorBeginWriteAlreadyCalled, kQ3ErrorBeginWriteNotCalled, kQ3ErrorBoundingLoopFailed, kQ3ErrorBoundsNotStarted, kQ3ErrorCameraNotSet, kQ3ErrorController, kQ3ErrorDataNotAvailable, kQ3ErrorDegenerateGeometry, kQ3ErrorDisplayNotSet, kQ3ErrorDrawContextNotSet, kQ3ErrorEndOfContainer, kQ3ErrorEndOfFile, kQ3ErrorEndWriteNotCalled, kQ3ErrorExtensionError, kQ3ErrorFileAlreadyOpen, kQ3ErrorFileCancelled, kQ3ErrorFileIsOpen, kQ3ErrorFileModeRestriction, kQ3ErrorFileNotOpen, kQ3ErrorFileVersionExists, kQ3ErrorGeometryInsufficientNumberOfPoints, kQ3ErrorImmediateModeUnderflow, kQ3ErrorInternalError, kQ3ErrorInvalidCameraValues, kQ3ErrorInvalidData, kQ3ErrorInvalidGeometryType, kQ3ErrorInvalidHexString, kQ3ErrorInvalidMetafile, kQ3ErrorInvalidMetafileLabel, kQ3ErrorInvalidMetafileObject, kQ3ErrorInvalidMetafilePrimitive, kQ3ErrorInvalidMetafileSubObject, kQ3ErrorInvalidObject, kQ3ErrorInvalidObjectClass, kQ3ErrorInvalidObjectForGroup, kQ3ErrorInvalidObjectForPosition, kQ3ErrorInvalidObjectName, kQ3ErrorInvalidObjectType, kQ3ErrorInvalidParameter, kQ3ErrorInvalidPositionForGroup, kQ3ErrorInvalidSubObjectForObject, kQ3ErrorLastFatalError, kQ3ErrorMacintoshError, kQ3ErrorMemoryLeak, kQ3ErrorMetaHandlerRequired, kQ3ErrorNeedRequiredMethods, kQ3ErrorNoBeginGroup, kQ3ErrorNoExtensionsFolder, kQ3ErrorNonInvertibleMatrix, kQ3ErrorNonUniqueLabel, kQ3ErrorNoRecovery, kQ3ErrorNoStorageSetForFile, kQ3ErrorNoSubClassType, kQ3ErrorNothingToPop, kQ3ErrorNotInitialized, kQ3ErrorNotSupported, kQ3ErrorNULLParameter, kQ3ErrorObjectClassInUse, kQ3ErrorOutOfMemory, kQ3ErrorParameterOutOfRange, kQ3ErrorPickingLoopFailed, kQ3ErrorPickingNotStarted, kQ3ErrorPrivateExtensionError, kQ3ErrorReadLessThanSize, kQ3ErrorReadMoreThanSize, kQ3ErrorReadStateInactive, kQ3ErrorRegistrationFailed, kQ3ErrorRendererNotSet, kQ3ErrorRenderingIsActive, kQ3ErrorRenderingLoopFailed, kQ3ErrorRenderingNotStarted, kQ3ErrorScaleOfZero, kQ3ErrorSizeMismatch, kQ3ErrorSizeNotLongAligned, kQ3ErrorStartGroupRange, kQ3ErrorStateUnavailable, kQ3ErrorStorageAlreadyOpen, kQ3ErrorStorageInUse, kQ3ErrorStorageIsOpen, kQ3ErrorStorageNotOpen, kQ3ErrorStringExceedsMaximumLength, kQ3ErrorTracker, kQ3ErrorTypeAlreadyExistsAndHasObjectInstances, kQ3ErrorTypeAlreadyExistsAndHasSubclasses, kQ3ErrorTypeAlreadyExistsAndOtherClassesDependOnIt, kQ3ErrorUnimplemented, kQ3ErrorUnixError, kQ3ErrorUnknownElementType, kQ3ErrorUnknownObject, kQ3ErrorUnknownStudioType, kQ3ErrorUnmatchedEndGroup, kQ3ErrorUnresolvableReference, kQ3ErrorUnsupportedFunctionality, kQ3ErrorUnsupportedGeometryType, kQ3ErrorUnsupportedPixelDepth, kQ3ErrorValueExceedsMaximumSize, kQ3ErrorVector3DNotUnitLength, kQ3ErrorVector3DZeroLength, kQ3ErrorViewIsStarted, kQ3ErrorViewNotStarted, kQ3ErrorWin32Error, kQ3ErrorWriteStateInactive, kQ3ErrorWritingLoopFailed, kQ3ErrorWroteLessThanSize, kQ3ErrorWroteMoreThanSize, kQ3ErrorX11Error, kQ3NoticeBrightnessGreaterThanOne, kQ3NoticeDataAlreadyEmpty, kQ3NoticeDrawContextNotSetUsingInternalDefaults, kQ3NoticeFileAliasWasChanged, kQ3NoticeFileCancelled, kQ3NoticeInvalidAttenuationTypeUsingInternalDefaults, kQ3NoticeMeshEdgeIsNotBoundary, kQ3NoticeMeshEdgeVertexDoNotCorrespond, kQ3NoticeMeshInvalidVertexFacePair, kQ3NoticeMeshVertexHasNoComponent, kQ3NoticeMethodNotSupported, kQ3NoticeObjectAlreadySet, kQ3NoticeParameterOutOfRange, kQ3NoticeScaleContainsZeroEntries, kQ3NoticeSystemAlreadyInitialized, kQ3NoticeViewSyncCalledAgain, kQ3WarningExtensionNotLoading, kQ3WarningFilePointerRedefined, kQ3WarningFilePointerResolutionFailed, kQ3WarningFunctionalityNotSupported, kQ3WarningInconsistentData, kQ3WarningInternalException, kQ3WarningInvalidHexString, kQ3WarningInvalidMetafileObject, kQ3WarningInvalidObjectInGroupMetafile, kQ3WarningInvalidPaneDimensions, kQ3WarningInvalidSubObjectForObject, kQ3WarningInvalidTableOfContents, kQ3WarningLowMemory, kQ3WarningNoAttachMethod, kQ3WarningNone, kQ3WarningNonInvertibleMatrix, kQ3WarningNoObjectSupportForDrawMethod, kQ3WarningNoObjectSupportForDuplicateMethod, kQ3WarningNoObjectSupportForReadMethod, kQ3WarningNoObjectSupportForWriteMethod, kQ3WarningParameterOutOfRange, kQ3WarningPickParamOutside, kQ3WarningPossibleMemoryLeak, kQ3WarningQuaternionEntriesAreZero, kQ3WarningReadLessThanSize, kQ3WarningScaleContainsNegativeEntries, kQ3WarningScaleEntriesAllZero, kQ3WarningStringExceedsMaximumLength, kQ3WarningTypeAlreadyRegistered, kQ3WarningTypeAndMethodAlreadyDefined, kQ3WarningTypeHasNotBeenRegistered, kQ3WarningTypeIsOutOfRange, kQ3WarningTypeNewerVersionAlreadyRegistered, kQ3WarningTypeSameVersionAlreadyRegistered, kQ3WarningUnknownElementType, kQ3WarningUnknownObject, kQ3WarningUnmatchedBeginGroup, kQ3WarningUnmatchedEndGroup, kQ3WarningUnresolvableReference, kQ3WarningVector3DNotUnitLength, kQ3WarningViewTraversalInProgress, kUnspecifiedErr, limitReachedErr, lockPortBitsBadPortErr, lockPortBitsBadSurfaceErr, lockPortBitsSurfaceLostErr, lockPortBitsWindowClippedErr, lockPortBitsWindowMovedErr, lockPortBitsWindowResizedErr, matrixErr, maxSizeToGrowTooSmall, mediaTypesDontMatch, memFullErr, midiManagerAbsentOSErr, missingRequiredParameterErr, movieTextNotFoundErr, movieToolboxUninitialized, noCodecErr, noDataHandler, noDefaultDataRef, noDeviceForChannel, noDMAErr, noErr, noExportProcAvailableErr, noGlobalsErr, noMediaHandler, noMemoryNodeFailedInitialize, noMoreKeyColorsErr, noMoreRealTime, noMovieFound, nonMatchingEditState, noPathMappingErr, noPortErr, noRecordOfApp, noSoundTrackInMovieErr, noSourceTreeFoundErr, notAllowedToSaveMovieErr, notAQTVRMovieErr, noteChannelNotAllocatedOSErr, notEnoughBufferSpace, notEnoughDataErr, notEnoughDiskSpaceToGrab, notEnoughHardwareErr, notEnoughMemoryToGrab, notExactMatrixErr, notExactSizeErr, notImplementedMusicOSErr, notLeafAtomErr, noVideoTrackInMovieErr, nsvErr, openErr, paramErr, pathNotVerifiedErr, pathTooLongErr, permErr, pictIsOpenErr, progressProcAborted, propertyNotSupportedByNodeErr, qfcbNotCreatedErr, qfcbNotFoundErr, qtActionNotHandledErr, qtmlDllEntryNotFoundErr, qtmlDllLoadErr, qtmlUninitialized, qtNetworkAlreadyAllocatedErr, qtParamErr, qtvrLibraryLoadErr, qtvrUninitialized, queueFull, readErr, resFNotFound, resNotFound, resProblem, rgnTooBigErr, rmvResFailed, samplesAlreadyInMediaErr, scTypeNotFoundErr, selectorNotSupportedByNodeErr, seqGrabInfoNotAvailable, settingNotSupportedByNodeErr, siBadDeviceName, siBadRefNum, siBadSoundInDevice, siDeviceBusyErr, siHardDriveTooSlow, siInputDeviceErr, siInvalidCompression, siInvalidSampleRate, siInvalidSampleSize, siNoBufferSpecified, siNoSoundInHardware, siUnknownInfoType, siUnknownQuality, soundSupportNotAvailableErr, sourceNotFoundErr, staleEditState, statusErr, streamingNodeNotReadyErr, synthesizerNotRespondingOSErr, synthesizerOSErr, timeNotInMedia, timeNotInTrack, timeNotInViewErr, trackIDNotFound, trackNotInMovie, tuneParseOSErr, tunePlayerFullOSErr, unitEmptyErr, unknownFormatErr, unresolvedComponentDLLErr, unsupportedAuxiliaryImportData, unsupportedOSErr, unsupportedProcessorErr, urlDataHFTPBadNameListErr, urlDataHFTPBadPasswordErr, urlDataHFTPBadUserErr, urlDataHFTPDataConnectionErr, urlDataHFTPFilenameErr, urlDataHFTPNeedPasswordErr, urlDataHFTPNoDirectoryErr, urlDataHFTPNoNetDriverErr, urlDataHFTPNoPasswordErr, urlDataHFTPPermissionsErr, urlDataHFTPProtocolErr, urlDataHFTPQuotaErr, urlDataHFTPServerDisconnectedErr, urlDataHFTPServerErr, urlDataHFTPShutdownErr, urlDataHFTPURLErr, urlDataHHTTPNoNetDriverErr, urlDataHHTTPProtocolErr, urlDataHHTTPRedirectErr, urlDataHHTTPURLErr, userCanceledErr, userDataItemNotFound, validInstancesExist, videoOutputInUseErr, vLckdErr, wackBadFileErr, wackBadMetaDataErr, wackForkNotFoundErr, wfFileNotFound, wPrErr, writErr
 
Constructor Summary
GraphicsExporter(int subType)
          Opens the specified graphics export component,'grex', with the given subType.
 
Method Summary
 boolean canTranscode()
          Format-specific exporters may delegate this call; the base graphics exporter's implementation gives a reply of false .Use this call to ask a graphics exporter whether it can transcode the current input with the current settings.
 GECompressorInfo canUseCompressor()
          The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
 int doExport()
          You can use the GraphicsExportDoExport function to perform an export operation.
 void doStandaloneExport()
          If both CanTranscode and CanUseCompressor reply false , the base graphics exporter makes this call of the format-specific exporter to perform the call.
 void doTranscode()
          The base graphics exporter makes this call of the format-specific graphics exporter to perform a transcoding export.
 ImageDescription doUseCompressor(AtomContainer ac)
          The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
 void drawInputImage(QDGraphics gw, QDRect srcRect, QDRect destRect)
          Used by format-specific graphics exporters, especially when doing standalone export: Draws a rectangular portion of the input image.
 int getCompressionMethod()
          Defines the compression method to use.
 int getCompressionQuality()
          Defines the compression quality to use.
 java.lang.String getDefaultFileCreator()
          Returns file creator for the new image file format.
 java.lang.String getDefaultFileNameExtension()
          Returns the suggested file name extension.
 java.lang.String getDefaultFileType()
          Returns the default file Type for the new image file format.
 int getDepth()
          Defines the depth to use.
 boolean getDontRecompress()
          Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
 int getHorizontalResolution()
          Gets the resolution to saved and stored.
 DataRef getInputDataReference()
          Gets the DataRef of the source for input images to graphics export component.
 int getInputDataSize()
          Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
 QTFile getInputFile()
          Gets the file that is the source for input images to graphics export component.
 GraphicsImporter getInputGraphicsImporter()
          Determines the GraphicsImporter that is the source for input images to graphics export component.
 QDGraphics getInputGWorld()
          Determines the QDGraphics that is the source for input images to graphics export component.
 QTHandle getInputHandle()
          Determines the data reference that is the source for input images to graphics export component.
 int getInputImageDepth()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the depth of the input image.
 ImageDescription getInputImageDescription()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the number of bytes of original image data that can be read.
 QDRect getInputImageDimensions()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the dimensions of the input image.
 int getInputLimit()
          Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
 int getInputOffset()
          Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
 Pict getInputPicture()
          Determines the Pict that is the source for input images to graphics export component.
 PixMap getInputPixmap()
          Determines the QDGraphics that is the source for input images to graphics export component.
 QTPointerRef getInputPtr()
          Determines the data reference that is the source for input images to graphics export component.
 int getInterlaceStyle()
          Returns the interlace style.
 UserData getMetaData()
          Returns supplemental data, such as textual copyright information.
 AtomContainer getMIMETypeList()
          Returns MIME types and other information about the graphics format.
 DataRef getOutputDataReference()
          Gets the DataRef of the destination for output images.
 QTFile getOutputFile()
          Gets the file that is the destination for output images.
 int getOutputFileCreator()
          Gets the Output file Creator.
 int getOutputFileType()
          Gets the Output file type.
 QTHandle getOutputHandle()
          Determines the data reference that is the destination for output images.
 int getOutputMaxSize()
          Gets the output starting offset and maximum size limit.
 int getOutputOffset()
          Gets the output starting offset and maximum size limit.
 boolean getOutputTruncateFile()
          Gets the output starting offset and maximum size limit.
 AtomContainer getSettingsAsAtomContainer()
          These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
 QTHandle getSettingsAsText()
          This function is used for obtaining graphics exporter settings and displaying a settings dialog box.
 int getTargetDataSize()
          Specifies a desired maximum data size and asks for a quality that does not exceed that size.
 int getVerticalResolution()
          Defines the compression quality to use.
 byte[] GraphicsExportReadOutputData(int dataOffset, int dataSize)
          This function is used by format-specific graphics exporters to write output data.
 void GraphicsExportWriteOutputData(byte[] data, int dataSize)
          This function is used by format-specific graphics exporters to write output data.
 boolean mayExporterReadInputData()
          Used by format-specific graphics exporters when transcoding: Asks whether the image source is in a form that can be read.
 byte[] readInputData(int dataOffset, int dataSize)
          Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
 void requestSettings()
          These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
 void setCompressionMethod(int compressionMethod)
          Defines the compression method to use.
 void setCompressionQuality(int spatialQuality)
          Defines the compression quality.
 void setDepth(int depth)
          Defines the depth to use.
 void setDontRecompress(boolean dontRecompress)
          Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
 void setInputDataReference(DataRef dataRef, ImageDescription desc)
          Sets the specified DataRef as the source for input images to graphics export component.
 void setInputFile(QTFile theFile, ImageDescription desc)
          Sets the specified QTFile as the source for input images to graphics export component.
 void setInputGraphicsImporter(GraphicsImporter grip)
          Sets the GraphicsImporter as the source for input images to graphics export component.
 void setInputGWorld(QDGraphics gworld)
          Sets the QDGraphics as the source for input images to graphics export component.
 void setInputHandle(QTHandle h, ImageDescription desc)
          Sets the data handle as the source for input images to graphics export component.
 void setInputOffsetAndLimit(int offset, int limit)
          Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
 void setInputPicture(Pict picture)
          Sets the Pict as the source for input images to graphics export component.
 void setInputPixmap(QDGraphics gworld)
          Sets the QDGraphics as the source for input images to graphics export component.
 void setInputPtr(QTPointerRef p, ImageDescription desc)
          Sets the data handle reference as the source for input images to graphics export component.
 void setInterlaceStyle(int interlaceStyle)
          Defines the interlace style.
 void setMetaData(UserData userData)
          Defines supplemental data, such as textual copyright information.
 void setOutputDataReference(DataRef dataRef)
          Used to specify destination for output images.
 void setOutputFile(QTFile theFile)
          Sets the specified QTFile as the destination for output images.
 void setOutputFileTypeAndCreator(int fileType, int fileCreator)
          Specifies the output starting offset and maximum size limit.
 void setOutputHandle(QTHandleRef h)
          Sets the data handle as the destination for output images.
 void setOutputOffsetAndMaxSize(int offset, int maxSize, boolean truncateFile)
          Specifies the output starting offset and maximum size limit.
 void setResolution(int horizontalResolution, int verticalResolution)
          Defines the resolution to save and store.
 void setSettingsFromAtomContainer(AtomContainer qtAtomContainer)
          These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
 void setTargetDataSize(int targetDataSize)
          Defines a desired maximum data size and asks for a quality that does not exceed that size.
 
Methods inherited from class quicktime.std.comp.Component
count
 
Methods inherited from class quicktime.std.comp.ComponentIdentifier
find, find, getInfo, toString
 
Methods inherited from class quicktime.QTObject
disposeQTObject, equals, ID
 
Methods inherited from class java.lang.Object
getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Constructor Detail

GraphicsExporter

public GraphicsExporter(int subType)
                 throws QTException
Opens the specified graphics export component,'grex', with the given subType.

QuickTime::OpenADefaultComponent

Parameters:
subType - The graphics export component sub type
Method Detail

doExport

public int doExport()
             throws StdQTException
You can use the GraphicsExportDoExport function to perform an export operation. Before calling GraphicsExportDoExport , you must specify an input image (using a GraphicsExportSetInput call) and a destination for the output image file (using a GraphicsExportSetOutput call).

QuickTime::GraphicsExportDoExport

Returns:
the actual size of the image exported

doStandaloneExport

public void doStandaloneExport()
                        throws QTException
If both CanTranscode and CanUseCompressor reply false , the base graphics exporter makes this call of the format-specific exporter to perform the call.

QuickTime::GraphicsExportDoStandaloneExport


setInputDataReference

public void setInputDataReference(DataRef dataRef,
                                  ImageDescription desc)
                           throws QTException
Sets the specified DataRef as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputDataReference

Parameters:
dataRef - The DataRef for input images to export component sub type
desc - the ImageDescription handle

getInputDataReference

public DataRef getInputDataReference()
                              throws QTException
Gets the DataRef of the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputDataReference

Returns:
a DataRef object specifying the source of input images to the Graphics exporter.
See Also:
QTHandle.fromGraphicsExporterInput(quicktime.std.image.GraphicsExporter)

setInputFile

public void setInputFile(QTFile theFile,
                         ImageDescription desc)
                  throws QTException
Sets the specified QTFile as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputFile

Parameters:
theFile - The QTFile that points to the source of input images to export component
desc - the ImageDescription handle

getInputFile

public QTFile getInputFile()
                    throws QTException
Gets the file that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputFile

Returns:
a QTFile object that has the source of input images to the Graphics exporter.
See Also:
quicktime.io.QTFile.fromGraphicsExporterInput

setInputHandle

public void setInputHandle(QTHandle h,
                           ImageDescription desc)
                    throws QTException
Sets the data handle as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputHandle

Parameters:
h - The data handle that points to the source of input images to export component
desc - the ImageDescription handle

getInputHandle

public QTHandle getInputHandle()
                        throws QTException
Determines the data reference that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputHandle

Returns:
a QTHandle object that has the source of input images to the Graphics exporter.
See Also:
quicktime.std.util.QTHandle.fromGraphicsExporter

setInputPtr

public void setInputPtr(QTPointerRef p,
                        ImageDescription desc)
                 throws QTException
Sets the data handle reference as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputPtr

Parameters:
p - The pointer that points to the source of input images of export component
desc - the ImageDescription handle

getInputPtr

public QTPointerRef getInputPtr()
                         throws QTException
Determines the data reference that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputPtr

Returns:
a QTPointerRef object that has the source of input images to the Graphics exporter.

setInputGraphicsImporter

public void setInputGraphicsImporter(GraphicsImporter grip)
                              throws QTException
Sets the GraphicsImporter as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputGraphicsImporter

Parameters:
grip - The GraphicsImporter that points to the source of input images to export component

getInputGraphicsImporter

public GraphicsImporter getInputGraphicsImporter()
                                          throws QTException
Determines the GraphicsImporter that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputGraphicsImporter

Returns:
a GraphicsImporter object that has the source of input images to the Graphics exporter.

setInputPicture

public void setInputPicture(Pict picture)
                     throws QTException
Sets the Pict as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputPicture

Parameters:
picture - The Pict that points to the source of input images to export component

getInputPicture

public Pict getInputPicture()
                     throws QTException
Determines the Pict that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputPicture

Returns:
a Pict object that has the source of input images to the Graphics exporter.
See Also:
quicktime.std.qd.Pict.fromGraphicsExporter

setInputGWorld

public void setInputGWorld(QDGraphics gworld)
                    throws QTException
Sets the QDGraphics as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputGWorld

Parameters:
gworld - The QDGraphics that points to the source of input images to export component

getInputGWorld

public QDGraphics getInputGWorld()
                          throws QTException
Determines the QDGraphics that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputGWorld

Returns:
a QDGraphics object that has the source of input images to the Graphics exporter.
See Also:
quicktime.qd.QDGraphics.fromGraphicsExporter

setInputPixmap

public void setInputPixmap(QDGraphics gworld)
                    throws StdQTException
Sets the QDGraphics as the source for input images to graphics export component.

QuickTime::GraphicsExportSetInputPixmap

Parameters:
gworld - The QDGraphics that points to the source of input images to export component

getInputPixmap

public PixMap getInputPixmap()
                      throws QTException
Determines the QDGraphics that is the source for input images to graphics export component.

QuickTime::GraphicsExportGetInputPixmap

Returns:
a QDGraphics object that has the source of input images to the Graphics exporter.
See Also:
quicktime.qd.QDGraphics.fromGraphicsExporter

setOutputDataReference

public void setOutputDataReference(DataRef dataRef)
                            throws QTException
Used to specify destination for output images. Sets the specified DataRef as the destination for output images.

QuickTime::GraphicsExportSetOutputDataReference

Parameters:
dataRef - The DataRef for output images to export

getOutputDataReference

public DataRef getOutputDataReference()
                               throws QTException
Gets the DataRef of the destination for output images.

QuickTime::GraphicsExportGetOutputDataReference

Returns:
a DataRef object specifying the destination for output images.
See Also:
QTHandle.fromGraphicsExporterOutput(quicktime.std.image.GraphicsExporter)

setOutputFile

public void setOutputFile(QTFile theFile)
                   throws QTException
Sets the specified QTFile as the destination for output images.

QuickTime::GraphicsExportSetOutputFile

Parameters:
theFile - The QTFile that points to destination for output images.

getOutputFile

public QTFile getOutputFile()
                     throws QTException
Gets the file that is the destination for output images.

QuickTime::GraphicsExportGetOutputFile

Returns:
a QTFile object that has the destination for output images.
See Also:
quicktime.io.QTFile.fromGraphicsExporter

setOutputHandle

public void setOutputHandle(QTHandleRef h)
                     throws QTException
Sets the data handle as the destination for output images.

QuickTime::GraphicsExportSetOutputHandle

Parameters:
h - The data handle that points to the destination for output images.

getOutputHandle

public QTHandle getOutputHandle()
                         throws QTException
Determines the data reference that is the destination for output images.

QuickTime::GraphicsExportGetOutputHandle

Returns:
a QTHandle object that has the destination for output images.
See Also:
quicktime.std.util.QTHandle.fromGraphicsExporter

setOutputOffsetAndMaxSize

public void setOutputOffsetAndMaxSize(int offset,
                                      int maxSize,
                                      boolean truncateFile)
                               throws QTException
Specifies the output starting offset and maximum size limit.

QuickTime::GraphicsExportSetOutputOffsetAndMaxSize

Parameters:
offset - The byte offset of the image data from the beginning of the data reference.
maxSize - A value describing the maximum size limit.
truncateFile - A Boolean value specifying whether to truncate the file.

getOutputOffset

public int getOutputOffset()
                    throws StdQTException
Gets the output starting offset and maximum size limit.

QuickTime::GraphicsExportGetOutputOffsetAndMaxSize

Returns:
a starting offset.

getOutputMaxSize

public int getOutputMaxSize()
                     throws StdQTException
Gets the output starting offset and maximum size limit.

QuickTime::GraphicsExportGetOutputOffsetAndMaxSize

Returns:
maximum size limit.

getOutputTruncateFile

public boolean getOutputTruncateFile()
                              throws StdQTException
Gets the output starting offset and maximum size limit.

QuickTime::GraphicsExportGetOutputOffsetAndMaxSize

Returns:
maximum size limit.

setOutputFileTypeAndCreator

public void setOutputFileTypeAndCreator(int fileType,
                                        int fileCreator)
                                 throws QTException
Specifies the output starting offset and maximum size limit.

QuickTime::GraphicsExportSetOutputFileTypeAndCreator

Parameters:
fileType - The file type for the new image file, such as `JPEG' .
fileCreator - The file creator for the new image file. This parameter may be 0, in which case a default file creator for this file type is used.

getOutputFileType

public int getOutputFileType()
                      throws QTException
Gets the Output file type.

QuickTime::GraphicsExportGetOutputFileTypeAndCreator

Returns:
fileType

getOutputFileCreator

public int getOutputFileCreator()
                         throws QTException
Gets the Output file Creator.

QuickTime::GraphicsExportGetOutputFileTypeAndCreator

Returns:
fileCreator

mayExporterReadInputData

public boolean mayExporterReadInputData()
                                 throws QTException
Used by format-specific graphics exporters when transcoding: Asks whether the image source is in a form that can be read.

QuickTime::GraphicsExportMayExporterReadInputData

return true if the exporter is allowed to read the input data

getInputDataSize

public int getInputDataSize()
                     throws QTException
Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.

QuickTime::GraphicsExportGetInputDataSize

Returns:
returns the size in bytes.

readInputData

public byte[] readInputData(int dataOffset,
                            int dataSize)
                     throws StdQTException
Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.

QuickTime::GraphicsExportReadInputData

Parameters:
dataPtr - the pointer to receive the input data.
dataOffset - The offset of the image data within the source image data. The function begins reading image data from this offset.
dataSize - The number of bytes of image data to read.
Returns:
the data of size datasize.

getInputImageDescription

public ImageDescription getInputImageDescription()
                                          throws QTException
Used by format-specific graphics exporters, especially when doing standalone export: Returns the number of bytes of original image data that can be read.

QuickTime::GraphicsExportGetInputImageDescription

Returns:
returns the ImageDescription

getInputImageDimensions

public QDRect getInputImageDimensions()
                               throws QTException
Used by format-specific graphics exporters, especially when doing standalone export: Returns the dimensions of the input image.

QuickTime::GraphicsExportGetInputImageDimensions

Returns:
Returns the rectangle that has the dimensions of the input image.

getInputImageDepth

public int getInputImageDepth()
                       throws QTException
Used by format-specific graphics exporters, especially when doing standalone export: Returns the depth of the input image.

QuickTime::GraphicsExportGetInputImageDepth

Returns:
Returns the depth of the input image..

drawInputImage

public void drawInputImage(QDGraphics gw,
                           QDRect srcRect,
                           QDRect destRect)
                    throws QTException
Used by format-specific graphics exporters, especially when doing standalone export: Draws a rectangular portion of the input image. srcRect and dstRect need not be the same width and height; you can use this function to scale the image portion. This would be useful, for example, if you were writing a graphics exporter for a multiple-resolution format.

QuickTime::GraphicsExportDrawInputImage


setInputOffsetAndLimit

public void setInputOffsetAndLimit(int offset,
                                   int limit)
                            throws QTException
Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read. This would be useful if, for example, the source was a JPEG image embedded within a larger file.

QuickTime::GraphicsExportSetInputOffsetAndLimit

Parameters:
offset - The byte offset of the input image data from the beginning of the data reference.
limit - The offset of the byte following the last byte of the input image data. (If you do not need to apply any limit unsigned int -1

getInputOffset

public int getInputOffset()
                   throws QTException
Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read. This would be useful if, for example, the source was a JPEG image embedded within a larger file.

QuickTime::GraphicsExportGetInputOffsetAndLimit

Returns:
offset of input image data

getInputLimit

public int getInputLimit()
                  throws QTException
Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read. This would be useful if, for example, the source was a JPEG image embedded within a larger file.

QuickTime::GraphicsExportGetInputOffsetAndLimit

Returns:
offset of the byte following the last byte of the input image data

requestSettings

public void requestSettings()
                     throws QTException
These functions are used for obtaining graphics exporter settings and displaying a settings dialog box. Some graphics exporters don't support settings dialogs, and so do not implement this call. To find out whether a graphics exporter implements this call, use CallComponentCanDo ( myGraphicsExporter , kGraphicsExportRequestSettingsSelect ).

QuickTime::GraphicsExportRequestSettings


setSettingsFromAtomContainer

public void setSettingsFromAtomContainer(AtomContainer qtAtomContainer)
                                  throws QTException
These functions are used for obtaining graphics exporter settings and displaying a settings dialog box. Sets the graphics exporter component's current configuration to match the settings in the passed atom container.

QuickTime::GraphicsExportSetSettingsFromAtomContainer

Parameters:
qtAtomContainer - A QuickTime atom container containing settings.

getSettingsAsAtomContainer

public AtomContainer getSettingsAsAtomContainer()
                                         throws QTException
These functions are used for obtaining graphics exporter settings and displaying a settings dialog box. Retrieves the current settings from the graphics exporter component

QuickTime::GraphicsExportGetSettingsAsAtomContainer

Returns:
AtomContainer containing settings.

getSettingsAsText

public QTHandle getSettingsAsText()
                           throws QTException
This function is used for obtaining graphics exporter settings and displaying a settings dialog box. Retrieves the current settings in a user-readable format.

QuickTime::GraphicsExportGetSettingsAsText

Returns:
QTHandle containing the text.

getDefaultFileNameExtension

public java.lang.String getDefaultFileNameExtension()
                                             throws QTException
Returns the suggested file name extension.

QuickTime::GraphicsExportGetDefaultFileNameExtension

Returns:
Returns the suggested file name extension.

getMIMETypeList

public AtomContainer getMIMETypeList()
                              throws QTException
Returns MIME types and other information about the graphics format.

QuickTime::GraphicsExportGetMIMETypeList

The format's name, as a string in an atom of type kMimeInfoDescriptionTag . Optionally, the MIME type, as a string in an atom of type kMimeInfoMimeTypeTag .
Returns:
Returns AtomContainer containing information about the graphics format.

getDefaultFileType

public java.lang.String getDefaultFileType()
                                    throws QTException
Returns the default file Type for the new image file format.

QuickTime::GraphicsExportGetDefaultFileTypeAndCreator

Returns:
Returns the default file Type for the new image file format

getDefaultFileCreator

public java.lang.String getDefaultFileCreator()
                                       throws QTException
Returns file creator for the new image file format.

QuickTime::GraphicsExportGetDefaultFileTypeAndCreator

Returns:
Returns file creator for the new image file format

canTranscode

public boolean canTranscode()
                     throws QTException
Format-specific exporters may delegate this call; the base graphics exporter's implementation gives a reply of false .Use this call to ask a graphics exporter whether it can transcode the current input with the current settings.

QuickTime::GraphicsExportCanTranscode

Returns:
Returns true if current export operation can be performed by transcoding.

doTranscode

public void doTranscode()
                 throws QTException
The base graphics exporter makes this call of the format-specific graphics exporter to perform a transcoding export.

QuickTime::GraphicsExportDoTranscode


canUseCompressor

public GECompressorInfo canUseCompressor()
                                  throws QTException
The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.

QuickTime::GraphicsExportCanUseCompressor

Returns:
true if allowed to use a compressor.
See Also:
AtomContainer.fromGraphicsExporterCompressor(quicktime.std.image.GraphicsExporter)

doUseCompressor

public ImageDescription doUseCompressor(AtomContainer ac)
                                 throws QTException
The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.

QuickTime::GraphicsExportDoUseCompressor

Returns:
ImageDescription object describing the compressed image.

setDontRecompress

public void setDontRecompress(boolean dontRecompress)
                       throws QTException
Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.

QuickTime::GraphicsExportSetDontRecompress

Parameters:
dontRecompress - true if not allowed to recompressor.

getDontRecompress

public boolean getDontRecompress()
                          throws QTException
Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.

QuickTime::GraphicsExportSetDontRecompress

Returns:
dontRecompress true if not allowed to recompressor.

setInterlaceStyle

public void setInterlaceStyle(int interlaceStyle)
                       throws QTException
Defines the interlace style.

QuickTime::GraphicsExportSetInterlaceStyle

Parameters:
interlaceStyle - A value describing the style of the image data .

getInterlaceStyle

public int getInterlaceStyle()
                      throws QTException
Returns the interlace style.

QuickTime::GraphicsExportGetInterlaceStyle

Returns:
the interlace style.

setMetaData

public void setMetaData(UserData userData)
                 throws QTException
Defines supplemental data, such as textual copyright information. In QuickTime 4, none of the supplied graphics exporters support setting MetaData .

QuickTime::GraphicsExportSetMetaData

Parameters:
userData - object .

getMetaData

public UserData getMetaData()
                     throws QTException
Returns supplemental data, such as textual copyright information. In QuickTime 4, none of the supplied graphics exporters support setting MetaData .

QuickTime::GraphicsExportGetMetaData

Returns:
user data list
See Also:
UserData.fromGraphicsExporter(quicktime.std.image.GraphicsExporter)

setTargetDataSize

public void setTargetDataSize(int targetDataSize)
                       throws QTException
Defines a desired maximum data size and asks for a quality that does not exceed that size.

QuickTime::GraphicsExportSetTargetDataSize

Parameters:
targetDataSize - A value describing the maximum size of the image data in bytes.

getTargetDataSize

public int getTargetDataSize()
                      throws QTException
Specifies a desired maximum data size and asks for a quality that does not exceed that size.

QuickTime::GraphicsExportGetTargetDataSize

Returns:
A value describing the maximum size of the image data in bytes.

setCompressionMethod

public void setCompressionMethod(int compressionMethod)
                          throws QTException
Defines the compression method to use.

QuickTime::GraphicsExportSetCompressionMethod

Parameters:
compressionMethod - A value describing the compression algorithm to be used by the graphics exporter.

getCompressionMethod

public int getCompressionMethod()
                         throws QTException
Defines the compression method to use.

QuickTime::GraphicsExportGetCompressionMethod

Returns:
a value describing the compression algorithm used by the graphics exporter.

setCompressionQuality

public void setCompressionQuality(int spatialQuality)
                           throws QTException
Defines the compression quality.

QuickTime::GraphicsExportSetCompressionQuality

Parameters:
spatialQuality - The currently specified quality value

getCompressionQuality

public int getCompressionQuality()
                          throws QTException
Defines the compression quality to use.

QuickTime::GraphicsExportGetCompressionQuality

Returns:
a value describing the compression quality used by the graphics exporter.

setResolution

public void setResolution(int horizontalResolution,
                          int verticalResolution)
                   throws QTException
Defines the resolution to save and store.

QuickTime::GraphicsExportSetResolution

Parameters:
spatialQuality - The currently specified quality value

getHorizontalResolution

public int getHorizontalResolution()
                            throws QTException
Gets the resolution to saved and stored.

QuickTime::GraphicsExportGetResolution

Returns:
a value describing the horizontal resolution of the image.

getVerticalResolution

public int getVerticalResolution()
                          throws QTException
Defines the compression quality to use.

QuickTime::GraphicsExportGetResolution

Returns:
a value describing the vertical resolution of the image.

setDepth

public void setDepth(int depth)
              throws QTException
Defines the depth to use. Some image file formats support more than one pixel depth.

QuickTime::GraphicsExportSetDepth

Parameters:
A - value describing the depth of the image data as an OSType specifying the pixel format.

getDepth

public int getDepth()
             throws QTException
Defines the depth to use. Some image file formats support more than one pixel depth.

QuickTime::GraphicsExportGetDepth

Returns:
A value describing the depth of the image data as an OSType specifying the pixel format

GraphicsExportWriteOutputData

public void GraphicsExportWriteOutputData(byte[] data,
                                          int dataSize)
                                   throws StdQTException
This function is used by format-specific graphics exporters to write output data. Writes output image data.

QuickTime::GraphicsExportWriteOutputData

Parameters:
data - block containing the data.
dataSize - The number of bytes of image data to write.

GraphicsExportReadOutputData

public byte[] GraphicsExportReadOutputData(int dataOffset,
                                           int dataSize)
                                    throws StdQTException
This function is used by format-specific graphics exporters to write output data. Reads output image data. Not all output data types support this feature.

QuickTime::GraphicsExportReadOutputData

Parameters:
dataOffset - The offset of the image data within the data reference. The function begins reading image data from this offset.
dataSize - The number of bytes of image data to read.