BuildCubeE/BootableMPW/Interfaces/CIncludes/Movies.h
2018-11-16 09:50:16 +08:00

1729 lines
54 KiB
C

/************************************************************
Created: Wednesday, October 21, 1992 at 2:54 PM
Movies.h
C Interface to the Macintosh Libraries
Copyright Apple Computer, Inc. 1991, 1992
All rights reserved
************************************************************/
#ifndef __MOVIES__
#define __MOVIES__
#ifndef __QUICKDRAW__
#include <QuickDraw.h>
#endif
#ifndef __ALIASES__
#include <Aliases.h>
#endif
#ifndef __EVENTS__
#include <Events.h>
#endif
#ifndef __MENUS__
#include <Menus.h>
#endif
#ifndef __COMPONENTS__
#include <Components.h>
#endif
#ifndef __IMAGECOMPRESSION__
#include <ImageCompression.h>
#endif
#ifndef kFix1
#define kFix1 (0x00010000)
#endif
#define gestaltQuickTime 'qtim'
#define MovieFileType 'MooV'
#define MediaHandlerType 'mhlr'
#define DataHandlerType 'dhlr'
#define VideoMediaType 'vide'
#define SoundMediaType 'soun'
#define TextMediaType 'text'
#define BaseMediaType 'gnrc'
#define VisualMediaCharacteristic 'eyes'
#define AudioMediaCharacteristic 'ears'
#define DoTheRightThing 0L
#define kFullVolume 0x100 /* 8.8 format */
#define kNoVolume 0
struct MovieRecord {
long data[1];
};
typedef struct MovieRecord MovieRecord;
typedef MovieRecord *Movie;
struct TrackRecord {
long data[1];
};
typedef struct TrackRecord TrackRecord;
typedef TrackRecord *Track;
struct MediaRecord {
long data[1];
};
typedef struct MediaRecord MediaRecord;
typedef MediaRecord *Media;
struct UserDataRecord {
long data[1];
};
typedef struct UserDataRecord UserDataRecord;
typedef UserDataRecord *UserData;
struct TrackEditStateRecord {
long data[1];
};
typedef struct TrackEditStateRecord TrackEditStateRecord;
typedef TrackEditStateRecord *TrackEditState;
struct MovieEditStateRecord {
long data[1];
};
typedef struct MovieEditStateRecord MovieEditStateRecord;
typedef MovieEditStateRecord *MovieEditState;
struct SampleDescription {
long descSize;
long dataFormat;
long resvd1;
short resvd2;
short dataRefIndex;
};
typedef struct SampleDescription SampleDescription;
typedef SampleDescription *SampleDescriptionPtr, **SampleDescriptionHandle;
struct SoundDescription {
long descSize; /* total size of SoundDescription including extra data */
long dataFormat; /* */
long resvd1; /* reserved for apple use */
short resvd2;
short dataRefIndex;
short version; /* which version is this data */
short revlevel; /* what version of that codec did this */
long vendor; /* whose codec compressed this data */
short numChannels; /* number of channels of sound */
short sampleSize; /* number of bits per sample */
short compressionID; /* sound compression used, 0 if none */
short packetSize; /* packet size for compression, 0 if no compression */
Fixed sampleRate; /* sample rate sound is captured at */
};
typedef struct SoundDescription SoundDescription;
typedef SoundDescription *SoundDescriptionPtr, **SoundDescriptionHandle;
struct TextDescription {
long size; // Total size of TextDescription
long type; // 'text'
long resvd1;
short resvd2;
short dataRefIndex;
long displayFlags; // see enum below for flag values
long textJustification; // Can be: teCenter,teFlush -Default,-Right,-Left
RGBColor bgColor; // Background color
Rect defaultTextBox; // Location to place the text within the track bounds
ScrpSTElement defaultStyle; // Default style (struct defined in TextEdit.h)
};
typedef struct TextDescription TextDescription;
typedef TextDescription *TextDescriptionPtr, **TextDescriptionHandle;
enum {
dfDontDisplay = 1<<0, // Don't display the text
dfDontAutoScale = 1<<1, // Don't scale text as track bounds grows or shrinks
dfClipToTextBox = 1<<2, // Clip update to the textbox
dfUseMovieBGColor = 1<<3, // Set text background to movie's background color
dfShrinkTextBoxToFit = 1<<4, // Compute minimum box to fit the sample
dfScrollIn = 1<<5, // Scroll text in until last of text is in view
dfScrollOut = 1<<6, // Scroll text out until last of text is gone (if both set, scroll in then out)
dfHorizScroll = 1<<7, // Scroll text horizontally (otherwise it's vertical)
dfReverseScroll = 1<<8 // vert: scroll down rather than up; horiz: scroll backwards (justfication dependent)
};
/* progress messages */
enum {
movieProgressOpen = 0,
movieProgressUpdatePercent = 1,
movieProgressClose = 2
};
/* progress operations */
enum {
progressOpFlatten = 1,
progressOpInsertTrackSegment,
progressOpInsertMovieSegment,
progressOpPaste,
progressOpAddMovieSelection,
progressOpCopy,
progressOpCut,
progressOpLoadMovieIntoRam,
progressOpLoadTrackIntoRam,
progressOpLoadMediaIntoRam,
progressOpImportMovie,
progressOpExportMovie
};
enum {
mediaQualityDraft = 0x0000,
mediaQualityNormal = 0x0040,
mediaQualityBetter = 0x0080,
mediaQualityBest = 0x00C0
};
typedef pascal OSErr (*MovieRgnCoverProc)(Movie theMovie, RgnHandle changedRgn, long refcon);
typedef pascal OSErr (*MovieProgressProcPtr)(Movie theMovie, short message, short whatOperation, Fixed percentDone, long refcon);
typedef ComponentInstance MediaHandler,DataHandler;
typedef Component MediaHandlerComponent,DataHandlerComponent;
typedef ComponentResult HandlerError;
#ifndef kSmallestArray
#define kSmallestArray 1
#endif
/* TimeBase equates */
typedef long TimeValue;
typedef long TimeScale;
#ifndef I64
#define I64
typedef struct
{
long hi;
long lo;
} Int64;
#endif I64
typedef Int64 CompTimeValue;
enum {
loopTimeBase = 1,
palindromeLoopTimeBase = 2
};
typedef unsigned long TimeBaseFlags;
struct TimeBaseRecord {
long data[1];
};
typedef struct TimeBaseRecord TimeBaseRecord;
typedef TimeBaseRecord *TimeBase;
struct CallBackRecord {
long data[1];
};
typedef struct CallBackRecord CallBackRecord;
typedef CallBackRecord *QTCallBack;
typedef struct TimeRecord
{
CompTimeValue value; /* units */
TimeScale scale; /* units per second */
TimeBase base;
} TimeRecord;
/* CallBack equates */
enum
{
triggerTimeFwd = 0x0001, /* when curTime exceeds triggerTime going forward */
triggerTimeBwd = 0x0002, /* when curTime exceeds triggerTime going backwards */
triggerTimeEither = 0x0003, /* when curTime exceeds triggerTime going either direction */
triggerRateLT = 0x0004, /* when rate changes to less than trigger value */
triggerRateGT = 0x0008, /* when rate changes to greater than trigger value */
triggerRateEqual = 0x0010, /* when rate changes to equal trigger value */
triggerRateLTE = triggerRateLT | triggerRateEqual,
triggerRateGTE = triggerRateGT | triggerRateEqual,
triggerRateNotEqual = triggerRateGT | triggerRateEqual | triggerRateLT,
triggerRateChange = 0,
triggerAtStart = 0x0001,
triggerAtStop = 0x0002
};
typedef unsigned short QTCallBackFlags;
enum
{
timeBaseBeforeStartTime = 1,
timeBaseAfterStopTime = 2
};
typedef unsigned long TimeBaseStatus;
enum
{
callBackAtTime = 1,
callBackAtRate = 2,
callBackAtTimeJump = 3,
callBackAtExtremes = 4,
callBackAtInterrupt = 0x8000
};
typedef unsigned short QTCallBackType;
typedef pascal void (*QTCallBackProc)(QTCallBack cb, long refCon);
enum {
qtcbNeedsRateChanges = 1, /* wants to know about rate changes */
qtcbNeedsTimeChanges = 2, /* wants to know about time changes */
qtcbNeedsStartStopChanges = 4 // wants to know when TimeBase start/stop is changed
};
typedef struct QTCallBackHeader {
long callBackFlags;
long reserved1;
char qtPrivate[40];
} QTCallBackHeader;
enum {
keepInRam = 1<<0, // load and make non-purgable
unkeepInRam = 1<<1, // mark as purgable
flushFromRam = 1<<2, // empty those handles
loadForwardTrackEdits = 1<<3, // load track edits into ram for playing forward
loadBackwardTrackEdits = 1<<4 // load track edits into ram for playing in reverse
};
typedef pascal Boolean (*MoviePreviewCallOutProc)(long refcon);
enum {
newMovieActive = 1<<0,
newMovieDontResolveDataRefs = 1<<1,
newMovieDontAskUnresolvedDataRefs = 1<<2,
newMovieDontAutoAlternates = 1<<3
};
enum { /* track usage bits */
trackUsageInMovie = 1<<1,
trackUsageInPreview = 1<<2,
trackUsageInPoster = 1<<3
};
enum { /* Add/GetMediaSample flags */
mediaSampleNotSync = 1<<0, /* sample is not a sync sample (eg. is frame differenced */
mediaSampleShadowSync = 1<<1 /* sample is a shadow sync */
};
enum {
pasteInParallel = 1
};
enum {
nextTimeMediaSample = 1<<0,
nextTimeMediaEdit = 1<<1,
nextTimeTrackEdit = 1<<2,
nextTimeSyncSample = 1<<3,
nextTimeEdgeOK = 1<<14,
nextTimeIgnoreActiveSegment = 1<<15};
typedef unsigned short nextTimeFlagsEnum;
enum {
createMovieFileDeleteCurFile = 1L<<31,
createMovieFileDontCreateMovie = 1L<<30,
createMovieFileDontOpenFile = 1L<<29
};
typedef unsigned long createMovieFileFlagsEnum;
enum {
flattenAddMovieToDataFork = 1L<<0,
flattenActiveTracksOnly = 1L<<2,
flattenDontInterleaveFlatten = 1L<<3
};
typedef unsigned long movieFlattenFlagsEnum;
enum {
movieInDataForkResID = -1 /* magic res ID */
};
enum {
mcTopLeftMovie = 1<<0, /* usually centered */
mcScaleMovieToFit = 1<<1, /* usually only scales down */
mcWithBadge = 1<<2, /* give me a badge */
mcNotVisible = 1<<3, /* don't show controller */
mcWithFrame = 1<<4 /* gimme a frame */
};
enum {
movieScrapDontZeroScrap = 1<<0,
movieScrapOnlyPutMovie = 1<<1
};
enum {
dataRefSelfReference = 1<<0,
dataRefWasNotResolved = 1<<1
};
typedef unsigned long dataRefAttributesFlags;
enum {
hintsScrubMode = 1<<0, /* mask == && (if flags == scrub on, flags != scrub off) */
hintsUseScreenBuffer = 1<<5,
hintsAllowInterlace = 1<<6,
hintsUseSoundInterp = 1<<7
} ;
typedef unsigned long playHintsEnum;
enum {
mediaHandlerFlagGenericClient = 1
};
typedef unsigned long mediaHandlerFlagsEnum;
#ifdef __cplusplus
extern "C" {
#endif __cplusplus
/*************************
* Initialization Routines
**************************/
pascal OSErr EnterMovies( void )
= {0x7001,0xAAAA};
pascal void ExitMovies( void )
= {0x7002,0xAAAA};
/*************************
* Error Routines
**************************/
typedef pascal void (*ErrorProcPtr)(OSErr theErr, long refcon);
pascal OSErr GetMoviesError( void )
= {0x7003,0xAAAA};
pascal void ClearMoviesStickyError( void )
= {0x303C,0xDE,0xAAAA};
pascal OSErr GetMoviesStickyError( void )
= {0x7004,0xAAAA};
pascal void SetMoviesErrorProc( ErrorProcPtr errProc, long refcon )
= {0x303C,0xEF,0xAAAA};
/*************************
* Idle Routines
**************************/
pascal void MoviesTask( Movie theMovie, long maxMilliSecToUse )
= {0x7005,0xAAAA};
pascal OSErr PrerollMovie( Movie theMovie, TimeValue time, Fixed Rate )
= {0x7006,0xAAAA};
pascal OSErr LoadMovieIntoRam( Movie theMovie, TimeValue time, TimeValue duration, long flags )
= {0x7007,0xAAAA};
pascal OSErr LoadTrackIntoRam( Track theTrack, TimeValue time, TimeValue duration, long flags )
= {0x303C,0x16E,0xAAAA};
pascal OSErr LoadMediaIntoRam( Media theMedia, TimeValue time, TimeValue duration, long flags )
= {0x7008,0xAAAA};
pascal void SetMovieActive( Movie theMovie, Boolean active )
= {0x7009,0xAAAA};
pascal Boolean GetMovieActive( Movie theMovie )
= {0x700A,0xAAAA};
/*************************
* calls for playing movies, previews, posters
**************************/
pascal void StartMovie( Movie theMovie )
= {0x700B,0xAAAA};
pascal void StopMovie( Movie theMovie )
= {0x700C,0xAAAA};
pascal void GoToBeginningOfMovie( Movie theMovie )
= {0x700D,0xAAAA};
pascal void GoToEndOfMovie( Movie theMovie )
= {0x700E,0xAAAA};
pascal Boolean IsMovieDone( Movie theMovie )
= {0x303C,0xDD,0xAAAA};
pascal Boolean GetMoviePreviewMode( Movie theMovie )
= {0x700F,0xAAAA};
pascal void SetMoviePreviewMode( Movie theMovie, Boolean usePreview )
= {0x7010,0xAAAA};
pascal void ShowMoviePoster( Movie theMovie )
= {0x7011,0xAAAA};
pascal void PlayMoviePreview( Movie theMovie, MoviePreviewCallOutProc callOutProc, long refcon )
= {0x303C,0xF2,0xAAAA};
/*************************
* calls for controlling movies & tracks which are playing
**************************/
pascal TimeBase GetMovieTimeBase( Movie theMovie )
= {0x7012,0xAAAA};
pascal void SetMovieMasterTimeBase( Movie theMovie, TimeBase tb,
const TimeRecord *slaveZero)
= {0x303C,0x167,0xAAAA};
pascal void SetMovieMasterClock( Movie theMovie, Component clockMeister,
const TimeRecord *slaveZero )
= {0x303C,0x168,0xAAAA};
pascal void GetMovieGWorld( Movie theMovie, CGrafPtr *port, GDHandle *gdh )
= {0x7015,0xAAAA};
pascal void SetMovieGWorld( Movie theMovie, CGrafPtr port, GDHandle gdh )
= {0x7016,0xAAAA};
pascal PicHandle GetMoviePict ( Movie theMovie, TimeValue time )
= {0x701D,0xAAAA};
pascal PicHandle GetTrackPict ( Track theTrack, TimeValue time )
= {0x701E,0xAAAA};
pascal PicHandle GetMoviePosterPict ( Movie theMovie )
= {0x303C,0xF7,0xAAAA};
pascal OSErr UpdateMovie( Movie theMovie )
= {0x701F,0xAAAA}; /* called between Begin & EndUpdate */
/**** spatial movie routines ****/
pascal void GetMovieBox( Movie theMovie, Rect *boxRect )
= {0x303C,0xF9,0xAAAA};
pascal void SetMovieBox( Movie theMovie, const Rect *boxRect )
= {0x303C,0xFA,0xAAAA};
/** movie display clip */
pascal RgnHandle GetMovieDisplayClipRgn( Movie theMovie )
= {0x303C,0xFC,0xAAAA};
pascal void SetMovieDisplayClipRgn( Movie theMovie, RgnHandle theClip )
= {0x303C,0xFD,0xAAAA};
/** movie src clip */
pascal RgnHandle GetMovieClipRgn( Movie theMovie )
= {0x303C,0x100,0xAAAA};
pascal void SetMovieClipRgn( Movie theMovie, RgnHandle theClip )
= {0x303C,0x101,0xAAAA};
/** track src clip */
pascal RgnHandle GetTrackClipRgn( Track theTrack )
= {0x303C,0x102,0xAAAA};
pascal void SetTrackClipRgn( Track theTrack, RgnHandle theClip )
= {0x303C,0x103,0xAAAA};
/** bounds in display space (not clipped by display clip) */
pascal RgnHandle GetMovieDisplayBoundsRgn( Movie theMovie )
= {0x303C,0xFB,0xAAAA};
pascal RgnHandle GetTrackDisplayBoundsRgn( Track theTrack )
= {0x303C,0x112,0xAAAA};
/** bounds in movie space */
pascal RgnHandle GetMovieBoundsRgn( Movie theMovie )
= {0x303C,0xFE,0xAAAA};
pascal RgnHandle GetTrackMovieBoundsRgn( Track theTrack )
= {0x303C,0xFF,0xAAAA};
/** bounds in track space */
pascal RgnHandle GetTrackBoundsRgn( Track theTrack )
= {0x303C,0x111,0xAAAA};
/** mattes - always in track space */
pascal PixMapHandle GetTrackMatte( Track theTrack )
= {0x303C,0x115,0xAAAA};
pascal void SetTrackMatte( Track theTrack, PixMapHandle theMatte)
= {0x303C,0x116,0xAAAA};
pascal void DisposeMatte( PixMapHandle theMatte )
= {0x303C,0x14A,0xAAAA};
/*************************
* calls for getting/saving movies
**************************/
pascal Movie NewMovie( long flags )
= {0x303C,0x187,0xAAAA};
pascal OSErr PutMovieIntoHandle( Movie theMovie, Handle publicMovie )
= {0x7022,0xAAAA};
pascal OSErr PutMovieIntoDataFork( Movie theMovie, short fRefNum, long offset, long maxSize )
= {0x303C,0x1B4,0xAAAA};
pascal void DisposeMovie( Movie theMovie )
= {0x7023,0xAAAA};
/*************************
* Movie State Routines
**************************/
pascal unsigned long GetMovieCreationTime( Movie theMovie )
= {0x7026,0xAAAA};
pascal unsigned long GetMovieModificationTime( Movie theMovie )
= {0x7027,0xAAAA};
pascal TimeScale GetMovieTimeScale( Movie theMovie )
= {0x7029,0xAAAA};
pascal void SetMovieTimeScale( Movie theMovie, TimeScale timeScale )
= {0x702A,0xAAAA};
pascal TimeValue GetMovieDuration( Movie theMovie )
= {0x702B,0xAAAA};
pascal Fixed GetMovieRate( Movie theMovie )
= {0x702C,0xAAAA};
pascal void SetMovieRate( Movie theMovie, Fixed rate )
= {0x702D,0xAAAA};
pascal Fixed GetMoviePreferredRate( Movie theMovie )
= {0x303C,0xF3,0xAAAA};
pascal void SetMoviePreferredRate( Movie theMovie, Fixed rate )
= {0x303C,0xF4,0xAAAA};
pascal short GetMoviePreferredVolume( Movie theMovie )
= {0x303C,0xF5,0xAAAA};
pascal void SetMoviePreferredVolume( Movie theMovie, short volume )
= {0x303C,0xF6,0xAAAA};
pascal short GetMovieVolume( Movie theMovie )
= {0x702E,0xAAAA};
pascal void SetMovieVolume( Movie theMovie, short volume )
= {0x702F,0xAAAA};
pascal void GetMovieMatrix( Movie theMovie, MatrixRecord *matrix )
= {0x7031,0xAAAA};
pascal void SetMovieMatrix( Movie theMovie, const MatrixRecord *matrix )
= {0x7032,0xAAAA};
pascal void GetMoviePreviewTime( Movie theMovie,
TimeValue *previewTime, TimeValue *previewDuration )
= {0x7033,0xAAAA};
pascal void SetMoviePreviewTime( Movie theMovie,
TimeValue previewTime, TimeValue previewDuration )
= {0x7034,0xAAAA};
pascal TimeValue GetMoviePosterTime( Movie theMovie )
= {0x7035,0xAAAA};
pascal void SetMoviePosterTime( Movie theMovie, TimeValue posterTime )
= {0x7036,0xAAAA};
pascal void GetMovieSelection( Movie theMovie,
TimeValue *selectionTime, TimeValue *selectionDuration )
= {0x7037,0xAAAA};
pascal void SetMovieSelection( Movie theMovie,
TimeValue selectionTime, TimeValue selectionDuration )
= {0x7038,0xAAAA};
pascal void SetMovieActiveSegment(Movie theMovie, TimeValue startTime, TimeValue duration)
= {0x303C,0x15C,0xAAAA};
pascal void GetMovieActiveSegment(Movie theMovie, TimeValue *startTime, TimeValue *duration)
= {0x303C,0x15D,0xAAAA};
pascal TimeValue GetMovieTime( Movie theMovie, TimeRecord *currentTime )
= {0x7039,0xAAAA};
pascal void SetMovieTime( Movie theMovie, const TimeRecord *newtime )
= {0x703C,0xAAAA};
pascal void SetMovieTimeValue( Movie theMovie, TimeValue newtime )
= {0x703D,0xAAAA};
pascal UserData GetMovieUserData( Movie theMovie )
= {0x703E,0xAAAA};
/*************************
* Track/Media finding routines
**************************/
pascal long GetMovieTrackCount( Movie theMovie )
= {0x703F,0xAAAA};
pascal Track GetMovieTrack( Movie theMovie, long trackID )
= {0x7040,0xAAAA};
pascal Track GetMovieIndTrack( Movie theMovie, long index )
= {0x303C,0x117,0xAAAA};
pascal long GetTrackID( Track theTrack )
= {0x303C,0x127,0xAAAA};
pascal Movie GetTrackMovie( Track theTrack )
= {0x303C,0xD0,0xAAAA};
/*************************
* Track creation routines
**************************/
pascal Track NewMovieTrack( Movie theMovie, Fixed width, Fixed height, short trackVolume)
= {0x303C,0x188,0xAAAA};
pascal void DisposeMovieTrack( Track theTrack )
= {0x7042,0xAAAA};
/*************************
* Track State routines
**************************/
pascal unsigned long GetTrackCreationTime( Track theTrack )
= {0x7043,0xAAAA};
pascal unsigned long GetTrackModificationTime( Track theTrack )
= {0x7044,0xAAAA};
pascal Boolean GetTrackEnabled( Track theTrack )
= {0x7045,0xAAAA};
pascal void SetTrackEnabled( Track theTrack, Boolean isEnabled )
= {0x7046,0xAAAA};
pascal long GetTrackUsage( Track theTrack )
= {0x7047,0xAAAA};
pascal void SetTrackUsage( Track theTrack, long usage )
= {0x7048,0xAAAA};
pascal TimeValue GetTrackDuration( Track theTrack )
= {0x704B,0xAAAA};
pascal TimeValue GetTrackOffset( Track theTrack )
= {0x704C,0xAAAA};
pascal void SetTrackOffset( Track theTrack, TimeValue movieOffsetTime )
= {0x704D,0xAAAA};
pascal short GetTrackLayer( Track theTrack )
= {0x7050,0xAAAA};
pascal void SetTrackLayer( Track theTrack, short layer )
= {0x7051,0xAAAA};
pascal Track GetTrackAlternate( Track theTrack )
= {0x7052,0xAAAA};
pascal void SetTrackAlternate( Track theTrack, Track alternateT )
= {0x7053,0xAAAA};
pascal void SetAutoTrackAlternatesEnabled(Movie theMovie, Boolean enable)
= {0x303C,0x15E,0xAAAA};
pascal void SelectMovieAlternates(Movie theMovie)
= {0x303C,0x15F,0xAAAA};
pascal short GetTrackVolume( Track theTrack )
= {0x7054,0xAAAA};
pascal void SetTrackVolume( Track theTrack, short volume )
= {0x7055,0xAAAA};
pascal void GetTrackMatrix( Track theTrack, MatrixRecord *matrix )
= {0x7056,0xAAAA};
pascal void SetTrackMatrix( Track theTrack, const MatrixRecord *matrix )
= {0x7057,0xAAAA};
pascal void GetTrackDimensions( Track theTrack, Fixed *width, Fixed *height )
= {0x705D,0xAAAA};
pascal void SetTrackDimensions( Track theTrack, Fixed width, Fixed height )
= {0x705E,0xAAAA};
pascal UserData GetTrackUserData( Track theTrack )
= {0x705F,0xAAAA};
/*************************
* get Media routines
**************************/
pascal Media NewTrackMedia( Track theTrack, OSType mediaType, TimeScale timeScale,
Handle dataRef, OSType dataRefType )
= {0x303C,0x18E,0xAAAA};
pascal void DisposeTrackMedia( Media theMedia )
= {0x7061,0xAAAA};
pascal Media GetTrackMedia( Track theTrack )
= {0x7062,0xAAAA};
pascal Track GetMediaTrack( Media theMedia )
= {0x303C,0xC5,0xAAAA};
/*************************
* Media State routines
**************************/
pascal unsigned long GetMediaCreationTime( Media theMedia )
= {0x7066,0xAAAA};
pascal unsigned long GetMediaModificationTime( Media theMedia )
= {0x7067,0xAAAA};
pascal TimeScale GetMediaTimeScale( Media theMedia )
= {0x7068,0xAAAA};
pascal void SetMediaTimeScale( Media theMedia, TimeScale timeScale )
= {0x7069,0xAAAA};
pascal TimeValue GetMediaDuration( Media theMedia )
= {0x706A,0xAAAA};
pascal short GetMediaLanguage( Media theMedia )
= {0x706B,0xAAAA};
pascal void SetMediaLanguage( Media theMedia, short language )
= {0x706C,0xAAAA};
pascal short GetMediaQuality( Media theMedia )
= {0x706D,0xAAAA};
pascal void SetMediaQuality( Media theMedia, short quality )
= {0x706E,0xAAAA};
pascal void GetMediaHandlerDescription( Media theMedia, OSType *mediaType, Str255 creatorName, OSType *creatorManufacturer )
= {0x706F,0xAAAA};
pascal UserData GetMediaUserData( Media theMedia )
= {0x7070,0xAAAA};
/*************************
* Media Handler routines
**************************/
pascal MediaHandler GetMediaHandler( Media theMedia )
= {0x7071,0xAAAA};
pascal OSErr SetMediaHandler( Media theMedia, MediaHandlerComponent mH )
= {0x303C,0x190,0xAAAA};
/*************************
* Media's Data routines
**************************/
pascal OSErr BeginMediaEdits( Media theMedia )
= {0x7072,0xAAAA};
pascal OSErr EndMediaEdits( Media theMedia )
= {0x7073,0xAAAA};
pascal void GetMediaDataHandlerDescription( Media theMedia, short index, OSType *dhType, Str255 creatorName, OSType *creatorManufacturer )
= {0x303C,0x19E,0xAAAA};
pascal DataHandler GetMediaDataHandler( Media theMedia, short index )
= {0x303C,0x19F,0xAAAA};
pascal OSErr SetMediaDataHandler( Media theMedia, short index, DataHandlerComponent dataHandler )
= {0x303C,0x1A0,0xAAAA};
/*************************
* Media Sample Table Routines
**************************/
pascal long GetMediaSampleDescriptionCount( Media theMedia )
= {0x7077,0xAAAA};
pascal void GetMediaSampleDescription( Media theMedia, long index, SampleDescriptionHandle descH )
= {0x7078,0xAAAA};
pascal OSErr SetMediaSampleDescription( Media theMedia, long index, SampleDescriptionHandle descH )
= {0x303C,0x1D0,0xAAAA};
pascal long GetMediaSampleCount( Media theMedia )
= {0x7079,0xAAAA};
pascal void SampleNumToMediaTime( Media theMedia, long logicalSampleNum,
TimeValue *sampleTime, TimeValue *sampleDuration )
= {0x707A,0xAAAA};
pascal void MediaTimeToSampleNum( Media theMedia, TimeValue time,
long *sampleNum, TimeValue *sampleTime, TimeValue *sampleDuration )
= {0x707B,0xAAAA};
pascal OSErr AddMediaSample( Media theMedia, Handle dataIn, long inOffset, unsigned long size,
TimeValue durationPerSample,
SampleDescriptionHandle sampleDescriptionH,
long numberOfSamples, short sampleFlags, TimeValue *sampleTime )
= {0x707C,0xAAAA};
pascal OSErr AddMediaSampleReference( Media theMedia, long dataOffset, unsigned long size,
TimeValue durationPerSample,
SampleDescriptionHandle sampleDescriptionH,
long numberOfSamples, short sampleFlags, TimeValue *sampleTime )
= {0x707D,0xAAAA};
pascal OSErr GetMediaSample( Media theMedia, Handle dataOut, long maxSizeToGrow, long *size,
TimeValue time, TimeValue *sampleTime, TimeValue *durationPerSample,
SampleDescriptionHandle sampleDescriptionH, long *sampleDescriptionIndex,
long maxNumberOfSamples, long *numberOfSamples, short *sampleFlags )
= {0x707E,0xAAAA};
pascal OSErr GetMediaSampleReference( Media theMedia, long *dataOffset, long *size,
TimeValue time, TimeValue *sampleTime, TimeValue *durationPerSample,
SampleDescriptionHandle sampleDescriptionH, long *sampleDescriptionIndex,
long maxNumberOfSamples, long *numberOfSamples, short *sampleFlags )
= {0x707F,0xAAAA};
pascal OSErr SetMediaShadowSync( Media theMedia, long frameDiffSampleNum, long syncSampleNum )
= {0x303C,0x121,0xAAAA};
pascal OSErr GetMediaShadowSync( Media theMedia, long frameDiffSampleNum, long *syncSampleNum )
= {0x303C,0x122,0xAAAA};
/*************************
* Editing Routines
**************************/
pascal OSErr InsertMediaIntoTrack( Track theTrack,
TimeValue trackStart,
TimeValue mediaTime, TimeValue mediaDuration,
Fixed mediaRate )
= {0x303C,0x183,0xAAAA};
pascal OSErr InsertTrackSegment( Track srcTrack, Track dstTrack,
TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn )
= {0x303C,0x85,0xAAAA};
pascal OSErr InsertMovieSegment( Movie srcMovie, Movie dstMovie,
TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn )
= {0x303C,0x86,0xAAAA};
pascal OSErr InsertEmptyTrackSegment( Track dstTrack,
TimeValue dstIn, TimeValue dstDuration )
= {0x303C,0x87,0xAAAA};
pascal OSErr InsertEmptyMovieSegment( Movie dstMovie,
TimeValue dstIn, TimeValue dstDuration )
= {0x303C,0x88,0xAAAA};
pascal OSErr DeleteTrackSegment( Track theTrack, TimeValue in, TimeValue duration )
= {0x303C,0x89,0xAAAA};
pascal OSErr DeleteMovieSegment( Movie theMovie, TimeValue in, TimeValue duration )
= {0x303C,0x8A,0xAAAA};
pascal OSErr ScaleTrackSegment( Track theTrack, TimeValue in,
TimeValue oldDuration, TimeValue newDuration )
= {0x303C,0x8B,0xAAAA};
pascal OSErr ScaleMovieSegment( Movie theMovie, TimeValue in,
TimeValue oldDuration, TimeValue newDuration )
= {0x303C,0x8C,0xAAAA};
/*************************
* Hi-level Editing Routines
**************************/
pascal Movie CutMovieSelection( Movie theMovie )
= {0x303C,0x8D,0xAAAA};
pascal Movie CopyMovieSelection( Movie theMovie )
= {0x303C,0x8E,0xAAAA};
pascal void PasteMovieSelection( Movie theMovie, Movie src )
= {0x303C,0x8F,0xAAAA};
pascal void AddMovieSelection( Movie theMovie, Movie src )
= {0x303C,0x152,0xAAAA};
pascal void ClearMovieSelection( Movie theMovie )
= {0x303C,0xE1,0xAAAA};
pascal OSErr PasteHandleIntoMovie(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp)
= {0x303C,0xCB,0xAAAA};
pascal OSErr PutMovieIntoTypedHandle(Movie theMovie, Track targetTrack, OSType handleType, Handle publicMovie,
TimeValue start, TimeValue dur, long flags, ComponentInstance userComp)
= {0x303C,0x1CD,0xAAAA};
pascal Component IsScrapMovie(Track targetTrack)
= {0x303C,0xCC,0xAAAA};
/*************************
* Middle-level Editing Routines
**************************/
pascal OSErr CopyTrackSettings(Track srcTrack, Track dstTrack)
= {0x303C,0x153,0xAAAA};
pascal OSErr CopyMovieSettings(Movie srcMovie, Movie dstMovie)
= {0x303C,0x154,0xAAAA};
/*************************
* movie & track edit state routines
**************************/
pascal MovieEditState NewMovieEditState(Movie theMovie)
= {0x303C,0x104,0xAAAA};
pascal OSErr UseMovieEditState(Movie theMovie, MovieEditState toState)
= {0x303C,0x105,0xAAAA};
pascal OSErr DisposeMovieEditState(MovieEditState state)
= {0x303C,0x106,0xAAAA};
pascal TrackEditState NewTrackEditState(Track theTrack)
= {0x303C,0x107,0xAAAA};
pascal OSErr UseTrackEditState(Track theTrack, TrackEditState state)
= {0x303C,0x108,0xAAAA};
pascal OSErr DisposeTrackEditState(TrackEditState state)
= {0x303C,0x109,0xAAAA};
/*************************
* high level file conversion routines
**************************/
pascal OSErr ConvertFileToMovieFile(const FSSpec *inputFile, const FSSpec *outputFile,
OSType creator, ScriptCode scriptTag, short *resID, long flags, ComponentInstance userComp,
MovieProgressProcPtr proc, long refCon)
= {0x303C,0x1CB,0xAAAA};
pascal OSErr ConvertMovieToFile(Movie theMovie, Track onlyTrack, const FSSpec *outputFile,
OSType fileType, OSType creator, ScriptCode scriptTag, short *resID, long flags,
ComponentInstance userComp)
= {0x303C,0x1CC,0xAAAA};
/*************************
* Movie Timebase Conversion Routines
**************************/
pascal TimeValue TrackTimeToMediaTime( TimeValue value, Track theTrack )
= {0x303C,0x96,0xAAAA};
pascal Fixed GetTrackEditRate(Track theTrack, TimeValue atTime)
= {0x303C,0x123,0xAAAA};
/*************************
* Miscellaneous Routines
**************************/
pascal long GetMovieDataSize( Movie theMovie, TimeValue startTime, TimeValue duration )
= {0x303C,0x98,0xAAAA};
pascal long GetTrackDataSize( Track theTrack, TimeValue startTime, TimeValue duration )
= {0x303C,0x149,0xAAAA};
pascal long GetMediaDataSize( Media theMedia, TimeValue startTime, TimeValue duration)
= {0x303C,0x99,0xAAAA};
pascal Boolean PtInMovie( Movie theMovie, Point pt )
= {0x303C,0x9A,0xAAAA};
pascal Boolean PtInTrack( Track theTrack, Point pt )
= {0x303C,0x9B,0xAAAA};
/*************************
* Group Selection Routines
**************************/
pascal void SetMovieLanguage( Movie theMovie, long language )
= {0x303C,0x9C,0xAAAA};
/*************************
* User Data
**************************/
pascal OSErr GetUserData( UserData theUserData, Handle data, OSType udType, long index )
= {0x303C,0x9E,0xAAAA};
pascal OSErr AddUserData( UserData theUserData, Handle data, OSType udType )
= {0x303C,0x9F,0xAAAA};
pascal OSErr RemoveUserData( UserData theUserData, OSType udType, long index )
= {0x303C,0xA0,0xAAAA};
pascal short CountUserDataType(UserData theUserData, OSType udType)
= {0x303C,0x14B,0xAAAA};
pascal long GetNextUserDataType(UserData theUserData, OSType udType)
= {0x303C,0x1A5,0xAAAA};
pascal OSErr GetUserDataItem(UserData theUserData, void *data, long size, OSType udType, long index )
= {0x303C,0x126,0xAAAA};
pascal OSErr SetUserDataItem(UserData theUserData, void *data, long size, OSType udType, long index )
= {0x303C,0x12E,0xAAAA};
pascal OSErr AddUserDataText(UserData theUserData, Handle data, OSType udType, long index,
short itlRegionTag)
= {0x303C,0x14C,0xAAAA};
pascal OSErr GetUserDataText(UserData theUserData, Handle data, OSType udType, long index,
short itlRegionTag)
= {0x303C,0x14D,0xAAAA};
pascal OSErr RemoveUserDataText(UserData theUserData, OSType udType, long index,
short itlRegionTag)
= {0x303C,0x14E,0xAAAA};
pascal OSErr NewUserData(UserData *theUserData)
= {0x303C,0x12F,0xAAAA};
pascal OSErr DisposeUserData(UserData theUserData)
= {0x303C,0x130,0xAAAA};
pascal OSErr NewUserDataFromHandle(Handle h, UserData *theUserData)
= {0x303C,0x131,0xAAAA};
pascal OSErr PutUserDataIntoHandle(UserData theUserData, Handle h)
= {0x303C,0x132,0xAAAA};
pascal void GetMediaNextInterestingTime( Media theMedia, short interestingTimeFlags, TimeValue time, Fixed rate,
TimeValue *interestingTime, TimeValue *interestingDuration )
= {0x303C,0x16D,0xAAAA};
pascal void GetTrackNextInterestingTime( Track theTrack, short interestingTimeFlags, TimeValue time, Fixed rate,
TimeValue *interestingTime, TimeValue *interestingDuration )
= {0x303C,0xE2,0xAAAA};
pascal void GetMovieNextInterestingTime( Movie theMovie, short interestingTimeFlags,
short numMediaTypes, const OSType *whichMediaTypes,
TimeValue time, Fixed rate,
TimeValue *interestingTime, TimeValue *interestingDuration )
= {0x303C,0x10E,0xAAAA};
pascal OSErr CreateMovieFile( const FSSpec *fileSpec, OSType creator,
ScriptCode scriptTag, long createMovieFileFlags, short *resRefNum, Movie *newmovie )
= {0x303C,0x191,0xAAAA};
pascal OSErr OpenMovieFile( const FSSpec *fileSpec, short *resRefNum, char perms )
= {0x303C,0x192,0xAAAA};
pascal OSErr CloseMovieFile( short resRefNum )
= {0x303C,0xD5,0xAAAA};
pascal OSErr DeleteMovieFile( const FSSpec *fileSpec )
= {0x303C,0x175,0xAAAA};
pascal OSErr NewMovieFromFile( Movie *theMovie, short resRefNum, short *resId, StringPtr resName,
short newMovieFlags, Boolean *dataRefWasChanged )
= {0x303C,0xF0,0xAAAA};
pascal OSErr NewMovieFromHandle( Movie *theMovie, Handle h,
short newMovieFlags, Boolean *dataRefWasChanged )
= {0x303C,0xF1,0xAAAA};
pascal OSErr NewMovieFromDataFork( Movie *theMovie, short fRefNum, long fileOffset,
short newMovieFlags, Boolean *dataRefWasChanged )
= {0x303C,0x1B3,0xAAAA};
pascal OSErr AddMovieResource( Movie theMovie, short resRefNum, short *resId, const StringPtr resName )
= {0x303C,0xD7,0xAAAA};
pascal OSErr UpdateMovieResource( Movie theMovie, short resRefNum, short resId, const StringPtr resName )
= {0x303C,0xD8,0xAAAA};
pascal OSErr RemoveMovieResource( short resRefNum, short resId )
= {0x303C,0x176,0xAAAA};
pascal Boolean HasMovieChanged( Movie theMovie )
= {0x303C,0xD9,0xAAAA};
pascal void ClearMovieChanged( Movie theMovie )
= {0x303C,0x113,0xAAAA};
pascal OSErr SetMovieDefaultDataRef(Movie theMovie, Handle dataRef, OSType dataRefType )
= {0x303C,0x1C1,0xAAAA};
pascal OSErr GetMovieDefaultDataRef(Movie theMovie, Handle *dataRef, OSType *dataRefType)
= {0x303C,0x1D2,0xAAAA};
pascal void FlattenMovie(Movie theMovie, long movieFlattenFlags,
const FSSpec *theFile, OSType creator, ScriptCode scriptTag,
long createMovieFileFlags, short *resId, const StringPtr resName)
= {0x303C,0x19B,0xAAAA};
pascal Movie FlattenMovieData(Movie theMovie, long movieFlattenFlags,
const FSSpec *theFile, OSType creator, ScriptCode scriptTag,
long createMovieFileFlags)
= {0x303C,0x19C,0xAAAA};
pascal void SetMovieProgressProc(Movie theMovie, MovieProgressProcPtr p, long refcon)
= {0x303C,0x19A,0xAAAA};
/*************************
* Video Media routines
**************************/
pascal HandlerError GetVideoMediaGraphicsMode( MediaHandler mh,
long *graphicsMode, RGBColor *opColor )
= {0x2F3C,0x8,0x101,0x7000,0xA82A};
pascal HandlerError SetVideoMediaGraphicsMode( MediaHandler mh,
long graphicsMode, const RGBColor *opColor )
= {0x2F3C,0x8,0x102,0x7000,0xA82A};
/*************************
* Sound Media routines
**************************/
pascal HandlerError GetSoundMediaBalance( MediaHandler mh,
short *balance )
= {0x2F3C,0x4,0x101,0x7000,0xA82A};
pascal HandlerError SetSoundMediaBalance( MediaHandler mh,
short balance )
= {0x2F3C,0x2,0x102,0x7000,0xA82A};
/*************************
* Text Media routines
**************************/
/* Return displayFlags for TextProc */
enum {
txtProcDefaultDisplay = 0, // Use the media's default
txtProcDontDisplay = 1, // Don't display the text
txtProcDoDisplay = 2 // Do display the text
};
typedef pascal OSErr (*TextMediaProcPtr)(Handle theText, Movie theMovie, short *displayFlag, long refcon);
pascal ComponentResult SetTextProc(MediaHandler mh, TextMediaProcPtr TextProc, long refcon)
= {0x2F3C,0x8,0x101,0x7000,0xA82A};
pascal ComponentResult AddTextSample(MediaHandler mh, Ptr text, unsigned long size,
short fontNumber, short fontSize, Style textFace, RGBColor *textColor,
RGBColor *backColor, short textJustification, Rect *textBox, long displayFlags,
TimeValue scrollDelay, short hiliteStart, short hiliteEnd, RGBColor *rgbHiliteColor,
TimeValue duration, TimeValue *sampleTime)
= {0x2F3C,0x34,0x102,0x7000,0xA82A};
pascal ComponentResult AddTESample(MediaHandler mh, TEHandle hTE, RGBColor *backColor,
short textJustification, Rect *textBox, long displayFlags, TimeValue scrollDelay,
short hiliteStart, short hiliteEnd, RGBColor *rgbHiliteColor, TimeValue duration,
TimeValue *sampleTime)
= {0x2F3C,0x26,0x103,0x7000,0xA82A};
pascal ComponentResult AddHiliteSample(MediaHandler mh, short hiliteStart, short hiliteEnd,
RGBColor *rgbHiliteColor, TimeValue duration, TimeValue *sampleTime)
= {0x2F3C,0x10,0x104,0x7000,0xA82A};
enum {
findTextEdgeOK = 1<<0, // Okay to find text at specified sample time
findTextCaseSensitive = 1<<1, // Case sensitive search
findTextReverseSearch = 1<<2, // Search from sampleTime backwards
findTextWrapAround = 1<<3 // Wrap search when beginning or end of movie is hit
};
pascal ComponentResult FindNextText(MediaHandler mh, Ptr text, long size, short findFlags,
TimeValue startTime, TimeValue *foundTime, TimeValue *foundDuration, long *offset)
= {0x2F3C,0x1A,0x105,0x7000,0xA82A};
pascal ComponentResult HiliteTextSample(MediaHandler mh, TimeValue sampleTime, short hiliteStart,
short hiliteEnd, RGBColor *rgbHiliteColor)
= {0x2F3C,0xC,0x106,0x7000,0xA82A};
pascal void GetPosterBox( Movie theMovie, Rect *boxRect )
= {0x303C,0x16F,0xAAAA};
pascal void SetPosterBox( Movie theMovie, const Rect *boxRect )
= {0x303C,0x170,0xAAAA};
pascal RgnHandle GetMovieSegmentDisplayBoundsRgn( Movie theMovie, TimeValue time, TimeValue duration )
= {0x303C,0x16C,0xAAAA};
pascal RgnHandle GetTrackSegmentDisplayBoundsRgn( Track theTrack, TimeValue time, TimeValue duration )
= {0x303C,0x16B,0xAAAA};
pascal void SetMovieCoverProcs(Movie theMovie, MovieRgnCoverProc uncoverProc, MovieRgnCoverProc coverProc, long refcon)
= {0x303C,0x179,0xAAAA};
pascal ComponentResult GetTrackStatus(Track theTrack)
= {0x303C,0x172,0xAAAA};
pascal ComponentResult GetMovieStatus(Movie theMovie, Track *firstProblemTrack)
= {0x303C,0x173,0xAAAA};
/****
Movie Controller support routines
****/
pascal ComponentInstance NewMovieController(Movie theMovie, const Rect *movieRect, long someFlags)
= {0x303C,0x18A,0xAAAA};
pascal void DisposeMovieController(ComponentInstance mc)
= {0x303C,0x18B,0xAAAA};
/*****
Scrap routines
*****/
pascal OSErr PutMovieOnScrap(Movie theMovie, long movieScrapFlags)
= {0x303C,0x18C,0xAAAA};
pascal Movie NewMovieFromScrap(long newMovieFlags)
= {0x303C,0x18D,0xAAAA};
/*****
DataRef routines
*****/
pascal OSErr GetMediaDataRef( Media theMedia, short index, Handle *dataRef, OSType *dataRefType, long *dataRefAttributes )
= {0x303C,0x197,0xAAAA};
pascal OSErr SetMediaDataRef( Media theMedia, short index, Handle dataRef, OSType dataRefType)
= {0x303C,0x1C9,0xAAAA};
pascal OSErr SetMediaDataRefAttributes( Media theMedia, short index, long dataRefAttributes)
= {0x303C,0x1CA,0xAAAA};
pascal OSErr AddMediaDataRef( Media theMedia, short *index, Handle dataRef, OSType dataRefType )
= {0x303C,0x198,0xAAAA};
pascal OSErr GetMediaDataRefCount( Media theMedia, short *count )
= {0x303C,0x199,0xAAAA};
/*****
Playback hint routines
*****/
pascal void SetMoviePlayHints( Movie theMovie, long flags, long flagsMask )
= {0x303C,0x1A1,0xAAAA};
pascal void SetMediaPlayHints( Media theMedia, long flags, long flagsMask )
= {0x303C,0x1A2,0xAAAA};
#ifdef __cplusplus
}
#endif __cplusplus
enum {
firstMoviesError = -2000,
couldNotResolveDataRef = -2000,
badImageDescription = -2001,
badPublicMovieAtom = -2002,
cantFindHandler = -2003,
cantOpenHandler = -2004,
badComponentType = -2005,
noMediaHandler = -2006,
noDataHandler = -2007,
invalidMedia = -2008,
invalidTrack = -2009,
invalidMovie = -2010,
invalidSampleTable = -2011,
invalidDataRef = -2012,
invalidHandler = -2013,
invalidDuration = -2014,
invalidTime = -2015,
cantPutPublicMovieAtom = -2016,
badEditList = -2017,
mediaTypesDontMatch = -2018,
progressProcAborted = -2019,
movieToolboxUninitialized = -2020,
wfFileNotFound = -2021,
cantCreateSingleForkFile = -2022, /* happens when file already exists */
invalidEditState = -2023,
nonMatchingEditState = -2024,
staleEditState = -2025,
userDataItemNotFound = -2026,
maxSizeToGrowTooSmall = -2027,
badTrackIndex = -2028,
trackIDNotFound = -2029,
trackNotInMovie = -2030,
timeNotInTrack = -2031,
timeNotInMedia = -2032,
badEditIndex = -2033,
internalQuickTimeError = -2034,
cantEnableTrack = -2035,
invalidRect = -2036,
invalidSampleNum = -2037,
invalidChunkNum = -2038,
invalidSampleDescIndex = -2039,
invalidChunkCache = -2040,
invalidSampleDescription = -2041,
/* this should probably be in its own range for data handlers */
dataNotOpenForRead = -2042,
dataNotOpenForWrite = -2043,
dataAlreadyOpenForWrite = -2044,
dataAlreadyClosed = -2045,
endOfDataReached = -2046,
dataNoDataRef = -2047,
/* private errors */
noMovieFound = -2048,
invalidDataRefContainer = -2049,
badDataRefIndex = -2050,
noDefaultDataRef = -2051,
couldNotUseAnExistingSample = -2052,
featureUnsupported = -2053,
unsupportedAuxiliaryImportData = -2057,
lastMoviesError,
noRecordOfApp = movieToolboxUninitialized /* replica */
};
#define MovieControllerComponentType 'play'
typedef ComponentInstance MovieController;
enum {
mcActionIdle = 1, // no param
mcActionDraw = 2, // param is WindowPtr
mcActionActivate = 3, // no param
mcActionDeactivate = 4, // no param
mcActionMouseDown = 5, // param is pointer to EventRecord
mcActionKey = 6, // param is pointer to EventRecord
mcActionPlay = 8, // param is Fixed, play rate
mcActionGoToTime = 12, // param is TimeRecord
mcActionSetVolume = 14, // param is a short
mcActionGetVolume = 15, // param is pointer to a short
mcActionStep = 18, // param is number of steps (short)
mcActionSetLooping = 21, // param is Boolean
mcActionGetLooping = 22, // param is pointer to a Boolean
mcActionSetLoopIsPalindrome = 23, // param is Boolean
mcActionGetLoopIsPalindrome = 24, // param is pointer to a Boolean
mcActionSetGrowBoxBounds = 25, // param is a Rect
mcActionControllerSizeChanged = 26, // no param
mcActionSetSelectionBegin = 29, // param is TimeRecord
mcActionSetSelectionDuration = 30, // param is TimeRecord, action only taken on set-duration
mcActionSetPosterTime = 31, // param is TimeRecord
mcActionSetKeysEnabled = 32, // param is Boolean
mcActionGetKeysEnabled = 33, // param is pointer to Boolean
mcActionSetPlaySelection = 34, // param is Boolean
mcActionGetPlaySelection = 35, // param is pointer to Boolean
mcActionSetUseBadge = 36, // param is Boolean
mcActionGetUseBadge = 37, // param is pointer to Boolean
mcActionSetFlags = 38, // param is long of flags
mcActionGetFlags = 39, // param is pointer to a long of flags
mcActionSetPlayEveryFrame = 40, // param is Boolean
mcActionGetPlayEveryFrame = 41, // param is pointer to Boolean
mcActionGetPlayRate = 42, // param is pointer to Fixed
mcActionShowBalloon = 43, // param is a pointer to a boolean. set to false to stop balloon
mcActionBadgeClick = 44, // param is pointer to Boolean. set to false to ignore click
mcActionMovieClick = 45, // param is pointer to event record. change “what” to nullEvt to kill click
mcActionSuspend = 46, // no param
mcActionResume = 47 // no param
};
typedef short mcAction;
enum
{
mcFlagSuppressMovieFrame = 1<<0,
mcFlagSuppressStepButtons = 1<<1,
mcFlagSuppressSpeakerButton = 1<<2,
mcFlagsUseWindowPalette = 1<<3
};
enum {
mcPositionDontInvalidate = 1<<5
};
typedef unsigned long mcFlags;
typedef pascal Boolean (*MCActionFilter)(MovieController mc, short *action, void *params);
typedef pascal Boolean (*MCActionFilterWithRefCon)(MovieController mc, short action, void *params, long refCon);
/*
menu related stuff
*/
enum {
mcInfoUndoAvailable = 1<<0,
mcInfoCutAvailable = 1<<1,
mcInfoCopyAvailable = 1<<2,
mcInfoPasteAvailable = 1<<3,
mcInfoClearAvailable = 1<<4,
mcInfoHasSound = 1<<5,
mcInfoIsPlaying = 1<<6,
mcInfoIsLooping = 1<<7,
mcInfoIsInPalindrome = 1<<8,
mcInfoEditingEnabled = 1<<9
};
// menu item codes
enum {
mcMenuUndo = 1,
mcMenuCut = 3,
mcMenuCopy = 4,
mcMenuPaste = 5,
mcMenuClear = 6
};
/**** error codes ******/
enum {
cannotMoveAttachedController = -9999,
controllerHasFixedHeight = -9998,
cannotSetWidthOfAttachedController = -9997,
controllerBoundsNotExact = -9996,
editingNotAllowed = -9995,
badControllerHeight = -9994
};
#ifdef __cplusplus
extern "C" {
#endif __cplusplus
/* target management */
pascal ComponentResult MCSetMovie (MovieController mc, Movie theMovie, WindowPtr movieWindow, Point where) = {0x2F3C,0xC,0x2,0x7000,0xA82A};
pascal Movie MCGetMovie(MovieController mc) = {0x4267,0x2F3C,0x2,0x5,0x7000,0xA82A};
pascal ComponentResult MCRemoveMovie (MovieController mc) = {0x2F3C,0,0x6,0x7000,0xA82A};
/* event handling etc. */
pascal ComponentResult MCIsPlayerEvent (MovieController mc, const EventRecord *e) = {0x2F3C,0x4,0x7,0x7000,0xA82A};
/* obsolete. use MCSetActionFilterWithRefCon instead. */
pascal ComponentResult MCSetActionFilter (MovieController mc, MCActionFilter blob) = {0x2F3C,0x4,0x8,0x7000,0xA82A};
/*
proc is of the form:
Boolean userPlayerFilter(MovieController mc, short *action, void *params) =
proc returns TRUE if it handles the action, FALSE if not
action is passed as a VAR so that it could be changed by filter (ick)
this is consistent with the current dialog manager stuff
params is any potential parameters that go with the action <triple ick>
such as set playback rate to xxx.
*/
pascal ComponentResult MCDoAction (MovieController mc, short action, void *params) = {0x2F3C,0x6,0x9,0x7000,0xA82A};
/* state type things */
pascal ComponentResult MCSetControllerAttached (MovieController mc, Boolean attach) = {0x2F3C,0x2,0xA,0x7000,0xA82A};
pascal ComponentResult MCIsControllerAttached (MovieController mc) = {0x2F3C,0,0xB,0x7000,0xA82A};
pascal ComponentResult MCSetControllerPort (MovieController mc, CGrafPtr gp) = {0x2F3C,0x4,0xC,0x7000,0xA82A};
pascal CGrafPtr MCGetControllerPort (MovieController mc) = {0x2F3C,0,0xD,0x7000,0xA82A};
pascal ComponentResult MCSetVisible (MovieController mc, Boolean visible) = {0x2F3C,0x2,0xE,0x7000,0xA82A};
pascal ComponentResult MCGetVisible (MovieController mc) = {0x2F3C,0,0xF,0x7000,0xA82A};
pascal ComponentResult MCGetControllerBoundsRect (MovieController mc, Rect *bounds) = {0x2F3C,0x4,0x10,0x7000,0xA82A};
pascal ComponentResult MCSetControllerBoundsRect (MovieController mc, const Rect *bounds) = {0x2F3C,0x4,0x11,0x7000,0xA82A};
pascal RgnHandle MCGetControllerBoundsRgn (MovieController mc) = {0x2F3C,0,0x12,0x7000,0xA82A};
pascal RgnHandle MCGetWindowRgn (MovieController mc, WindowPtr w) = {0x2F3C,0x4,0x13,0x7000,0xA82A};
/* other stuff */
pascal ComponentResult MCMovieChanged (MovieController mc, Movie m) = {0x2F3C,0x4,0x14,0x7000,0xA82A};
/*
called when the app has changed thing about the movie (like bounding rect) or rate. So that we
can update our graphical (and internal) state accordingly.
*/
pascal ComponentResult MCSetDuration (MovieController mc, TimeValue duration) = {0x2F3C,0x4,0x15,0x7000,0xA82A};
/*
duration to use for time slider -- will be reset next time MCMovieChanged is called
or MCSetMovie is called
*/
pascal TimeValue MCGetCurrentTime (MovieController mc, TimeScale *scale) = {0x2F3C,0x4,0x16,0x7000,0xA82A};
/*
returns the time value and the time scale it is on. if there are no movies, the
time scale is passed back as 0. scale is an optional parameter
*/
pascal ComponentResult MCNewAttachedController (MovieController mc, Movie theMovie, WindowPtr w, Point where) = {0x2F3C,0xC,0x17,0x7000,0xA82A};
/*
makes m the only movie attached to the controller. makes the controller visible.
the window and where parameters are passed a long to MCSetMovie and behave as
described there
*/
pascal ComponentResult MCDraw (MovieController mc, WindowPtr w) = {0x2F3C,0x4,0x18,0x7000,0xA82A};
pascal ComponentResult MCActivate (MovieController mc, WindowPtr w, Boolean activate) = {0x2F3C,0x6,0x19,0x7000,0xA82A};
pascal ComponentResult MCIdle (MovieController mc) = {0x2F3C,0,0x1A,0x7000,0xA82A};
pascal ComponentResult MCKey (MovieController mc, char key, long modifiers) = {0x2F3C,0x6,0x1B,0x7000,0xA82A};
pascal ComponentResult MCClick (MovieController mc, WindowPtr w, Point where, long when, long modifiers) = {0x2F3C,0x10,0x1C,0x7000,0xA82A};
/*
calls for editing
*/
pascal ComponentResult MCEnableEditing (MovieController mc, Boolean enabled) = {0x2F3C,0x2,0x1D,0x7000,0xA82A};
pascal long MCIsEditingEnabled (MovieController mc) = {0x2F3C,0,0x1E,0x7000,0xA82A};
pascal Movie MCCopy (MovieController mc) = {0x2F3C,0,0x1F,0x7000,0xA82A};
pascal Movie MCCut (MovieController mc) = {0x2F3C,0,0x20,0x7000,0xA82A};
pascal ComponentResult MCPaste (MovieController mc, Movie srcMovie) = {0x2F3C,0x4,0x21,0x7000,0xA82A};
pascal ComponentResult MCClear (MovieController mc) = {0x2F3C,0,0x22,0x7000,0xA82A};
pascal ComponentResult MCUndo (MovieController mc) = {0x2F3C,0,0x23,0x7000,0xA82A};
/*
* somewhat special stuff
*/
pascal ComponentResult MCPositionController (MovieController mc, const Rect *movieRect, const Rect *controllerRect, long someFlags) = {0x2F3C,0xC,0x24,0x7000,0xA82A};
pascal ComponentResult MCGetControllerInfo (MovieController mc, long *someFlags) = {0x2F3C,0x4,0x25,0x7000,0xA82A};
pascal ComponentResult MCSetClip (MovieController mc, RgnHandle theClip, RgnHandle movieClip) = {0x2F3C,0x8,0x28,0x7000,0xA82A};
pascal ComponentResult MCGetClip (MovieController mc, RgnHandle *theClip, RgnHandle *movieClip) = {0x2F3C,0x8,0x29,0x7000,0xA82A};
pascal ComponentResult MCDrawBadge (MovieController mc, RgnHandle movieRgn, RgnHandle *badgeRgn) = {0x2F3C,0x8,0x2A,0x7000,0xA82A};
pascal ComponentResult MCSetUpEditMenu (MovieController mc, long modifiers, MenuHandle mh) = {0x2F3C,0x8,0x2B,0x7000,0xA82A};
pascal ComponentResult MCGetMenuString (MovieController mc, long modifiers, short item, Str255 aString) = {0x2F3C,0xA,0x2C,0x7000,0xA82A};
pascal ComponentResult MCSetActionFilterWithRefCon (MovieController mc, MCActionFilterWithRefCon blob, long refCon) = {0x2F3C,0x8,0x2D,0x7000,0xA82A};
#ifdef __cplusplus
}
#endif __cplusplus
enum {
kMCSetMovieSelect = 0x2,
kMCRemoveMovieSelect = 0x6,
kMCIsPlayerEventSelect = 0x7,
kMCSetActionFilterSelect = 0x8,
kMCDoActionSelect = 0x9,
kMCSetControllerAttachedSelect = 0xA,
kMCIsControllerAttachedSelect = 0xB,
kMCSetControllerPortSelect = 0xC,
kMCGetControllerPortSelect = 0xD,
kMCSetVisibleSelect = 0xE,
kMCGetVisibleSelect = 0xF,
kMCGetControllerBoundsRectSelect = 0x10,
kMCSetControllerBoundsRectSelect = 0x11,
kMCGetControllerBoundsRgnSelect = 0x12,
kMCGetWindowRgnSelect = 0x13,
kMCMovieChangedSelect = 0x14,
kMCSetDurationSelect = 0x15,
kMCGetCurrentTimeSelect = 0x16,
kMCNewAttachedControllerSelect = 0x17,
kMCDrawSelect = 0x18,
kMCActivateSelect = 0x19,
kMCIdleSelect = 0x1A,
kMCKeySelect = 0x1B,
kMCClickSelect = 0x1C,
kMCEnableEditingSelect = 0x1D,
kMCIsEditingEnabledSelect = 0x1E,
kMCCopySelect = 0x1F,
kMCCutSelect = 0x20,
kMCPasteSelect = 0x21,
kMCClearSelect = 0x22,
kMCUndoSelect = 0x23,
kMCPositionControllerSelect = 0x24,
kMCGetControllerInfoSelect = 0x25,
kMCSetClipSelect = 0x28,
kMCGetClipSelect = 0x29,
kMCDrawBadgeSelect = 0x2A,
kMCSetUpEditMenuSelect = 0x2B,
kMCGetMenuStringSelect = 0x2C,
kMCSetActionFilterWithRefConSelect = 0x2D
};
#ifdef __cplusplus
extern "C" {
#endif __cplusplus
/****************************************
* *
* T I M E B A S E *
* *
****************************************/
pascal TimeBase NewTimeBase(void)
= {0x303C,0xA5,0xAAAA};
pascal void DisposeTimeBase(TimeBase tb)
= {0x303C,0xB6,0xAAAA};
pascal TimeValue GetTimeBaseTime(TimeBase tb,TimeScale s, TimeRecord *tr)
= {0x303C,0xA6,0xAAAA};
pascal void SetTimeBaseTime(TimeBase tb,const TimeRecord *tr)
= {0x303C,0xA7,0xAAAA};
pascal void SetTimeBaseValue(TimeBase tb,TimeValue t,TimeScale s)
= {0x303C,0xA8,0xAAAA};
pascal Fixed GetTimeBaseRate(TimeBase tb)
= {0x303C,0xA9,0xAAAA};
pascal void SetTimeBaseRate(TimeBase tb, Fixed r)
= {0x303C,0xAA,0xAAAA};
pascal TimeValue GetTimeBaseStartTime(TimeBase tb,TimeScale s,TimeRecord *tr)
= {0x303C,0xAB,0xAAAA};
pascal void SetTimeBaseStartTime(TimeBase tb,const TimeRecord *tr)
= {0x303C,0xAC,0xAAAA};
pascal TimeValue GetTimeBaseStopTime(TimeBase tb,TimeScale s,TimeRecord *tr)
= {0x303C,0xAD,0xAAAA};
pascal void SetTimeBaseStopTime(TimeBase tb,const TimeRecord *tr)
= {0x303C,0xAE,0xAAAA};
pascal long GetTimeBaseFlags(TimeBase tb)
= {0x303C,0xB1,0xAAAA};
pascal void SetTimeBaseFlags(TimeBase tb,long timeBaseFlags)
= {0x303C,0xB2,0xAAAA};
pascal void SetTimeBaseMasterTimeBase(TimeBase slave,TimeBase master,
const TimeRecord *slaveZero)
= {0x303C,0xB4,0xAAAA};
pascal TimeBase GetTimeBaseMasterTimeBase(TimeBase tb)
= {0x303C,0xAF,0xAAAA};
pascal void SetTimeBaseMasterClock(TimeBase slave,Component clockMeister,
const TimeRecord *slaveZero)
= {0x303C,0xB3,0xAAAA};
pascal ComponentInstance GetTimeBaseMasterClock(TimeBase tb)
= {0x303C,0xB0,0xAAAA};
pascal void ConvertTime(TimeRecord *inout,TimeBase newBase)
= {0x303C,0xB5,0xAAAA};
pascal void ConvertTimeScale(TimeRecord *inout,TimeScale newScale)
= {0x303C,0xB7,0xAAAA};
pascal void AddTime(TimeRecord *dst,const TimeRecord *src)
= {0x303C,0x10C,0xAAAA};
pascal void SubtractTime(TimeRecord *dst,const TimeRecord *src)
= {0x303C,0x10D,0xAAAA};
pascal long GetTimeBaseStatus(TimeBase tb,TimeRecord *unpinnedTime)
= {0x303C,0x10B,0xAAAA};
pascal void SetTimeBaseZero(TimeBase tb, TimeRecord *zero)
= {0x303C,0x128,0xAAAA};
pascal Fixed GetTimeBaseEffectiveRate(TimeBase tb)
= {0x303C,0x124,0xAAAA};
/****************************************
* *
* C A L L B A C K *
* *
****************************************/
pascal QTCallBack NewCallBack(TimeBase tb, short cbType)
= {0x303C,0xEB,0xAAAA};
pascal void DisposeCallBack(QTCallBack cb)
= {0x303C,0xEC,0xAAAA};
pascal short GetCallBackType(QTCallBack cb)
= {0x303C,0xED,0xAAAA};
pascal TimeBase GetCallBackTimeBase(QTCallBack cb)
= {0x303C,0xEE,0xAAAA};
pascal OSErr CallMeWhen(QTCallBack cb, QTCallBackProc callBackProc, long refCon,
long param1, long param2, long param3)
= {0x303C,0xB8,0xAAAA};
pascal void CancelCallBack(QTCallBack cb)
= {0x303C,0xB9,0xAAAA};
/****************************************
* *
* C L O C K C A L L B A C K *
* S U P P O R T *
* *
****************************************/
pascal OSErr AddCallBackToTimeBase(QTCallBack cb)
= {0x303C,0x129,0xAAAA};
pascal OSErr RemoveCallBackFromTimeBase(QTCallBack cb)
= {0x303C,0x12A,0xAAAA};
pascal QTCallBack GetFirstCallBack(TimeBase tb)
= {0x303C,0x12B,0xAAAA};
pascal QTCallBack GetNextCallBack(QTCallBack cb)
= {0x303C,0x12C,0xAAAA};
pascal void ExecuteCallBack(QTCallBack cb)
= {0x303C,0x12D,0xAAAA};
#ifdef __cplusplus
}
#endif __cplusplus
#endif __MOVIES__