static mrb_value
cfunc_type_initialize(mrb_state *mrb, mrb_value self)
{
struct cfunc_type_data *data;
data = mrb_data_check_get_ptr(mrb, self, &cfunc_type_data);
if (!data) {
data = mrb_malloc(mrb, sizeof(struct cfunc_type_data));
data->value._uint64 = 0;
}
data->autofree = false;
data->refer = false;
DATA_PTR(self) = data;
DATA_TYPE(self) = &cfunc_type_data;
mrb_value val;
int argc = mrb_get_args(mrb, "|o", &val);
if(argc > 0) {
struct mrb_ffi_type *mft = rclass_to_mrb_ffi_type(mrb, mrb_object(self)->c);
if(mft && mft->mrb_to_data) {
mft->mrb_to_data(mrb, val, data);
}
else {
mrb_raise(mrb, E_TYPE_ERROR, "Fatal in cfunc_type_initialize");
}
}
return self;
}
static mrb_value mrb_sample_buffer_length_method(mrb_state *mrb, mrb_value self)
{
mrb_sample_buffer *b;
b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
return mrb_fixnum_value(MRB_SAMPLE_BUFFER_LEN(b));
}
h2o_mruby_http_request_context_t *h2o_mruby_http_set_shortcut(mrb_state *mrb, mrb_value obj, void (*cb)(h2o_mruby_generator_t *))
{
struct st_h2o_mruby_http_request_context_t *ctx;
if ((ctx = mrb_data_check_get_ptr(mrb, obj, &input_stream_type)) == NULL)
return NULL;
ctx->shortcut_notify_cb = cb;
return ctx;
}
static mrb_value mrb_sample_buffer_channel_get_method(mrb_state *mrb, mrb_value self)
{
mrb_sample_buffer *b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
if (b->shared) {
return b->shared->channel;
} else {
return mrb_nil_value();
}
}
static mrb_value mrb_sample_buffer_offset_method(mrb_state *mrb, mrb_value self)
{
mrb_sample_buffer *b;
b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
if (!b->shared) {
return mrb_fixnum_value(b->offset);
} else {
return mrb_fixnum_value(b->offset + b->shared->offset);
}
}
mrb_value
cfunc_closure_initialize(mrb_state *mrb, mrb_value self)
{
struct cfunc_closure_data *data;
data = mrb_data_check_get_ptr(mrb, self, &cfunc_closure_data_type);
if (!data) {
data = mrb_malloc(mrb, sizeof(struct cfunc_closure_data));
}
data->refer = 0;
data->autofree = 0;
DATA_PTR(self) = data;
DATA_TYPE(self) = &cfunc_closure_data_type;
data->mrb = mrb;
data->closure = NULL;
data->arg_types = NULL;
mrb_value rettype_mrb, block, args_mrb;
mrb_get_args(mrb, "&oo", &block, &rettype_mrb, &args_mrb);
data->argc = RARRAY_LEN(args_mrb);
ffi_type *return_ffi_type = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(rettype_mrb))->ffi_type_value;
data->return_type = rettype_mrb;
data->arg_ffi_types = mrb_malloc(mrb, sizeof(ffi_type*) * data->argc);
data->arg_types = mrb_malloc(mrb, sizeof(mrb_value) * data->argc);
int i;
for (i = 0; i < data->argc; ++i) {
data->arg_types[i] = mrb_ary_ref(mrb, args_mrb, i);
data->arg_ffi_types[i] = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(data->arg_types[i]))->ffi_type_value;
}
mrb_iv_set(mrb, self, mrb_intern_cstr(data->mrb, "@block"), block);
void *closure_pointer = NULL;
data->closure = ffi_closure_alloc(sizeof(ffi_closure) + sizeof(void*), &closure_pointer);
data->cif = mrb_malloc(mrb, sizeof(ffi_cif));
if (data->closure) {
if (ffi_prep_cif(data->cif, FFI_DEFAULT_ABI, data->argc, return_ffi_type, data->arg_ffi_types) == FFI_OK) {
if (ffi_prep_closure_loc(data->closure, data->cif, cfunc_closure_call_binding, mrb_object(self), closure_pointer) == FFI_OK) {
set_cfunc_pointer_data((struct cfunc_type_data *)data, closure_pointer);
return self;
}
}
}
mrb_raise(mrb, E_SCRIPT_ERROR, "Internal FFI call error");
return mrb_nil_value();
}
static mrb_value mrb_sample_buffer_set_method(mrb_state *mrb, mrb_value self)
{
mrb_int i;
mrb_float f;
mrb_sample_buffer *b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
mrb_get_args(mrb, "if", &i, &f);
if (0 <= i && i < b->len) {
MRB_SAMPLE_BUFFER_DATA(b)[i] = f;
return mrb_float_value(mrb, f);
} else {
mrb_raise(mrb, E_ARGUMENT_ERROR, "Index out of bounds");
}
}
static mrb_value mrb_sample_buffer_get_method(mrb_state *mrb, mrb_value self)
{
mrb_int i;
mrb_sample_buffer *b;
b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
mrb_get_args(mrb, "i", &i);
if (0 <= i && i < b->len) {
return mrb_float_value(mrb, MRB_SAMPLE_BUFFER_DATA(b)[i]);
} else {
return mrb_nil_value();
}
}
mrb_value h2o_mruby_http_join_response_callback(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value args,
int *next_action)
{
mrb_state *mrb = generator->ctx->mrb;
struct st_h2o_mruby_http_request_context_t *ctx;
if (generator->req == NULL)
return create_downstream_closed_exception(mrb);
if ((ctx = mrb_data_check_get_ptr(mrb, mrb_ary_entry(args, 0), &request_type)) == NULL)
return mrb_exc_new_str_lit(mrb, E_ARGUMENT_ERROR, "HttpRequest#join wrong self");
ctx->receiver = receiver;
*next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_ASYNC;
return mrb_nil_value();
}
static mrb_value mrb_sample_buffer_each_method(mrb_state *mrb, mrb_value self)
{
mrb_int i;
mrb_value block;
mrb_bool block_given;
mrb_sample_buffer *b = mrb_data_check_get_ptr(mrb, self, &mrb_sample_buffer_type);
mrb_get_args(mrb, "|&?", &block, &block_given);
if (block_given) {
for (i = 0; i < b->len; ++i) {
mrb_yield(mrb, block, mrb_float_value(mrb, MRB_SAMPLE_BUFFER_DATA(b)[i]));
}
return self;
} else {
return mrb_funcall(mrb, self, "enum_for", 1, mrb_symbol_value(mrb_intern_lit(mrb, "each")));
}
}
mrb_value h2o_mruby_http_fetch_chunk_callback(h2o_mruby_generator_t *generator, mrb_value receiver, mrb_value args,
int *next_action)
{
mrb_state *mrb = generator->ctx->mrb;
struct st_h2o_mruby_http_request_context_t *ctx;
mrb_value ret;
if (generator->req == NULL)
return create_downstream_closed_exception(mrb);
if ((ctx = mrb_data_check_get_ptr(mrb, mrb_ary_entry(args, 0), &input_stream_type)) == NULL)
return mrb_exc_new_str_lit(mrb, E_ARGUMENT_ERROR, "_HttpInputStream#each wrong self");
if (ctx->resp.has_content) {
ret = build_chunk(ctx);
} else {
ctx->receiver = receiver;
*next_action = H2O_MRUBY_CALLBACK_NEXT_ACTION_ASYNC;
ret = mrb_nil_value();
}
return ret;
}
mrb_value
cfunc_rubyvm_dispatch(mrb_state *mrb, mrb_value self)
{
struct cfunc_rubyvm_data *data = mrb_data_check_get_ptr(mrb, self, &cfunc_rubyvm_data_type);
mrb_value name_obj, *args;
int args_len;
mrb_get_args(mrb, "o*", &name_obj, &args, &args_len);
struct queue_task *task = mrb_malloc(mrb, sizeof(struct queue_task));
task->refcount = 2;
task->result = NULL;
task->status = queue_task_queued;
pthread_mutex_init(&task->sync_mutex, NULL);
pthread_cond_init(&task->sync_cond, NULL);
const char* name = mrb_string_value_ptr(mrb, name_obj);
int name_len = strlen(name);
task->name = mrb_malloc(mrb, name_len+1);
strncpy(task->name, name, name_len+1);
task->args_len = args_len;
task->args = mrb_malloc(mrb, sizeof(struct task_arg) * task->args_len);
int i;
for(i=0; i<args_len; ++i) {
task->args[i] = mrb_value_to_task_arg(mrb, args[i]);
}
pthread_mutex_lock(&data->queue_mutex);
vector_enqueue(data->queue, task);
pthread_cond_signal(&data->queue_cond);
pthread_mutex_unlock(&data->queue_mutex);
struct cfunc_state *state = cfunc_state(mrb, mrb_obj_ptr(self)->c);
return mrb_obj_value((struct RObject *)Data_Wrap_Struct(mrb, state->rubyvm_task_class, &cfunc_rubyvm_task_data_type, task));
}
mrb_value
cfunc_pointer_initialize(mrb_state *mrb, mrb_value self)
{
struct cfunc_type_data *data;
data = mrb_data_check_get_ptr(mrb, self, &cfunc_pointer_data_type);
if(!data) {
data = mrb_malloc(mrb, sizeof(struct cfunc_type_data));
DATA_PTR(self) = data;
DATA_TYPE(self) = &cfunc_pointer_data_type;
}
data->refer = false;
data->autofree = false;
mrb_value ptr;
int argc = mrb_get_args(mrb, "|o", &ptr);
if(argc == 0) {
set_cfunc_pointer_data(data, NULL);
}
else {
set_cfunc_pointer_data(data, cfunc_pointer_ptr(ptr));
}
return self;
}
cv::Mat*
mrb_mruby_opencv_mat(mrb_state* mrb, mrb_value value) {
cv::Mat* mat = (cv::Mat*)mrb_data_check_get_ptr(mrb, value, &mrb_mruby_opencv_data_type);
return mat;
}
MRB_API mrb_sample_buffer *mrb_sample_buffer_check(mrb_state *mrb, mrb_value b)
{
return mrb_data_check_get_ptr(mrb, b, &mrb_sample_buffer_type);
}
