Max 5 API Reference

jit.gworld.c

/* 
    jit.gworld.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/
#include "jit.common.h"

//static CTabHandle _g_clut = 0; //probably not needed.

/**
 * Set all pixels in a QuickDraw GWorld to a specified 32-bit value
 *
 * @ingroup qtutilsmod 
 *
 * @param   gp          QuickDraw GWorldPtr
 * @param   c           clear color
 *
 */
void jit_gworld_clear(GWorldPtr gp, long c)
{
    PixMapHandle pmh;
    uchar *addr;
    long width,height,rowstride,i,j;
    long *p;
    Rect r;
    long widfactor;
    long v = BE_I32(c);
    
    if (gp) {
        pmh = GetGWorldPixMap(gp);
        if (!pmh) { 
            return;
        }

        LockPixels(pmh); 

#ifdef WIN_VERSION
#ifndef USE_QTML
    ASI_SetCurrentPixMapType(*pmh, PMTYPE_SetMacCurrent);
    ASI_UnfoldPixMap((BitMapPtr)*pmh,(BitMapPtr)*pmh,&(*pmh)->bounds,&(*pmh)->bounds,0);
#endif //USE_QTML
#endif //WIN_VERSION

        addr = (uchar *)GetPixBaseAddr(pmh);
        if (!addr) { 
            UnlockPixels(pmh); 
            return;
        }
        GetPortBounds(gp,&r);
        if ((**pmh).pixelSize == 16) // uyvy
            widfactor = 1L;
        else
            widfactor = 0L;
        width       = (r.right-r.left) >> widfactor;
        height      = (r.bottom-r.top);                 
        rowstride   = GetPixRowBytes(pmh);
        if (rowstride<(width*4)) { 
            //assuming one of the various uyvy packed types
            //could be better, perhaps convert argb value to 
            //whatever colorspace?
            width /= 2; 
        }   
        for(i=0;i<height;i++) {
            p = (long *)(addr + (i * rowstride));
            
            --p; 
            for(j=0;j<width;j++) { *++p = v; }
        }
        UnlockPixels(pmh); 
    }       
}

/**
 * Determine whether a Jitter matrix can be wrapped in a QuickDraw GWorld (without a copy)
 *
 * @ingroup qtutilsmod 
 *
 * @param   gc          optional pointer to a t_gworld_conv_info struct
 * @param   m           input t_jit_matrix pointer
 *
 * @return long success code (1 = can coerce, 0 = cannot coerce)
 */
long jit_gworld_can_coerce_matrix(t_gworld_conv_info *gc, void *m)
{
    t_jit_matrix_info minfo;
    long rv=0,savelock;
    
    if (m) {
        savelock = (long)jit_object_method(m,_jit_sym_lock,1);
        jit_object_method(m,_jit_sym_getinfo,&minfo);
        if (minfo.type!=_jit_sym_char) goto out;
        if (minfo.planecount!=4) goto out;
        if (minfo.dimstride[1]>16382) goto out; //QD maximum
        if (gc) {
            if (gc->planemap[0]!=0) goto out;
            if (gc->planemap[1]!=1) goto out;
            if (gc->planemap[2]!=2) goto out;
            if (gc->planemap[3]!=3) goto out;
            if (gc->flags&JIT_MATRIX_CONVERT_INTERP) goto out;
            if (gc->flags&JIT_MATRIX_CONVERT_SRCDIM) goto out;
            if (gc->flags&JIT_MATRIX_CONVERT_DSTDIM) goto out;
        }
        jit_object_method(m,_jit_sym_lock,savelock);        
        rv = 1;
    }
out:
    return rv;
}

/**
 * Test for equality of dimensions between a QuickDraw GWorld and a Jitter matrix
 * Note: supports UYVY matrices
 *
 * @ingroup qtutilsmod 
 *
 * @param   gp          input GWorldPtr
 * @param   m           input t_jit_matrix pointer
 *
 * @return long success code (1 = dims are equal, 0 = dims are not equal)
 */
long jit_gworld_matrix_equal_dim(GWorldPtr gp, void *m)
{
    t_jit_matrix_info minfo;
    long rv=0,savelock;
    Rect r;
    PixMapHandle pmh;
    long widfactor;

    if (gp&&m) {
        savelock = (long)jit_object_method(m,_jit_sym_lock,1);
        jit_object_method(m,_jit_sym_getinfo,&minfo);
        GetPortBounds(gp,&r);
        pmh = GetGWorldPixMap(gp);
        if ((**pmh).pixelSize == 16) // uyvy
            widfactor = 1L;
        else
            widfactor = 0L;
        if (minfo.dim[0] != (ABS(r.right-r.left) >> widfactor)) 
            goto out;
        if (minfo.dim[1] != ABS(r.bottom-r.top)) 
            goto out;
        jit_object_method(m,_jit_sym_lock,savelock);        
        rv = 1;
    }
out:
    return rv;
}


/**
 * Generate a QuickDraw PixMap for a given Jitter matrix
 *
 * @ingroup qtutilsmod 
 *
 * @param   m           input t_jit_matrix pointer
 * @param   pm          on output, a pointer to the generated PixMap
 *
 * @return t_jit_err error code
 *
 * @warning The matrix should be locked previous to this call, and unlocked afterward.
 */
//no call to save lock since this should be called outside
t_jit_err jit_coerce_matrix_pixmap(void *m, PixMap *pm)
{
    t_jit_matrix_info minfo;
    long rv=JIT_ERR_GENERIC;
    
    if (m&&pm) {
        jit_object_method(m,_jit_sym_getinfo,&minfo);
        //if (!_g_clut) _g_clut = GetCTable(72); //don't know if we really need this
        pm->baseAddr = NULL;
        jit_object_method(m,_jit_sym_getdata,&pm->baseAddr);
        if (!pm->baseAddr) goto out;
        
        if (minfo.dimstride[1]>16382) goto out; //QD maximum
        else if (minfo.dim[1]==1) {
            // on windows, we need a nonzero dimstride
            minfo.dimstride[1] = 4*minfo.dim[0];
        }
        pm->rowBytes = minfo.dimstride[1] | 0x8000; //pixmap vs. bitmap 
        MacSetRect(&pm->bounds,0,0,minfo.dim[0],minfo.dim[1]);
        pm->pmVersion   = 0;            // nothing in reserved  
        pm->packType    = 0;
        pm->packSize    = 0;
        pm->hRes        = 0x00480000;   // 72 dpi
        pm->vRes        = 0x00480000;
        pm->pixelType   = 16;           // RGBDirect
        pm->pixelSize   = 32;
        pm->cmpCount    = 3;
        pm->cmpSize     = 8;
#if OLDPIXMAPSTRUCT
        pm->planeBytes  = 0;
        pm->pmTable     = NULL;         //may need to call GetCTable(), but shouldn't
        //pm->pmTable   = _g_clut;      
        pm->pmReserved  = 0; 
#else
        pm->pixelFormat = k32ARGBPixelFormat;
        pm->pmTable     = NULL;         //may need to call GetCTable(), but shouldn't
        pm->pmExt       = NULL;         /*Handle to pixMap extension*/
#endif
        
        rv = JIT_ERR_NONE;
    }
out:
    return rv;
}

Copyright © 2008, Cycling '74