void camera_extract(void *obj, char *func){ return; //tCamera *camera = (tCamera *)obj; try { cout << func << endl; vector<string> elems = split(func, '_'); /* cout << "size : " << elems.size() << endl; vector<string>::iterator it; cout << "elems contains:"; for ( it=elems.begin() ; it < elems.end(); it++ ) cout << " " << *it; cout << endl; */ if(elems[0] == "start") cout << "START !" << endl; else if(elems[0] == "stop") cout << "STOP !" << endl; else cout << "F**K !" << endl; long toto = ygets_l(0); ypush_long(toto); } catch ( string msg ) { y_error(msg.c_str()); } catch ( char const * msg ) { y_error(msg); } }
void Y_camera_obj(int argc) { tCamera *camera = (tCamera *) ypush_obj(&camera_yObj, sizeof(tCamera)); // memset(handle,0,sizeof(tCamera)); try { // initialise the Prosilica API if (!PvInitialize()) { // wait for a camera to be plugged waitForCamera(); // get a camera from the list cameraGet(camera); // setup the camera cameraSetup(camera); } else { throw "failed to initialise the API\n"; } } catch ( string msg ) { y_error(msg.c_str()); } catch ( char const * msg ) { y_error(msg); } }
void Y_gy_setlocale(int argc) { if (argc > 2) y_error("gy_setlocale, [[CATEGORY, ], LOCALE]"); char * scat="LC_ALL"; char * sloc =NULL; int cat=0; if (argc == 2) scat = ygets_q(1); if (yarg_string(0)) sloc = ygets_q(0); if (!strcmp(scat, "LC_ALL")) cat = LC_ALL; else if (!strcmp(scat, "LC_COLLATE")) cat = LC_COLLATE; else if (!strcmp(scat, "LC_CTYPE")) cat = LC_CTYPE; else if (!strcmp(scat, "LC_MONETARY")) cat = LC_MONETARY; else if (!strcmp(scat, "LC_NUMERIC")) cat = LC_NUMERIC; else if (!strcmp(scat, "LC_TIME")) cat = LC_TIME; else y_error("unsupported locale category"); if (sloc && cat==LC_NUMERIC && strcmp(sloc, "C")) y_error("Yorick does not support LC_NUMERIC != \"C\""); *ypush_q(0) = p_strcpy(setlocale(cat, sloc)); setlocale(LC_NUMERIC, "C"); }
void yav_opencodec(yav_ctxt *obj, unsigned int width, unsigned int height) { obj->video_st->codec->width=width; obj->video_st->codec->height=height; av_dump_format(obj->oc, 0, obj->oc->filename, 1); if (obj->video_st) { AVCodecContext *c; c = obj->video_st->codec; if (avcodec_open2(c, obj->codec, NULL) < 0) y_error("could not open codec\n"); obj->picture = av_frame_alloc(); if (!obj->picture) y_error("Could not allocate picture"); int size = avpicture_get_size(c->pix_fmt, c->width, c->height); uint8_t *picture_buf = av_malloc(size); if (!picture_buf) { av_frame_free(&obj->picture); y_error("unable to allocate memory"); } avpicture_fill((AVPicture *)obj->picture, picture_buf, c->pix_fmt, c->width, c->height); if (obj->oc->oformat->video_codec == AV_CODEC_ID_H264 || obj->oc->oformat->video_codec == AV_CODEC_ID_THEORA) obj->picture->pts=-1; /* if the output format is not RGB24, then a temporary RGB24 picture is needed too. It is then converted to the required output format */ if (c->pix_fmt != AV_PIX_FMT_RGB24) { obj->tmp_picture = av_frame_alloc(); if (!obj->tmp_picture) { y_error("Could not allocate picture"); } size = avpicture_get_size(AV_PIX_FMT_RGB24, c->width, c->height); uint8_t *tmp_picture_buf = av_malloc(size); if (!tmp_picture_buf) { av_frame_free(&obj->tmp_picture); av_frame_free(&obj->picture); y_error("unable to allocate memory"); } avpicture_fill((AVPicture *)obj->tmp_picture, tmp_picture_buf, AV_PIX_FMT_RGB24, c->width, c->height); } } /* open the output file, if needed */ if (!(obj->oc->oformat->flags & AVFMT_NOFILE)) if (avio_open(&obj->oc->pb, obj->oc->filename, AVIO_FLAG_WRITE) < 0) y_errorq("Could not open '%s'", obj->oc->filename); obj->open = 1; /* write the stream header, if any */ avformat_write_header(obj->oc, NULL); }
static void failure(const char* reason, int code) { static char msg[256]; if (reason == NULL || reason[0] == 0) { y_error(get_error_description(code)); } else { sprintf(msg, "%s [%s]", reason, get_error_name(code)); y_error(msg); } }
void camera_free(void *obj) { tCamera *camera = (tCamera *) obj; try { // unsetup the camera cameraUnsetup(camera); // uninitialise the API PvUnInitialize(); } catch ( string msg ) { y_error(msg.c_str()); } catch ( char const * msg ) { y_error(msg); } }
static void load_device_list(void) { INITIALIZE; free_dev_list(); /* in case of interrupts */ dev_count = libusb_get_device_list(ctx, &dev_list); if (dev_count < 0) { y_error("failed to get USB devices list"); } }
long yarg_key(int iarg) { if (iarg>=0 && !sp[-iarg].ops) { if (!iarg) y_error("(BUG) stack corrupted in yarg_key"); return sp[-iarg].index; } return -1; }
static void initialize(void) { if (ctx == NULL) { int code = libusb_init(&ctx); if (code != 0) { if (ctx != NULL) { y_error("*** ASSERTION FAILED *** non NULL context on libusb_init failure"); } failure(NULL, code); } if (ctx == NULL) { y_error("*** ASSERTION FAILED *** NULL context on libusb_init success"); } ycall_on_quit(finalize); libusb_set_debug(ctx, LIBUSB_LOG_LEVEL_NONE); libusb_setlocale("en"); } }
ypointer_t ygets_p(int iarg) { Operations *ops; Member *type; void **p; if (iarg < 0) return 0; p = ygeta_array(iarg, &ops, &type); if (ops!=&pointerOps || type->dims) y_error("expecting scalar pointer argument"); return p[0]; }
ystring_t ygets_q(int iarg) { Operations *ops; Member *type; char **q; if (iarg < 0) return 0; q = ygeta_array(iarg, &ops, &type); if (ops!=&stringOps || type->dims) y_error("expecting scalar string argument"); return q[0]; }
void Y_usb_debug(int argc) { int level; if (argc != 1) { y_error("expecting exactly one argument"); } level = ygets_i(0); INITIALIZE; libusb_set_debug(ctx, level); ypush_nil(); }
ypointer_t * ygeta_p(int iarg, long *ntot, long *dims) { Operations *ops; Member *type; void *p; if (iarg < 0) return 0; p = ygeta_array(iarg, &ops, &type); yget_dims(ntot, dims, type); if (ops != &pointerOps) y_error("expecting pointer argument"); return p; }
void Y_usb_control_transfer(int argc) { ydev_instance_t* obj; int ret; int type, request, value, index, length; long size; unsigned char* data; unsigned int timeout; /* Get arguments. */ if (argc != 8) { y_error("expecting exactly 8 arguments"); } obj = get_device(7); type = ygets_i(6) & 0xff; /* uint8_t */ request = ygets_i(5) & 0xff; /* uint8_t */ value = ygets_i(4) & 0xffff; /* uint16_t */ index = ygets_i(3) & 0xffff; /* uint16_t */ data = (unsigned char*)get_data(2, &size); length = ygets_i(1) & 0xffff; /* uint16_t */ timeout = (unsigned int)(ygets_l(0) & 0xffffffffL); if (length < 0) { y_error("invalid length"); } if (length > size) { y_error("length must be at most the size of the data"); } /* Apply operation. */ ret = libusb_control_transfer(obj->handle, type, request, value, index, data, length, timeout); if (ret < 0 && yarg_subroutine()) { failure(NULL, ret); } ypush_int(ret); }
void Y_timestamp(int argc) { time_t n_time = time((void *)0); char *time = ctime(&n_time); long index = yget_ref(0); if (argc != 1) y_error("timestamp takes exactly one argument"); if (index >= 0) { ypush_long((long)n_time); yput_global(index, 0); } if (!yarg_subroutine()) { char **q = ypush_q(0); q[0] = p_strcpy(strtok(time, "\n")); } }
int yarg_kw(int iarg, long *kglobs, int *kiargs) { long n, *globs, vndex; while (iarg>=0 && !sp[-iarg].ops) { if (!iarg) y_error("(BUG) stack corrupted in yarg_kw"); vndex = sp[-iarg].index; n = kglobs[0]; for (globs=kglobs+1 ; --n >= 0 ; globs++) if (globs[0] == vndex) break; if (n < 0) y_errorq("unrecognized keyword: %s", globalTable.names[vndex]); kiargs[kglobs[0]-1-n] = --iarg; --iarg; } return iarg; }
void Y_usb_claim_interface(int argc) { ydev_instance_t* obj; int interface_number; int ret; if (argc != 2) { y_error("expecting exactly 2 arguments"); } obj = get_device(1); interface_number = ygets_i(0); ret = libusb_claim_interface(obj->handle, interface_number); if (ret < 0 && yarg_subroutine()) { failure(NULL, ret); } ypush_int(ret); }
static void* get_data(int iarg, long* the_size) { void* data; long size, ntot; int type; data = NULL; size = 0; if (! yarg_nil(iarg)) { data = ygeta_any(iarg, &ntot, NULL, &type); switch(type) { case Y_CHAR: size = sizeof(char)*ntot; break; case Y_SHORT: size = sizeof(short)*ntot; break; case Y_INT: size = sizeof(int)*ntot; break; case Y_LONG: size = sizeof(long)*ntot; break; case Y_FLOAT: size = sizeof(float)*ntot; break; case Y_DOUBLE: size = sizeof(double)*ntot; break; case Y_COMPLEX: size = 2*sizeof(double)*ntot; break; default: y_error("bad data type"); } } if (the_size != NULL) { *the_size = size; } return data; }
void Y_usb_open_device(int argc) { ydev_instance_t *obj = NULL; libusb_device* dev; int bus, port; int i, ret; if (argc != 2) { y_error("expecting exactly 2 arguments"); } bus = ygets_i(1); port = ygets_i(0); load_device_list(); for (i = 0; i < dev_count; ++i) { dev = dev_list[i]; if (libusb_get_bus_number(dev) == bus && libusb_get_port_number(dev) == port) { obj = (ydev_instance_t *)ypush_obj(&ydev_class, sizeof(ydev_instance_t)); obj->device = libusb_ref_device(dev); ret = libusb_open(obj->device, &obj->handle); if (ret < 0) { obj->handle = NULL; failure("failed to open device", ret); } obj->bus = bus; obj->port = port; obj->address = libusb_get_device_address(dev); ret = libusb_get_device_descriptor(dev, &obj->descriptor); if (ret != 0) { free_dev_list(); failure("unable to get device descriptor", ret); } break; } } free_dev_list(); if (obj == NULL) { ypush_nil(); } }
void Y_usb_get_string(int argc) { char str[STRING_DESCRIPTOR_SIZE]; ydev_instance_t* obj; int index; int ret; if (argc != 2) { y_error("expecting exactly 2 arguments"); } obj = get_device(1); index = ygets_i(0); ret = get_string_descriptor(obj->handle, index, str, sizeof(str)); if (ret < 0) { ypush_int(ret); } else { str[sizeof(str)/sizeof(str[0]) - 1] = 0; push_string(str); } }
static void ydev_extract(void *addr, char *member) { ydev_instance_t *obj = (ydev_instance_t *)addr; int c = (member != NULL ? member[0] : '\0'); if (c == 'b' && strcmp(member, "bus") == 0) { ypush_int(obj->bus); } else if (c == 'p' && strcmp(member, "port") == 0) { ypush_int(obj->port); } else if (c == 'a' && strcmp(member, "address") == 0) { ypush_int(obj->address); } else if (c == 'v' && strcmp(member, "vendor") == 0) { ypush_int(obj->descriptor.idVendor); } else if (c == 'p' && strcmp(member, "product") == 0) { ypush_int(obj->descriptor.idProduct); } else if (c == 'm' && strcmp(member, "manufacturer") == 0) { ypush_int(obj->descriptor.iManufacturer); } else if (c == 's' && strcmp(member, "serial") == 0) { ypush_int(obj->descriptor.iSerialNumber); } else { y_error("bad member name"); } }
void Y__usb_probe_devices(int argc) { struct libusb_device_descriptor desc; libusb_device* dev; long dims[3]; int* data; int i, ret; if (argc != 1 || ! yarg_nil(0)) { y_error("expecting exactly one nil argument"); } load_device_list(); if (dev_count > 0) { dims[0] = 2; dims[1] = 7; dims[2] = dev_count; data = ypush_i(dims); for (i = 0; i < dev_count; ++i) { dev = dev_list[i]; ret = libusb_get_device_descriptor(dev, &desc); if (ret != 0) { free_dev_list(); failure("unable to get device descriptor", ret); } data[0] = libusb_get_bus_number(dev); data[1] = libusb_get_port_number(dev); data[2] = libusb_get_device_address(dev); data[3] = desc.idVendor; data[4] = desc.idProduct; data[5] = desc.iManufacturer; data[6] = desc.iSerialNumber; data += 7; } } else { ypush_nil(); } free_dev_list(); }
long ygets_l(int iarg) { Operations *ops; Member *type; void *p; if (iarg < 0) return 0; p = ygeta_array(iarg, &ops, &type); if (!type->dims && ops->promoteID<T_FLOAT) { if (ops != &longOps) { int is_db = (sp[-iarg].ops == &dataBlockSym); long x; y_to_l[ops->promoteID](p, &x, type->number); sp[-iarg].ops = &longScalar; if (is_db) Unref(sp[-iarg].value.db); sp[-iarg].value.l = x; return x; } return *(long *)p; } y_error("expecting scalar integer argument"); return 0; }
double ygets_d(int iarg) { Operations *ops; Member *type; void *p; if (iarg < 0) return 0; p = ygeta_array(iarg, &ops, &type); if (!type->dims && ops->promoteID<T_COMPLEX) { if (ops != &doubleOps) { int is_db = (sp[-iarg].ops == &dataBlockSym); double x; y_to_d[ops->promoteID](p, &x, type->number); sp[-iarg].ops = &doubleScalar; if (is_db) Unref(sp[-iarg].value.db); sp[-iarg].value.d = x; return x; } return *(double *)p; } y_error("expecting scalar real argument"); return 0; }
void gy_value_set_iarg(GValue* pval, GITypeInfo * info, int iarg) { GY_DEBUG("in gy_value_set_iarg\n"); GITypeTag type = g_type_info_get_tag(info); GIBaseInfo * itrf; switch (type) { case GI_TYPE_TAG_BOOLEAN: g_value_set_boolean(pval, ygets_c(iarg)); break; case GI_TYPE_TAG_INT8: g_value_set_schar(pval, ygets_c(iarg)); break; case GI_TYPE_TAG_UINT8: g_value_set_uchar(pval, ygets_c(iarg)); break; case GI_TYPE_TAG_INT16: case GI_TYPE_TAG_INT32: g_value_set_int(pval, ygets_i(iarg)); break; case GI_TYPE_TAG_UINT16: case GI_TYPE_TAG_UINT32: g_value_set_uint(pval, ygets_i(iarg)); break; case GI_TYPE_TAG_INT64: g_value_set_int64(pval, ygets_l(iarg)); break; case GI_TYPE_TAG_UINT64: g_value_set_uint64(pval, ygets_l(iarg)); break; case GI_TYPE_TAG_FLOAT: g_value_set_float(pval, ygets_f(iarg)); break; case GI_TYPE_TAG_DOUBLE: g_value_set_double(pval, ygets_d(iarg)); break; case GI_TYPE_TAG_GTYPE: g_value_set_gtype(pval, ygets_l(iarg)); break; case GI_TYPE_TAG_UTF8: case GI_TYPE_TAG_FILENAME: g_value_set_static_string (pval, ygets_q(iarg)); GY_DEBUG("GValue is string: \"%s\"\n", ygets_q(iarg)); break; /* interface types */ case GI_TYPE_TAG_INTERFACE: itrf = g_type_info_get_interface(info); switch(g_base_info_get_type (itrf)) { case GI_INFO_TYPE_ENUM: g_value_set_enum (pval, ygets_l(iarg)); break; case GI_INFO_TYPE_OBJECT: g_value_set_object(pval, yget_gy_Object(iarg)->object); break; default: y_errorn("Unimplemented GValue interface type %ld", g_base_info_get_type (itrf)); } g_base_info_unref(itrf); break; case GI_TYPE_TAG_VOID: default: y_error("Unimplement property GValue type"); } GY_DEBUG("out gy_iarg2gvalue\n"); }
void gy_value_init(GValue * val, GITypeInfo * info) { GY_DEBUG("in gy_value_init\n"); GITypeTag type = g_type_info_get_tag(info); GIBaseInfo * itrf; GY_DEBUG("Initializing GValue to %s\n", g_type_tag_to_string(type)); switch (type) { /* basic types */ case GI_TYPE_TAG_BOOLEAN: g_value_init(val, G_TYPE_BOOLEAN); break; case GI_TYPE_TAG_INT8: g_value_init(val, G_TYPE_CHAR); break; case GI_TYPE_TAG_UINT8: g_value_init(val, G_TYPE_UCHAR); break; case GI_TYPE_TAG_INT16: case GI_TYPE_TAG_INT32: g_value_init(val, G_TYPE_INT); break; case GI_TYPE_TAG_UINT16: case GI_TYPE_TAG_UINT32: g_value_init(val, G_TYPE_INT); break; case GI_TYPE_TAG_INT64: g_value_init(val, G_TYPE_INT64); break; case GI_TYPE_TAG_UINT64: g_value_init(val, G_TYPE_UINT64); break; case GI_TYPE_TAG_FLOAT: g_value_init(val, G_TYPE_FLOAT); break; case GI_TYPE_TAG_DOUBLE: g_value_init(val, G_TYPE_DOUBLE); break; case GI_TYPE_TAG_GTYPE: g_value_init(val, G_TYPE_GTYPE); break; case GI_TYPE_TAG_UTF8: case GI_TYPE_TAG_FILENAME: g_value_init(val, G_TYPE_STRING); GY_DEBUG("GValue is string\n"); break; /* interface types */ case GI_TYPE_TAG_INTERFACE: itrf = g_type_info_get_interface(info); switch(g_base_info_get_type (itrf)) { case GI_INFO_TYPE_OBJECT: g_value_init(val, G_TYPE_OBJECT); break; case GI_INFO_TYPE_ENUM: g_value_init(val, g_registered_type_info_get_g_type(itrf)); GY_DEBUG("GValue is enum\n"); break; default: y_errorn("Unimplemented GValue interface type %ld", g_base_info_get_type (itrf)); } g_base_info_unref(itrf); break; case GI_TYPE_TAG_VOID: default: y_error("Unimplement property GValue type"); } GY_DEBUG("out gy_value_init\n"); }
void gy_value_push(GValue * pval, GITypeInfo * info, gy_Object* o) { GITypeTag tag = g_type_info_get_tag(info); GY_DEBUG("Pushing %s from GValue\n", g_type_tag_to_string(tag)); switch (tag) { /* basic types */ case GI_TYPE_TAG_VOID:{ GITypeInfo * cellinfo = g_type_info_get_param_type(info, 0); if (cellinfo) { GITypeTag ctag = g_type_info_get_tag(cellinfo); GY_DEBUG("void contains %s\n", g_type_tag_to_string(ctag)); g_base_info_unref(cellinfo); } ypush_nil(); break;} case GI_TYPE_TAG_BOOLEAN: *ypush_c(NULL) = g_value_get_boolean(pval); break; case GI_TYPE_TAG_INT8: *ypush_gint8(NULL) = g_value_get_schar(pval); break; case GI_TYPE_TAG_UINT8: *ypush_guint8(NULL)= g_value_get_uchar(pval); break; case GI_TYPE_TAG_INT16: case GI_TYPE_TAG_INT32: *ypush_gint32(NULL) = g_value_get_int(pval); break; case GI_TYPE_TAG_UINT16: case GI_TYPE_TAG_UINT32: *ypush_guint32(NULL) = g_value_get_uint(pval); break; case GI_TYPE_TAG_INT64: ypush_long(g_value_get_int64(pval)); break; case GI_TYPE_TAG_UINT64: ypush_long(g_value_get_uint64(pval)); break; case GI_TYPE_TAG_FLOAT: *ypush_f(NULL)=g_value_get_float(pval); break; case GI_TYPE_TAG_DOUBLE: ypush_double(g_value_get_double(pval)); break; case GI_TYPE_TAG_GTYPE: ypush_long(g_value_get_gtype(pval)); break; case GI_TYPE_TAG_UTF8: case GI_TYPE_TAG_FILENAME: *ypush_q(NULL) = p_strcpy(g_value_get_string(pval)); break; /* array types */ case GI_TYPE_TAG_ARRAY: y_error("array"); break; /* interface types */ case GI_TYPE_TAG_INTERFACE: { GIBaseInfo * itrf = g_type_info_get_interface (info); switch(g_base_info_get_type (itrf)) { case GI_INFO_TYPE_ENUM: ypush_long(g_value_get_enum(pval)); g_base_info_unref(itrf); break; case GI_INFO_TYPE_OBJECT: { GObject * prop=g_value_get_object(pval); g_object_ref_sink(prop); if (!prop) { g_base_info_unref(itrf); y_error("get property failed"); } GY_DEBUG("pushing result... "); ypush_check(1); gy_Object * out = ypush_gy_Object(); out->info=itrf; out->object=prop; out->repo=o->repo; } break; default: g_base_info_unref(itrf); y_error ("fix me: only properties of type object supported yet"); } break; } default: y_error("Unimplemented"); } }
static void do_transfer(int argc, int (*transfer)(struct libusb_device_handle* handle, unsigned char endpoint, unsigned char* data, int length, int* transferred, unsigned int timeout)) { ydev_instance_t* obj; int ret, iarg; int endpoint, length, transferred, offset; long size; unsigned char* data; unsigned int timeout; long transferred_index; /* Get arguments. */ if (argc != 6 && argc != 7) { y_error("expecting 6 or 7 arguments"); } iarg = argc; obj = get_device(--iarg); endpoint = ygets_i(--iarg) & 0xff; /* uint8_t */ data = (unsigned char*)get_data(--iarg, &size); length = ygets_i(--iarg); if (length < 0) { y_error("invalid length"); } if (length > size) { y_error("length must be at most the size of the data"); } transferred_index = yget_ref(--iarg); if (transferred_index < 0L) { y_error("expecting a simple variable reference"); } timeout = (unsigned int)(ygets_l(--iarg) & 0xffffffffL); if (iarg > 0) { offset = ygets_i(--iarg); if (offset < 0 || offset > length) { y_error("invalid offset"); } } else { offset = 0; } /* Apply operation. */ if (length > offset) { ret = transfer(obj->handle, endpoint, data + offset, length - offset, &transferred, timeout); if (!(ret == 0 || (ret == LIBUSB_ERROR_TIMEOUT && transferred > 0))) { /* No data has been transferred. */ transferred = 0; if (yarg_subroutine()) { /* Some error has occured. */ failure(NULL, ret); } } } else { /* Nothing to do. */ transferred = 0; ret = 0; } if (transferred_index >= 0L) { /* Store total number of transferred bytes so far. */ ypush_int(offset + transferred); yput_global(transferred_index, 0); } ypush_int(ret); }
// av_opt_set missing at least until this version int av_opt_set (void *obj, const char * name, const char * val, int search_flags) { y_error("av_opt_set unimplemented in this libav/ffmpeg"); return -1; }
void Y_usb_error_description(int argc) { if (argc != 1) y_error("expected exactly one argument"); push_string(get_error_description(ygets_i(0))); }