Max 5 API Reference

jit.qt.utils.c

#if TARGET_RT_MAC_MACHO

#include <QuickTime/Movies.h>
#include <QuickTime/MediaHandlers.h>
#include <QuickTime/QuicktimeVR.h>

#else

#include <Movies.h>
#include <MediaHandlers.h>
#include <Script.h>
#include <QuicktimeVR.h>

#endif

#include "jit.common.h"
#include "ext_obex.h"
#include "jit.qt.h"
#include "jit.fixmath.h"
#include "jit.charset.h"

/**
 *  @defgroup qtutilsmod QuickTime Utilties Module
    @ingroup jitter
 */

#define type2str(type,typestr)                      \
            (typestr)[0]=((type)>>24L)&0x000000ff;  \
            (typestr)[1]=((type)>>16L)&0x000000ff;  \
            (typestr)[2]=((type)>>8L)&0x000000ff;   \
            (typestr)[3]=(type)&0x000000ff;         \
            (typestr)[4]=0; 
            
long _jit_qt_optimize = true; // this can be set from the kernel ; jit qtoptimize 1/0

/**
 * Media type symbols:  "video", "sound", "test", "base", "mpeg", "music", "timecode",
 *                      "sprite", "flash", "movie", "tween", "3d", "qtvr", "qtvrpano",
 *                      "qtvrobject", "unknown"
 *
 * @ingroup qtutilsmod
 *
 * @warning These symbols aren't exported, but are provided for reference, as they
 *          may be returned by jit_qt_utils_tracktype_get().
 */
static t_symbol *ps_media_video;
static t_symbol *ps_media_sound;
static t_symbol *ps_media_text;
static t_symbol *ps_media_base;
static t_symbol *ps_media_mpeg;
static t_symbol *ps_media_music;
static t_symbol *ps_media_timecode;
static t_symbol *ps_media_sprite;
static t_symbol *ps_media_flash;
static t_symbol *ps_media_movie;
static t_symbol *ps_media_tween;
static t_symbol *ps_media_3d;
static t_symbol *ps_media_qtvr;
static t_symbol *ps_media_qtvrpano;
static t_symbol *ps_media_qtvrobject;
static t_symbol *ps_media_unknown;

static t_symbol *ps_file_aiff;
static t_symbol *ps_file_aifc;
static t_symbol *ps_file_dvc;
static t_symbol *ps_file_midi;
static t_symbol *ps_file_pict;
static t_symbol *ps_file_movie;
static t_symbol *ps_file_text;
static t_symbol *ps_file_wave;
static t_symbol *ps_file_sfil;
static t_symbol *ps_file_ulaw;
static t_symbol *ps_file_avi;
static t_symbol *ps_file_sd2;
static t_symbol *ps_file_cdtrack;
static t_symbol *ps_file_pics;
static t_symbol *ps_file_gif;
static t_symbol *ps_file_png;
static t_symbol *ps_file_tiff;
static t_symbol *ps_file_photoshop;
static t_symbol *ps_file_sgi;
static t_symbol *ps_file_bmp;
static t_symbol *ps_file_jpeg;
static t_symbol *ps_file_macpaint;
static t_symbol *ps_file_targa;
static t_symbol *ps_file_qdgx;
static t_symbol *ps_file_qtimage;
static t_symbol *ps_file_3dmf;
static t_symbol *ps_file_flc;
static t_symbol *ps_file_flash;
static t_symbol *ps_file_flashpix;
static t_symbol *ps_file_mpeg4;


/**
* Creates a new Data Reference from a file path, returning it and the filename/path pair
 *
 * @ingroup qtutilsmod 
 *
 * @param   sname       (in/out) in: file name or fully qualified path in; out: file name of opened movie file
 * @param   path        (in/out) in: only necessary if sname is unqualified; out: path of opened movie file
 * @param   dataRef     (on output) QuickTime-compatible Data Reference for the specified file name, must be disposed by the caller
 * @param   dataRefType (on output) Data Reference type
 * 
 * @return  t_jit_err   error
 *
 */
t_jit_err jit_qt_utils_moviedataref_create(t_symbol **sname, short *path, Handle *dataRef, OSType *dataRefType)
{
    char name[MAX_PATH_CHARS];
    short vol;
    long type = FOUR_CHAR_CODE('MooV');
    Handle dr = NULL;
    OSType drt = 0;
    OSErr err;

    if (!(sname && path && dataRef && dataRefType))
        return JIT_ERR_GENERIC;
    
    if (*sname==_jit_sym_nothing) {
        strcpy(name,"untitled.mov");
        if ((err = saveasdialog_extended(name, &vol, &type, &type, 1)))
            return JIT_ERR_GENERIC;
    } 
    else {
        // convert any full paths into path/name combo before getting the data ref
        if (path_frompotentialpathname((*sname)->s_name, &vol, name)) {
            strcpy(name, (*sname)->s_name);         
            vol = path_getdefault();
        }
    }
    
    XQT_NewDataReferenceFromMaxPath(vol, name, &dr, &drt, &err);

    if (err)
        return JIT_ERR_GENERIC;
    
    *sname = gensym(name);
    *path = vol;
    *dataRef = dr;
    *dataRefType = drt;

    return JIT_ERR_NONE;
}


/**
 * Creates a new QuickTime Movie from a file path, optionally returning the Data Handler and/or filename/path pair
 *
 * @ingroup qtutilsmod 
 *
 * @param   sname       (in/out) in: file name or fully qualified path in; out: file name of opened movie file
 * @param   path        (in/out, optional) in: only necessary if sname is unqualified; out: path of opened movie file
 * @param   flags       movie file creation flags (see QuickTime Documentation for more information)
 *                      if no flags are specified, the following flags are used:
 *                      createMovieFileDeleteCurFile | createMovieFileDontCreateResFile
 * @param   dhandler    (on output, optional) data handler for the opened movie file
 * 
 * @return  Movie       QuickTime Movie
 *
 */
Movie jit_qt_utils_moviefile_create(t_symbol **sname, short *path, long flags, DataHandler *dhandler)
{
    OSErr err = 0;
    Movie movie = NULL;
    Handle dataRef = NULL;
    OSType dataRefType = 0;
    OSErr derr;
    
    if (jit_qt_utils_moviedataref_create(sname, path, &dataRef, &dataRefType) != JIT_ERR_NONE)
        return NULL;
    
    if (!flags) { //default case
        flags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;
    }
    
    err = CreateMovieStorage(dataRef, dataRefType, FOUR_CHAR_CODE('TVOD'), smCurrentScript, flags, dhandler, &movie);
    if (err) {
        movie = NULL;
    }
    DisposeHandle(dataRef);

    return movie;
}

/**
 * Returns a QuickTime-compatible Data Reference for a named file in the system's temporary files directory
 *
 * @ingroup qtutilsmod 
 *
 * @param   name        file name
 * @param   dataRef     (on output) QuickTime-compatible Data Reference for the specified file name, must be disposed by the caller
 * @param   dataRefType (on output) Data Reference type
 * 
 * @return  Boolean     success (true) or failure (false)
 *
 */
Boolean jit_qt_utils_tempfile(char *name, Handle *dataRef, OSType *dataRefType)
{
    OSErr err;
    short vref;
    long dirid;
    char fname[MAX_PATH_CHARS];
    short path;
    char cname[MAX_PATH_CHARS];
    char tmpfilename[MAX_PATH_CHARS];
#ifdef WIN_VERSION
    TCHAR tcname[MAX_PATH + 1];
    TCHAR cvtname[MAX_PATH + 1] = "";
    t_jit_charset_converter *conv;
    t_symbol *srcenc = ps_macroman;
    t_symbol *dstenc = ps_ms_ansi;
    char *cvtbuffer = NULL;
    long cvtbuffersize = 0;
    t_jit_err jiterr;
#endif
    
    if (!name) {
        name = tmpfilename;
        sprintf(name, "tmp_%s.mov", jit_symbol_unique()->s_name);
    }

    // TODO: TEST WINDOWS
#ifdef WIN_VERSION
    // convert name to Windows code page
    if (conv = (t_jit_charset_converter *)jit_object_new(ps_jit_charset_converter, ps_utf_8, ps_ms_ansi)) {
        jiterr = (t_jit_err)jit_object_method(conv, ps_convert, name, strlen(name) + 1, &cvtbuffer, &cvtbuffersize);
        if (!jiterr && cvtbuffer) {
            strcpy(cvtname, cvtbuffer);
            sysmem_freeptr(cvtbuffer);
        }
        jit_object_free(conv);
    }
    if (cvtname[0] == '\0') {
        return false;
    }
    
    if (!GetTempPath(MAX_PATH, tcname)) {
        error("jit.broadcast: can't create temp file");
        return false;
    }
    strcat((char *)tcname, cvtname);
    // TODO: this looks wrong
    if (path_nameconform(tcname, fname, PATH_STYLE_NATIVE, PATH_TYPE_PATH)) {
        return false;
    }
#else
    FSRef fref;
    CFURLRef url;
    
    err = FSFindFolder(kUserDomain, kTemporaryFolderType, kCreateFolder, &fref);
    if (err) {
        return false;
    }
    url = CFURLCreateFromFSRef(kCFAllocatorDefault, &fref);
    if (url) {
        if (CFURLGetFileSystemRepresentation(url, TRUE, (UInt8 *)fname, MAX_PATH_CHARS)) {
            long len = strlen(fname);
            if (fname[len-1] != '/') {
                fname[len] = '/';
                fname[len+1] = '\0';
            }
            strcat(fname, name);
            strcpy(cname, fname);
        }
        CFRelease(url);
    }
    if (path_nameconform(cname, fname, PATH_STYLE_MAX, PATH_TYPE_ABSOLUTE)) {
        return false;
    }
#endif
    
    // convert full path into path/name combo before getting the data ref
    path_frompotentialpathname(fname, &path, cname);
    XQT_NewDataReferenceFromMaxPath(path, cname, dataRef, dataRefType, &err);
    
    if (err) return false; // fnfErr?
    return true; 
}

/**
 * Creates a new QuickTime Movie in the system's temporary file directory, 
 * optionally returning the movie's data handler
 *
 * @ingroup qtutilsmod 
 *
 * @param   sname       (in/out) in: file name or fully qualified path in; out: file name of opened movie file
 * @param   path        (in/out, optional) in: only necessary if sname is unqualified; out: path of opened movie file
 * @param   flags       movie file creation flags (see QuickTime Documentation for more information)
 *                      if no flags are specified, the following flags are used:
 *                      createMovieFileDeleteCurFile | createMovieFileDontCreateResFile
 * @param   dhandler    (on output, optional) data handler for the opened movie file
 * 
 * 
 * @return  Movie       QuickTime Movie
 *
 */
Movie jit_qt_utils_tempmoviefile_create(t_symbol **sname, short *path, long flags, DataHandler *dhandler)
{
    char name[256];
    short vol;
    long type = FOUR_CHAR_CODE('MooV');
    short resId=movieInDataForkResID;
    long err = 0;
    Movie movie = NULL;
    unsigned long ticks;
    Handle dataRef = NULL;
    OSType dataRefType = 0;
    
    if (*sname==_jit_sym_nothing) {
        GetDateTime(&ticks);
        sprintf(name, "temp%X.mov", ticks);
    }
    else {
        strcpy(name, (*sname)->s_name);
        vol = path_getdefault();
    }
    
    if (jit_qt_utils_tempfile(name, &dataRef, &dataRefType)) {
        if (!flags) //default case
            flags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;
        err = CreateMovieStorage(dataRef, dataRefType, FOUR_CHAR_CODE('TVOD'), smCurrentScript, flags, dhandler, &movie);
        if (err)
            movie = NULL;
        DisposeHandle(dataRef);
    }

    *sname = gensym(name);
    if (path)
        *path = vol;
    return movie;
}

/**
 * Closes a QuickTime Movie previously created with jit_qt_utils_moviefile_create 
 * or jit_qt_utils_tempmoviefile_create, adding the necessary movie resources
 *
 * @ingroup qtutilsmod 
 *
 * @param   movie       QuickTime Movie, as returned from one of the above-named functions
 * @param   dhandler    data handler for the Movie, as returned from one of the above-named functions
 * 
 * @return  long        QuickTime error code
 *
 */
long jit_qt_utils_moviefile_close(Movie movie, DataHandler dhandler)
{
    short resId=movieInDataForkResID;
    long err = noErr;

    if (!(movie && dhandler))
        return noErr;
    
    err = AddMovieToStorage(movie, dhandler);
    if (err) 
        goto out;

    err = CloseMovieStorage(dhandler);
    if (err)
        goto out;
    
out:
    DisposeMovie(movie);
    err = GetMoviesError();

    return err;
}
    
t_jit_err jit_qt_utils_exchange_files(t_object *owner, Handle aDataRef, OSType aDataRefType, Handle bDataRef, OSType bDataRefType)
{
    CFStringRef aStr = NULL;
    CFStringRef bStr = NULL;
    OSErr err;

    err = QTGetDataReferenceFullPathCFString(aDataRef, aDataRefType, kQTNativeDefaultPathStyle, &aStr);
    if (err != noErr) {
        jit_object_error(owner, "%s: error %ld getting path string for file A data reference", object_classname(owner)->s_name, err);
        goto out;
    }
    err = QTGetDataReferenceFullPathCFString(bDataRef, bDataRefType, kQTNativeDefaultPathStyle, &bStr);
    if (err != noErr) {
        jit_object_error(owner, "%s: error %d getting path string for flat data reference (flatten)", object_classname(owner)->s_name, err);
    }
#ifdef WIN_VERSION
    {
        char caStr[MAX_PATH_CHARS] = "";
        char cbStr[MAX_PATH_CHARS] = "";

        CFStringGetCString(aStr, caStr, MAX_PATH_CHARS, kCFStringEncodingWindowsLatin1);
        CFStringGetCString(bStr, cbStr, MAX_PATH_CHARS, kCFStringEncodingWindowsLatin1);

        if (*caStr && *cbStr) {
            // do names have to be windows-encoded?
            if (!CopyFile(cbStr, caStr, FALSE))
                jit_object_error(owner, "%s: error %ld exchanging file contents", object_classname(owner)->s_name, GetLastError());
            if (!DeleteFile(cbStr)) {
                jit_object_error(owner, "%s: error %ld deleting file ", object_classname(owner)->s_name, GetLastError());
            }
        }
    }
#else
    {
        CFURLRef aUrl = NULL;
        CFURLRef bUrl = NULL;
        FSRef aFref, bFref;

        aUrl = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, aStr, kQTNativeDefaultPathStyle, FALSE);
        bUrl = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, bStr, kQTNativeDefaultPathStyle, FALSE);
        if (aUrl && bUrl) {
            if (!CFURLGetFSRef(aUrl, &aFref)) {
                jit_object_error(owner, "%s: error getting FSRef from movie file A", object_classname(owner)->s_name);
            }
            if (!CFURLGetFSRef(bUrl, &bFref)) {
                jit_object_error(owner, "%s: error getting FSRef from movie file B", object_classname(owner)->s_name);
            }
            err = FSExchangeObjects(&bFref, &aFref);
            if (err != noErr)
                jit_object_error(owner, "%s: error %ld exchanging file contents", object_classname(owner)->s_name, err);
            err = FSDeleteObject(&bFref);
            if (err != noErr)
                jit_object_error(owner, "%s: error %ld deleting temp file", object_classname(owner)->s_name, err);
        }
        if (aUrl)
            CFRelease(aUrl);
        if (bUrl)
            CFRelease(bUrl);
    }
#endif
out:
    if (aStr) CFRelease(aStr);
    if (bStr) CFRelease(bStr);

    if (err) return JIT_ERR_GENERIC;
    return JIT_ERR_NONE;
}

/**
 * Adds a new Track, with associated Media, to a QuickTime Movie
 *
 * @ingroup qtutilsmod 
 *
 * @param   movie       QuickTime Movie
 * @param   type        four-char code specifying the track/media type to be added (see QuickTime Documentation)
 * @param   trackframe  the new Track's Rect, relative to the Movie's Rect
 * @param   vol         initial value for the sound volume in the new Track
 * @param   timescale   the new Track's timescale
 * 
 * @return  Track       QuickTime Track
 *
 */
Track jit_qt_utils_trackmedia_add(Movie movie, long type, Rect *trackframe, long vol, long timescale)
{
    Track track = NULL;
    Media media = NULL;
    long width = trackframe->right - trackframe->left;
    long height = trackframe->bottom - trackframe->top;
    ComponentDescription cd;
    Component c;
    Boolean visual = false;
    
    cd.componentType = MediaHandlerType;
    cd.componentSubType = type;
    cd.componentManufacturer = 0;
    cd.componentFlags = 0;
    cd.componentFlagsMask = 0;
    
    if (c = FindNextComponent(NULL, &cd)) {
        MediaHasCharacteristic((ComponentInstance)c, VisualMediaCharacteristic, &visual);
        if (visual) {
            vol = 0;
        }
        else {
            width = height = 0;
        }
        track = NewMovieTrack(movie, IntToFixed(width), IntToFixed(height), vol);
        if (track) {
            media = NewTrackMedia(track, type, timescale, NULL, 0);
            if (media)
                return track;
            else {
                DisposeMovieTrack(track);
                return NULL;
            }
        }
    }
    return NULL;
}

/**
 * Returns the Media for a specified Track
 *
 * @ingroup qtutilsmod 
 *
 * @param   track       QuickTime Track
 * 
 * @return  Media       QuickTime Media
 *
 */
Media jit_qt_utils_trackmedia_get(Track track)
{
    Media media = NULL;
    
    media = GetTrackMedia(track);
    return media;
}

long jit_qt_utils_trackmedia_close(Track track, long trackstart, long mediastart)
{
    long err = noErr;
    Media media = NULL;
    
    if (track) {
        media = GetTrackMedia(track);
        if (media) {
            err = InsertMediaIntoTrack(track, trackstart, mediastart, GetMediaDuration(media), fixed1);
        }
    }
    return err;
}

/**
 * Removes a Track, with associated Media, from a QuickTime Movie
 *
 * @ingroup qtutilsmod 
 *
 * @param   track       QuickTime Track
 * 
 * @return  long        QuickTime error code
 *
 */
long jit_qt_utils_trackmedia_dispose(Track track)
{
    long err = noErr;
    Media media = NULL;

    if (track) {
        media = GetTrackMedia(track);
        if (media) {
            DisposeTrackMedia(media);
            err = GetMoviesError();
            if (err) goto out;
        }
        DisposeMovieTrack(track);
        err = GetMoviesError();
    }
out:
    return err;
}

/**
 * Given a four-char type code, return a 0-terminated C string
 *
 * @ingroup qtutilsmod 
 *
 * @param   type        four-char code
 * @param   typestr     (on output) 0-terminated C string
 * 
 */
void jit_qt_utils_type2str(OSType type, char *typestr)
{
    type2str(type, typestr);
}

/**
 * Given a C string, return a four-char code
 *
 * @ingroup qtutilsmod 
 *
 * @param   typestr     C string
 *
 * @return  OSType      four-char code
 * 
 */
OSType jit_qt_utils_str2type(char *typestr)
{
    long len = strlen(typestr);
    OSType rv = 0;

    len = MIN(len, 4);

    switch(len) {
        case 4:
            rv += (typestr[3]);
        case 3:
            rv += (typestr[2] << 8L);
        case 2:
            rv += (typestr[1] << 16L);
        case 1:
            rv += (typestr[0] << 24L);
            break;
    }
    return rv;
}
            
/**
 * Set the name of a QuickTime Track
 *
 * @ingroup qtutilsmod 
 *
 * @param   track       QuickTime Track
 * @param   s           track name
 * 
 */
void jit_qt_utils_trackname_set(Track track, t_symbol *s)
{
    UserData ud;
    Str255 pname;
    
    ud = GetTrackUserData(track);
    
    ctopcpy(pname, s->s_name);
    while (RemoveUserData(ud, kUserDataName, 1) == noErr)
        ;
    SetUserDataItem(ud, &pname[1], pname[0], kUserDataName, 0);
}

/**
 * Get the name of a QuickTime Track
 *
 * @ingroup qtutilsmod 
 *
 * @param   track       QuickTime Track
 *
 * @return  t_symbol pointer containing Track's name
 * 
 */
t_symbol *jit_qt_utils_trackname_get(Track track)
{
    UserData ud;
    Handle h;
    char cname[256];
    long nameLength = 0;

    h = NewHandle(0);
    
    ud = GetTrackUserData(track);
    if (GetUserData(ud, h, kUserDataName, 1) == noErr) {
        nameLength = GetHandleSize(h);
        if (nameLength > 255)
            nameLength = 255;
        BlockMoveData(*h, cname, nameLength);
    }
    DisposeHandle(h);   
    cname[nameLength] = '\0';
    
    return (gensym(cname));
}

/**
 * Get the Media Type name from a QuickTime Track
 *
 * @ingroup qtutilsmod 
 *
 * @param   track       QuickTime Track
 *
 * @return  t_symbol pointer containing the name of the Track's Media Type
 * 
 */
t_symbol *jit_qt_utils_tracktype_get(Track track)
{
    Media media;
    unsigned long type;
    t_symbol *sname;
    Str255 desc;
    char cdesc[256];
    
    media = GetTrackMedia(track);
    GetMediaHandlerDescription(media, &type, NULL, NULL);
    if ((sname = jit_qt_utils_mediatype2sym(type)) == ps_media_unknown) {
        MediaGetName(GetMediaHandler(media), desc, 0, NULL);
        ptoccpy(cdesc,desc);
        return gensym(cdesc);
    }
    else return sname;
}

/**
 * Get the four-char code for a Track's Media Type, formatted as a symbol
 *
 * @ingroup qtutilsmod 
 *
 * @param   track       QuickTime Track
 *
 * @return  t_symbol pointer containing C string representation of the Media Type
 * 
 */
t_symbol *jit_qt_utils_tracktypecode_get(Track track)
{
    unsigned long type;
    char typestr[5];
    
    GetMediaHandlerDescription(GetTrackMedia(track), &type, NULL, NULL);
    jit_qt_utils_type2str(type, typestr);
    return gensym(typestr);
}

/*
  srcCopy                       = 0,    
  srcOr                         = 1,
  srcXor                        = 2,
  srcBic                        = 3,
  notSrcCopy                    = 4,
  notSrcOr                      = 5,
  notSrcXor                     = 6,
  notSrcBic                     = 7,
  patCopy                       = 8,
  patOr                         = 9,
  patXor                        = 10,
  patBic                        = 11,
  notPatCopy                    = 12,
  notPatOr                      = 13,
  notPatXor                     = 14,
  notPatBic                     = 15,   // Special Text Transfer Mode
  grayishTextOr                 = 49,
  hilitetransfermode            = 50,
  hilite                        = 50,   // Arithmetic transfer modes
  blend                         = 32,
  addPin                        = 33,
  addOver                       = 34,
  subPin                        = 35,
  addMax                        = 37,
  adMax                         = 37,
  subOver                       = 38,
  adMin                         = 39,
  ditherCopy                    = 64,   // Transparent mode constant
  transparent                   = 36
*/

/*  kQTFileTypeAIFF               = FOUR_CHAR_CODE('AIFF'),
  kQTFileTypeAIFC               = FOUR_CHAR_CODE('AIFC'),
  kQTFileTypeDVC                = FOUR_CHAR_CODE('dvc!'),
  kQTFileTypeMIDI               = FOUR_CHAR_CODE('Midi'),
  kQTFileTypePicture            = FOUR_CHAR_CODE('PICT'),
  kQTFileTypeMovie              = FOUR_CHAR_CODE('MooV'),
  kQTFileTypeText               = FOUR_CHAR_CODE('TEXT'),
  kQTFileTypeWave               = FOUR_CHAR_CODE('WAVE'),
  kQTFileTypeSystemSevenSound   = FOUR_CHAR_CODE('sfil'),
  kQTFileTypeMuLaw              = FOUR_CHAR_CODE('ULAW'),
  kQTFileTypeAVI                = FOUR_CHAR_CODE('VfW '),
  kQTFileTypeSoundDesignerII    = FOUR_CHAR_CODE('Sd2f'),
  kQTFileTypeAudioCDTrack       = FOUR_CHAR_CODE('trak'),
  kQTFileTypePICS               = FOUR_CHAR_CODE('PICS'),
  kQTFileTypeGIF                = FOUR_CHAR_CODE('GIFf'),
  kQTFileTypePNG                = FOUR_CHAR_CODE('PNGf'),
  kQTFileTypeTIFF               = FOUR_CHAR_CODE('TIFF'),
  kQTFileTypePhotoShop          = FOUR_CHAR_CODE('8BPS'),
  kQTFileTypeSGIImage           = FOUR_CHAR_CODE('.SGI'),
  kQTFileTypeBMP                = FOUR_CHAR_CODE('BMPf'),
  kQTFileTypeJPEG               = FOUR_CHAR_CODE('JPEG'),
  kQTFileTypeJFIF               = FOUR_CHAR_CODE('JPEG'),
  kQTFileTypeMacPaint           = FOUR_CHAR_CODE('PNTG'),
  kQTFileTypeTargaImage         = FOUR_CHAR_CODE('TPIC'),
  kQTFileTypeQuickDrawGXPicture = FOUR_CHAR_CODE('qdgx'),
  kQTFileTypeQuickTimeImage     = FOUR_CHAR_CODE('qtif'),
  kQTFileType3DMF               = FOUR_CHAR_CODE('3DMF'),
  kQTFileTypeFLC                = FOUR_CHAR_CODE('FLC '),
  kQTFileTypeFlash              = FOUR_CHAR_CODE('SWFL'),
  kQTFileTypeFlashPix           = FOUR_CHAR_CODE('FPix')
*/
 
void jit_qt_utils_gensymbols(void)
{
    ps_media_video = gensym("video");
    ps_media_sound = gensym("sound");
    ps_media_text = gensym("text");
    ps_media_base = gensym("base");
    ps_media_mpeg = gensym("mpeg");
    ps_media_music = gensym("music");
    ps_media_timecode = gensym("timecode");
    ps_media_sprite = gensym("sprite");
    ps_media_flash = gensym("flash");
    ps_media_movie = gensym("movie");
    ps_media_tween = gensym("tween");
    ps_media_3d = gensym("3d");
    ps_media_qtvr = gensym("qtvr");
    ps_media_qtvrpano = gensym("qtvr_panorama");
    ps_media_qtvrobject = gensym("qtvr_object");
    ps_media_unknown = gensym("unknown");
    
    ps_file_aiff = gensym("aiff");
    ps_file_aifc = gensym("aifc");
    ps_file_dvc = gensym("dvc");
    ps_file_midi = gensym("midi");
    ps_file_pict = gensym("pict");
    ps_file_movie = gensym("movie");
    ps_file_text = gensym("text");
    ps_file_wave = gensym("wave");
    ps_file_sfil = gensym("sfil");
    ps_file_ulaw = gensym("ulaw");
    ps_file_avi = gensym("avi");
    ps_file_sd2 = gensym("sd2");
    ps_file_cdtrack = gensym("cdtrack");
    ps_file_pics = gensym("pics");
    ps_file_gif = gensym("gif");
    ps_file_png = gensym("png");
    ps_file_tiff = gensym("tiff");
    ps_file_photoshop = gensym("photoshop");
    ps_file_sgi = gensym("sgi");
    ps_file_bmp = gensym("bmp");
    ps_file_jpeg = gensym("jpeg");
    ps_file_macpaint = gensym("macpaint");
    ps_file_targa = gensym("tga");
    ps_file_qdgx = gensym("qdgx");
    ps_file_qtimage = gensym("qtimage");
    ps_file_3dmf = gensym("3dmf");
    ps_file_flc = gensym("flc");
    ps_file_flash = gensym("flash");
    ps_file_flashpix = gensym("flashpix");
    ps_file_mpeg4 = gensym("mpeg4");
}

t_symbol *jit_qt_utils_filetype2sym(long type)
{
    t_symbol *sname = NULL;
    
    switch(type) {
        case kQTFileTypeAIFF: sname = ps_file_aiff; break;
        case kQTFileTypeAIFC: sname = ps_file_aifc; break;
        case kQTFileTypeDVC: sname = ps_file_dvc; break;
        case kQTFileTypeMIDI: sname = ps_file_midi; break;
        case kQTFileTypePicture: sname = ps_file_pict; break;
        case kQTFileTypeMovie: sname = ps_file_movie; break;
        case kQTFileTypeText: sname = ps_file_text; break;
        case kQTFileTypeWave: sname = ps_file_wave; break;
        case kQTFileTypeSystemSevenSound: sname = ps_file_sfil; break;
        case kQTFileTypeMuLaw: sname = ps_file_ulaw; break;
        case kQTFileTypeAVI: sname = ps_file_avi; break;
        case kQTFileTypeSoundDesignerII: sname = ps_file_sd2; break;
        case kQTFileTypeAudioCDTrack: sname = ps_file_cdtrack; break;
        case kQTFileTypePICS: sname = ps_file_pics; break;
        case kQTFileTypeGIF: sname = ps_file_gif; break;
        case kQTFileTypePNG: sname = ps_file_png; break;
        case kQTFileTypeTIFF: sname = ps_file_tiff; break;
        case kQTFileTypePhotoShop: sname = ps_file_photoshop; break;
        case kQTFileTypeSGIImage: sname = ps_file_sgi; break;
        case kQTFileTypeBMP: sname = ps_file_bmp; break;
        case kQTFileTypeJPEG: sname = ps_file_jpeg; break;
        case kQTFileTypeMacPaint: sname = ps_file_macpaint; break;
        case kQTFileTypeTargaImage: sname = ps_file_targa; break;
        case kQTFileTypeQuickDrawGXPicture: sname = ps_file_qdgx; break;
        case kQTFileTypeQuickTimeImage: sname = ps_file_qtimage; break;
        case kQTFileType3DMF: sname = ps_file_3dmf; break;
        case kQTFileTypeFLC: sname = ps_file_flc; break;
        case kQTFileTypeFlash: sname = ps_file_flash; break;
        case kQTFileTypeFlashPix: sname = ps_file_flashpix; break;
        case FOUR_CHAR_CODE('mpg4'): sname = ps_file_mpeg4; break;
    }
    
    if (!sname)
        sname = gensym("unknown");
        
    return sname;
}

long jit_qt_utils_sym2filetype(t_symbol *s)
{
    long type = 0;
    
    if (s == ps_file_aiff) type = kQTFileTypeAIFF;
    else if (s == ps_file_aifc) type = kQTFileTypeAIFC;
    else if (s == ps_file_dvc) type = kQTFileTypeDVC;
    else if (s == ps_file_midi) type = kQTFileTypeMIDI;
    else if (s == ps_file_pict) type = kQTFileTypePicture;
    else if (s == ps_file_movie) type = kQTFileTypeMovie;
    else if (s == ps_file_text) type = kQTFileTypeText;
    else if (s == ps_file_wave) type = kQTFileTypeWave;
    else if (s == ps_file_sfil) type = kQTFileTypeSystemSevenSound;
    else if (s == ps_file_ulaw) type = kQTFileTypeMuLaw;
    else if (s == ps_file_avi) type = kQTFileTypeAVI;
    else if (s == ps_file_sd2) type = kQTFileTypeSoundDesignerII;
    else if (s == ps_file_cdtrack) type = kQTFileTypeAudioCDTrack;
    else if (s == ps_file_pics) type = kQTFileTypePICS;
    else if (s == ps_file_gif) type = kQTFileTypeGIF;
    else if (s == ps_file_png) type = kQTFileTypePNG;
    else if (s == ps_file_tiff) type = kQTFileTypeTIFF;
    else if (s == ps_file_photoshop) type = kQTFileTypePhotoShop;
    else if (s == ps_file_sgi) type = kQTFileTypeSGIImage;
    else if (s == ps_file_bmp) type = kQTFileTypeBMP;
    else if (s == ps_file_jpeg) type = kQTFileTypeJPEG;
    else if (s == ps_file_macpaint) type = kQTFileTypeMacPaint;
    else if (s == ps_file_targa) type = kQTFileTypeTargaImage;
    else if (s == ps_file_qdgx) type = kQTFileTypeQuickDrawGXPicture;
    else if (s == ps_file_qtimage) type = kQTFileTypeQuickTimeImage;
    else if (s == ps_file_3dmf) type = kQTFileType3DMF;
    else if (s == ps_file_flc) type = kQTFileTypeFLC;
    else if (s == ps_file_flash) type = kQTFileTypeFlash;
    else if (s == ps_file_flashpix) type = kQTFileTypeFlashPix;
    else if (s == ps_file_mpeg4) type = FOUR_CHAR_CODE('mpg4');
    
    return type;
}

t_symbol *jit_qt_utils_mediatype2sym(long type)
{
    t_symbol *sname = NULL;
    
    switch(type) {
        case VideoMediaType: sname = ps_media_video; break;
        case SoundMediaType: sname = ps_media_sound; break;
        case TextMediaType: sname = ps_media_text; break;
        case BaseMediaType: sname = ps_media_base; break;
        case MPEGMediaType: sname = ps_media_mpeg; break;
        case MusicMediaType: sname = ps_media_music; break;
        case TimeCodeMediaType: sname = ps_media_timecode; break;
        case SpriteMediaType: sname = ps_media_sprite; break;
        case FlashMediaType: sname = ps_media_flash; break;
        case MovieMediaType: sname = ps_media_movie; break;
        case TweenMediaType: sname = ps_media_tween; break;
        case ThreeDeeMediaType: sname = ps_media_3d; break;
        case kQTVRQTVRType: sname = ps_media_qtvr; break;
        case kQTVRPanoramaType: sname = ps_media_qtvrpano; break;
        case kQTVRObjectType: sname = ps_media_qtvrobject; break;
    }
    
    if (!sname)
        sname = ps_media_unknown;
        
    return sname;
}

long jit_qt_utils_sym2mediatype(t_symbol *s)
{
    long type;
    
    if (s == ps_media_video) type = VideoMediaType;
    else if (s == ps_media_sound) type = SoundMediaType;
    else if (s == ps_media_text) type = TextMediaType;
    else if (s == ps_media_base) type = BaseMediaType;
    else if (s == ps_media_mpeg) type = MPEGMediaType;
    else if (s == ps_media_music) type = MusicMediaType;
    else if (s == ps_media_timecode) type = TimeCodeMediaType;
    else if (s == ps_media_sprite) type = SpriteMediaType;
    else if (s == ps_media_flash) type = FlashMediaType;
    else if (s == ps_media_movie) type = MovieMediaType;
    else if (s == ps_media_tween) type = TweenMediaType;
    else if (s == ps_media_3d) type = ThreeDeeMediaType;
    else if (s == ps_media_qtvr) type = kQTVRQTVRType;
    else if (s == ps_media_qtvrpano) type = kQTVRPanoramaType;
    else if (s == ps_media_qtvrobject) type = kQTVRObjectType;
    else {
        char typestr[5];
        long i, max;
        
        max = (strlen(s->s_name) < 4) ? strlen(s->s_name) : 4;
        
        for (i = 0; i < max; i++) {
            typestr[i] = s->s_name[i];
        }
        for ( ; i < 4; i++)
            typestr[i] = 32;
        typestr[4] = 0;
        
        strcpy(typestr, s->s_name);
        if (typestr[3] == '\0') typestr[3] = ' ';
        type = (typestr[0] << 24L) + (typestr[1] << 16L) + (typestr[2] << 8L) + (typestr[3]);
    }
    
    return type;
}

double jit_qt_utils_double_BtoN(double d)
{
#if WIN_VERSION
    double temp;
    char *a, *b;

    a = (char *)&d;
    b = (char *)&temp;

    b[0] = a[7];
    b[1] = a[6];
    b[2] = a[5];
    b[3] = a[4];
    b[4] = a[3];
    b[5] = a[2];
    b[6] = a[1];
    b[7] = a[0];

    return temp;
#else
    return d;
#endif
}

double jit_qt_utils_double_NtoB(double d)
{
#if WIN_VERSION
    double temp;
    char *a, *b;

    a = (char *)&d;
    b = (char *)&temp;

    b[0] = a[7];
    b[1] = a[6];
    b[2] = a[5];
    b[3] = a[4];
    b[4] = a[3];
    b[5] = a[2];
    b[6] = a[1];
    b[7] = a[0];

    return temp;
#else
    return d;
#endif
}

void jit_qt_utils_doiter_atom(QTAtomContainer parent, QTAtom child, long *level);
void jit_qt_utils_doiter_atom(QTAtomContainer parent, QTAtom child, long *level)
{
    QTAtom at = 0L;
    long ct = 0;
    long l = *level;
    char pfx[256] = "";

    while(l--)
        strcat(pfx, "-");
        
    ct = QTCountChildrenOfType(parent, child, 0);
    post("ct %d", ct);
    while (ct--) {
        QTNextChildAnyType(parent, child, at, &at);
        if (at) {
            long type;
            long id;
            char str[5];
//          long size;
//          Ptr p;
            
            if (!QTGetAtomTypeAndID(parent, at, &type, &id)) {
                jit_qt_utils_type2str(type, str);
//              QTGetAtomDataPtr(parent, at, &size, &p);
//              post("%s%d: %s, id %d [size: %d]", pfx, ct + 1, str, id, size);
                post("%s%d: %s, id %d", pfx, ct + 1, str, id);
/*              if (p) {
                    char c[1024] = "0x";
                    char tmp[2];
                    long i;
                    
                    for (i = 0; i < size; i++) {
                        sprintf(tmp, "%x", p[i]);
                        strcat(c, tmp);
                    }
                    jit_object_post((t_object *)x,"%s", c);
                }
*/
                if (QTCountChildrenOfType(parent, at, 0)) {
                    post("%spush", pfx);
                    (*level)++;
                    jit_qt_utils_doiter_atom(parent, at, level);
                    (*level)--;
                    post("%spop", pfx);
                }
            }
        }
    }   
}

void jit_qt_utils_iter_atom(QTAtomContainer parent, QTAtom child)
{
    long level = 1;
    long type;
    long id;
    char str[5];

    if (!QTGetAtomTypeAndID(parent, child, &type, &id)) {
        jit_qt_utils_type2str(type, str);
        post("Iterating QTAtom %s, id %d", str, id);
        jit_qt_utils_doiter_atom(parent, child, &level);
        post("Iteration Done.");
    }
}

void jit_qt_utils_atomcontainer_new(void **atc)
{
    if (atc)
        QTNewAtomContainer((QTAtomContainer *)atc);
}

void jit_qt_utils_atomcontainer_dispose(void *atc)
{
    if (atc)
        QTDisposeAtomContainer((QTAtomContainer)atc);
}

Copyright © 2008, Cycling '74