volker böhm

i'm using a typed message to a buffer object to change its size in samples like this:

t_atom aa;
SETLONG(&aa, dstlen);
typedmess((void *)b, gensym("sizeinsamps"), 1, &aa);


right after, i'd like to write some new values to the buffer. 

how do i know, when the resizing is done?

checking "b->b_inuse" doesn't seem to work.

right after, i'd like to write some new values to the buffer. 
how do i know, when the resizing is done?

checking "b->b_inuse" doesn't seem to work.
anyone?


resizing-buffer-notify

If you are accessing a buffer as detailed @ 

http://blog.74objects.com/2009/03/22/accessing-buffers/

 then you should receive a "buffer_modified" message in your notify method when the buffer is resized.

If you are accessing a buffer as detailed @ http://blog.74objects.com/2009/03/22/accessing-buffers/ then you should receive a "buffer_modified" message in your notify method when the buffer is resized.

hi tim, i've already found your article, which is a good read - thanks for that.

i forgot to mention however, that i'm looking for a method that (also) works in max4. for what i'm doing right now, it seems 'defer_low'-ing the calls seems to work (so far - lets see...).

hi tim, i've already found your article, which is a good read - thanks for that.
i forgot to mention however, that i'm looking for a method that (also) works in max4. for what i'm doing right now, it seems 'defer_low'-ing the calls seems to work (so far - lets see...).
vb


Using defer_low() should work for your purposes since you have the multiple versions to support.

In general, it is strongly advisable to avoid introducing that sort of asynchonicity into your call chain. However, it is very difficult to avoid in situations like this in Max 4. We've made things a lot better in this regard in Max 5. Glad you have it working!

In general, it is strongly advisable to avoid introducing that sort of asynchonicity into your call chain.  However, it is very difficult to avoid in situations like this in Max 4.  We've made things a lot better in this regard in Max 5.  Glad you have it working!


i'm updating some old code to work with the new max 5 sdk.

so i'm back to the problem of resizing a buffer before i can go on an write to it... that's why i wanted to try the notify method, that tim outlined in his article 

everything seems to work fine, and i get a notify message whenever the buffer i'm attaching to in my external is changed or resized.

i get a lot of "buffer_modified" messages, when other objects interact with the same buffer (for example if the record~ object records into the buffer). but i'm looking only for a "resize" notification. how can i get that out of the pointers that are passed to my notify method?

and related: in the end i will attach to several buffers in my external. how do i know which buffer was modified?

below is the notify method i'm using right now (pretty much the same as in tim's article).

t_max_err myObj_notify(t_myObj *x, t_symbol *s, t_symbol *msg, void *sender, void *data) {

    post("msg: %s from: %X (%s)", msg->s_name, s->s_name);

    if (msg == ps_globalsymbol_binding)

        x->buf = (t_buffer*)x->bufname->s_thing;

    else if (msg == ps_globalsymbol_unbinding)

    else if (msg == ps_buffer_modified)

hi -
i'm updating some old code to work with the new max 5 sdk.
so i'm back to the problem of resizing a buffer before i can go on an write to it... that's why i wanted to try the notify method, that tim outlined in his article http://blog.74objects.com/2009/03/22/accessing-buffers/ 

everything seems to work fine, and i get a notify message whenever the buffer i'm attaching to in my external is changed or resized.
two questions:
1)
i get a lot of "buffer_modified" messages, when other objects interact with the same buffer (for example if the record~ object records into the buffer). but i'm looking only for a "resize" notification. how can i get that out of the pointers that are passed to my notify method?
2)
and related: in the end i will attach to several buffers in my external. how do i know which buffer was modified?

below is the notify method i'm using right now (pretty much the same as in tim's article).
thanks,
volker.

	post("msg: %s from: %X (%s)", msg->s_name, s->s_name);

	if (msg == ps_globalsymbol_binding)
		x->buf = (t_buffer*)x->bufname->s_thing;
	else if (msg == ps_globalsymbol_unbinding)
		x->buf = NULL;
	else if (msg == ps_buffer_modified)
		x->changed = true;

is the only thing that's you're going to get. It's up to you to look at what changed depending on what interest you.

if (msg == ps_buffer_modified) {
        t_buffer *b = (t_buffer *)data;
        if (b->b_name && b->b_name->s_name)
            post("buffer_modified %s", b->b_name->s_name);
}



#1… you don't… buffer_modifiedis the only thing that's you're going to get. It's up to you to look at what changed depending on what interest you.

#2 the *data is actually a pointer to the t_buffer

if (msg == ps_buffer_modified) {
		t_buffer *b = (t_buffer *)data;
		if (b->b_name && b->b_name->s_name)
			post("buffer_modified %s", b->b_name->s_name);
}



#1 leaves me wondering how others are resizing a buffer~ before writing to it.

the code below seems to be working, but it looks ugly and unsafe...

void myObj_fill(t_myObj *x, long n, double freq) {
    float            *tab;
    long            frames, nchnls, i;
    t_buffer        *b = NULL;
    double            incr;

    b = x->buf;
    if(!b) {
        object_error((t_object *)x,"%s is no valid buffer", x->bufname);
        return ;
    }

    ATOMIC_INCREMENT(&b->b_inuse);
    if (!b->b_valid) {
        ATOMIC_DECREMENT(&b->b_inuse);
        return;
    }

    tab = b->b_samples;
    frames = b->b_frames;
    nchnls = b->b_nchans;

    // n: number of samples we need. check if buffer is long enough
    if(n>frames) {
        post("sorry have to resize first");
        ATOMIC_DECREMENT(&b->b_inuse);
        x->changed = false;
        myObj_resize(x, n);        // resize buffer

        while(!x->changed)
            ;                    // wait until notify method toggles x->changed true
        post("ok, lets go!");

        ATOMIC_INCREMENT(&b->b_inuse);
        if (!b->b_valid) {
            ATOMIC_DECREMENT(&b->b_inuse);
            return;
        }

        tab = b->b_samples;
        frames = b->b_frames;
        nchnls = b->b_nchans;
    }

     if(nb_inuse);
         return;
     }

    ATOMIC_DECREMENT(&b->b_inuse);

    // still have to call this, otherwise 'waveform~' will not redraw ?
    object_method( (t_object *)x->buf, gensym("dirty"));

}



thanks emmanuel!
#2 is exactly what i need.
#1 leaves me wondering how others are resizing a buffer~ before writing to it.

void myObj_fill(t_myObj *x, long n, double freq) {
	float			*tab;
	long			frames, nchnls, i;
	t_buffer		*b = NULL;
	double			incr;

	b = x->buf;
	if(!b) {
		object_error((t_object *)x,"%s is no valid buffer", x->bufname);
		return ;
	}

	ATOMIC_INCREMENT(&b->b_inuse);
	if (!b->b_valid) {
		ATOMIC_DECREMENT(&b->b_inuse);
		return;
	}

	tab = b->b_samples;
	frames = b->b_frames;
	nchnls = b->b_nchans;

	// n: number of samples we need. check if buffer is long enough
	if(n>frames) {
		post("sorry have to resize first");
		ATOMIC_DECREMENT(&b->b_inuse);
		x->changed = false;
		myObj_resize(x, n);		// resize buffer

		while(!x->changed)
			;					// wait until notify method toggles x->changed true
		post("ok, lets go!");

		ATOMIC_INCREMENT(&b->b_inuse);
		if (!b->b_valid) {
			ATOMIC_DECREMENT(&b->b_inuse);
			return;
		}

		tab = b->b_samples;
		frames = b->b_frames;
		nchnls = b->b_nchans;
	}

	 if(nb_inuse);
		 return;
	 }

	ATOMIC_DECREMENT(&b->b_inuse);

	// still have to call this, otherwise 'waveform~' will not redraw ?
	object_method( (t_object *)x->buf, gensym("dirty"));

}



, instead I would just trigger a method in response to the 

I would avoid the while(!x->changed), instead I would just trigger a method in response to the buffer_modified.


ok, that's what i'm doing right now, which seems to work ok, but only if i defer the call to the function, that starts writing to the newly resized buffer (see below). is that correct?

one more thing that makes me curious: in tim's article, when he talks about using ATOMIC_INCREMENT/DECREMENT, he says:

"This is truly threadsafe. And as a bonus you no longer need to call the dirty method on the buffer to tell that it changed."

for me, it doesn't work without calling the dirty method of the underlying buffer (which in return notifies my external with another "buffer_modified" message...).


void myObj_fill(t_myObj *x, long n, double freq) {

    long            frames;
    t_buffer        x->buf;

    x->n = n;
    x->freq = freq;

    ATOMIC_INCREMENT(&b->b_inuse);
    if (!b->b_valid) {
        ATOMIC_DECREMENT(&b->b_inuse);
        return;
    }

    frames = b->b_frames;
    ATOMIC_DECREMENT(&b->b_inuse);

    // n: number of samples we need. check if buffer is long enough
    if(n>frames) {
        post("sorry have to resize first");
        x->resize = true;            // set flag for notify method
        myObj_resize(x, n);        // resize buffer
        return;
    }

    myObj_doFill(x);
}

t_max_err myObj_notify(t_myObj *x, t_symbol *s, t_symbol *msg, void *sender, void *data) {
    if (msg == ps_globalsymbol_binding)
        x->buf = (t_buffer*)x->bufname->s_thing;
    else if (msg == ps_globalsymbol_unbinding)
        x->buf = NULL;
    else if (msg == ps_buffer_modified) {
        if(x->resize) {
            x->resize = false;
            defer_low(x, (method)myObj_doFill, 0,0,0);        // have to defer this call
        }
    }
    return MAX_ERR_NONE;
}

void myObj_doFill(t_myObj *x) {
    float            *tab;
    long            frames, nchnls, i;
    t_buffer        *b = NULL;
    double            incr;
    long            n = x->n;
    double            freq = x->freq;

    b = x->buf;

    // etc....
}


one more thing that makes me curious: in tim's article, when he talks about using ATOMIC_INCREMENT/DECREMENT, he says:
"This is truly threadsafe.  And as a bonus you no longer need to call the dirty method on the buffer to tell that it changed."
does that work for anybody?
for me, it doesn't work without calling the dirty method of the underlying buffer (which in return notifies my external with another "buffer_modified" message...).


void myObj_fill(t_myObj *x, long n, double freq) {

	long			frames;
	t_buffer		x->buf;

	x->n = n;
	x->freq = freq;

	ATOMIC_INCREMENT(&b->b_inuse);
	if (!b->b_valid) {
		ATOMIC_DECREMENT(&b->b_inuse);
		return;
	}

	frames = b->b_frames;
	ATOMIC_DECREMENT(&b->b_inuse);

	// n: number of samples we need. check if buffer is long enough
	if(n>frames) {
		post("sorry have to resize first");
		x->resize = true;			// set flag for notify method
		myObj_resize(x, n);		// resize buffer
		return;
	}

	myObj_doFill(x);
}

t_max_err myObj_notify(t_myObj *x, t_symbol *s, t_symbol *msg, void *sender, void *data) {
	if (msg == ps_globalsymbol_binding)
		x->buf = (t_buffer*)x->bufname->s_thing;
	else if (msg == ps_globalsymbol_unbinding)
		x->buf = NULL;
	else if (msg == ps_buffer_modified) {
		if(x->resize) {
			x->resize = false;
			defer_low(x, (method)myObj_doFill, 0,0,0);		// have to defer this call
		}
	}
	return MAX_ERR_NONE;
}

void myObj_doFill(t_myObj *x) {
	float			*tab;
	long			frames, nchnls, i;
	t_buffer		*b = NULL;
	double			incr;
	long			n = x->n;
	double			freq = x->freq;

	b = x->buf;

	// etc....
}


@volker, I think that maybe my coffee had run out (or something) when writing that. It's not correct. When you modify the buffer~ contents you still need to call the dirty method to notify objects like waveform~. I'll correct the text.

@volker, I think that maybe my coffee had run out (or something) when writing that.  It's not correct.  When you modify the buffer~ contents you still need to call the dirty method to notify objects like waveform~.  I'll correct the text.  

ok thanks for the clarification. i've got it working fine now.

ok thanks for the clarification. i've got it working fine now.
vb


Sometime ago I too found out by trial and error that's indeed the case.

However, that means that buffer~ operations are asynchronous in nature and therefore a buffer_modified notification does not guarantee in any way buffer~ to be ready: there might still be something in process or about to complete...

So, is it correct to assume that any code that gets called in response to a buffer_modified notification should ALWAYS be deferred to the BACK of the low priority thread and ONLY to the back ? This is the only deferral that would really guarantee the code to be called when the buffer~ is really done with all processes and it's ready.

Neither defer_medium nor defer_front are appropriate, right ?

I am thinking about the scenario of writing to the buffer (like Volker is doing) or even simply (re)reading the samples of a buffer to update a graphical display (like waveform~ probably does) in response to some changes in the buffer's content.

Is it correct to think along these lines?

ok, that's what i'm doing right now, which seems to work ok, but only if i defer the call to the function, that starts writing to the newly resized buffer (see below). is that correct?


Sometime ago I too found out by trial and error that's indeed the case.
However, that means that buffer~ operations are asynchronous in nature and therefore a buffer_modified notification does not guarantee in any way buffer~ to be ready: there might still be something in process or about to complete...

So, is it correct to assume that any code that gets called in response to a buffer_modified notification should ALWAYS be deferred to the BACK of the low priority thread and ONLY to the back ? This is the only deferral that would really guarantee the code to be called when the buffer~ is really done with all processes and it's ready.
Neither defer_medium nor defer_front are appropriate, right ?

yes, this question is still open. i just settled with the defer_low in the end, which is fine for what i'm doing right now.

but if someone wants to look deeper into this:

from experimentation, i have found, that you have to defer_low any call, that wants to access the just newly resized buffer, when executed in response to a 'buffer_modified' notification.

the show stopper seems to be the ATOMIC_INCREMENT/DECREMENT combo.

if i comment them out in the function where i write to the buffer (which is of course not recommended), i can make it work without defer_low.

attached is an xcode project and a short patch demonstrating what i'm talking about.

might also be possible, that i'm just doing something wrong here.

hi luigi,
yes, this question is still open. i just settled with the defer_low in the end, which is fine for what i'm doing right now.

but if someone wants to look deeper into this:
from experimentation, i have found, that you have to defer_low any call, that wants to access the just newly resized buffer, when executed in response to a 'buffer_modified' notification.
the show stopper seems to be the ATOMIC_INCREMENT/DECREMENT combo.
if i comment them out in the function where i write to the buffer (which is of course not recommended), i can make it work without defer_low.

attached is an xcode project and a short patch demonstrating what i'm talking about.
might also be possible, that i'm just doing something wrong here.


I found this thread when I was facing similar issues... but I finally found a solution for my needs which I'd like to contribute here.

Volker's buftest above was extremely helpful and it's still working in Max 8 even though it's using the Max 5 way of doing this which was explained (after some digging on the web) in the 2009 article by Tim Place: "Accessing buffer~ Objects in Max5"(

https://74objects.wordpress.com/2009/03/22/accessing-buffers/

After some close reading of "ext_buffer.h", I came up with the attached demonstration which exclusively uses according the most recent (as of Max 8) buffer api. The big aha was that `buffer_edit_begin` / `buffer_edit_end` duo don't need `buffer_locksamples` / `buffer_unlocksamples` and that the former resolve the atomic access to the buffer which previously required the previously mentioned ATOMIC_INCREMENT/DECREMENT construct.

I hope this proves useful to this discussion and to whoever encounters the same problem.

buffer-resize-demo.zip

#include "ext.h"
#include "ext_obex.h"
#include <ext_buffer.h>

typedef struct _buf {
    t_object ob;
    void* outlet;
    t_symbol* buf_name;    // buffer name
    t_buffer_ref* buf_ref; // buffer ref
} t_buf;

// method prototypes
void* buf_new(t_symbol* s, long argc, t_atom* argv);
void buf_free(t_buf* x);
void buf_bang(t_buf* x);
void buf_float(t_buf* x, double f);
void buf_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv);
void buf_do_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv);
t_max_err buf_notify(t_buf* x, t_symbol* s, t_symbol* msg, void* sender,
                     void* data);
t_max_err buf_set_buf(t_buf* x, t_symbol* s);

// global class pointer variable
static t_class* buf_class = NULL;

void ext_main(void* r)
{
    t_class* c = class_new("buf", (method)buf_new, (method)buf_free,
                           (long)sizeof(t_buf), 0L, A_GIMME, 0);

    class_addmethod(c, (method)buf_bang, "bang", 0);
    class_addmethod(c, (method)buf_resize, "resize", A_GIMME, 0);
    class_addmethod(c, (method)buf_notify, "notify", A_CANT, 0);

    class_register(CLASS_BOX, c);
    buf_class = c;
}

void* buf_new(t_symbol* s, long argc, t_atom* argv)
{
    t_buf* x = (t_buf*)object_alloc(buf_class);

    if (x) {
        x->outlet = outlet_new(x, NULL); // outlet

        x->buf_ref = NULL;
    }
    return (x);
}

void buf_free(t_buf* x)
{
    if (x->buf_ref)
        object_free(x->buf_ref);
}

void buf_bang(t_buf* x)
{
    outlet_bang(x->outlet);
}

t_max_err buf_notify(t_buf* x, t_symbol* s, t_symbol* msg, void* sender,
                     void* data)
{
    return buffer_ref_notify(x->buf_ref, s, msg, sender, data);
}

t_max_err buf_set_buf(t_buf* x, t_symbol* s)
{
    if (!x->buf_ref) {
        x->buf_ref = buffer_ref_new((t_object*)x, s);
    } else {
        buffer_ref_set(x->buf_ref, s);
    }

    if (buffer_ref_exists(x->buf_ref)) {
        object_post((t_object*)x, "found buffer with name '%s'", s->s_name);
        x->buf_name = s;
        return MAX_ERR_NONE;
    }
    object_error((t_object*)x, "buffer with name '%s' not found", s->s_name);
    return MAX_ERR_GENERIC;
}

void buf_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv)
{
    defer_low(x, (method)buf_do_resize, s, argc, argv);
}

void buf_do_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv)
{
    t_buffer_obj* buf_obj = NULL;
    t_symbol* buf_name = NULL;
    t_atom_long new_size = 0;
    t_max_err err = 0;

    if (argc < 2) {
        object_error((t_object*)x, "need at least 2 args to resize buffer");
        goto error;
    }

    if ((argv + 0)->a_type != A_SYM) {
        object_error((t_object*)x,
                     "1st arg of buf_resize needs to be a symbol name of the "
                     "target buffer");
        goto error;
    }

    // retrieve params
    buf_name = atom_getsym(argv);
    if (buf_name == NULL) {
        object_error((t_object*)x, "buffer name not provided");
        goto error;
    }

    new_size = atom_getlong(argv + 1);
    if (new_size == 0) {
        object_error((t_object*)x, "cannot resize buffer '%s' to 0 samples", buf_name->s_name);
        goto error;
    }

    err = buf_set_buf(x, buf_name);
    if (err) {
        object_error((t_object*)x, "cannot resize unknown buffer '%s'",
                     buf_name->s_name);
        goto error;
    }

    buf_obj = buffer_ref_getobject(x->buf_ref);

    object_post((t_object*)x, "to resize buffer '%s' from %d to %d samples", 
        buf_name->s_name, buffer_getframecount(buf_obj), new_size);

    // NOT REQUIRED!
    // float* buf_ptr = buffer_locksamples(buf_obj);
    // if (!buf_ptr) {
    //     object_error((t_object*)x, "Cannot claim buffer~");
    //     goto error;
    // }

    err = buffer_edit_begin(buf_obj);
    if (err) {
        object_error((t_object*)x, "cannot start editing buffer '%s'",
                     buf_name->s_name);
        goto error;        
    }

    err = object_method_typed((t_object*)buf_obj,
        gensym("sizeinsamps"), 1, argv+1, NULL);

    if (err) {
        object_error((t_object*)x, "failed to resize buffer '%s'",
                     buf_name->s_name);
        goto error;
    }

    err = buffer_edit_begin(buf_obj);
    if (err) {
        object_error((t_object*)x, "cannot end editing buffer %s",
                     buf_name->s_name);
        goto error;        
    }

    buffer_setdirty(buf_obj);
    
    // NOT REQUIRED!
    // buffer_unlocksamples(buf_obj);

    // success
    object_post((t_object*)x, "successfully resized buffer '%s' to %d samples",
        buf_name->s_name, new_size);
    buf_bang(x);
    goto cleanup;

error:
    object_error((t_object*)x, "buf_do_resize failed");

cleanup:
    if (x->buf_ref)
        object_free(x->buf_ref);
    x->buf_ref = NULL;    
}

 Volker's buftest above was extremely helpful and it's still working in Max 8 even though it's using the Max 5 way of doing this which was explained (after some digging on the web) in the 2009 article by Tim Place: "Accessing buffer~ Objects in Max5"(https://74objects.wordpress.com/2009/03/22/accessing-buffers/).

After some close reading of  "ext_buffer.h",  I came up with the attached demonstration which exclusively uses according the most recent (as of Max 8) buffer api. The big aha was that `buffer_edit_begin` / `buffer_edit_end` duo don't need `buffer_locksamples` / `buffer_unlocksamples` and that the former resolve the atomic access to the buffer which previously required the previously mentioned ATOMIC_INCREMENT/DECREMENT construct.

I hope this proves useful to this discussion and to whoever encounters the same problem.


Volker's buftest above was extremely helpful and it's still working in Max 8 even though it's using the Max 5 way of doing this I found explained (after some digging on the web) in the 2009 article by Tim Place: "Accessing buffer~ Objects in Max5"(

With some close reading of "ext_buffer.h", I came up with the attached demo which exclusively uses the post-Max 6 buffer api. The big aha for me was that `buffer_edit_begin` / `buffer_edit_end` duo don't need `buffer_locksamples` / `buffer_unlocksamples` and that the former resolve the atomic access to the buffer which previously required the previously mentioned ATOMIC_INCREMENT/DECREMENT combo.


#include "ext.h"
#include "ext_obex.h"
#include "ext_buffer.h"

typedef struct _buf {
    t_object ob;
    void* outlet;
    t_symbol* buf_name;    // buffer name
    t_buffer_ref* buf_ref; // buffer ref
} t_buf;

// method prototypes
void* buf_new(t_symbol* s, long argc, t_atom* argv);
void buf_free(t_buf* x);
void buf_bang(t_buf* x);
void buf_float(t_buf* x, double f);
void buf_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv);
void buf_do_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv);
t_max_err buf_notify(t_buf* x, t_symbol* s, t_symbol* msg, void* sender,
                     void* data);
t_max_err buf_set_buf(t_buf* x, t_symbol* s);

// global class pointer variable
static t_class* buf_class = NULL;

void ext_main(void* r)
{
    t_class* c = class_new("buf", (method)buf_new, (method)buf_free,
                           (long)sizeof(t_buf), 0L, A_GIMME, 0);
    class_addmethod(c, (method)buf_bang,   "bang",  0);
    class_addmethod(c, (method)buf_resize, "resize", A_GIMME, 0);
    class_addmethod(c, (method)buf_notify, "notify", A_CANT, 0);
    class_register(CLASS_BOX, c);
    buf_class = c;
}

void* buf_new(t_symbol* s, long argc, t_atom* argv)
{
    t_buf* x = (t_buf*)object_alloc(buf_class);

    if (x) {
        x->outlet = outlet_new(x, NULL); // outlet
        x->buf_ref = NULL;
        x->buf_name = gensym("");
    }
    return (x);
}

void buf_free(t_buf* x)
{
    if (x->buf_ref)
        object_free(x->buf_ref);
}

void buf_bang(t_buf* x)
{
    outlet_bang(x->outlet);
}

t_max_err buf_notify(t_buf* x, t_symbol* s, t_symbol* msg, void* sender,
                     void* data)
{
    return buffer_ref_notify(x->buf_ref, s, msg, sender, data);
}

t_max_err buf_set_buf(t_buf* x, t_symbol* s)
{
    if (!x->buf_ref) {
        x->buf_ref = buffer_ref_new((t_object*)x, s);
    } else {
        buffer_ref_set(x->buf_ref, s);
    }

    if (buffer_ref_exists(x->buf_ref)) {
        object_post((t_object*)x, "found buffer with name '%s'", s->s_name);
        x->buf_name = s;
        return MAX_ERR_NONE;
    }
    object_error((t_object*)x, "buffer with name '%s' not found", s->s_name);
    return MAX_ERR_GENERIC;
}

void buf_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv)
{
    defer_low(x, (method)buf_do_resize, s, argc, argv);
}

void buf_do_resize(t_buf* x, t_symbol* s, long argc, t_atom* argv)
{
    t_buffer_obj* buf_obj = NULL;
    t_symbol* buf_name = NULL;
    t_atom_long new_size = 0;
    t_max_err err = 0;

    if (argc < 2) {
        object_error((t_object*)x, "need at least 2 args to resize buffer");
        goto error;
    }

    if ((argv + 0)->a_type != A_SYM) {
        object_error((t_object*)x,
                     "1st arg of buf_resize needs to be a symbol name of the "
                     "target buffer");
        goto error;
    }

    // retrieve params
    buf_name = atom_getsym(argv);
    if (buf_name == NULL) {
        object_error((t_object*)x, "buffer name not provided");
        goto error;
    }

    new_size = atom_getlong(argv + 1);
    if (new_size == 0) {
        object_error((t_object*)x, "cannot resize buffer '%s' to 0 samples", buf_name->s_name);
        goto error;
    }

    err = buf_set_buf(x, buf_name);
    if (err) {
        object_error((t_object*)x, "cannot resize unknown buffer '%s'",
                     buf_name->s_name);
        goto error;
    }

    buf_obj = buffer_ref_getobject(x->buf_ref);

    object_post((t_object*)x, "to resize buffer '%s' from %d to %d samples", 
        buf_name->s_name, buffer_getframecount(buf_obj), new_size);

    err = buffer_edit_begin(buf_obj);
    if (err) {
        object_error((t_object*)x, "cannot start editing buffer '%s'",
                     buf_name->s_name);
        goto error;        
    }

    err = object_method_typed((t_object*)buf_obj,
        gensym("sizeinsamps"), 1, argv+1, NULL);

    if (err) {
        object_error((t_object*)x, "failed to resize buffer '%s'",
                     buf_name->s_name);
        goto error;
    }

    err = buffer_edit_end(buf_obj, 1);
    if (err) {
        object_error((t_object*)x, "cannot end editing buffer %s",
                     buf_name->s_name);
        goto error;        
    }

    buffer_setdirty(buf_obj);
    
    // success
    object_post((t_object*)x, "successfully resized buffer '%s' to %d samples",
        buf_name->s_name, new_size);
    buf_bang(x);
    goto cleanup;

error:
    object_error((t_object*)x, "buf_do_resize failed");

cleanup:
    if (x->buf_ref)
        object_free(x->buf_ref);
    x->buf_ref = NULL;    
}


Volker's buftest above was extremely helpful and it's still working in Max 8 even though it's using the Max 5 way of doing this I found explained (after some digging on the web) in the 2009 article by Tim Place: "Accessing buffer~ Objects in Max5"(https://74objects.wordpress.com/2009/03/22/accessing-buffers/).

resizing buffer --> notify?