/* Obtains the wrapped object for a given call */
VALUE grpc_rb_wrap_call(grpc_call *c) {
VALUE obj = Qnil;
if (c == NULL) {
return Qnil;
}
obj = rb_hash_aref(hash_all_calls, OFFT2NUM((VALUE)c));
if (obj == Qnil) { /* Not in the hash add it */
rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)c), UINT2NUM(1));
} else {
rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)c),
UINT2NUM(NUM2UINT(obj) + 1));
}
return Data_Wrap_Struct(rb_cCall, GC_NOT_MARKED, grpc_rb_call_destroy, c);
}
/* Obtains the wrapped object for a given call */
VALUE grpc_rb_wrap_call(grpc_call *c) {
VALUE obj = Qnil;
if (c == NULL) {
return Qnil;
}
obj = rb_hash_aref(hash_all_calls, OFFT2NUM((VALUE)c));
if (obj == Qnil) { /* Not in the hash add it */
rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)c), UINT2NUM(1));
} else {
rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)c),
UINT2NUM(NUM2UINT(obj) + 1));
}
return TypedData_Wrap_Struct(grpc_rb_cCall, &grpc_call_data_type, c);
}
static VALUE
match_end(VALUE self)
{
Match *match;
VALUE2MATCH(self, match);
return OFFT2NUM(match->end);
}
static VALUE
match_begin(VALUE self)
{
Match *match;
VALUE2MATCH(self, match);
return OFFT2NUM(match->begin);
}
/* Destroys a Call. */
static void grpc_rb_call_destroy(void *p) {
grpc_call *call = NULL;
VALUE ref_count = Qnil;
if (p == NULL) {
return;
};
call = (grpc_call *)p;
ref_count = rb_hash_aref(hash_all_calls, OFFT2NUM((VALUE)call));
if (ref_count == Qnil) {
return; /* No longer in the hash, so already deleted */
} else if (NUM2UINT(ref_count) == 1) {
rb_hash_delete(hash_all_calls, OFFT2NUM((VALUE)call));
grpc_call_destroy(call);
} else {
rb_hash_aset(hash_all_calls, OFFT2NUM((VALUE)call),
UINT2NUM(NUM2UINT(ref_count) - 1));
}
}
static sf_count_t ra_vir_read(void *ptr, sf_count_t count, void *user_data) {
VALUE io = (VALUE)user_data;
if(count <= 0) return 0;
// It would be nice if we could create a fake buffer string with ptr as the target
VALUE read = rb_funcall(io, id_read, 1, OFFT2NUM(count));
sf_count_t len = RSTRING_LEN(read);
memcpy(ptr, RSTRING_PTR(read), RSTRING_LEN(read));
return len;
}
static VALUE
blkgetsize64(VALUE self, VALUE rfd) {
int fd;
int64_t sz;
fd = NUM2INT(rfd);
if (ioctl(fd, BLKGETSIZE64, &sz) < 0) {
rb_raise(rb_eSystemCallError,
"%s::blkgetsize64 - ioctl failed on file descriptor: %d, %s\n",
module_name,
fd,
strerror(errno)
);
}
return OFFT2NUM(sz);
}
/*
* call-seq:
* snd.write(buf) => integer
*
* Writes the entire contents of the given buffer to the sound and returns the
* number of frames written.
*/
static VALUE ra_sound_write(VALUE self, VALUE buf) {
RA_SOUND *snd;
Data_Get_Struct(self, RA_SOUND, snd);
if(snd->closed) rb_raise(eRubyAudioError, "closed sound");
// Get buffer struct
RA_BUFFER *b;
Data_Get_Struct(buf, RA_BUFFER, b);
// Get info struct
SF_INFO *info;
Data_Get_Struct(snd->info, SF_INFO, info);
// Check buffer channels matches actual channels
if(b->channels != info->channels) {
rb_raise(eRubyAudioError, "channel count mismatch: %d vs %d", b->channels, info->channels);
}
// Write data
sf_count_t written;
switch(b->type) {
case RA_BUFFER_TYPE_SHORT:
written = sf_writef_short(snd->snd, b->data, b->real_size);
break;
case RA_BUFFER_TYPE_INT:
written = sf_writef_int(snd->snd, b->data, b->real_size);
break;
case RA_BUFFER_TYPE_FLOAT:
written = sf_writef_float(snd->snd, b->data, b->real_size);
break;
case RA_BUFFER_TYPE_DOUBLE:
written = sf_writef_double(snd->snd, b->data, b->real_size);
break;
}
return OFFT2NUM(written);
}
/*
* Gets the current rotate threshold size that is used by the default
* query logger.
*
* If the size is larger than 0, log rotate feature is enabled in the
* default query logger.
*
* @overload threshold
* @return [Integer] The current rotate threshold size
*
* @since 5.0.2
*/
static VALUE
rb_grn_query_logger_s_get_rotate_threshold_size (VALUE klass)
{
return OFFT2NUM(grn_default_query_logger_get_rotate_threshold_size());
}
static VALUE rb_smbfile_rewind(VALUE self)
{
VALUE argv = OFFT2NUM(0);
return rb_smbfile_seek(1, &argv, self);
}
static VALUE cie_info_pack(VALUE UNUSED(module), VALUE rnr, VALUE rkey)
{
xdcc *xd;
const char *key;
const char *val;
char *tempstr;
unsigned int nr;
unsigned int ival;
off_t oval;
size_t len;
VALUE rval;
if (NIL_P(rnr) || NIL_P(rkey))
return Qnil;
nr = FIX2UINT(rnr);
if (nr == 0)
return Qnil;
if (nr > irlist_size(&gdata.xdccs))
return Qnil;
xd = get_xdcc_pack(nr);
if (xd == NULL)
return Qnil;
key = rb_obj_as_string_protected(rkey);
if (!key)
return Qnil;
for (;;) {
if (strcmp(key, "file") == 0) { /* NOTRANSLATE */
val = xd->file;
break;
}
if (strcmp(key, "name") == 0) { /* NOTRANSLATE */
val = getfilename(xd->file);
break;
}
if (strcmp(key, "desc") == 0) { /* NOTRANSLATE */
val = xd->desc;
break;
}
if (strcmp(key, "note") == 0) { /* NOTRANSLATE */
val = xd->note;
break;
}
if (strcmp(key, "group") == 0) { /* NOTRANSLATE */
val = xd->group;
break;
}
if (strcmp(key, "group_desc") == 0) { /* NOTRANSLATE */
val = find_groupdesc(xd->group);
break;
}
if (strcmp(key, "trigger") == 0) { /* NOTRANSLATE */
val = xd->trigger;
break;
}
if (strcmp(key, "lock") == 0) { /* NOTRANSLATE */
val = xd->lock;
break;
}
if (strcmp(key, "gets") == 0) { /* NOTRANSLATE */
ival = xd->gets;
return UINT2NUM(ival);
}
if (strcmp(key, "color") == 0) { /* NOTRANSLATE */
ival = xd->color;
return UINT2NUM(ival);
}
if (strcmp(key, "dlimit_max") == 0) { /* NOTRANSLATE */
ival = xd->dlimit_max;
return UINT2NUM(ival);
}
if (strcmp(key, "dlimit_used") == 0) { /* NOTRANSLATE */
ival = xd->dlimit_used;
return UINT2NUM(ival);
}
if (strcmp(key, "has_md5sum") == 0) { /* NOTRANSLATE */
ival = xd->has_md5sum;
return UINT2NUM(ival);
}
if (strcmp(key, "has_crc32") == 0) { /* NOTRANSLATE */
ival = xd->has_crc32;
return UINT2NUM(ival);
}
if (strcmp(key, "bytes") == 0) { /* NOTRANSLATE */
oval = xd->st_size;
return OFFT2NUM(oval);
}
if (strcmp(key, "size") == 0) { /* NOTRANSLATE */
tempstr = sizestr(0, xd->st_size);
len = strlen(tempstr);
rval = rb_str_new(tempstr, len);
mydelete(tempstr);
return rval;
}
if (strcmp(key, "mtime") == 0) { /* NOTRANSLATE */
return rb_time_new(xd->mtime, 0);
}
if (strcmp(key, "xtime") == 0) { /* NOTRANSLATE */
return rb_time_new(xd->xtime, 0);
}
if (strcmp(key, "crc32") == 0) { /* NOTRANSLATE */
tempstr = mymalloc(maxtextlengthshort);
len = add_snprintf(tempstr, maxtextlengthshort, CRC32_PRINT_FMT, xd->crc32);
rval = rb_str_new(tempstr, len);
mydelete(tempstr);
return rval;
}
if (strcmp(key, "md5sum") == 0) { /* NOTRANSLATE */
tempstr = mymalloc(maxtextlengthshort);
len = add_snprintf(tempstr, maxtextlengthshort, MD5_PRINT_FMT, MD5_PRINT_DATA(xd->md5sum));
rval = rb_str_new(tempstr, len);
mydelete(tempstr);
return rval;
}
/* minspeed, maxspeed */
return Qnil;
}
if (val == NULL)
return Qnil;
return rb_str_new(val, strlen(val));
}
static sf_count_t ra_vir_seek(sf_count_t offset, int whence, void *user_data) {
VALUE io = (VALUE)user_data;
rb_funcall(io, id_seek, 2, OFFT2NUM(offset), INT2FIX(whence));
return NUM2OFFT(rb_funcall(io, id_tell, 0));
}