Max 5 API Reference

jit.foundation.c

/* 
    jit.object.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/
#include "jit.common.h"
#include "jit.class.h"
#include "jit.xml.h"
#include "ext_user.h"
#include "ext_wind.h"
#include "ext_path.h"
#include "ext_patchline.h"
#include "ext_obex.h"
#include "ext_systime.h"
#if !TARGET_RT_MAC_MACHO
#include "Folders.h"
#endif
#ifdef WIN_VERSION
#include "resource.h"
extern HINSTANCE _jitlib_hinst;
#endif

#define F_DRAWN         16  // t_box flags no longer defined in ext_maxtypes.h, but apparently still used in this file???  [tap]

/**
 *  @defgroup classmod Class Module
    @ingroup jitter
 */

/**
 *  @defgroup objectmod Object Module
    @ingroup jitter
 */

/**
 *  @defgroup utilitymod Miscellaneous Utility Module
    @ingroup jitter
 */

#if TARGET_API_MAC_CARBON && !TARGET_RT_MAC_MACHO
#define CLASS_JITTER ((_cfm_in_ub)?ps_jitterCFM:ps_jitter)
#else
#define CLASS_JITTER ps_jitter
#endif
#define REGOB_NAMESPACE_JITTER ps_jitter

static long _jit_object_init=0;
static long _jit_pink_roses=0;
static t_hashtab *_jcs_hash=NULL;
long _cfm_in_ub=0;

static t_jit_class *_jit_class_class;
static t_jit_class *_jit_robject_class;
extern t_jit_class *_jit_linklist_class;

#if (TARGET_RT_MAC_MACHO)
char *_jit_version_str = "1.7.0";
#else
#ifdef WIN_VERSION
char *_jit_version_str = "1.7.0";
#else
char *_jit_version_str = "1.5.3 rc4";
#endif
#endif
long _jit_nosplash=0;
long _jit_javaload=0;

#ifdef WIN_VERSION
static long _win_qt_init = 0;
#endif 

t_symbol *ps_jitter=NULL;
t_symbol *ps_jitterCFM=NULL;

t_jit_err jit_object_init(void);
t_jit_err jit_object_shutdown(void);
method jit_class_attr_method(t_jit_class *x, t_symbol *methodname, void **attr);
void jit_symbols_init(void); 
t_jit_err jit_err_from_max_err(t_max_err err);

void crawly(uchar *a, char *b);

#if TARGET_API_MAC_CARBON
void jit_cpost_console_init(void);
#endif

//registered object list
typedef struct _jit_robject 
{
    t_jit_object    ob;
    t_symbol        *name;
    void            *rob;
    long            refcount;   
    void            *attachlist;    
} t_jit_robject;

t_jit_err jit_robject_init(void);
void *jit_robject_new(void *x, t_symbol *s);
void jit_robject_free(t_jit_robject *x);
long jit_robject_symcompare(t_jit_robject *x, t_symbol *name);
long jit_robject_obcompare(t_jit_robject *x, t_jit_object *o);
t_messlist _jit_mess_nonmethod,_jit_mess_freemethod;

long _initlate=1;

#if TARGET_RT_MAC_MACHO
char _jit_initialized = false;
#endif

long jit_cp_isauth(void);
void sched_setpollthrottle(long c, long *savethrottle); 
void patchline_addmess(t_symbol *s, method m);

void init_late(void);
void terminate(void);

//initialization routines for internal classes
t_jit_err jit_attr_init(void);
t_jit_err jit_robject_init(void);
t_jit_err jit_max_init(void);
t_jit_err jit_matrix_init(void);
t_jit_err jit_mop_init(void);
t_jit_err jit_kernel_init(void);
t_jit_err jit_qt_movie_init(void);
t_jit_err jit_qt_record_init(void);
t_jit_err jit_qt_component_init(void);
t_jit_err jit_la_mult_init(void);
t_jit_err jit_la_uppertri_init(void);
t_jit_err jit_la_trace_init(void);
t_jit_err jit_la_diagproduct_init(void);
t_jit_err jit_la_determinant_init(void);
t_jit_err jit_la_inverse_init(void);
t_jit_err jit_gl_init(void);
t_jit_err jit_op_init(void);
t_jit_err jit_matrix_wrapper_init(void);
t_jit_err jit_java_init(void);
t_jit_err jit_functor_init(void);
t_jit_err jit_listener_init(void);
t_jit_err jit_charset_init(void);
t_jit_err jit_xml_init(void);
t_jit_err jit_tree_init(void);  
t_jit_err jit_expr_init(void);  
t_jit_err jit_uyvy_init(void); 

#if TARGET_RT_MAC_MACHO
short open_framework_resources(CFBundleRef *bun);
void close_framework_resources(CFBundleRef bun, short ref);
#endif

    
//Move this init/maxruntime/splashscreen stuff ot a separate file
long maxruntime(void) 
{
    t_patcher *p;
    t_symbol *nsym,*psym;
    method m;
    void *pcache,*bcache;
    long rv=0;
    t_atom av[4];
    
    jit_atom_setlong(av,0);
    jit_atom_setlong(av+1,0);
    jit_atom_setlong(av+2,10);
    jit_atom_setlong(av+3,10);

    //determine if in runtime by instantiating a new vpatcher,
    //calling its dirty method and seeing if it really gets dirty   
    psym = gensym("vpatcher");
    nsym = gensym("#N");
        
    if (nsym->s_thing) {
        if (m=zgetfn(nsym->s_thing,psym)) {
            //jit_cpost("got vpatcher constructor %x, %x",m,((ulong *)m)[0]);
            pcache=gensym("#P")->s_thing;
            bcache=gensym("#B")->s_thing;
            if (p=(*(m))(NULL,0,20,20)) { //type method assumes void * arg
            //if (p=typedmess(nsym->s_thing,psym,4,av)) {
                //jit_cpost("constructed vpatcher %x",p);
                typedmess((t_object *)p,gensym("dirty"),0,0L);
                if (!(object_attr_getchar(p,gensym("dirty")))) rv=1;
                //jit_cpost("patcher dirty is %d",!rv);
                typedmess((t_object *)p,gensym("clean"),0,0L);
                defer_low(p,(method)freeobject,NULL,0,NULL);
            }
            gensym("#P")->s_thing=pcache;
            gensym("#B")->s_thing=bcache;
            return rv;
        }
    } 
    return rv;
}

#ifdef MAC_VERSION

void PicAt(short picID, short slopOffset, short top, short left, short eraseFlag)
{
    PicHandle thePicture;
    Rect tempRect;

    thePicture = GetPicture(picID);
#if TARGET_RT_MAC_MACHO
    QDGetPictureBounds(thePicture,&tempRect);
#else
    tempRect = (*thePicture)->picFrame;
#endif
    MacOffsetRect(&tempRect,-(tempRect.left)+left-slopOffset,
                         -(tempRect.top)+top-slopOffset);
    if (eraseFlag)
        EraseRect(&tempRect);
    DrawPicture(thePicture,&tempRect);
}

void CenterRectInRect(Rect *in, Rect *of)
{
    short w1,w2;
    Rect new;
    
    w1 = in->right - in->left;
    w2 = of->right - of->left;
    new.left = of->left + ((w2 - w1)/2);
    new.right = new.left + w1;
    w1 = in->bottom - in->top;
    w2 = of->bottom - of->top;
    new.top = of->top + ((w2 - w1)/2);
    new.bottom = new.top + w1;
    *in = new;
}

void CenterWindowInMainScreen(OSType type, short idOfWindow, Rect *outRect)
{
    Handle h;
    Rect *dr;
    GDHandle main;
    
    h = (Handle) GetResource(type,idOfWindow);
    if (!h)
        return;
    HLock(h);
    main = GetMainDevice();
#if (TARGET_RT_MAC_MACHO)
    *outRect = *((Rect *)*h);
    dr = outRect;
#else
    dr = (Rect *)*h;
#endif
    CenterRectInRect(dr,&(*main)->gdRect);
    HUnlock(h);
}


void brag(void *x, short hold)
{
    WindowPtr w;
    EventRecord myEvent;
    long a,b;
    CGrafPtr saveport;
    short vol,rsRefNum,oldResFile;
    long type;
    char name[MAX_PATH_CHARS];

    oldResFile = CurResFile();
    sprintf(name,":jitlib");
#if !TARGET_RT_MAC_MACHO
    if (!locatefile_extended(name, &vol, &type, 0L, 0)) {
        FSSpec fs;
        
        if (!path_tospec(vol, name, &fs)) {
            if ((rsRefNum = FSpOpenResFile(&fs, READ_PERM)) != -1) {
                UseResFile(rsRefNum);
#else
    if (1) {
        CFBundleRef bun;
        long version;
        
        rsRefNum = open_framework_resources(&bun);
        version = maxversion();
        if (rsRefNum != -1) {
            if (1) {
#endif
                if (GetResource('WIND',529) && GetResource('PICT',529)) 
                {
                    Rect newRect;
                    
                    CenterWindowInMainScreen('WIND',529,&newRect);
                    w = GetNewWindow(529,0L,(WindowPtr)-1L);
                    if (!w) {
                        error("Could not create Jitter splash window");
                        goto out;
                    }
#if TARGET_RT_MAC_MACHO
                    MacMoveWindow(w,newRect.left,newRect.top,1);
#endif
                    MacShowWindow(w);
                    SelectWindow(w);
                    GetPort(&saveport);
                    SetTheWindowPort(w);
                    PicAt(529,1,0,0,FALSE);
#if TARGET_API_MAC_CARBON
                    if (maxversion()<0x0450) {
                        EventRecord ev;
                        WaitNextEvent(everyEvent,&ev,0,0); // carbon hack -jkc
                    } else { 
                        EventRecord ev;
                        EventAvail(everyEvent,&ev);
                    }
#endif      

                    if (hold&&maxversion()<0x0450) {
                        HideCursor();
                        a = TickCount();
                        while ((TickCount()>=a)&&((TickCount()-a)<60))
                            ;
                        while (!Button())
                            ;
                        ShowCursor();
                        GetNextEvent(mDownMask,&myEvent);
                        SetPort(saveport);
                        DisposeWindow(w);
                        goto out;
                    } else {
                        a = TickCount();
                        while ((TickCount()>=a)&&((TickCount()-a)<65)) {
                            if (Button()&&maxversion()<0x0450) {
                                GetNextEvent(mDownMask,&myEvent);
                                goto out;
                            }
                        }   
                        SetPort(saveport);
                        DisposeWindow(w);   
                        goto out;
                    }
                } else {
                    goto out;
                }
            }
        }
out:
#if TARGET_RT_MAC_MACHO
        if (bun)
            close_framework_resources(bun,rsRefNum);
#else
        UseResFile(oldResFile);
        if (rsRefNum)
            CloseResFile(rsRefNum);
#endif
    }
}

void addresources(void)
{
    short vol,rsRefNum,oldResFile;
    long type;
    char name[MAX_PATH_CHARS];

#if TARGET_RT_MAC_MACHO
    CFBundleRef bun = 0;
    
    oldResFile = CurResFile();
    rsRefNum = open_framework_resources(&bun);
    if (rsRefNum != -1) {
        UseResFile(rsRefNum);
        rescopy('WIND',529); // obsolete
        rescopy('PICT',529); // obsolete
        UseResFile(oldResFile);
    }
    close_framework_resources(bun,rsRefNum);

#else
    oldResFile = CurResFile();
    sprintf(name,":jitlib");
    if (!locatefile_extended(name, &vol, &type, 0L, 0)) {
        FSSpec fs;
        
        if (!path_tospec(vol, name, &fs)) {
            if ((rsRefNum = FSpOpenResFile(&fs, READ_PERM)) != -1) {
    //      if (!path_openresfile(name,vol,&rsRefNum,READ_PERM)) {
                UseResFile(rsRefNum);
                //rescopy('WIND',529);
                //rescopy('PICT',529);
                UseResFile(oldResFile);
                CloseResFile(rsRefNum);
            }
        }
    }
#endif
}


#endif //MAC_VERSION

#ifdef WIN_VERSION
VOID ResizeBragDialog(HWND hdlg);
VOID ResizeBragDialog(HWND hdlg)
{
    HBITMAP hbm;
    BITMAP bm;

    hbm = LoadBitmap(_jitlib_hinst, MAKEINTRESOURCE(IDB_JITTER_SPLASH));
    if (hbm) {
        if (GetObject(hbm, sizeof(BITMAP), (LPVOID) &bm)) {
            HMONITOR mon;
            MONITORINFO mi;
            mi.cbSize = sizeof (mi);
            mon = MonitorFromWindow(main_get_frame(), MONITOR_DEFAULTTOPRIMARY);
            if (mon && GetMonitorInfo(mon, &mi)) {
                int x, y, cx, cy;
                cx = bm.bmWidth;
                cy = bm.bmHeight;
                x = (mi.rcMonitor.right+mi.rcMonitor.left-cx)/2;
                y = (mi.rcMonitor.bottom+mi.rcMonitor.top-cy)/2;
                SetWindowPos(hdlg, NULL, x, y, cx, cy, SWP_NOZORDER);
            }
        }
        DeleteObject(hbm);
    }
}

INT_PTR CALLBACK BragDialogProc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam);
INT_PTR CALLBACK BragDialogProc(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        ResizeBragDialog(hdlg);
        SetTimer(hdlg,1,1500,NULL);
        return TRUE;

    case WM_TIMER:
    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
    case WM_KEYDOWN:
    case WM_SYSKEYDOWN:
    case WM_CHAR:
        KillTimer(hdlg,1);
        EndDialog(hdlg,0);
        return TRUE;
    }
    return FALSE;
}

INT_PTR CALLBACK BragDialogProcHold(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam);
INT_PTR CALLBACK BragDialogProcHold(HWND hdlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    WINDOWINFO winfo;
    HBITMAP hbm;
    BITMAP bm;
        
    switch (msg)
    {
    case WM_INITDIALOG:
        ResizeBragDialog(hdlg);
        ShowCursor(FALSE);
        SetCapture(hdlg);
        GetWindowInfo(hdlg,&winfo);
        SetCursorPos((winfo.rcWindow.left+winfo.rcWindow.right)/2,
            (winfo.rcWindow.top+winfo.rcWindow.bottom)/2);
        return TRUE;

    case WM_MOUSEMOVE:
        //move to center of the window
        GetWindowInfo(hdlg,&winfo);
        SetCursorPos((winfo.rcWindow.left+winfo.rcWindow.right)/2,
            (winfo.rcWindow.top+winfo.rcWindow.bottom)/2);
        return TRUE;

    case WM_LBUTTONDOWN:
    case WM_MBUTTONDOWN:
    case WM_RBUTTONDOWN:
    case WM_KEYDOWN:
    case WM_SYSKEYDOWN:
    case WM_CHAR:
        ReleaseCapture();
        ShowCursor(TRUE);
        EndDialog(hdlg,0);
        return TRUE;
    }
    return FALSE;
}

void brag(void *x, short hold)
{
    DialogBox(_jitlib_hinst,MAKEINTRESOURCE(IDD_JITTER_SPLASH),main_get_frame(),hold?BragDialogProcHold:BragDialogProc);    
}

#endif //WIN_VERSION 


long offer_protcheck(void)
{
    FSSpec spec;
    Str255 pname;
    CFragConnectionID connectionID;
    ProcPtr mainAddr;
    Str255 errMsg;
    long x = 0;
    char chal[16];
    uchar uid[6];
    uchar uid2[6];
    short err;
#if TARGET_API_MAC_CARBON
    err = FindFolder(kOnSystemDisk,kPreferencesFolderType,kDontCreateFolder,&spec.vRefNum,&spec.parID);
    BlockMove("\pj-offer-15-osx",spec.name,15);
    BlockMove("\pj-offer-15-osx",pname,15);
    err = GetDiskFragment(&spec, 0, 0, pname, kPrivateCFragCopy, &connectionID, (Ptr*)&mainAddr, errMsg);
    if (err) {
        //post("protcheck err %d",err);
        return 0;
    } else {
        short ref;
        long size,sum,temp,i;
        long count,pos;
    
        err = FSpOpenDF(&spec,READ_PERM,&ref);
        if (err) {
            //post("FSpOpenDF err %d",err);
            return 0;
        }
        GetEOF(ref,&size);
        
        if (size != 1641706) {
            //post("incorrect filesize: %d",size);
            FSClose(ref);
            return 0;
        }

        for (i=0,sum=0,pos=0;i<32;i++) {
            count = 4;
            SetFPos(ref,fsFromStart,pos);
            FSRead(ref,&count,&temp);
            sum += temp;
            //post("i %d temp %d sum %d", i, temp, sum);
            pos = (pos+552299)%(size-4);
        }
        if (sum!=-1163725234) {     
            //post("incorrect checksum: %d",sum);
            FSClose(ref);
            return 0;
        }
        //post("protcheck no err");
        FSClose(ref);
    }
    return 1;
#elif defined(WIN_VERSION)
    HMODULE hModule;
    typedef void (*JITTER_OK_FUNC)(char *, uchar *);
    JITTER_OK_FUNC pf;
    CHAR path[MAX_PATH];
    HANDLE hFile;
    BOOL bOk;
    hModule = LoadLibrary("j-offer-15-win.dll");

    if (!hModule) {
        //post("Can't LoadLibrary on j-offer-15-win.dll: %d", GetLastError());  
        return 0;
    }
    pf = (JITTER_OK_FUNC) GetProcAddress(hModule, TEXT("jitter_ok"));
    if (!pf) {
        //post("Can't GetProcAddress on jitter_ok.");
        FreeLibrary(hModule);
        return 0;
    }   
        
    jit_rand_setseed(0);
    jit_rand();
    
    uid[0] = (jit_rand()>>8L);
    uid[1] = (jit_rand()>>8L);
    uid[2] = (jit_rand()>>8L);
    uid[3] = (jit_rand()>>8L);
    uid[4] = (jit_rand()>>8L);
    uid[5] = (jit_rand()>>8L);
    
    crawly(uid,chal);
    
    (*pf)(chal,uid2);
    
    if (!((uid[0]==uid2[0])&&
        (uid[1]==uid2[1])&&
        (uid[2]==uid2[2])&&
        (uid[3]==uid2[3])&&
        (uid[4]==uid2[4])&&
        (uid[5]==uid2[5])))
    {
        //post("jitter_ok returning false");
        FreeLibrary(hModule);
        return 0;
    }

    GetModuleFileName(hModule, path, MAX_PATH);
    FreeLibrary(hModule);
    hFile = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        //post("Can't open j-offer-15-win.dll for reading.");
        return 0;
    }
    else {
        long size,sum,temp,i;
        long count,pos;

        size = GetFileSize(hFile, NULL);
        
        if (size != 2438874) {
            //post("incorrect filesize: %d", size);
            CloseHandle(hFile);
            return 0;
        }

        for (i=0,sum=0,pos=0;i<32;i++) {
            count = 4;
            SetFilePointer(hFile, pos, NULL, FILE_BEGIN);
            ReadFile(hFile, &temp, count, &count, NULL);
            sum += temp;
            //post("i %d temp %d sum %d", i, temp, sum);
            pos = (pos+552299)%(size-4);
        }

        if (sum!=-1121912074) {     
            //post("incorrect checksum %d", sum);
            CloseHandle(hFile);
            return 0;
        }
        //post("protcheck no err");
        CloseHandle(hFile);
    }
    return 1;
#endif //TARGET_API_MAC_CARBON
}

void init_late(void)
{
    if (!_initlate) {
        _initlate = 1;
#ifdef WIN_VERSION
        qti_extra_flags_set(NULL,0x74747474); //require Max 4.3.1 or later
    //  post("init_late");
        if (InitializeQTML(kInitializeQTMLUseGDIFlag)==noErr)
        {
            _win_qt_init=1;     
            InitializeQTVR();
            EnterMovies();
            jit_qt_component_init();
            jit_qt_codec_init();
            jit_qt_utils_gensymbols();
        } else {
            error("Quicktime not installed.");
            post("Jitter requires Quicktime to be installed to run.");
            post("Please download from www.apple.com and install.");
            _jit_pink_roses = 0;
        }
        quittask_install((method)terminate,NULL);
        if (_jit_pink_roses&&_jit_javaload)
            jit_java_init();
#endif //WIN_VERSION
    }
}

void jit_load_config(void);
void jit_load_config(void)
{
    long type=0;
    char filename[MAX_PATH_CHARS];
    short vol;

    strcpy(filename,"jitter-config.txt");

    if (!locatefile_extended(filename,&vol,&type,NULL,0))
    {
        void *b = binbuf_new();
        if (!binbuf_read(b,filename,vol,0))
            binbuf_eval(b,0,NULL,NULL);
        binbuf_free(b);
        //post("found %s",filename);
    } else {
        ; //post("could not find jitter-config.txt");
    }
}

long initialize()
{   
    long err;
    long val=0x8523;
    method fn=0;
    long value;
    
    
#if TARGET_RT_MAC_MACHO
    if (_jit_initialized)
        return 0;
        
    _jit_initialized = true;
#endif

#if TARGET_API_MAC_CARBON
    // need to do this first so we can console post during startup
    jit_cpost_console_init();
#endif

    //always build our symbols
    jit_symbols_init();
    ps_jitter = gensym("jitter");
    ps_jitterCFM = gensym("jitterCFM");
#if defined(MAC_VERSION) && !(TARGET_RT_MAC_MACHO)  
    if (!object_attr_getvalueof) {
        post("Jitter requires Max/MSP 4.5.5 or higher");
        return -1;
    }
#endif

    // 1. are we in runtime?    
    _jit_pink_roses = maxruntime();
    //_jit_pink_roses = 1;
    //jit_cpost("jitlib: initialize 03: runtime %d",_jit_pink_roses);

    // 2. are we authorized?

#ifdef JITTER_AUTH_PRE_5_1 //legacy cp code
/* commenting out to avoid confusion, but leaving for future generations
#ifdef JIT_PROT_ORIGINAL
    if ((!_jit_pink_roses)&&(fn=(method)gensym("%7&[n3e")->s_thing)) 
#else   // JIT_PROT_ORIGINAL: new token check for Jitter 1.5
#if TARGET_RT_MAC_MACHO
        fn = (method)gensym("%dpf!!2ezx")->s_thing;
#else //TARGET_RT_MAC_MACHO
#if MAC_VERSION
        Gestalt('max2',&value); 
        if (value == 'max2') { // we are in MACHO host
            post("Jitter CFM support loaded");
            post("warning: Jitter CFM objects are not guaranteed to work in Max 4.6 and higher");
            _cfm_in_ub = 1;
        }

#endif //MAC_VERSION
        {
            // Windows and CFM use the original symbol
            fn = (method)gensym("%943f}>ee")->s_thing;
        }
#endif //TARGET_RT_MAC_MACHO
#endif //JIT_PROT_ORIGINAL
*/  
#else   //JITTER_AUTH_PRE_5_1
    fn = (method)gensym("%x9*!gv?Z")->s_thing;  
#endif  //JITTER_AUTH_PRE_5_1   
    
    if ((!_jit_pink_roses)&&fn) 
    {
        (*fn)(&val); 
        if (val==1) {
            post("Jitter is in demo mode"); 
            _jit_pink_roses = 1;
            offer_protcheck();      //prevent 60 day demo
            gensym("###succotash")->s_thing = (t_object *)1; // for auth menu item
        } else if (val==0){
            _jit_pink_roses = 1;
        }
    }   

    // 3. are we in demo mode?
    if (!_jit_pink_roses) { //try loading demo
        if (_jit_pink_roses=offer_protcheck()) {
            post("Jitter %s is in demo mode", _jit_version_str);    
            gensym("###succotash")->s_thing = (t_object *)1; // for auth menu item
        } else
            post("Jitter demo period has expired"); 
    } 
    
    if (!_jit_pink_roses) {
        error("Jitter is not authorized");
        _jit_nosplash = 1;
    } else {
        post("Jitter %s installed", _jit_version_str);
    }

#ifdef JIT_TEST_NO_AUTHORIZATION
    _jit_pink_roses = FALSE;
#endif


#ifdef MAC_VERSION  
    jit_altivec_init();
#endif      
    if (err = jit_object_init()) {
        error("Jitter could not load %d", err);
    } else {
#ifdef MAC_VERSION
        //addresources(); obsolete
#endif      
        jit_load_config();
        //if (!_jit_nosplash)
        //  defer_low(gensym("jit")->s_thing,(method)brag,0L,0,0L);
#ifndef WIN_VERSION //else happens in init late
        if (_jit_pink_roses&&_jit_javaload)
            jit_java_init();
#endif
    }
    
    return 0; //always succeed
}

#if !TARGET_RT_MAC_MACHO

void main(void)
{
//  jit_object_init();
}

#endif // TARGET_RT_MAC_MACHO

void terminate(void)
{
//  jit_object_shutdown();

#ifdef WIN_VERSION //win_todo
    if (_win_qt_init) {
        jit_qt_codec_free();
        ExitMovies();
        TerminateQTVR();
        TerminateQTML();
    }
#else
    jit_qt_codec_free();
    ExitMovies();
#endif //WIN_VERSION
}

#ifndef WIN_VERSION //win_todo
extern _jit_cord_pattern;
RGBColor optc  = {0x0000,0xFFFF,0x0000};
RGBColor optc2 = {0xFFFF,0x0000,0xFFFF};
RGBColor black = {0x0000,0x0000,0x0000};

void jit_matrix_optdraw(void *x, Patchline *l);
void jit_matrix_optdraw(void *x, Patchline *l)
{
        short i,off;
        RGBColor saveFore, saveBack,rgb;
        Pattern p;

        GetForeColor(&saveFore);
        GetBackColor(&saveBack);
        
        if (l->l_selected)
                RGBForeColor(&optc2);                   // do something distinctive when it is selected
        else if (l->l_color) {
                box_getcolor(l->l_box1,l->l_color-1,&rgb);      // pay attention to patch cord color, default black
                RGBForeColor(&rgb);
        }
        RGBBackColor(&optc);

        if (_jit_cord_pattern>=0)
            PenSize(2,2);           // optional patch cords must be 2x2 for now
        else 
            PenSize(3,3);
                
        if (_jit_cord_pattern>=1) {
            GetIndPattern(&p, sysPatListID, _jit_cord_pattern );    /* system pattern */
            PenPat(&p);
        }
        
        //draw fatty
        if (l->l_selected)
                RGBForeColor(&optc2);                   // do something distinctive when it is selected
        else if (l->l_color) {
                box_getcolor(l->l_box1,l->l_color-1,&rgb);      // pay attention to patch cord color, default black
                RGBForeColor(&black);
        } else {
            rgb = optc;
        }
        
        MoveTo(l->l_x[0], l->l_y[0]);
        if (l->l_segments > 1) {
                for (i=1; i <= l->l_segments; i++)
                        LineTo(l->l_x[i],l->l_y[i]);
        } else if (l->l_segments)
                LineTo(l->l_x[1], l->l_y[1]);
            
        if (_jit_cord_pattern<=0) {
            off = (_jit_cord_pattern<0) ? 1 : 0;
            //draw skinny
            PenSize(1,1);          
            RGBForeColor(&rgb);

            MoveTo(l->l_x[0]+off, l->l_y[0]+off);
            if (l->l_segments > 1) {
                    for (i=1; i <= l->l_segments; i++)
                            LineTo(l->l_x[i]+off,l->l_y[i]+off);
            } else if (l->l_segments)
                    LineTo(l->l_x[1]+off, l->l_y[1]+off);
        }
        
        l->l_flags |= F_DRAWN;  // set drawn flag

        RGBForeColor(&saveFore);        // restore colors & pen
        RGBBackColor(&saveBack);
        PenNormal();
        PenSize(1,1);
}

RGBColor txoptc  = {0x2222,0x8888,0xFFFF};
RGBColor txoptc2 = {0xFFFF,0x0000,0xFFFF};

void jit_gl_texture_optdraw(void *x, Patchline *l);
void jit_gl_texture_optdraw(void *x, Patchline *l)
{
        short i,off;
        RGBColor saveFore, saveBack,rgb;
        Pattern p;

        GetForeColor(&saveFore);
        GetBackColor(&saveBack);
        
        if (l->l_selected)
                RGBForeColor(&txoptc2);                   // do something distinctive when it is selected
        else if (l->l_color) {
                box_getcolor(l->l_box1,l->l_color-1,&rgb);      // pay attention to patch cord color, default black
                RGBForeColor(&rgb);
        }
        RGBBackColor(&txoptc);

        if (_jit_cord_pattern>=0)
            PenSize(2,2);           // optional patch cords must be 2x2 for now
        else 
            PenSize(3,3);
                
        if (_jit_cord_pattern>=1) {
            GetIndPattern(&p, sysPatListID, _jit_cord_pattern );    /* system pattern */
            PenPat(&p);
        }
        
        //draw fatty
        if (l->l_selected)
                RGBForeColor(&txoptc2);                   // do something distinctive when it is selected
        else if (l->l_color) {
                box_getcolor(l->l_box1,l->l_color-1,&rgb);      // pay attention to patch cord color, default black
                RGBForeColor(&black);
        } else {
            rgb = txoptc;
        }
        
        MoveTo(l->l_x[0], l->l_y[0]);
        if (l->l_segments > 1) {
                for (i=1; i <= l->l_segments; i++)
                        LineTo(l->l_x[i],l->l_y[i]);
        } else if (l->l_segments)
                LineTo(l->l_x[1], l->l_y[1]);
            
        if (_jit_cord_pattern<=0) {
            off = (_jit_cord_pattern<0) ? 1 : 0;
            //draw skinny
            PenSize(1,1);          
            RGBForeColor(&rgb);

            MoveTo(l->l_x[0]+off, l->l_y[0]+off);
            if (l->l_segments > 1) {
                    for (i=1; i <= l->l_segments; i++)
                            LineTo(l->l_x[i]+off,l->l_y[i]+off);
            } else if (l->l_segments)
                    LineTo(l->l_x[1]+off, l->l_y[1]+off);
        }
        
        l->l_flags |= F_DRAWN;  // set drawn flag

        RGBForeColor(&saveFore);        // restore colors & pen
        RGBBackColor(&saveBack);
        PenNormal();
        PenSize(1,1);
}

#endif


#pragma mark -
// --------------------------------------------------------------------------------
//

long jit_method_true(void *x)
{
    return 1;
}   

long jit_method_false(void *x)
{
    return 0;
}   

#pragma mark -
// --------------------------------------------------------------------------------
//

t_jit_err jit_class_init(void) 
{
    _jit_class_class = jit_class_new("jit_class",(method)jit_class_new,(method)jit_class_free,
        sizeof(t_jit_class),A_CANT,0L); //A_CANT = untyped
    
    if (!_jit_class_class) post("couldn't allocate memory for class jit_class");

    return JIT_ERR_NONE;
}

/**
 * Creates a new class with the name specified by the name argument. 
 *
 * @ingroup classmod
 *
 * @param   name    class name
 * @param   mnew    class constructor
 * @param   mfree   class destructor
 * @param   size    object struct size in bytes
 * @param   ...     type signature for the constructor in the standard 
 *                  Max type list format (see Chapter 3 of the Writing 
 *                  Externals in Max document for more information)
 * @warning In order for the Jitter class to be exposed to
 * JavaScript and Java, it is important that the constructor is typed,
 * even if no arguments are provided--i.e. do not use the older strategy
 * of defining Jitter constructors as private and untyped with A_CANT.
 * 
 * @return  class pointer to be used in other class functions   
 *
 */
void *jit_class_new(char *name, method mnew, method mfree, long size, ...)
{
    long type;
    void *c;

#if TARGET_RT_MAC_MACHO
    initialize();
#endif
    
    //there might be a bit of a problem here with short/long
    type = *((long *)(((char *)(&size))+4));
    c = class_new(name,mnew,mfree,size,NULL/*menu*/,(short)type,*((t_stack_splat *)(((char *)(&size))+8)));
#if defined(MAC_VERSION) && (!TARGET_RT_MAC_MACHO)
    class_extra_store(c,gensym("runtime_architecture"),(t_object *)gensym("CFM"));  
#endif
    class_addmethod(c,(method)jit_method_true,"class_jitter",A_CANT);
    class_addmethod(c,(method)jit_object_importattrs,"importattrs",A_GIMME);
    class_addmethod(c,(method)jit_object_exportattrs,"exportattrs",A_GIMME);
    return c;
}


/**
 * Adds a named method to a class. 
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 * @param   m       function called when method is invoked
 * @param   name    method name
 * @param   ...     type signature for the method in the standard 
 *                  Max type list format (see Chapter 3 of the Writing 
 *                  Externals in Max document for more information)
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_addmethod(void *c, method m, char *name, ...)
{
    t_max_err err;  
    err = class_addmethod((t_class *)c,m,name,*((t_stack_splat *)(((char *)(&name))+4)));
    return jit_err_from_max_err(err);
}

/**
 * Adds an attribute to a class. 
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 * @param   attr    attribute object 
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_addattr(void *c,t_jit_object *attr)
{
    t_max_err err;
    err = class_addattr((t_class *)c,attr);
    return jit_err_from_max_err(err);
}

/**
 * Adds an adornment to a class. 
 * Adornments provide additional state and behavior to
 * a class. This is most commonly used for the jit_mop
 * adornment.
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 * @param   o       object to use as adornment
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_addadornment(void *c,t_jit_object *o)
{
    t_max_err err;
    err = class_addadornment((t_class *)c,o);
    return jit_err_from_max_err(err);
}

/**
 * Compares object's class name with the name provided.  
 *
 * @ingroup objectmod
 *
 * @param   x       object pointer
 * @param   name    name to compare with class name
 * 
 * @return  1 if equal, 0 if not equal
 *
 */
long jit_object_classname_compare(void *x, t_symbol *name)
{
    return (name&&(name==jit_object_classname(x)));
}

/**
 * Retrieves an adornment from a class. 
 * Adornments provide additional state and behavior to
 * a class. This is most commonly used for the jit_mop
 * adornment.
 *
 * @ingroup classmod
 *
 * @param   c           class pointer
 * @param   classname   classname of adornment to retrieve
 * 
 * @return  t_jit_err error code
 *
 */
void *jit_class_adornment_get(void *c,t_symbol *classname)
{
    return class_adornment_get((t_class *)c,classname);
}

/**
 * Frees a class. 
 * 
 * @warning This function is not typically used outside of jitlib.
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 *
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_free(void *c)
{
    t_max_err err;
    err = class_free((t_class *)c);  
    return jit_err_from_max_err(err);
}

/**
 * Retrieves the name of a class 
 * 
 * @ingroup classmod
 *
 * @param   c       class pointer
 *
 * @return  t_symbol pointer containing name of class
 *
 */
t_symbol *jit_class_nameget(void *c)
{
    return class_nameget((t_class *)c);
}

/**
 * Compares name of class with the name provided.  
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 * @param   name    name to compare with class name
 * 
 * @return  1 if equal, 0 if not equal
 *
 */
long jit_class_symcompare(void *c, t_symbol *name)
{
    return (name&&(jit_class_nameget(c)==name));
}

/**
 * Registers class in the class registry.  
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_register(void *c)
{
    t_max_err err;
    err = class_register(CLASS_JITTER,(t_class *)c);  
    return jit_err_from_max_err(err);
}

/**
 * Retrieves method function pointer for named method.  
 *
 * @ingroup classmod
 *
 * @param   c           class pointer
 * @param   methodname  method name
 * 
 * @return  method function pointer.
 *
 */
method jit_class_method(void *c, t_symbol *methodname)
{
    return class_method((t_class *)c,methodname);
}

/**
 * Retrieves messlist entry for named method.  
 *
 * @ingroup classmod
 *
 * @param   c           class pointer
 * @param   methodname  method name
 * 
 * @return  t_messlist pointer.
 *
 */
t_messlist *jit_class_mess(t_jit_class *c, t_symbol *methodname)
{
    return class_mess((t_class *)c,methodname);
}

/**
 * Compares symbol name with name provided.  
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 * @param   name    attribute name
 * 
 * @return  1 if equal, 0 if not equal
 *
 */
long jit_attr_symcompare(void *x, t_symbol *name)
{
    return (name == object_method(x,_jit_sym_getname));
}

method jit_class_attr_method(t_jit_class *c, t_symbol *methodname, void **attr)
{
    long get=0;
    return class_attr_method(c,methodname,attr,&get);
}

/**
 * Retrieves attribute pointer associated with name provided.  
 *
 * @ingroup classmod 
 *
 * @param   c           class pointer
 * @param   attrname    attribute name
 * 
 * @return  attribute object pointer
 *
 */
void *jit_class_attr_get(void *c, t_symbol *attrname)
{
    return class_attr_get((t_class *)c,attrname);
}

/**
 * Retrieves class pointer associated with name provided.  
 *
 * @ingroup classmod 
 *
 * @param   classname   class name
 * 
 * @return  class pointer
 *
 */
void *jit_class_findbyname(t_symbol *classname)
{
    return class_findbyname(CLASS_JITTER,classname);
}

/**
 * Adds a typed wrapper method to a class. 
 * Typed wrappers typically are used when there is an existing
 * private, untyped method defined for a Jitter class, but it is
 * desirable to expose the method to language bindings which 
 * require a typed interface--e.g. Java or JavaScript.
 *
 * @ingroup classmod
 *
 * @param   c       class pointer
 * @param   m       function called when method is invoked
 * @param   name    method name
 * @param   ...     type signature for the method in the standard 
 *                  Max type list format (see Chapter 3 of the Writing 
 *                  Externals in Max document for more information)
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_addtypedwrapper(void *c, method m, char *name, ...)
{
    t_max_err err;  
    err = class_addtypedwrapper((t_class *)c,m,name,*((t_stack_splat *)(((char *)(&name))+4)));
    return jit_err_from_max_err(err);
}

/**
 * Retrieves typed wrapper messlist pointer associated with name provided.  
 *
 * @ingroup classmod 
 *
 * @param   c   class pointer
 * @param   s   name
 * 
 * @return  t_messlist pointer
 *
 */
t_messlist *jit_class_typedwrapper_get(void *c, t_symbol *s)
{
    return class_typedwrapper_get((t_class *)c,s);
}

// the argsafe implementation could be more elegant, but since it is 
// wrapped with accessor functions, can always change implementation

/**
 * Marks a method as safe to call as an attribute style argument.
 *
 * @warning It is important that no argument settable method causes
 *          any output into the patcher, or else it could lead to a
 *          crash, or other undesired behavior.  
 *
 * @ingroup classmod 
 *
 * @param   c           class pointer
 * @param   argname     name as used via argument
 * @param   methodname  name of method to map the argument name to
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_class_method_addargsafe(void *c, char *argname, char *methodname)
{
    t_max_err err;  
    char str[255];
    sprintf(str,"%s_argsafe",argname);
    err = class_extra_store((t_class *)c,gensym(str),(t_object *)gensym(methodname));
    return jit_err_from_max_err(err);
}

/**
 * Checks to see if symbol is safe to call as an attribute style argument.
 *
 * @ingroup classmod 
 *
 * @param   c   class pointer
 * @param   s   name as used via argument
 * 
 * @return  If successful, name of method to map the argument name to. 
 *          Otherwise, NULL.
 *
 */
t_symbol *jit_class_method_argsafe_get(void *c, t_symbol *s)
{
    char str[255];
    sprintf(str,"%s_argsafe",s->s_name);
    return (t_symbol *) class_extra_lookup((t_class *)c,gensym(str));
}

/**
 * Checks to see if symbol is safe to call as an attribute style argument.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * @param   s   name as used via argument
 * 
 * @return  If successful, name of method to map the argument name to. 
 *          Otherwise, NULL.
 *
 */
t_symbol *jit_object_method_argsafe_get(void *x, t_symbol *s)
{
    return jit_class_method_argsafe_get(jit_object_class(x),s);
}


#pragma mark -
// --------------------------------------------------------------------------------
//

/**
 * Allocates object struct memory.
 *
 * This function is used within an object's constructor.
 *
 * @ingroup obejctfun 
 *
 * @param   c   class pointer
 * 
 * @return  If successful, an object pointer equal in size to that  
 *          defined in {@link jit_class_new}. Otherwise, NULL.
 *
 * @warning This memory is not cleared to zero, so it is important
 *          that you explicitly initialize as necessary. It is not
 *          safe to simply zero out all of your object struct as the
 *          t_jit_object header contains necessary data. if you wish
 *          to zero out your object struct, do so beginning at the  
 *          sizeof(t_jit_object) byte offset.  
 *
 */
void *jit_object_alloc(void *c)
{
    return object_alloc((t_class *)c);
}

/**
 * Instantiates an object specified by class name.
 *
 * This function may used to create instances of any Jitter object.
 *
 * @ingroup objectmod 
 *
 * @param   classname   class name
 * @param   ...         untyped arguments passed on to the constructor
 * @warning It is important to know any necessary arguments for untyped 
 *          constructors such as those used by jit_matrix or jit_attr_offset.
 * 
 * @return  If successful, a valid object pointer. Otherwise, NULL.
 *
 */
void *jit_object_new(t_symbol *classname, ...)
{
    t_object *o=NULL;

#if TARGET_RT_MAC_MACHO
    initialize();
#endif

    if (!_jit_pink_roses) {

#ifdef WIN_VERSION // don't let these instantiate if QT is not installed
        if (_win_qt_init)
#endif
            hashtab_lookup(_jcs_hash,classname,&o);
            
            
        if (!o) goto out; //cp  
    }
    
    if (!_initlate)
        init_late();
    //////////////////////////////////////////////////////////

    return object_new(CLASS_JITTER,classname,*((t_stack_splat *)(((char *)(&classname))+4)));
out:
    //post("jit_object_new: could not create: %s", classname->s_name);
    return NULL;
}

/**
 * Calls an object method specified by method name.
 *
 * This operation is untyped, and the contents of the stack following
 * the method name argument are blindly passed to the method called.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       method name
 * @param   ...     untyped arguments passed on to the method
 * @warning It is important to know any necessary arguments for untyped 
 *          constructors such as those used by jit_matrix or jit_attr_offset.
 * 
 * @return  method dependent, but uses void * as a super type. 
 *
 */
void *jit_object_method(void *x, t_symbol *s, ...)
{   
    return object_method(x,s,*((t_stack_splat *)(((char *)(&s))+4)));
}

/**
 * Calls a typed object method specified by method name.
 * This operation only supports methods which are typed--i.e. it cannot
 * be used to call private, untyped A_CANT methods. 
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       method name
 * @param   ac      argument count
 * @param   av      argument vector
 * @param   rv      return value for A_GIMMEBACK methods
 * 
 * @return  method dependent, but uses void * as a super type. 
 *
 */
void *jit_object_method_typed(void *x, t_symbol *s, long ac, t_atom *av, t_atom *rv)
{   
    return (void *)object_method_typed(x,s,ac,av,rv);
}

/**
 * Retrieves an object method specified by method name.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       method name
 * 
 * @return  method 
 *
 */
method jit_object_getmethod(void *x, t_symbol *s)
{
    return object_getmethod(x,s);
}

/**
 * Determines if an object attribute is user settable.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * 
 * @return  1 if settable, 0 if not settable
 *
 */
long jit_object_attr_usercanset(void *x, t_symbol *s)
{   
    return object_attr_usercanset(x,s);
}

/**
 * Determines if an object attribute is user gettable.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       attribute name
 * 
 * @return  1 if gettable, 0 if not gettable
 *
 */
long jit_object_attr_usercanget(void *x, t_symbol *s)
{   
    return object_attr_usercanget(x,s);
}

/**
 * Retrieves an object's attribute pointer specified by attribute name.
 *
 * @ingroup objectmod 
 *
 * @param   x           object pointer
 * @param   attrname    attribute name
 * 
 * @return  attribute object pointer 
 *
 */
void *jit_object_attr_get(void *x, t_symbol *attrname)
{
    return object_attr_get(x,attrname);
}

/**
 * Frees an object.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_free(void *x)
{
    t_max_err err;  
    err = object_free(x);
    return jit_err_from_max_err(err);
}

/**
 * Retrieves an object's class name.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * 
 * @return  class name t_symbol pointer 
 *
 */
t_symbol *jit_object_classname(void *x)
{
    return object_classname(x); 
}

/**
 * Retrieves an object's class pointer.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * 
 * @return  class pointer 
 *
 */
void *jit_object_class(void *x)
{
    return object_class(x); 
}

t_jit_err jit_object_init(void)
{   
    if (!_jit_object_init) {
        // free hipno classes
        _jcs_hash = hashtab_new(0);
        hashtab_store(_jcs_hash,_jit_sym_jit_attr_offset,(t_object *)TRUE);
        hashtab_store(_jcs_hash,_jit_sym_jit_attr_offset_array,(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_attr_filter_clip"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,_jit_sym_jit_linklist,(t_object *)TRUE);
        hashtab_store(_jcs_hash,_jit_sym_jit_mop,(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_mop_io"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_alphablend"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_kernel"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_matrix"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_op"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_pwindow"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_xfade"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_pack"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_unpack"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_fill"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_spill"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_iter"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_qt_movie"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_uyvy2ayuv"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_ayuv2uyvy"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_ayuv2argb"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("jit_uyvy2argb"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("tap_jit_sum"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("tap_jit_proximity"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("tap_jit_kernel"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("tap_jit_colortrack"),(t_object *)TRUE);
        hashtab_store(_jcs_hash,gensym("tap_jit_ali"),(t_object *)TRUE);
                
        _jit_object_init=1;
        jit_rand_setseed(0);
        jit_rand(); //once for good measure (first 2 times around it's duplicated)
        _jit_mess_nonmethod.m_sym = gensym("nonmethod");
        _jit_mess_nonmethod.m_fun = (method)jit_method_false;
        _jit_mess_freemethod.m_sym = gensym("free");
        _jit_mess_freemethod.m_fun = (method)jit_object_free;
        jit_class_init(); //register class class manually
        jit_linklist_init(); //register list class manually
        //previously we manually added these classes, but
        //now that we are actualling using the obex classes, 
        //we can register with jit_class_register 
        //(i.e. no chicken/egg problem, as before) 
        jit_class_register(_jit_class_class); 
        jit_class_register(_jit_linklist_class); 

        //now register other classes
        //later some of these should move to better places
        jit_attr_init();
        jit_max_init();
        jit_matrix_init();
        jit_matrix_wrapper_init();
        jit_mop_init();
        jit_kernel_init();
        jit_la_mult_init();
        jit_la_uppertri_init();
        jit_la_trace_init();
        jit_la_diagproduct_init();
        jit_la_determinant_init();
        jit_la_inverse_init();
        if (_jit_pink_roses)
            jit_gl_init();
        jit_parallel_utils_init();  
        jit_op_init();
        jit_tree_init();
        jit_expr_init();
        jit_functor_init();
        jit_listener_init();
        jit_charset_init();
        jit_xml_init();
        jit_uyvy_init();
#ifndef WIN_VERSION //win_todo
        EnterMovies();
        jit_qt_movie_init(); 
        jit_qt_record_init();
        jit_qt_component_init();
        jit_qt_codec_init();
        jit_qt_utils_gensymbols();
        //Max stuff
        
#ifdef USE_ALTURA
        patchline_addmess(_jit_sym_jit_matrix,(method)jit_matrix_optdraw);
        patchline_addmess(gensym("jit_gl_texture"),(method)jit_gl_texture_optdraw);
#endif

#else
        // IMPORTANT!!! ON WINDOWS ALL QT CALLS
        // MUST BE MADE IN init_late(). CURRENTLY 
        // IT IS SAFE TO CALL jit_qt_movie_init() ANY record_init() 
        // AS THEY DON'T MAKE ANY QT CALLS. IF THIS
        // CHANGES, WE NEED TO MOVE TO init_late()
        //InitializeQTVR();
        //EnterMovies();
        jit_qt_movie_init(); 
        jit_qt_record_init();
        _initlate=0;
        defer_low(gensym("jit")->s_thing,(method)init_late,NULL,0,NULL);
#endif //WIN_VERSION
    } 
    
    return JIT_ERR_NONE;
}

//a general mechanism for multiply referenced named objects

/**
 * Registers an object in the named object registry.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * @param   s   object name
 * 
 * @return  object pointer
 *
 * @warning It is important to use the object pointer returned 
 *          by jit_object_register, since if there is an existing
 *          object with the same name and class, it could free
 *          the input object and pass back a reference to the 
 *          previously defined object.   
 *
 */
void *jit_object_register(void *x, t_symbol *s)
{
    // name argument is now before object argument
    return object_register(REGOB_NAMESPACE_JITTER,s,x);     
}

/**
 * Unregisters an object from the named object registry.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_unregister(void *x)
{       

    t_max_err err;  
    err = object_unregister(x);
    return jit_err_from_max_err(err);
}

/**
 * Retrieves a registered object associated with name.
 *
 * @ingroup objectmod 
 *
 * @param   s           registered name
 * 
 * @return  If successful, object pointer. Otherwise NULL. 
 *
 */
void *jit_object_findregistered(t_symbol *s)
{       
    return object_findregistered(REGOB_NAMESPACE_JITTER,s);
}

/**
 * Retrieves a registered object's name.
 *
 * @ingroup objectmod 
 *
 * @param   x   object pointer
 * 
 * @return  If successful, t_symbol pointer name. Otherwise NULL. 
 *
 */
t_symbol *jit_object_findregisteredbyptr(void *x)
{       
    t_symbol *s=NULL;
    t_symbol *name_space=NULL;  
    object_findregisteredbyptr(&name_space,&s,x);
    if (name_space!=REGOB_NAMESPACE_JITTER)
        s = NULL;
    return s;
}

/**
 * Attaches an object as a client of a named server object for notification.
 *
 * @ingroup objectmod 
 *
 * @param   s   name of server object
 * @param   x   client object pointer
 * 
 * @return  If successful, server object pointer. Otherwise NULL. 
 *
 */
void *jit_object_attach(t_symbol *s, void *x)
{       
    return object_attach(REGOB_NAMESPACE_JITTER,s,x);
}

/**
 * Detaches a client object from a named server object.
 *
 * @ingroup objectmod 
 *
 * @param   s   name of server object
 * @param   x   client object pointer
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_detach(t_symbol *s, void *x)
{       
    t_max_err err;
    err = object_detach(REGOB_NAMESPACE_JITTER,s,x);
    return jit_err_from_max_err(err);
}

/**
 * Notifies all client objects for a named server object.
 *
 * @ingroup objectmod 
 *
 * @param   x       server object pointer
 * @param   s       notification message
 * @param   data    message specific data
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_notify(void *x, t_symbol *s, void *data)
{       
    object_notify(x,s,data);
    return JIT_ERR_NONE;
}

t_jit_err jit_object_shutdown(void)
{
    if (_jit_object_init) {
        _jit_object_init=0;
    } 
    return JIT_ERR_NONE;
}

/**
 * Imports object attributes from an XML file.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       ignored
 * @param   argc    argument count
 * @param   argv    argument vector
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_importattrs(void *x, t_symbol *s, long argc, t_atom *argv)
{
    t_jit_linklist *attrlist;
    long size,i,j = 0;
    t_symbol *name;
    long err;
    long ac2,attrcount;
    t_atom *av2;
    t_jit_xml_document *doc;
    t_jit_xml_element *el;
    
    // later establish some means of filtering which attributes are read?

    if (doc=jit_xml_document_new(NULL,0,NULL)) {
        err = jit_xml_document_read(doc,s,argc,argv);
        if(err)
        {
            jit_object_error((t_object *)x,"jit_object_importattrs: error reading import file");
        }

        attrlist = jit_xml_document_getelementsbytagname(doc,gensym("attribute"));
        if(attrlist)
        {
            attrcount = jit_linklist_getsize(attrlist);
            for(i=0;i<attrcount;i++)
            {
                el = jit_linklist_getindex(attrlist,i);
                name = jit_xml_element_getattribute_sym(el, _jit_sym_name);
                ac2=0; av2=NULL;
                jit_xml_element_getattribute(el, gensym("value"),&ac2,&av2);
                // could enforce usercanset
                object_attr_setvalueof(x,name,ac2,av2); // always do for the empty value?
                if (ac2&&av2) {
                    freebytes(av2,ac2*sizeof(t_atom));
                }
            }
            jit_linklist_chuck(attrlist);
        }
        jit_object_free(doc);
    }
    return JIT_ERR_NONE;
}

/**
 * Exports object attributes to an XML file.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       ignored
 * @param   argc    argument count
 * @param   argv    argument vector
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_exportattrs(void *x, t_symbol *s, long argc, t_atom *argv)
{
    t_jit_linklist *attrlist;
    long size,i,j = 0;
    t_symbol *name,*classname;
    t_jit_object *o;
    t_atom a[256];
    char tmpstr[256];
    long ac2;
    t_atom *av2;
    long symcount=0;
    t_symbol **symarray=NULL;
    t_jit_xml_document *doc;
    t_jit_xml_element *mel,*sel;
        
    if (!x)
        return JIT_ERR_INVALID_PTR;

    // later establish some means of filtering which attributes are written?
    
    if (doc=jit_xml_document_new(NULL,0,NULL))
    {
        if (mel=jit_xml_document_createelement(doc,gensym("c74object")))
        {
            jit_xml_node_appendchild((t_jit_xml_node *)doc,(t_jit_xml_node *)mel);
            if (classname=jit_object_classname(x)) {
                for(i=0;classname->s_name[i];i++)
                    tmpstr[i] = (classname->s_name[i]=='_') ? '.' : classname->s_name[i];
                tmpstr[i] = 0;
                jit_atom_setsym(a,gensym(tmpstr));
                jit_xml_element_setattribute(mel,gensym("class"),1,a);                  
            }
            if (x&&!object_attr_getnames(x,&symcount,&symarray)) 
            {
                symbolarray_sort(symcount,symarray);
                for (i=0;i<symcount;i++) {
                    if (o=object_attr_get(x,symarray[i])) {         
                        if (jit_object_method(o,gensym("usercanset"))&&jit_object_method(o,gensym("usercanget"))) 
                        {
                            if (name = jit_object_method(o,_jit_sym_getname)) {
                                if (sel=jit_xml_document_createelement(doc,gensym("attribute"))) {
                                    jit_atom_setsym(a,name);
                                    jit_xml_element_setattribute(sel,gensym("name"),1,a);
                                    ac2=0; av2=NULL;
                                    object_attr_getvalueof(x,name,&ac2,&av2);
                                    if (ac2&&av2) {
                                        jit_xml_element_setattribute(sel,gensym("value"),ac2,av2);
                                        freebytes(av2,ac2*sizeof(t_atom));
                                    }                                   
                                    jit_xml_node_appendchild((t_jit_xml_node *)mel,(t_jit_xml_node *)sel);
                                }
                                j++;
                            }
                        }
                    } 
                }
            }
            if (symarray)
                freebytes((char *)symarray,symcount*sizeof(t_symbol *));
        }
        jit_xml_document_write(doc,NULL,argc,argv);
        jit_object_free(doc);
    }
    return JIT_ERR_NONE;
}

/**
 * Exports object summary to an XML file.
 *
 * @warning Currently this function does nothing, but is reserved for future use.
 *
 * @ingroup objectmod 
 *
 * @param   x       object pointer
 * @param   s       ignored
 * @param   argc    argument count
 * @param   argv    argument vector
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_object_exportsummary(void *x, t_symbol *s, long argc, t_atom *argv)
{
    return JIT_ERR_NONE;
}


#pragma mark -
// --------------------------------------------------------------------------------
// error/posting stuff

#define POST_MAXCOLS 2048

char *post_class_stroffset(t_object *o, char *msg);
char *post_class_stroffset(t_object *o, char *msg)
{
    t_symbol *classname = object_classname(o);
    char *p;
    
    if (classname&&classname!=_jit_sym_nothing) 
    {
        p = strstr(msg,classname->s_name);
        if (p) {
            p += strlen(classname->s_name);
            if (p[0]&&p[0]==':')
                p++;
            if (p[0]&&p[0]==' ')
                p++;
            //post("eliminated classname string in (%s)", msg);
            return p;
        }
    }
    return msg;
}

void jit_object_post(t_object *x, char *s, ...)
{
    static t_symbol *ps_poundB=NULL;
    static t_symbol *ps_maxwrapper=NULL;
    char msg[POST_MAXCOLS+2];
    char *msg2;
    t_object *box = NULL;
    t_object *wrapper = NULL;
    va_list ap;

    if (!ps_poundB) {
        ps_poundB = gensym("#B");
        ps_maxwrapper = gensym("maxwrapper");
    }   
            
    va_start(ap,s);
    vsnprintf(msg, POST_MAXCOLS, s, ap);
    va_end(ap);
    msg[POST_MAXCOLS] = '\0';   
    
    if (x&&(!NOGOOD(x))) {
        object_obex_lookup(x,ps_poundB,&box);
        if (box) {
            msg2 = post_class_stroffset(x,msg);
            object_post(x, msg2);
            return;
        }
        object_obex_lookup(x,ps_maxwrapper,&wrapper);
        if (wrapper) {
            msg2 = post_class_stroffset(wrapper,msg);
            object_post(wrapper, msg2);
            return;
        }
    }
    post(msg);
}

void jit_object_error(t_object *x, char *s, ...)
{
    static t_symbol *ps_poundB=NULL;
    static t_symbol *ps_maxwrapper=NULL;
    char msg[POST_MAXCOLS+2];
    char *msg2;
    t_object *box = NULL;
    t_object *wrapper = NULL;
    va_list ap;

    if (!ps_poundB) {
        ps_poundB = gensym("#B");
        ps_maxwrapper = gensym("maxwrapper");
    }   
            
    va_start(ap,s);
    vsnprintf(msg, POST_MAXCOLS, s, ap);
    va_end(ap);
    msg[POST_MAXCOLS] = '\0';   
    
    if (x&&(!NOGOOD(x))) {
        object_obex_lookup(x,ps_poundB,&box);
        if (box) {          
            msg2 = post_class_stroffset(x,msg);
            object_error(x, msg2);
            return;
        }
        object_obex_lookup(x,ps_maxwrapper,&wrapper);
        if (wrapper) {
            msg2 = post_class_stroffset(wrapper,msg);
            object_error(wrapper, msg2);
            return;
        }
    }
    error(msg);
}



void jit_error_dosym(void *x,t_symbol *s);
void jit_error_dosym(void *x,t_symbol *s)
{
    jit_object_error((t_object *)x,"%s: %s",ob_sym(x)->s_name,s->s_name);
}

/**
 * Sends symbol based error message to Max console (safe from all threads)
 *
 * @ingroup utilitymod 
 *
 * @param   x       object pointer
 * @param   s       error message symbol
 * 
 */
void jit_error_sym(void *x,t_symbol *s)
{
    defer(x,(method)jit_error_dosym,s,0,0L);
}

void jit_error_docode(void *x,t_jit_err v);
void jit_error_docode(void *x,t_jit_err v)
{
    switch (v) {
    case 0:
    case JIT_ERR_SUPPRESS_OUTPUT:
        break;
    case JIT_ERR_GENERIC:
        jit_object_error((t_object *)x,"%s: error type unspecified",ob_sym(x)->s_name);
        break;
    case JIT_ERR_INVALID_OBJECT:
        jit_object_error((t_object *)x,"%s: invalid object",ob_sym(x)->s_name);
        break;
    case JIT_ERR_OBJECT_BUSY:
        jit_object_error((t_object *)x,"%s: object busy",ob_sym(x)->s_name);
        break;
    case JIT_ERR_OUT_OF_MEM:
        jit_object_error((t_object *)x,"%s: out of memory",ob_sym(x)->s_name);
        break;
    case JIT_ERR_INVALID_PTR:
        jit_object_error((t_object *)x,"%s: invalid pointer",ob_sym(x)->s_name);
        break;
    case JIT_ERR_DUPLICATE:
        jit_object_error((t_object *)x,"%s: duplicate",ob_sym(x)->s_name);
        break;
    case JIT_ERR_OUT_OF_BOUNDS:
        jit_object_error((t_object *)x,"%s: out of bounds",ob_sym(x)->s_name);
        break;
    case JIT_ERR_INVALID_INPUT:
        jit_object_error((t_object *)x,"%s: invalid input",ob_sym(x)->s_name);
        break;
    case JIT_ERR_INVALID_OUTPUT:
        jit_object_error((t_object *)x,"%s: invalid output",ob_sym(x)->s_name);
        break;
    case JIT_ERR_MISMATCH_TYPE:
        jit_object_error((t_object *)x,"%s: mismatch type",ob_sym(x)->s_name);
        break;
    case JIT_ERR_MISMATCH_PLANE:
        jit_object_error((t_object *)x,"%s: mismatch plane",ob_sym(x)->s_name);
        break;
    case JIT_ERR_MISMATCH_DIM:
        jit_object_error((t_object *)x,"%s: mismatch dim",ob_sym(x)->s_name);
        break;
    case JIT_ERR_MATRIX_UNKNOWN:
        jit_object_error((t_object *)x,"%s: matrix unknown",ob_sym(x)->s_name);
        break;
    case JIT_ERR_DATA_UNAVAILABLE:
        jit_object_error((t_object *)x,"%s: data unavailable for request",ob_sym(x)->s_name);
        break;
    case JIT_ERR_HW_UNAVAILABLE:
        jit_object_error((t_object *)x,"%s: hardware unavailable for request",ob_sym(x)->s_name);
        break;
    default:
        jit_object_error((t_object *)x,"%s: '%c%c%c%c' (%d)",ob_sym(x)->s_name,((char *)v)[0],((char *)v)[1],((char *)v)[2],((char *)v)[3],(long)v);
    }
}

/**
 * Sends error code based error message to Max console (safe from all threads)
 *
 * @ingroup utilitymod 
 *
 * @param   x       object pointer
 * @param   v       error code
 * 
 */
void jit_error_code(void *x,t_jit_err v)
{
    defer(x,(method)jit_error_docode,(t_symbol *)v,0,0L); // hack: error number as symbol
}

void jit_post_dosym(void *x,t_symbol *s);
void jit_post_dosym(void *x,t_symbol *s)
{
    jit_object_post((t_object *)x,"%s: %s",ob_sym(x)->s_name,s->s_name);
}

/**
 * Sends symbol based message to Max console (safe from all threads)
 *
 * @ingroup utilitymod 
 *
 * @param   x       object pointer
 * @param   s       message symbol
 * 
 */
void jit_post_sym(void *x,t_symbol *s)
{
    defer(x,(method)jit_post_dosym,s,0,0L);
}

/**
 * Converts Max style error codes to Jitter style error codes
 *
 * @ingroup utilitymod 
 *
 * @param   err     Max error code
 * 
 * @return  t_jit_err error code
 *
 */
t_jit_err jit_err_from_max_err(t_max_err err)
{
    switch (err) {
    case MAX_ERR_NONE:
        return JIT_ERR_NONE;
    case MAX_ERR_GENERIC:
        return JIT_ERR_GENERIC;
    case MAX_ERR_INVALID_PTR:
        return JIT_ERR_INVALID_PTR;
    case MAX_ERR_DUPLICATE:
        return JIT_ERR_DUPLICATE;
    case MAX_ERR_OUT_OF_MEM:
        return JIT_ERR_OUT_OF_MEM;
    default:
        return JIT_ERR_GENERIC;
    }
}

// taken from c74support-private/mac-support/CurrentBundle.c and modified for frameworks

#if TARGET_RT_MAC_MACHO

#include <dlfcn.h>

CFBundleRef GetCurrentlyExecutingFrameworkBundleOfFunction(void *fun); // declared below

short open_framework_resources(CFBundleRef *bun)
{
    short rsRefNum;
    
    *bun = GetCurrentlyExecutingFrameworkBundleOfFunction((void *)open_framework_resources);
    if (*bun) {
        rsRefNum = CFBundleOpenBundleResourceMap(*bun);
        if (rsRefNum != -1)
            return rsRefNum;
        else {
            CFRelease(*bun);
            *bun = 0;
            return -1;
        }
    } else
        return -1;
}

void close_framework_resources(CFBundleRef bun, short ref)
{
    if (bun && ref != -1)
        CFBundleCloseBundleResourceMap(bun,ref);
    if (bun)
        CFRelease(bun);
}

CFBundleRef GetCurrentlyExecutingFrameworkBundleOfFunction(void *fun)
{
    Dl_info info;
    CFURLRef url;
    CFBundleRef bun;
    char str[512];
    char *p;

    dladdr(fun,&info);  // ask dynamic loader (10.3 or later) for address of something
    strcpy(str,info.dli_fname);
    p = strstr(str,"JitterAPI.framework");
    if (p) {
        *(p+strlen("JitterAPI.framework")) = 0;
    } else
        return NULL;
    url = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault,(UInt8 *)str, strlen(str),true);
    if (!url)
        return NULL;
    bun = CFBundleCreate(kCFAllocatorDefault,url);
    CFRelease(url);
    return bun;
}

#endif

Copyright © 2008, Cycling '74