911 lines
32 KiB
C
911 lines
32 KiB
C
/* Copyright (c) 1997-1999 Miller Puckette.
|
|
* For information on usage and redistribution, and for a DISCLAIMER OF ALL
|
|
* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
|
|
|
|
#ifndef __m_pd_h_
|
|
|
|
#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define PD_MAJOR_VERSION 0
|
|
#define PD_MINOR_VERSION 51
|
|
#define PD_BUGFIX_VERSION 4
|
|
#define PD_TEST_VERSION ""
|
|
extern int pd_compatibilitylevel; /* e.g., 43 for pd 0.43 compatibility */
|
|
|
|
/* old name for "MSW" flag -- we have to take it for the sake of many old
|
|
"nmakefiles" for externs, which will define NT and not MSW */
|
|
#if defined(NT) && !defined(MSW)
|
|
#define MSW
|
|
#endif
|
|
|
|
/* These pragmas are only used for MSVC, not MinGW or Cygwin <hans@at.or.at> */
|
|
#ifdef _MSC_VER
|
|
/* #pragma warning( disable : 4091 ) */
|
|
#pragma warning( disable : 4305 ) /* uncast const double to float */
|
|
#pragma warning( disable : 4244 ) /* uncast float/int conversion etc. */
|
|
#pragma warning( disable : 4101 ) /* unused automatic variables */
|
|
#endif /* _MSC_VER */
|
|
|
|
/* the external storage class is "extern" in UNIX; in MSW it's ugly. */
|
|
#ifdef _WIN32
|
|
#ifdef PD_INTERNAL
|
|
#define EXTERN __declspec(dllexport) extern
|
|
#else
|
|
#define EXTERN __declspec(dllimport) extern
|
|
#endif /* PD_INTERNAL */
|
|
#else
|
|
#define EXTERN extern
|
|
#endif /* _WIN32 */
|
|
|
|
/* On most c compilers, you can just say "struct foo;" to declare a
|
|
structure whose elements are defined elsewhere. On MSVC, when compiling
|
|
C (but not C++) code, you have to say "extern struct foo;". So we make
|
|
a stupid macro: */
|
|
#if defined(_MSC_VER) && !defined(_LANGUAGE_C_PLUS_PLUS) \
|
|
&& !defined(__cplusplus)
|
|
#define EXTERN_STRUCT extern struct
|
|
#else
|
|
#define EXTERN_STRUCT struct
|
|
#endif
|
|
|
|
/* Define some attributes, specific to the compiler */
|
|
#if defined(__GNUC__)
|
|
#define ATTRIBUTE_FORMAT_PRINTF(a, b) __attribute__ ((format (printf, a, b)))
|
|
#else
|
|
#define ATTRIBUTE_FORMAT_PRINTF(a, b)
|
|
#endif
|
|
|
|
#if !defined(_SIZE_T) && !defined(_SIZE_T_)
|
|
#include <stddef.h> /* just for size_t -- how lame! */
|
|
#endif
|
|
|
|
/* Microsoft Visual Studio is not C99, but since VS2015 has included most C99 headers:
|
|
https://docs.microsoft.com/en-us/previous-versions/hh409293(v=vs.140)#c-runtime-library
|
|
These definitions recreate stdint.h types, but only in pre-2015 Visual Studio: */
|
|
#if defined(_MSC_VER) && _MSC_VER < 1900
|
|
typedef signed __int8 int8_t;
|
|
typedef signed __int16 int16_t;
|
|
typedef signed __int32 int32_t;
|
|
typedef signed __int64 int64_t;
|
|
typedef unsigned __int8 uint8_t;
|
|
typedef unsigned __int16 uint16_t;
|
|
typedef unsigned __int32 uint32_t;
|
|
typedef unsigned __int64 uint64_t;
|
|
#else
|
|
# include <stdint.h>
|
|
#endif
|
|
|
|
/* for FILE, needed by sys_fopen() and sys_fclose() only */
|
|
#include <stdio.h>
|
|
|
|
#define MAXPDSTRING 1000 /* use this for anything you want */
|
|
#define MAXPDARG 5 /* max number of args we can typecheck today */
|
|
|
|
/* signed and unsigned integer types the size of a pointer: */
|
|
#if !defined(PD_LONGINTTYPE)
|
|
#if defined(_WIN32) && defined(_WIN64)
|
|
#define PD_LONGINTTYPE long long
|
|
#else
|
|
#define PD_LONGINTTYPE long
|
|
#endif
|
|
#endif
|
|
|
|
#if !defined(PD_FLOATSIZE)
|
|
/* normally, our floats (t_float, t_sample,...) are 32bit */
|
|
# define PD_FLOATSIZE 32
|
|
#endif
|
|
|
|
#if PD_FLOATSIZE == 32
|
|
# define PD_FLOATTYPE float
|
|
/* an unsigned int of the same size as FLOATTYPE: */
|
|
# define PD_FLOATUINTTYPE uint32_t
|
|
|
|
#elif PD_FLOATSIZE == 64
|
|
# define PD_FLOATTYPE double
|
|
# define PD_FLOATUINTTYPE uint64_t
|
|
#else
|
|
# error invalid FLOATSIZE: must be 32 or 64
|
|
#endif
|
|
|
|
typedef PD_LONGINTTYPE t_int; /* pointer-size integer */
|
|
typedef PD_FLOATTYPE t_float; /* a float type at most the same size */
|
|
typedef PD_FLOATTYPE t_floatarg; /* float type for function calls */
|
|
|
|
typedef struct _symbol
|
|
{
|
|
const char *s_name;
|
|
struct _class **s_thing;
|
|
struct _symbol *s_next;
|
|
} t_symbol;
|
|
|
|
EXTERN_STRUCT _array;
|
|
#define t_array struct _array /* g_canvas.h */
|
|
|
|
/* pointers to glist and array elements go through a "stub" which sticks
|
|
around after the glist or array is freed. The stub itself is deleted when
|
|
both the glist/array is gone and the refcount is zero, ensuring that no
|
|
gpointers are pointing here. */
|
|
|
|
#define GP_NONE 0 /* the stub points nowhere (has been cut off) */
|
|
#define GP_GLIST 1 /* the stub points to a glist element */
|
|
#define GP_ARRAY 2 /* ... or array */
|
|
|
|
typedef struct _gstub
|
|
{
|
|
union
|
|
{
|
|
struct _glist *gs_glist; /* glist we're in */
|
|
struct _array *gs_array; /* array we're in */
|
|
} gs_un;
|
|
int gs_which; /* GP_GLIST/GP_ARRAY */
|
|
int gs_refcount; /* number of gpointers pointing here */
|
|
} t_gstub;
|
|
|
|
typedef struct _gpointer /* pointer to a gobj in a glist */
|
|
{
|
|
union
|
|
{
|
|
struct _scalar *gp_scalar; /* scalar we're in (if glist) */
|
|
union word *gp_w; /* raw data (if array) */
|
|
} gp_un;
|
|
int gp_valid; /* number which must match gpointee */
|
|
t_gstub *gp_stub; /* stub which points to glist/array */
|
|
} t_gpointer;
|
|
|
|
typedef union word
|
|
{
|
|
t_float w_float;
|
|
t_symbol *w_symbol;
|
|
t_gpointer *w_gpointer;
|
|
t_array *w_array;
|
|
struct _binbuf *w_binbuf;
|
|
int w_index;
|
|
} t_word;
|
|
|
|
typedef enum
|
|
{
|
|
A_NULL,
|
|
A_FLOAT,
|
|
A_SYMBOL,
|
|
A_POINTER,
|
|
A_SEMI,
|
|
A_COMMA,
|
|
A_DEFFLOAT,
|
|
A_DEFSYM,
|
|
A_DOLLAR,
|
|
A_DOLLSYM,
|
|
A_GIMME,
|
|
A_CANT
|
|
} t_atomtype;
|
|
|
|
#define A_DEFSYMBOL A_DEFSYM /* better name for this */
|
|
|
|
typedef struct _atom
|
|
{
|
|
t_atomtype a_type;
|
|
union word a_w;
|
|
} t_atom;
|
|
|
|
EXTERN_STRUCT _class;
|
|
#define t_class struct _class
|
|
|
|
EXTERN_STRUCT _outlet;
|
|
#define t_outlet struct _outlet
|
|
|
|
EXTERN_STRUCT _inlet;
|
|
#define t_inlet struct _inlet
|
|
|
|
EXTERN_STRUCT _binbuf;
|
|
#define t_binbuf struct _binbuf
|
|
|
|
EXTERN_STRUCT _clock;
|
|
#define t_clock struct _clock
|
|
|
|
EXTERN_STRUCT _outconnect;
|
|
#define t_outconnect struct _outconnect
|
|
|
|
EXTERN_STRUCT _glist;
|
|
#define t_glist struct _glist
|
|
#define t_canvas struct _glist /* LATER lose this */
|
|
|
|
EXTERN_STRUCT _template;
|
|
|
|
typedef t_class *t_pd; /* pure datum: nothing but a class pointer */
|
|
|
|
typedef struct _gobj /* a graphical object */
|
|
{
|
|
t_pd g_pd; /* pure datum header (class) */
|
|
struct _gobj *g_next; /* next in list */
|
|
} t_gobj;
|
|
|
|
typedef struct _scalar /* a graphical object holding data */
|
|
{
|
|
t_gobj sc_gobj; /* header for graphical object */
|
|
t_symbol *sc_template; /* template name (LATER replace with pointer) */
|
|
t_word sc_vec[1]; /* indeterminate-length array of words */
|
|
} t_scalar;
|
|
|
|
typedef struct _text /* patchable object - graphical, with text */
|
|
{
|
|
t_gobj te_g; /* header for graphical object */
|
|
t_binbuf *te_binbuf; /* holder for the text */
|
|
t_outlet *te_outlet; /* linked list of outlets */
|
|
t_inlet *te_inlet; /* linked list of inlets */
|
|
short te_xpix; /* x&y location (within the toplevel) */
|
|
short te_ypix;
|
|
short te_width; /* requested width in chars, 0 if auto */
|
|
unsigned int te_type:2; /* from defs below */
|
|
} t_text;
|
|
|
|
#define T_TEXT 0 /* just a textual comment */
|
|
#define T_OBJECT 1 /* a MAX style patchable object */
|
|
#define T_MESSAGE 2 /* a MAX type message */
|
|
#define T_ATOM 3 /* a cell to display a number or symbol */
|
|
|
|
#define te_pd te_g.g_pd
|
|
|
|
/* t_object is synonym for t_text (LATER unify them) */
|
|
|
|
typedef struct _text t_object;
|
|
|
|
#define ob_outlet te_outlet
|
|
#define ob_inlet te_inlet
|
|
#define ob_binbuf te_binbuf
|
|
#define ob_pd te_g.g_pd
|
|
#define ob_g te_g
|
|
|
|
typedef void (*t_method)(void);
|
|
typedef void *(*t_newmethod)(void);
|
|
|
|
/* in ARM 64 a varargs prototype generates a different function call sequence
|
|
from a fixed one, so in that special case we make a more restrictive
|
|
definition for t_gotfn. This will break some code in the "chaos" package
|
|
in Pd extended. (that code will run incorrectly anyhow so why not catch it
|
|
at compile time anyhow.) */
|
|
#if defined(__APPLE__) && defined(__aarch64__)
|
|
typedef void (*t_gotfn)(void *x);
|
|
#else
|
|
typedef void (*t_gotfn)(void *x, ...);
|
|
#endif
|
|
|
|
/* ---------------- pre-defined objects and symbols --------------*/
|
|
EXTERN t_pd pd_objectmaker; /* factory for creating "object" boxes */
|
|
EXTERN t_pd pd_canvasmaker; /* factory for creating canvases */
|
|
|
|
/* --------- prototypes from the central message system ----------- */
|
|
EXTERN void pd_typedmess(t_pd *x, t_symbol *s, int argc, t_atom *argv);
|
|
EXTERN void pd_forwardmess(t_pd *x, int argc, t_atom *argv);
|
|
EXTERN t_symbol *gensym(const char *s);
|
|
EXTERN t_gotfn getfn(const t_pd *x, t_symbol *s);
|
|
EXTERN t_gotfn zgetfn(const t_pd *x, t_symbol *s);
|
|
EXTERN void nullfn(void);
|
|
EXTERN void pd_vmess(t_pd *x, t_symbol *s, const char *fmt, ...);
|
|
|
|
/* the following macros are for sending non-type-checkable messages, i.e.,
|
|
using function lookup but circumventing type checking on arguments. Only
|
|
use for internal messaging protected by A_CANT so that the message can't
|
|
be generated at patch level. */
|
|
#define mess0(x, s) ((*getfn((x), (s)))((x)))
|
|
typedef void (*t_gotfn1)(void *x, void *arg1);
|
|
#define mess1(x, s, a) ((*(t_gotfn1)getfn((x), (s)))((x), (a)))
|
|
typedef void (*t_gotfn2)(void *x, void *arg1, void *arg2);
|
|
#define mess2(x, s, a,b) ((*(t_gotfn2)getfn((x), (s)))((x), (a),(b)))
|
|
typedef void (*t_gotfn3)(void *x, void *arg1, void *arg2, void *arg3);
|
|
#define mess3(x, s, a,b,c) ((*(t_gotfn3)getfn((x), (s)))((x), (a),(b),(c)))
|
|
typedef void (*t_gotfn4)(void *x,
|
|
void *arg1, void *arg2, void *arg3, void *arg4);
|
|
#define mess4(x, s, a,b,c,d) \
|
|
((*(t_gotfn4)getfn((x), (s)))((x), (a),(b),(c),(d)))
|
|
typedef void (*t_gotfn5)(void *x,
|
|
void *arg1, void *arg2, void *arg3, void *arg4, void *arg5);
|
|
#define mess5(x, s, a,b,c,d,e) \
|
|
((*(t_gotfn5)getfn((x), (s)))((x), (a),(b),(c),(d),(e)))
|
|
|
|
EXTERN void obj_list(t_object *x, t_symbol *s, int argc, t_atom *argv);
|
|
EXTERN t_pd *pd_newest(void);
|
|
|
|
/* --------------- memory management -------------------- */
|
|
EXTERN void *getbytes(size_t nbytes);
|
|
EXTERN void *getzbytes(size_t nbytes);
|
|
EXTERN void *copybytes(const void *src, size_t nbytes);
|
|
EXTERN void freebytes(void *x, size_t nbytes);
|
|
EXTERN void *resizebytes(void *x, size_t oldsize, size_t newsize);
|
|
|
|
/* -------------------- atoms ----------------------------- */
|
|
|
|
#define SETSEMI(atom) ((atom)->a_type = A_SEMI, (atom)->a_w.w_index = 0)
|
|
#define SETCOMMA(atom) ((atom)->a_type = A_COMMA, (atom)->a_w.w_index = 0)
|
|
#define SETPOINTER(atom, gp) ((atom)->a_type = A_POINTER, \
|
|
(atom)->a_w.w_gpointer = (gp))
|
|
#define SETFLOAT(atom, f) ((atom)->a_type = A_FLOAT, (atom)->a_w.w_float = (f))
|
|
#define SETSYMBOL(atom, s) ((atom)->a_type = A_SYMBOL, \
|
|
(atom)->a_w.w_symbol = (s))
|
|
#define SETDOLLAR(atom, n) ((atom)->a_type = A_DOLLAR, \
|
|
(atom)->a_w.w_index = (n))
|
|
#define SETDOLLSYM(atom, s) ((atom)->a_type = A_DOLLSYM, \
|
|
(atom)->a_w.w_symbol= (s))
|
|
|
|
EXTERN t_float atom_getfloat(const t_atom *a);
|
|
EXTERN t_int atom_getint(const t_atom *a);
|
|
EXTERN t_symbol *atom_getsymbol(const t_atom *a);
|
|
EXTERN t_symbol *atom_gensym(const t_atom *a);
|
|
EXTERN t_float atom_getfloatarg(int which, int argc, const t_atom *argv);
|
|
EXTERN t_int atom_getintarg(int which, int argc, const t_atom *argv);
|
|
EXTERN t_symbol *atom_getsymbolarg(int which, int argc, const t_atom *argv);
|
|
|
|
EXTERN void atom_string(const t_atom *a, char *buf, unsigned int bufsize);
|
|
|
|
/* ------------------ binbufs --------------- */
|
|
|
|
EXTERN t_binbuf *binbuf_new(void);
|
|
EXTERN void binbuf_free(t_binbuf *x);
|
|
EXTERN t_binbuf *binbuf_duplicate(const t_binbuf *y);
|
|
|
|
EXTERN void binbuf_text(t_binbuf *x, const char *text, size_t size);
|
|
EXTERN void binbuf_gettext(const t_binbuf *x, char **bufp, int *lengthp);
|
|
EXTERN void binbuf_clear(t_binbuf *x);
|
|
EXTERN void binbuf_add(t_binbuf *x, int argc, const t_atom *argv);
|
|
EXTERN void binbuf_addv(t_binbuf *x, const char *fmt, ...);
|
|
EXTERN void binbuf_addbinbuf(t_binbuf *x, const t_binbuf *y);
|
|
EXTERN void binbuf_addsemi(t_binbuf *x);
|
|
EXTERN void binbuf_restore(t_binbuf *x, int argc, const t_atom *argv);
|
|
EXTERN void binbuf_print(const t_binbuf *x);
|
|
EXTERN int binbuf_getnatom(const t_binbuf *x);
|
|
EXTERN t_atom *binbuf_getvec(const t_binbuf *x);
|
|
EXTERN int binbuf_resize(t_binbuf *x, int newsize);
|
|
EXTERN void binbuf_eval(const t_binbuf *x, t_pd *target, int argc, const t_atom *argv);
|
|
EXTERN int binbuf_read(t_binbuf *b, const char *filename, const char *dirname,
|
|
int crflag);
|
|
EXTERN int binbuf_read_via_canvas(t_binbuf *b, const char *filename, const t_canvas *canvas,
|
|
int crflag);
|
|
EXTERN int binbuf_read_via_path(t_binbuf *b, const char *filename, const char *dirname,
|
|
int crflag);
|
|
EXTERN int binbuf_write(const t_binbuf *x, const char *filename, const char *dir,
|
|
int crflag);
|
|
EXTERN void binbuf_evalfile(t_symbol *name, t_symbol *dir);
|
|
EXTERN t_symbol *binbuf_realizedollsym(t_symbol *s, int ac, const t_atom *av,
|
|
int tonew);
|
|
|
|
/* ------------------ clocks --------------- */
|
|
|
|
EXTERN t_clock *clock_new(void *owner, t_method fn);
|
|
EXTERN void clock_set(t_clock *x, double systime);
|
|
EXTERN void clock_delay(t_clock *x, double delaytime);
|
|
EXTERN void clock_unset(t_clock *x);
|
|
EXTERN void clock_setunit(t_clock *x, double timeunit, int sampflag);
|
|
EXTERN double clock_getlogicaltime(void);
|
|
EXTERN double clock_getsystime(void); /* OBSOLETE; use clock_getlogicaltime() */
|
|
EXTERN double clock_gettimesince(double prevsystime);
|
|
EXTERN double clock_gettimesincewithunits(double prevsystime,
|
|
double units, int sampflag);
|
|
EXTERN double clock_getsystimeafter(double delaytime);
|
|
EXTERN void clock_free(t_clock *x);
|
|
|
|
/* ----------------- pure data ---------------- */
|
|
EXTERN t_pd *pd_new(t_class *cls);
|
|
EXTERN void pd_free(t_pd *x);
|
|
EXTERN void pd_bind(t_pd *x, t_symbol *s);
|
|
EXTERN void pd_unbind(t_pd *x, t_symbol *s);
|
|
EXTERN t_pd *pd_findbyclass(t_symbol *s, const t_class *c);
|
|
EXTERN void pd_pushsym(t_pd *x);
|
|
EXTERN void pd_popsym(t_pd *x);
|
|
EXTERN void pd_bang(t_pd *x);
|
|
EXTERN void pd_pointer(t_pd *x, t_gpointer *gp);
|
|
EXTERN void pd_float(t_pd *x, t_float f);
|
|
EXTERN void pd_symbol(t_pd *x, t_symbol *s);
|
|
EXTERN void pd_list(t_pd *x, t_symbol *s, int argc, t_atom *argv);
|
|
EXTERN void pd_anything(t_pd *x, t_symbol *s, int argc, t_atom *argv);
|
|
#define pd_class(x) (*(x))
|
|
|
|
/* ----------------- pointers ---------------- */
|
|
EXTERN void gpointer_init(t_gpointer *gp);
|
|
EXTERN void gpointer_copy(const t_gpointer *gpfrom, t_gpointer *gpto);
|
|
EXTERN void gpointer_unset(t_gpointer *gp);
|
|
EXTERN int gpointer_check(const t_gpointer *gp, int headok);
|
|
|
|
/* ----------------- patchable "objects" -------------- */
|
|
EXTERN t_inlet *inlet_new(t_object *owner, t_pd *dest, t_symbol *s1,
|
|
t_symbol *s2);
|
|
EXTERN t_inlet *pointerinlet_new(t_object *owner, t_gpointer *gp);
|
|
EXTERN t_inlet *floatinlet_new(t_object *owner, t_float *fp);
|
|
EXTERN t_inlet *symbolinlet_new(t_object *owner, t_symbol **sp);
|
|
EXTERN t_inlet *signalinlet_new(t_object *owner, t_float f);
|
|
EXTERN void inlet_free(t_inlet *x);
|
|
|
|
EXTERN t_outlet *outlet_new(t_object *owner, t_symbol *s);
|
|
EXTERN void outlet_bang(t_outlet *x);
|
|
EXTERN void outlet_pointer(t_outlet *x, t_gpointer *gp);
|
|
EXTERN void outlet_float(t_outlet *x, t_float f);
|
|
EXTERN void outlet_symbol(t_outlet *x, t_symbol *s);
|
|
EXTERN void outlet_list(t_outlet *x, t_symbol *s, int argc, t_atom *argv);
|
|
EXTERN void outlet_anything(t_outlet *x, t_symbol *s, int argc, t_atom *argv);
|
|
EXTERN t_symbol *outlet_getsymbol(t_outlet *x);
|
|
EXTERN void outlet_free(t_outlet *x);
|
|
EXTERN t_object *pd_checkobject(t_pd *x);
|
|
|
|
|
|
/* -------------------- canvases -------------- */
|
|
|
|
EXTERN void glob_setfilename(void *dummy, t_symbol *name, t_symbol *dir);
|
|
|
|
EXTERN void canvas_setargs(int argc, const t_atom *argv);
|
|
EXTERN void canvas_getargs(int *argcp, t_atom **argvp);
|
|
EXTERN t_symbol *canvas_getcurrentdir(void);
|
|
EXTERN t_glist *canvas_getcurrent(void);
|
|
EXTERN void canvas_makefilename(const t_glist *c, const char *file,
|
|
char *result, int resultsize);
|
|
EXTERN t_symbol *canvas_getdir(const t_glist *x);
|
|
EXTERN char sys_font[]; /* default typeface set in s_main.c */
|
|
EXTERN char sys_fontweight[]; /* default font weight set in s_main.c */
|
|
EXTERN int sys_hostfontsize(int fontsize, int zoom);
|
|
EXTERN int sys_zoomfontwidth(int fontsize, int zoom, int worstcase);
|
|
EXTERN int sys_zoomfontheight(int fontsize, int zoom, int worstcase);
|
|
EXTERN int sys_fontwidth(int fontsize);
|
|
EXTERN int sys_fontheight(int fontsize);
|
|
EXTERN void canvas_dataproperties(t_glist *x, t_scalar *sc, t_binbuf *b);
|
|
EXTERN int canvas_open(const t_canvas *x, const char *name, const char *ext,
|
|
char *dirresult, char **nameresult, unsigned int size, int bin);
|
|
|
|
/* ---------------- widget behaviors ---------------------- */
|
|
|
|
EXTERN_STRUCT _widgetbehavior;
|
|
#define t_widgetbehavior struct _widgetbehavior
|
|
|
|
EXTERN_STRUCT _parentwidgetbehavior;
|
|
#define t_parentwidgetbehavior struct _parentwidgetbehavior
|
|
EXTERN const t_parentwidgetbehavior *pd_getparentwidget(t_pd *x);
|
|
|
|
/* -------------------- classes -------------- */
|
|
|
|
#define CLASS_DEFAULT 0 /* flags for new classes below */
|
|
#define CLASS_PD 1
|
|
#define CLASS_GOBJ 2
|
|
#define CLASS_PATCHABLE 3
|
|
#define CLASS_NOINLET 8
|
|
|
|
#define CLASS_TYPEMASK 3
|
|
|
|
EXTERN t_class *class_new(t_symbol *name, t_newmethod newmethod,
|
|
t_method freemethod, size_t size, int flags, t_atomtype arg1, ...);
|
|
|
|
EXTERN t_class *class_new64(t_symbol *name, t_newmethod newmethod,
|
|
t_method freemethod, size_t size, int flags, t_atomtype arg1, ...);
|
|
|
|
EXTERN void class_free(t_class *c);
|
|
|
|
#ifdef PDINSTANCE
|
|
EXTERN t_class *class_getfirst(void);
|
|
#endif
|
|
|
|
EXTERN void class_addcreator(t_newmethod newmethod, t_symbol *s,
|
|
t_atomtype type1, ...);
|
|
EXTERN void class_addmethod(t_class *c, t_method fn, t_symbol *sel,
|
|
t_atomtype arg1, ...);
|
|
EXTERN void class_addbang(t_class *c, t_method fn);
|
|
EXTERN void class_addpointer(t_class *c, t_method fn);
|
|
EXTERN void class_doaddfloat(t_class *c, t_method fn);
|
|
EXTERN void class_addsymbol(t_class *c, t_method fn);
|
|
EXTERN void class_addlist(t_class *c, t_method fn);
|
|
EXTERN void class_addanything(t_class *c, t_method fn);
|
|
EXTERN void class_sethelpsymbol(t_class *c, t_symbol *s);
|
|
EXTERN void class_setwidget(t_class *c, const t_widgetbehavior *w);
|
|
EXTERN void class_setparentwidget(t_class *c, const t_parentwidgetbehavior *w);
|
|
EXTERN const char *class_getname(const t_class *c);
|
|
EXTERN const char *class_gethelpname(const t_class *c);
|
|
EXTERN const char *class_gethelpdir(const t_class *c);
|
|
EXTERN void class_setdrawcommand(t_class *c);
|
|
EXTERN int class_isdrawcommand(const t_class *c);
|
|
EXTERN void class_domainsignalin(t_class *c, int onset);
|
|
EXTERN void class_set_extern_dir(t_symbol *s);
|
|
#define CLASS_MAINSIGNALIN(c, type, field) \
|
|
class_domainsignalin(c, (char *)(&((type *)0)->field) - (char *)0)
|
|
|
|
/* prototype for functions to save Pd's to a binbuf */
|
|
typedef void (*t_savefn)(t_gobj *x, t_binbuf *b);
|
|
EXTERN void class_setsavefn(t_class *c, t_savefn f);
|
|
EXTERN t_savefn class_getsavefn(const t_class *c);
|
|
EXTERN void obj_saveformat(const t_object *x, t_binbuf *bb); /* add format to bb */
|
|
|
|
/* prototype for functions to open properties dialogs */
|
|
typedef void (*t_propertiesfn)(t_gobj *x, struct _glist *glist);
|
|
EXTERN void class_setpropertiesfn(t_class *c, t_propertiesfn f);
|
|
EXTERN t_propertiesfn class_getpropertiesfn(const t_class *c);
|
|
|
|
typedef void (*t_classfreefn)(t_class *);
|
|
EXTERN void class_setfreefn(t_class *c, t_classfreefn fn);
|
|
|
|
#ifndef PD_CLASS_DEF
|
|
#define class_addbang(x, y) class_addbang((x), (t_method)(y))
|
|
#define class_addpointer(x, y) class_addpointer((x), (t_method)(y))
|
|
#define class_addfloat(x, y) class_doaddfloat((x), (t_method)(y))
|
|
#define class_addsymbol(x, y) class_addsymbol((x), (t_method)(y))
|
|
#define class_addlist(x, y) class_addlist((x), (t_method)(y))
|
|
#define class_addanything(x, y) class_addanything((x), (t_method)(y))
|
|
#endif
|
|
|
|
#if PD_FLOATSIZE == 64
|
|
# define class_new class_new64
|
|
#endif
|
|
|
|
/* ------------ printing --------------------------------- */
|
|
EXTERN void post(const char *fmt, ...);
|
|
EXTERN void startpost(const char *fmt, ...);
|
|
EXTERN void poststring(const char *s);
|
|
EXTERN void postfloat(t_floatarg f);
|
|
EXTERN void postatom(int argc, const t_atom *argv);
|
|
EXTERN void endpost(void);
|
|
EXTERN void error(const char *fmt, ...) ATTRIBUTE_FORMAT_PRINTF(1, 2);
|
|
EXTERN void verbose(int level, const char *fmt, ...) ATTRIBUTE_FORMAT_PRINTF(2, 3);
|
|
EXTERN void bug(const char *fmt, ...) ATTRIBUTE_FORMAT_PRINTF(1, 2);
|
|
EXTERN void pd_error(const void *object, const char *fmt, ...) ATTRIBUTE_FORMAT_PRINTF(2, 3);
|
|
EXTERN void logpost(const void *object, const int level, const char *fmt, ...)
|
|
ATTRIBUTE_FORMAT_PRINTF(3, 4);
|
|
|
|
/* ------------ system interface routines ------------------- */
|
|
EXTERN int sys_isabsolutepath(const char *dir);
|
|
EXTERN void sys_bashfilename(const char *from, char *to);
|
|
EXTERN void sys_unbashfilename(const char *from, char *to);
|
|
EXTERN int open_via_path(const char *dir, const char *name, const char *ext,
|
|
char *dirresult, char **nameresult, unsigned int size, int bin);
|
|
EXTERN int sched_geteventno(void);
|
|
EXTERN double sys_getrealtime(void);
|
|
EXTERN int (*sys_idlehook)(void); /* hook to add idle time computation */
|
|
|
|
/* Win32's open()/fopen() do not handle UTF-8 filenames so we need
|
|
* these internal versions that handle UTF-8 filenames the same across
|
|
* all platforms. They are recommended for use in external
|
|
* objectclasses as well so they work with Unicode filenames on Windows */
|
|
EXTERN int sys_open(const char *path, int oflag, ...);
|
|
EXTERN int sys_close(int fd);
|
|
EXTERN FILE *sys_fopen(const char *filename, const char *mode);
|
|
EXTERN int sys_fclose(FILE *stream);
|
|
|
|
/* ------------ threading ------------------- */
|
|
EXTERN void sys_lock(void);
|
|
EXTERN void sys_unlock(void);
|
|
EXTERN int sys_trylock(void);
|
|
|
|
|
|
/* --------------- signals ----------------------------------- */
|
|
|
|
typedef PD_FLOATTYPE t_sample;
|
|
typedef union _sampleint_union {
|
|
t_sample f;
|
|
PD_FLOATUINTTYPE i;
|
|
} t_sampleint_union;
|
|
#define MAXLOGSIG 32
|
|
#define MAXSIGSIZE (1 << MAXLOGSIG)
|
|
|
|
typedef struct _signal
|
|
{
|
|
int s_n; /* number of points in the array */
|
|
t_sample *s_vec; /* the array */
|
|
t_float s_sr; /* sample rate */
|
|
int s_refcount; /* number of times used */
|
|
int s_isborrowed; /* whether we're going to borrow our array */
|
|
struct _signal *s_borrowedfrom; /* signal to borrow it from */
|
|
struct _signal *s_nextfree; /* next in freelist */
|
|
struct _signal *s_nextused; /* next in used list */
|
|
int s_vecsize; /* allocated size of array in points */
|
|
} t_signal;
|
|
|
|
typedef t_int *(*t_perfroutine)(t_int *args);
|
|
|
|
EXTERN t_int *plus_perform(t_int *args);
|
|
EXTERN t_int *zero_perform(t_int *args);
|
|
EXTERN t_int *copy_perform(t_int *args);
|
|
|
|
EXTERN void dsp_add_plus(t_sample *in1, t_sample *in2, t_sample *out, int n);
|
|
EXTERN void dsp_add_copy(t_sample *in, t_sample *out, int n);
|
|
EXTERN void dsp_add_scalarcopy(t_float *in, t_sample *out, int n);
|
|
EXTERN void dsp_add_zero(t_sample *out, int n);
|
|
|
|
EXTERN int sys_getblksize(void);
|
|
EXTERN t_float sys_getsr(void);
|
|
EXTERN int sys_get_inchannels(void);
|
|
EXTERN int sys_get_outchannels(void);
|
|
|
|
EXTERN void dsp_add(t_perfroutine f, int n, ...);
|
|
EXTERN void dsp_addv(t_perfroutine f, int n, t_int *vec);
|
|
EXTERN void pd_fft(t_float *buf, int npoints, int inverse);
|
|
EXTERN int ilog2(int n);
|
|
|
|
EXTERN void mayer_fht(t_sample *fz, int n);
|
|
EXTERN void mayer_fft(int n, t_sample *real, t_sample *imag);
|
|
EXTERN void mayer_ifft(int n, t_sample *real, t_sample *imag);
|
|
EXTERN void mayer_realfft(int n, t_sample *real);
|
|
EXTERN void mayer_realifft(int n, t_sample *real);
|
|
|
|
EXTERN float *cos_table;
|
|
#define LOGCOSTABSIZE 9
|
|
#define COSTABSIZE (1<<LOGCOSTABSIZE)
|
|
|
|
EXTERN int canvas_suspend_dsp(void);
|
|
EXTERN void canvas_resume_dsp(int oldstate);
|
|
EXTERN void canvas_update_dsp(void);
|
|
EXTERN int canvas_dspstate;
|
|
|
|
/* up/downsampling */
|
|
typedef struct _resample
|
|
{
|
|
int method; /* up/downsampling method ID */
|
|
|
|
int downsample; /* downsampling factor */
|
|
int upsample; /* upsampling factor */
|
|
|
|
t_sample *s_vec; /* here we hold the resampled data */
|
|
int s_n;
|
|
|
|
t_sample *coeffs; /* coefficients for filtering... */
|
|
int coefsize;
|
|
|
|
t_sample *buffer; /* buffer for filtering */
|
|
int bufsize;
|
|
} t_resample;
|
|
|
|
EXTERN void resample_init(t_resample *x);
|
|
EXTERN void resample_free(t_resample *x);
|
|
|
|
EXTERN void resample_dsp(t_resample *x, t_sample *in, int insize, t_sample *out, int outsize, int method);
|
|
EXTERN void resamplefrom_dsp(t_resample *x, t_sample *in, int insize, int outsize, int method);
|
|
EXTERN void resampleto_dsp(t_resample *x, t_sample *out, int insize, int outsize, int method);
|
|
|
|
/* ----------------------- utility functions for signals -------------- */
|
|
EXTERN t_float mtof(t_float);
|
|
EXTERN t_float ftom(t_float);
|
|
EXTERN t_float rmstodb(t_float);
|
|
EXTERN t_float powtodb(t_float);
|
|
EXTERN t_float dbtorms(t_float);
|
|
EXTERN t_float dbtopow(t_float);
|
|
|
|
EXTERN t_float q8_sqrt(t_float);
|
|
EXTERN t_float q8_rsqrt(t_float);
|
|
#ifndef N32
|
|
EXTERN t_float qsqrt(t_float); /* old names kept for extern compatibility */
|
|
EXTERN t_float qrsqrt(t_float);
|
|
#endif
|
|
|
|
/* --------------------- data --------------------------------- */
|
|
|
|
/* graphical arrays */
|
|
EXTERN_STRUCT _garray;
|
|
#define t_garray struct _garray
|
|
|
|
EXTERN t_class *garray_class;
|
|
EXTERN int garray_getfloatarray(t_garray *x, int *size, t_float **vec);
|
|
EXTERN int garray_getfloatwords(t_garray *x, int *size, t_word **vec);
|
|
EXTERN void garray_redraw(t_garray *x);
|
|
EXTERN int garray_npoints(t_garray *x);
|
|
EXTERN char *garray_vec(t_garray *x);
|
|
EXTERN void garray_resize(t_garray *x, t_floatarg f); /* avoid; use this: */
|
|
EXTERN void garray_resize_long(t_garray *x, long n); /* better version */
|
|
EXTERN void garray_usedindsp(t_garray *x);
|
|
EXTERN void garray_setsaveit(t_garray *x, int saveit);
|
|
EXTERN t_glist *garray_getglist(t_garray *x);
|
|
EXTERN t_array *garray_getarray(t_garray *x);
|
|
EXTERN t_class *scalar_class;
|
|
|
|
EXTERN t_float *value_get(t_symbol *s);
|
|
EXTERN void value_release(t_symbol *s);
|
|
EXTERN int value_getfloat(t_symbol *s, t_float *f);
|
|
EXTERN int value_setfloat(t_symbol *s, t_float f);
|
|
|
|
/* ------- GUI interface - functions to send strings to TK --------- */
|
|
typedef void (*t_guicallbackfn)(t_gobj *client, t_glist *glist);
|
|
|
|
EXTERN void sys_vgui(const char *fmt, ...);
|
|
EXTERN void sys_gui(const char *s);
|
|
EXTERN void sys_pretendguibytes(int n);
|
|
EXTERN void sys_queuegui(void *client, t_glist *glist, t_guicallbackfn f);
|
|
EXTERN void sys_unqueuegui(void *client);
|
|
/* dialog window creation and destruction */
|
|
EXTERN void gfxstub_new(t_pd *owner, void *key, const char *cmd);
|
|
EXTERN void gfxstub_deleteforkey(void *key);
|
|
|
|
extern t_class *glob_pdobject; /* object to send "pd" messages */
|
|
|
|
/*------------- Max 0.26 compatibility --------------------*/
|
|
|
|
/* the following reflects the new way classes are laid out, with the class
|
|
pointing to the messlist and not vice versa. Externs shouldn't feel it. */
|
|
typedef t_class *t_externclass;
|
|
|
|
EXTERN void c_extern(t_externclass *cls, t_newmethod newroutine,
|
|
t_method freeroutine, t_symbol *name, size_t size, int tiny, \
|
|
t_atomtype arg1, ...);
|
|
EXTERN void c_addmess(t_method fn, t_symbol *sel, t_atomtype arg1, ...);
|
|
|
|
#define t_getbytes getbytes
|
|
#define t_freebytes freebytes
|
|
#define t_resizebytes resizebytes
|
|
#define typedmess pd_typedmess
|
|
#define vmess pd_vmess
|
|
|
|
/* A definition to help gui objects straddle 0.34-0.35 changes. If this is
|
|
defined, there is a "te_xpix" field in objects, not a "te_xpos" as before: */
|
|
|
|
#define PD_USE_TE_XPIX
|
|
|
|
#ifndef _MSC_VER /* Microoft compiler can't handle "inline" function/macros */
|
|
#if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
|
|
/* a test for NANs and denormals. Should only be necessary on i386. */
|
|
#if PD_FLOATSIZE == 32
|
|
|
|
typedef union
|
|
{
|
|
t_float f;
|
|
unsigned int ui;
|
|
}t_bigorsmall32;
|
|
|
|
static inline int PD_BADFLOAT(t_float f) /* malformed float */
|
|
{
|
|
t_bigorsmall32 pun;
|
|
pun.f = f;
|
|
pun.ui &= 0x7f800000;
|
|
return((pun.ui == 0) | (pun.ui == 0x7f800000));
|
|
}
|
|
|
|
static inline int PD_BIGORSMALL(t_float f) /* exponent outside (-64,64) */
|
|
{
|
|
t_bigorsmall32 pun;
|
|
pun.f = f;
|
|
return((pun.ui & 0x20000000) == ((pun.ui >> 1) & 0x20000000));
|
|
}
|
|
|
|
#elif PD_FLOATSIZE == 64
|
|
|
|
typedef union
|
|
{
|
|
t_float f;
|
|
unsigned int ui[2];
|
|
}t_bigorsmall64;
|
|
|
|
static inline int PD_BADFLOAT(t_float f) /* malformed double */
|
|
{
|
|
t_bigorsmall64 pun;
|
|
pun.f = f;
|
|
pun.ui[1] &= 0x7ff00000;
|
|
return((pun.ui[1] == 0) | (pun.ui[1] == 0x7ff00000));
|
|
}
|
|
|
|
static inline int PD_BIGORSMALL(t_float f) /* exponent outside (-512,512) */
|
|
{
|
|
t_bigorsmall64 pun;
|
|
pun.f = f;
|
|
return((pun.ui[1] & 0x20000000) == ((pun.ui[1] >> 1) & 0x20000000));
|
|
}
|
|
|
|
#endif /* PD_FLOATSIZE */
|
|
#else /* not INTEL or ARM */
|
|
#define PD_BADFLOAT(f) 0
|
|
#define PD_BIGORSMALL(f) 0
|
|
#endif
|
|
|
|
#else /* _MSC_VER */
|
|
#if PD_FLOATSIZE == 32
|
|
#define PD_BADFLOAT(f) ((((*(unsigned int*)&(f))&0x7f800000)==0) || \
|
|
(((*(unsigned int*)&(f))&0x7f800000)==0x7f800000))
|
|
/* more stringent test: anything not between 1e-19 and 1e19 in absolute val */
|
|
#define PD_BIGORSMALL(f) ((((*(unsigned int*)&(f))&0x60000000)==0) || \
|
|
(((*(unsigned int*)&(f))&0x60000000)==0x60000000))
|
|
#else /* 64 bits... don't know what to do here */
|
|
#define PD_BADFLOAT(f) (!(((f) >= 0) || ((f) <= 0)))
|
|
#define PD_BIGORSMALL(f) ((f) > 1e150 || (f) < -1e150 \
|
|
|| (f) > -1e-150 && (f) < 1e-150 )
|
|
#endif
|
|
#endif /* _MSC_VER */
|
|
/* get version number at run time */
|
|
EXTERN void sys_getversion(int *major, int *minor, int *bugfix);
|
|
|
|
EXTERN_STRUCT _instancemidi;
|
|
#define t_instancemidi struct _instancemidi
|
|
|
|
EXTERN_STRUCT _instanceinter;
|
|
#define t_instanceinter struct _instanceinter
|
|
|
|
EXTERN_STRUCT _instancecanvas;
|
|
#define t_instancecanvas struct _instancecanvas
|
|
|
|
EXTERN_STRUCT _instanceugen;
|
|
#define t_instanceugen struct _instanceugen
|
|
|
|
EXTERN_STRUCT _instancestuff;
|
|
#define t_instancestuff struct _instancestuff
|
|
|
|
#ifndef PDTHREADS
|
|
#define PDTHREADS 1
|
|
#endif
|
|
|
|
struct _pdinstance
|
|
{
|
|
double pd_systime; /* global time in Pd ticks */
|
|
t_clock *pd_clock_setlist; /* list of set clocks */
|
|
t_canvas *pd_canvaslist; /* list of all root canvases */
|
|
struct _template *pd_templatelist; /* list of all templates */
|
|
int pd_instanceno; /* ordinal number of this instance */
|
|
t_symbol **pd_symhash; /* symbol table hash table */
|
|
t_instancemidi *pd_midi; /* private stuff for x_midi.c */
|
|
t_instanceinter *pd_inter; /* private stuff for s_inter.c */
|
|
t_instanceugen *pd_ugen; /* private stuff for d_ugen.c */
|
|
t_instancecanvas *pd_gui; /* semi-private stuff in g_canvas.h */
|
|
t_instancestuff *pd_stuff; /* semi-private stuff in s_stuff.h */
|
|
t_pd *pd_newest; /* most recently created object */
|
|
#ifdef PDINSTANCE
|
|
t_symbol pd_s_pointer;
|
|
t_symbol pd_s_float;
|
|
t_symbol pd_s_symbol;
|
|
t_symbol pd_s_bang;
|
|
t_symbol pd_s_list;
|
|
t_symbol pd_s_anything;
|
|
t_symbol pd_s_signal;
|
|
t_symbol pd_s__N;
|
|
t_symbol pd_s__X;
|
|
t_symbol pd_s_x;
|
|
t_symbol pd_s_y;
|
|
t_symbol pd_s_;
|
|
#endif
|
|
#if PDTHREADS
|
|
int pd_islocked;
|
|
#endif
|
|
};
|
|
#define t_pdinstance struct _pdinstance
|
|
EXTERN t_pdinstance pd_maininstance;
|
|
|
|
/* m_pd.c */
|
|
#ifdef PDINSTANCE
|
|
EXTERN t_pdinstance *pdinstance_new(void);
|
|
EXTERN void pd_setinstance(t_pdinstance *x);
|
|
EXTERN void pdinstance_free(t_pdinstance *x);
|
|
#endif /* PDINSTANCE */
|
|
|
|
#if defined(PDTHREADS) && defined(PDINSTANCE)
|
|
#ifdef _MSC_VER
|
|
#define PERTHREAD __declspec(thread)
|
|
#else
|
|
#define PERTHREAD __thread
|
|
#endif /* _MSC_VER */
|
|
#else
|
|
#define PERTHREAD
|
|
#endif
|
|
|
|
#ifdef PDINSTANCE
|
|
extern PERTHREAD t_pdinstance *pd_this;
|
|
EXTERN t_pdinstance **pd_instances;
|
|
EXTERN int pd_ninstances;
|
|
#else
|
|
#define pd_this (&pd_maininstance)
|
|
#endif /* PDINSTANCE */
|
|
|
|
#ifdef PDINSTANCE
|
|
#define s_pointer (pd_this->pd_s_pointer)
|
|
#define s_float (pd_this->pd_s_float)
|
|
#define s_symbol (pd_this->pd_s_symbol)
|
|
#define s_bang (pd_this->pd_s_bang)
|
|
#define s_list (pd_this->pd_s_list)
|
|
#define s_anything (pd_this->pd_s_anything)
|
|
#define s_signal (pd_this->pd_s_signal)
|
|
#define s__N (pd_this->pd_s__N)
|
|
#define s__X (pd_this->pd_s__X)
|
|
#define s_x (pd_this->pd_s_x)
|
|
#define s_y (pd_this->pd_s_y)
|
|
#define s_ (pd_this->pd_s_)
|
|
#else
|
|
EXTERN t_symbol s_pointer, s_float, s_symbol, s_bang, s_list, s_anything,
|
|
s_signal, s__N, s__X, s_x, s_y, s_;
|
|
#endif
|
|
|
|
EXTERN t_canvas *pd_getcanvaslist(void);
|
|
EXTERN int pd_getdspstate(void);
|
|
|
|
/* x_text.c */
|
|
EXTERN t_binbuf *text_getbufbyname(t_symbol *s); /* get binbuf from text obj */
|
|
EXTERN void text_notifybyname(t_symbol *s); /* notify it was modified */
|
|
|
|
#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#define __m_pd_h_
|
|
#endif /* __m_pd_h_ */
|