struct FFC2PContext *c2p;
struct FFC2PRequest  req;

c2p = CreateFFC2P(
    FFC2PT_BitMap,        playfield,
    FFC2PT_AssumeAligned, TRUE,           /* full-frame blits */
    TAG_DONE);

req.cr_Chunky   = buf->fb_Data;           /* FFBM_FAST decode buffer */
req.cr_StartX   = 0;
req.cr_StartY   = 0;
req.cr_Width    = width;
req.cr_Height   = height;
req.cr_SrcModulo = width;                 /* tight rows; omit when
                                             cr_Width == stride */
req.cr_Flags    = FFC2PF_NO_TRAILING_RMW; /* full-width overwrite */
RenderFFC2P(c2p, &req);

struct FFString {
    STRPTR  fs_Data;
    ULONG   fs_Length;     /* used bytes, not counting any trailing NUL */
    ULONG   fs_Capacity;   /* allocated bytes; 0 == borrowed view       */
    UWORD   fs_Encoding;   /* FFSE_LATIN1 / FFSE_UTF8 / FFSE_LOCAL / ...*/
    UWORD   fs_Flags;      /* FFSF_OWNED / FFSF_NUL_TERMINATED /        */
                           /* FFSF_READONLY / FFSF_TRUNCATED            */
};

struct FFData {
    APTR    fd_Data;
    ULONG   fd_Length;
    ULONG   fd_Capacity;
    ULONG   fd_Flags;
};

struct FFString title;
FFBorrowCString(&title, "Song Title", FFSE_LATIN1);
/* title now points at the literal; FFDisposeStringAlloc is a no-op */

struct FFString *name = FFNewStringAlloc(64, FFSE_LATIN1);
FFCopyIntoString(name, src_bytes, src_length);
if (name->fs_Flags & FFSF_TRUNCATED) {
    /* tag came in longer than 63 bytes - we still have a valid
       NUL-terminated prefix in name->fs_Data and the truncation
       was deliberate */
}
FFDisposeStringAlloc(name);

CPU=68000
STRUCTUREEQUIVALENCE
STRINGMERGE
NOSTACKCHECK
OPTIMIZE
OPTGLOBAL
OPTTIME
OPTPEEP
OPTSCHED
NOICONS
IGNORE=315
IGNORE=316
INCLUDEDIR=/include
MATH=STANDARD
UTILLIB
NOCHECKABORT
DATA=FARONLY

#include <exec/types.h>
#include <exec/memory.h>
#include <proto/exec.h>

#include <libraries/ffplugin.h>
#include <libraries/fastforward.h>
#include <fastforward/ff_string.h>

/*
 * UTILLIB pragmas reference _UtilityBase. Declare and refcount it so
 * the first Open() lazy-opens utility.library and the last Close()
 * releases it. Without this, slink complains _UtilityBase is unresolved.
 */
struct Library *UtilityBase = NULL;
static UWORD MyPluginUtilityRefCount = 0;

struct MyCodecPriv {
    UBYTE                myc_HaveFormat;
    UBYTE                myc_Pad[3];
    struct FFVideoFormat myc_In;
    /* ... per-instance state, including any decoder context ... */
};

static CONST_STRPTR MyCodecTypes[] = { "MYCC", NULL };

const UBYTE version[] = "$VER: mycodec.codec 0.1 (FastForward)";

static LONG FF_PLUGIN_ENTRY
MyProbe(struct FFHost *host, struct FFProbe *probe);

static struct FFInstance * FF_PLUGIN_ENTRY
MyOpen(struct FFHost *host);

static LONG FF_PLUGIN_ENTRY
MyConfigure(struct FFInstance *inst, struct TagItem *tags);

static LONG FF_PLUGIN_ENTRY
MyPush(struct FFInstance *inst, struct FFBuffer *buf);

static LONG FF_PLUGIN_ENTRY
MyPull(struct FFInstance *inst, struct FFBuffer *buf);

static void FF_PLUGIN_ENTRY
MyClose(struct FFInstance *inst);

struct FFPlugin MyCodecPlugin = {
    NULL,                /* p_Next - engine fills in */
    FFPLUGIN_VERSION,
    FFENGINE_VERSION,
    0,                   /* p_Reserved */
    1,                   /* p_API */
    0x4001,              /* p_Identifier - allocate per-plugin */
    FFK_CODEC,
    FFC_VIDEO | FFC_REENTRANT,
    "My codec description",
    MyCodecTypes,
    MyProbe,
    MyOpen,
    MyConfigure,
    MyPush,
    MyPull,
    MyClose,
    NULL, NULL, NULL, NULL
};

static struct FFInstance * FF_PLUGIN_ENTRY
MyOpen(struct FFHost *host)
{
    struct FFInstance *in;
    struct MyCodecPriv *priv;

    if (host == NULL) {
        return NULL;
    }

    /* Lazy-open utility.library before any 32-bit divmul runs. */
    if (MyPluginUtilityRefCount == 0) {
        UtilityBase = (struct Library *)host->fh_OpenLibrary(
            (CONST_STRPTR)"utility.library", 37);
        if (UtilityBase == NULL) {
            return NULL;
        }
    }

    priv = (struct MyCodecPriv *)host->fh_Alloc(
        sizeof(struct MyCodecPriv), MEMF_CLEAR | MEMF_ANY);
    if (priv == NULL) {
        if (MyPluginUtilityRefCount == 0 && UtilityBase != NULL) {
            host->fh_CloseLibrary((APTR)UtilityBase);
            UtilityBase = NULL;
        }
        return NULL;
    }

    in = (struct FFInstance *)host->fh_Alloc(
        sizeof(struct FFInstance), MEMF_CLEAR | MEMF_ANY);
    if (in == NULL) {
        host->fh_Free(priv, sizeof(struct MyCodecPriv));
        if (MyPluginUtilityRefCount == 0 && UtilityBase != NULL) {
            host->fh_CloseLibrary((APTR)UtilityBase);
            UtilityBase = NULL;
        }
        return NULL;
    }

    in->fi_Host    = host;
    in->fi_Plugin  = &MyCodecPlugin;
    in->fi_Private = priv;
    MyPluginUtilityRefCount++;
    return in;
}

struct FFString *msg;

msg = FFNewStringAlloc(256, FFENC_ASCII);
if (msg == NULL) {
    return -1;
}
FFCopyIntoString(msg, "Hello", 5);   /* never overruns */
/* ... use msg->fs_Data, msg->fs_Length ... */
FFDisposeStringAlloc(msg);

struct FileInfoBlock *fib;
ULONG filesize = 0;

fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL);
if (fib != NULL) {
    if (ExamineFH(fh, fib)) {
        filesize = (ULONG)fib->fib_Size;
    }
    FreeDosObject(DOS_FIB, fib);
}

Seek(fh, 0, OFFSET_END);
seekrc = Seek(fh, 0, OFFSET_BEGINNING);
if (seekrc >= 0) {
    filesize = (ULONG)seekrc;
}

n = Read(fh, buf, (LONG)want);
if (n < 0 || (ULONG)n != want) {
    /* error or short read - bail */
}

priv->vs_Window  = (struct Window *)GetTagData(FFMT_Window,  0UL, tags);
priv->vs_RPort   = (struct RastPort *)GetTagData(FFMT_RastPort, 0UL, tags);
priv->vs_BitMap  = (struct BitMap *)GetTagData(FFMT_BitMap,  0UL, tags);

/* Don't (field-of-struct <- struct): */
buf->fb_Video = priv->myc_In;

/* Don't (array-element <- local struct - the cdxl.demux miss): */
priv->frames[count] = rec;

/* Don't (struct return from function being captured): */
priv->cc_In = MyMakeFormat();

/* Do (works for all three): */
CopyMem((APTR)&priv->myc_In, (APTR)&buf->fb_Video,
    sizeof(struct FFVideoFormat));
CopyMem((APTR)&rec, (APTR)&priv->frames[count],
    sizeof(struct MyFrameRec));

setup->cs_CodecFourCC = 0;
setup->cs_CodecTag = 0;
setup->cs_BlockAlign = 0;
setup->cs_ExtraData = NULL;
setup->cs_ExtraDataLen = 0;
setup->cs_Flags = 0;

static CONST_STRPTR MsAdpcmCodecTypes[] = { "0x57410002", NULL };

struct Library *UtilityBase = NULL;
static UWORD MyPluginUtilityRefCount = 0;

/* In Open(): */
if (MyPluginUtilityRefCount == 0) {
    UtilityBase = (struct Library *)host->fh_OpenLibrary(
        (CONST_STRPTR)"utility.library", 37);
    if (UtilityBase == NULL) {
        return NULL;
    }
}
/* ...AllocMem priv / inst... */
MyPluginUtilityRefCount++;

/* In Close(): */
if (host != NULL && MyPluginUtilityRefCount > 0) {
    MyPluginUtilityRefCount--;
    if (MyPluginUtilityRefCount == 0 && UtilityBase != NULL) {
        host->fh_CloseLibrary((APTR)UtilityBase);
        UtilityBase = NULL;
    }
}

#include <proto/exec.h>      /* AllocMem, FreeMem, CopyMem, ...    */
#include <proto/dos.h>       /* Open, Read, Seek, Close, FPrintf   */
#include <proto/utility.h>   /* GetTagData, FindTagItem, CallHook  */
#include <proto/intuition.h> /* OpenScreen, OpenWindow, ...        */
#include <proto/graphics.h>  /* BltBitMap, InitBitMap, ...         */

/* Match a single fixed 4-byte extension without utility.library.    */
static LONG
PathHasFooExt(CONST_STRPTR path)
{
    CONST_STRPTR p;
    CONST_STRPTR dot;
    UBYTE c0;
    UBYTE c1;
    UBYTE c2;

    if (path == NULL) {
        return 0;
    }
    dot = NULL;
    p = path;
    while (*p != '\0') {
        if (*p == '.') {
            dot = p;
        } else if (*p == '/' || *p == ':') {
            dot = NULL;
        }
        p++;
    }
    if (dot == NULL || dot[1] == 0 || dot[2] == 0 ||
        dot[3] == 0 || dot[4] != 0) {
        return 0;
    }
    c0 = (UBYTE)dot[1];
    c1 = (UBYTE)dot[2];
    c2 = (UBYTE)dot[3];
    if (c0 >= 'A' && c0 <= 'Z') c0 = (UBYTE)(c0 + 32);
    if (c1 >= 'A' && c1 <= 'Z') c1 = (UBYTE)(c1 + 32);
    if (c2 >= 'A' && c2 <= 'Z') c2 = (UBYTE)(c2 + 32);
    return (c0 == 'f' && c1 == 'o' && c2 == 'o') ? 1 : 0;
}

#include <proto/dos.h>

struct DosLibrary *DOSBase = NULL;   /* file scope */

/* In Open(), first thing after the host NULL-check: */
if (DOSBase == NULL) {
    DOSBase = (struct DosLibrary *)host->fh_DOSBase;
}

#include <proto/mathieeedoubbas.h>
#include <proto/mathieeedoubtrans.h>

#define exp(x)   IEEEDPExp((double)(x))
#define log10(x) IEEEDPLog10((double)(x))
#include "decode288.c"     /* vendored core that calls exp()/log10() */
#undef log10
#undef exp

struct MathIEEEBase *MathIeeeDoubBasBase = NULL;
struct MathIEEEBase *MathIeeeDoubTransBase = NULL;

/* In Open(), gated on the same refcount as UtilityBase: */
MathIeeeDoubBasBase = (struct MathIEEEBase *)host->fh_OpenLibrary(
    (CONST_STRPTR)"mathieeedoubbas.library", 37);
MathIeeeDoubTransBase = (struct MathIEEEBase *)host->fh_OpenLibrary(
    (CONST_STRPTR)"mathieeedoubtrans.library", 37);
/* ...NULL-check, close-on-failure, CloseLibrary on last Close()... */

DEFINE @__XCEXIT=@__dummy DEFINE @__chkabort=@__dummy

#ifdef __SASC
int  _XCEXIT(void)              { return 0; }   /* never called */
void __regargs __chkabort(void) { }
void __regargs _CXBRK(void)     { }
#endif

/* CRASHES on odd addresses on 68000/68010: */
flag = *(ULONG *)from;

#define get32(p) \
    (((ULONG)(p)[0] << 24) | \
     ((ULONG)(p)[1] << 16) | \
     ((ULONG)(p)[2] <<  8) | \
      (ULONG)(p)[3])

void (*fh_LogLock)(struct FFHost *host);
void (*fh_LogUnlock)(struct FFHost *host);

/* single-line message */
if (host != NULL && host->fh_LogLock != NULL) {
    host->fh_LogLock(host);
}
FPrintf((BPTR)host->fh_LogOutput, "DEBUG mycodec: pkt=%lx\n", pkt);
Flush((BPTR)host->fh_LogOutput);
if (host != NULL && host->fh_LogUnlock != NULL) {
    host->fh_LogUnlock(host);
}

/* multi-line atomic burst */
host->fh_LogLock(host);
FPrintf(out, "DEBUG mycodec: header\n"); Flush(out);
FPrintf(out, "DEBUG mycodec: body line %ld\n", n); Flush(out);
host->fh_LogUnlock(host);

LONG  doneSig;
ULONG doneMask;
struct Task *parent;

doneSig = AllocSignal(-1);
if (doneSig < 0) {
    return /* fallback */;
}
doneMask = 1UL << (ULONG)doneSig;
parent   = FindTask(NULL);
/* ... pass parent + doneMask to child via tc_UserData or your ctx ... */
/* ... start child ... */
/* parent waits: */
Wait(doneMask);
FreeSignal(doneSig);

if (atomsize < 8 || atomsize > limit - current_pos) {
    break;
}
current_pos += atomsize;

ctx = host->fh_C2PCreate(host, ctags);
host->fh_C2PRender(host, ctx, &req);
host->fh_C2PDispose(host, ctx);

now = host->fh_GetTime(inst->fi_Clock);
deadline = buf->fb_Timestamp + priv->vs_FramePeriod;
if (now > deadline) {
    host->fh_BumpDropped(host, 1);
    return 0;          /* drop, don't render */
}

static LONG FF_PLUGIN_ENTRY
MyPush(struct FFInstance *inst, struct FFBuffer *buf)
{
    if (inst == NULL || inst->fi_Private == NULL || buf == NULL) {
        return -1;
    }
    if ((buf->fb_Flags & FFBF_EOF) != 0) {
        /* flush remaining state and propagate the EOF tag */
        return 0;
    }
    /* ... normal decode path ... */
}

if (debug && host->fh_LogOutput != 0) {
    /* ... lock the log (section 4.6) ... */
    FPrintf((BPTR)host->fh_LogOutput,
        "DEBUG mycodec: Push w=%lu h=%lu sz=%lu\n",
        (ULONG)w, (ULONG)h, buf->fb_Size);
    Flush((BPTR)host->fh_LogOutput);
    /* ... unlock the log ... */
}

ptr = host->fh_Alloc(size, MEMF_CLEAR | MEMF_ANY);
host->fh_Free(ptr, size);                /* same size you allocated */

ptr = AllocMem(size, MEMF_CLEAR | MEMF_ANY);   /* same size on free */
FreeMem(ptr, size);

vec = AllocVec(size, flags);
FreeVec(vec);

fh = Open(path, MODE_OLDFILE);  /* 0 on failure, IoErr() has reason */
n  = Read(fh, buf, len);        /* >0 ok, 0 EOF, -1 error */
n  = Seek(fh, pos, mode);       /* returns previous position */
Close(fh);

fib = AllocDosObject(DOS_FIB, NULL);
ok  = ExamineFH(fh, fib);       /* fib->fib_Size after */
FreeDosObject(DOS_FIB, fib);

sig  = AllocSignal(-1);              /* -1 = any, returns -1 on fail */
mask = 1UL << (ULONG)sig;
self = FindTask(NULL);
Signal(target, mask);                /* from any context */
got  = Wait(mask);                   /* blocks current task */
FreeSignal(sig);                     /* -1 harmless in V37+ */

CopyMem(src, dst, n);                /* src, dst, size (A0/A1/D0) */
FFCopyBytes(src, dst, n);            /* NULL-guarded wrapper */
FFFillBytes(dst, n, value);          /* byte fill */
/* Use MEMF_CLEAR instead of zero-filling after AllocMem. */

len    = FFStrLen(s);
isEq   = FFStrEqual(a, b);
FFStrCopy(dst, src);                 /* dst large enough for src + NUL */
FFStrCopyN(dst, src, dstCap);        /* always NUL-terminates */

s = FFNewStringAlloc(cap, FFENC_ASCII);
FFCopyIntoString(s, src, srclen);
FFDisposeStringAlloc(s);

d = FFNewDataAlloc(cap);
FFCopyIntoData(d, src, srclen);
FFDisposeDataAlloc(d);

base = host->fh_OpenLibrary("foo.library", 37);
host->fh_CloseLibrary((APTR)base);

if (host->fh_LogOutput != 0) {
    /* obtain lock */
    FPrintf((BPTR)host->fh_LogOutput, "DEBUG ...: ...\n");
    Flush((BPTR)host->fh_LogOutput);
    /* release lock */
}