SCM image_convert(SCM scm_ptr, SCM scm_source_type, SCM scm_dest_ptr, SCM scm_dest_type)
{
enum AVPixelFormat format;
int width, height;
void *ptr = scm_to_pointer(scm_ptr);
uint8_t *source_data[8];
int32_t source_pitches[8];
memset(source_pitches, 0, sizeof(source_pitches));
image_setup(scm_source_type, &format, &width, &height, source_data, source_pitches, ptr);
enum AVPixelFormat dest_format;
int dest_width, dest_height;
void *dest_ptr = scm_to_pointer(scm_dest_ptr);
uint8_t *dest_data[8];
int32_t dest_pitches[8];
memset(dest_pitches, 0, sizeof(dest_pitches));
image_setup(scm_dest_type, &dest_format, &dest_width, &dest_height, dest_data, dest_pitches, dest_ptr);
struct SwsContext *sws_context = sws_getContext(width, height, format,
dest_width, dest_height, dest_format,
SWS_FAST_BILINEAR, 0, 0, 0);
sws_scale(sws_context, (const uint8_t * const *)source_data, source_pitches, 0, height,
dest_data, dest_pitches);
sws_freeContext(sws_context);
return SCM_UNSPECIFIED;
}
SCM mjpeg_to_yuv420p(SCM scm_source_ptr, SCM scm_shape, SCM scm_dest_ptr, SCM scm_offsets)
{
unsigned char *source_ptr = scm_to_pointer(scm_source_ptr);
unsigned char *dest_ptr = scm_to_pointer(scm_dest_ptr);
int width = scm_to_int(scm_cadr(scm_shape));
int height = scm_to_int(scm_car(scm_shape));
int64_t offsets[3];
memset(offsets, 0, sizeof(offsets));
scm_to_long_array(scm_offsets, offsets);
decode_jpeg_raw(source_ptr, width * height * 2, Y4M_ILACE_NONE, 0, width, height,
dest_ptr + offsets[0], dest_ptr + offsets[2], dest_ptr + offsets[1]);
return SCM_UNSPECIFIED;
}
static SCM api_set_status(SCM s_, SCM status_)
{
servlet *s = scm_to_pointer(s_);
int status = scm_to_int(status_);
set_status(s, status);
return SCM_UNSPECIFIED;
}
static SCM call_callable(SCM scm_args)
{
SCM stack = scm_make_stack(SCM_BOOL_T, SCM_EOL);
SCM frame = scm_stack_ref(stack, scm_from_int(0));
SCM proc = scm_frame_procedure(frame);
PyObject *callable = scm_to_pointer(scm_assq_ref(gsubr_alist, proc));
scm_dynwind_begin(0);
PyObject *py_args = scm2py(scm_args);
if (py_args == NULL)
py2scm_exception(); /* does not return */
scm_dynwind_py_decref(py_args);
struct call_callable_data data = { callable, py_args };
PyObject *py_result = (PyObject *)scm_without_guile(
(void *(*)(void *))call_callable1, &data);
if (py_result == NULL)
py2scm_exception(); /* does not return */
scm_dynwind_py_decref(py_result);
SCM scm_result = py2scm(py_result);
scm_dynwind_end();
return scm_result;
}
SCM make_tensor(SCM scm_type, SCM scm_shape, SCM scm_size, SCM scm_source)
{
SCM retval;
struct tf_tensor_t *self = (struct tf_tensor_t *)scm_gc_calloc(sizeof(struct tf_tensor_t), "make-tensor");
SCM_NEWSMOB(retval, tf_tensor_tag, self);
int type = scm_to_int(scm_type);
int num_dims = scm_to_int(scm_length(scm_shape));
int64_t *dims = scm_gc_malloc_pointerless(sizeof(int64_t) * num_dims, "make-tensor");
int count = 1;
for (int i=0; i<num_dims; i++) {
dims[i] = scm_to_int(scm_car(scm_shape));
count = count * dims[i];
scm_shape = scm_cdr(scm_shape);
};
if (type == TF_STRING) {
SCM* pointer = scm_to_pointer(scm_source);
size_t encoded_size = 0;
for (int i=0; i<count; i++) {
encoded_size += TF_StringEncodedSize(scm_c_string_length(*pointer)) + 8;
pointer++;
};
self->tensor = TF_AllocateTensor(type, dims, num_dims, encoded_size);
int64_t *offsets = TF_TensorData(self->tensor);
int offset = 0;
void *result = offsets + count;
pointer = scm_to_pointer(scm_source);
encoded_size = encoded_size - count * sizeof(int64_t);
for (int i=0; i<count; i++) {
char *str = scm_to_locale_string(*pointer);
int len = TF_StringEncodedSize(scm_c_string_length(*pointer));
*offsets++ = offset;
TF_StringEncode(str, scm_c_string_length(*pointer), result, encoded_size, status());
free(str);
if (TF_GetCode(_status) != TF_OK)
scm_misc_error("make-tensor", TF_Message(_status), SCM_EOL);
offset += len;
encoded_size -= len;
result += len;
pointer++;
};
} else {
self->tensor = TF_AllocateTensor(type, dims, num_dims, scm_to_int(scm_size));
memcpy(TF_TensorData(self->tensor), scm_to_pointer(scm_source), scm_to_int(scm_size));
};
return retval;
}
static SCM api_rwrite(SCM s_, SCM buffer_)
{
servlet *s = scm_to_pointer(s_);
size_t length;
char *str = scm_to_utf8_stringn(buffer_, &length);
size_t ret = rwrite(s, str, length);
free(str);
return scm_from_size_t(ret);
}
static SCM api_get_method(SCM s_)
{
servlet *s = scm_to_pointer(s_);
const char *method = get_method(s);
if (method)
{
return scm_from_utf8_string(method);
}
return SCM_UNSPECIFIED;
}
static SCM api_set_header(SCM s_, SCM key_, SCM value_)
{
servlet *s = scm_to_pointer(s_);
char *key = scm_to_utf8_string(key_);
char *value = scm_to_utf8_string(value_);
set_header(s, key, value);
free(key);
free(value);
return SCM_UNSPECIFIED;
}
static SCM api_get_header(SCM s_, SCM key_)
{
servlet *s = scm_to_pointer(s_);
char *key = scm_to_utf8_string(key_);
const char *value = get_header(s, key);
free(key);
if (value)
{
return scm_from_utf8_string(value);
}
return SCM_UNSPECIFIED;
}
static SCM api_get_arg(SCM s_, SCM name_)
{
servlet *s = scm_to_pointer(s_);
char *name = scm_to_utf8_string(name_);
const char *arg = get_arg(s, name);
free(name);
if (arg)
{
return scm_from_utf8_string(arg);
}
return SCM_UNSPECIFIED;
}
SCM negate(SCM scm_ptr, SCM scm_stride, SCM scm_size)
{
int *p = (int *)scm_to_pointer(scm_ptr);
int s = scm_to_int(scm_stride);
int n = scm_to_int(scm_size);
ret = malloc(n * sizeof(int));
int *rend = ret + n;
int *r;
for (r=ret; r!=rend; r+=s, p+=s)
*r = -*p;
free(ret);
return SCM_UNDEFINED;
}
static void
test_scm_to_pointer ()
{
int (*add3) (int a, int b, int c);
SCM int_type = scm_c_public_ref ("system foreign", "int");
add3 = scm_to_pointer
(scm_procedure_to_pointer (int_type,
scm_c_public_ref ("guile", "+"),
scm_list_3 (int_type,
int_type,
int_type)));
assert ((*add3) (1000000, 1000, -1) == 1000999);
}
static SCM api_rflush(SCM s_)
{
servlet *s = scm_to_pointer(s_);
rflush(s);
return SCM_UNSPECIFIED;
}
VISIBLE rexp_t
scm_to_rexp_t (SCM re)
{
return (rexp_t) scm_to_pointer (scm_call_1 (_rexp_to_pointer (), re));
}
SCM ffmpeg_fetch_audio(SCM scm_self, SCM scm_data, SCM scm_bytes)
{
struct ffmpeg_t *self = get_self(scm_self);
ringbuffer_fetch(&self->audio_buffer, scm_to_int(scm_bytes), fetch_buffered_audio_data, scm_to_pointer(scm_data));
return SCM_UNSPECIFIED;
}
PyObject *scm2py(SCM value)
{
if (value == NULL)
return NULL;
if (value == SCM_UNSPECIFIED) {
Py_INCREF(Py_None);
return Py_None;
}
if (scm_is_exact_integer(value))
return PyInt_FromLong(scm_to_long(value));
if (scm_is_real(value))
return PyFloat_FromDouble(scm_to_double(value));
if (scm_is_bool(value)) {
PyObject *result = scm_to_bool(value) ? Py_True : Py_False;
Py_INCREF(result);
return result;
}
if (value == SCM_EOL)
return PyTuple_New(0);
if (scm_is_string(value)) {
size_t len = 0;
char *s = scm_to_utf8_stringn(value, &len);
PyObject *result = PyUnicode_FromStringAndSize(s, len);
free(s);
return result;
}
if (scm_is_pair(value)) {
unsigned int len = scm_to_uint(scm_length(value));
PyObject *result = PyTuple_New(len);
scm_dynwind_begin(0);
scm_dynwind_unwind_handler(
(void (*)(void *))Py_DecRef, result, 0);
unsigned int i;
for (i = 0; i < len; i++) {
PyObject *item = scm2py(scm_car(value));
if (item == NULL) {
scm_dynwind_end();
Py_DECREF(result);
return NULL;
}
PyTuple_SET_ITEM(result, i, item);
value = scm_cdr(value);
}
scm_dynwind_end();
return result;
}
if (scm_to_bool(scm_procedure_p(value))) {
SCM ptr = scm_assq_ref(gsubr_alist, value);
if (!scm_is_false(ptr)) {
PyObject *result = scm_to_pointer(ptr);
Py_INCREF(result);
return result;
}
Procedure *result =
(Procedure *)ProcedureType.tp_alloc(&ProcedureType, 0);
if (result == NULL)
return NULL;
result->proc = value;
return (PyObject *)result;
}
char *msg = scm_to_utf8_stringn(
scm_simple_format(
SCM_BOOL_F,
scm_from_utf8_string(
"Guile expression ~S doesn't have a "
"corresponding Python value"),
scm_list_1(value)), NULL);
PyErr_SetString(PyExc_TypeError, msg);
free(msg);
return NULL;
}
// FIXME: Try to use garbage-collected allocation for the management
// of anchor point lists. Note: after this is done, we can get rid of
// the ‘catch’ calls in the Guile code.
static SCM
scm_free_AnchorPoint_linked_list (SCM ap_ptr)
{
AnchorPointsFree (scm_to_pointer (ap_ptr));
return SCM_UNSPECIFIED;
}
SCM ffmpeg_buffer_audio(SCM scm_self, SCM scm_data, SCM scm_bytes)
{
struct ffmpeg_t *self = get_self(scm_self);
ringbuffer_store(&self->audio_buffer, scm_to_pointer(scm_data), scm_to_int(scm_bytes));
return SCM_UNSPECIFIED;
}
VISIBLE rexp_match_t
scm_to_rexp_match_t (SCM m)
{
return (rexp_match_t)
scm_to_pointer (scm_call_1 (_rexp_match_to_pointer (), m));
}
