void Y__usb_init(int argc) { #undef ERROR_ENTRY #define ERROR_ENTRY(a,b) define_global_int("USB_"#a, LIBUSB_##a); ERROR_TABLE; ypush_nil(); }
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(); }
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_summary(int argc) { ssize_t i; libusb_device_handle* handle; load_device_list(); for (i = 0; i < dev_count; ++i) { int code; struct libusb_device_descriptor desc; libusb_device* dev = dev_list[i]; uint8_t bus_number = libusb_get_bus_number(dev); uint8_t port_number = libusb_get_port_number(dev); uint8_t device_address = libusb_get_device_address(dev); fprintf(stdout, "USB Device %ld:\n", (long)i); fprintf(stdout, " Bus Number ---------> %d\n", (int)bus_number); fprintf(stdout, " Port Number --------> %d\n", (int)port_number); fprintf(stdout, " Device Address -----> %d\n", (int)device_address); code = libusb_get_device_descriptor(dev, &desc); if (code != 0) { failure(NULL, code); } fprintf(stdout, " Vendor ID ----------> 0x%04x\n", (unsigned int)desc.idVendor); fprintf(stdout, " Product ID ---------> 0x%04x\n", (unsigned int)desc.idProduct); code = libusb_open(dev, &handle); if (code == 0) { fprintf(stdout, " Manufacturer -------> %s\n", get_string(handle, desc.iManufacturer)); fprintf(stdout, " Product ------------> %s\n", get_string(handle, desc.idProduct)); fprintf(stdout, " Serial Number ------> %s\n", get_string(handle, desc.iSerialNumber)); libusb_close(handle); } } free_dev_list(); ypush_nil(); }
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(); }
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"); } }
void Y_av_write(int argc) { yav_ctxt * obj = yget_obj(argc-1, &yav_ops); AVCodecContext *c = obj->video_st->codec; long ntot=0; long dims[Y_DIMSIZE]={0,0}; uint8_t *data = ygeta_c(argc-2, &ntot, dims); if (!c->width) yav_opencodec(obj, dims[2], dims[3]); if (dims[0]!=3 || dims[1]!=3 || dims[2]!=c->width || dims[3]!=c->height) y_error("DATA should be an array(char, 3, width, height)"); long npix=dims[2]*dims[3]; const uint8_t *src[4] = {data, 0, 0, 0}; int src_linesizes[4] = {3*c->width,0,0,0}; if (c->pix_fmt != AV_PIX_FMT_RGB24) { /* as we only generate a RGB24 picture, we must convert it to the codec pixel format if needed */ obj->img_convert_ctx = sws_getCachedContext(obj->img_convert_ctx, c->width, c->height, AV_PIX_FMT_RGB24, c->width, c->height, c->pix_fmt, SWS_BICUBIC, NULL, NULL, NULL); if (obj->img_convert_ctx == NULL) y_error("Cannot initialize the conversion context"); av_image_copy(obj->tmp_picture->data, obj->tmp_picture->linesize, src, src_linesizes, AV_PIX_FMT_RGB24, c->width, c->height); sws_scale(obj->img_convert_ctx, (const uint8_t * const*)obj->tmp_picture->data, obj->tmp_picture->linesize, 0, c->height, obj->picture->data, obj->picture->linesize); } else { av_image_copy(obj->picture->data, obj->picture->linesize, src, src_linesizes, AV_PIX_FMT_RGB24, c->width, c->height); } /* encode the image */ if (obj->oc->oformat->flags & AVFMT_RAWPICTURE) y_error("RAW picture not supported"); if (obj->oc->oformat->video_codec == AV_CODEC_ID_H264 || obj->oc->oformat->video_codec == AV_CODEC_ID_THEORA) ++obj->picture->pts; int ret=0; #if (LIBAVCODEC_VERSION_MAJOR > 53) if (obj->oc->oformat->flags & AVFMT_RAWPICTURE) { /* Raw video case - directly store the picture in the packet */ AVPacket pkt; av_init_packet(&pkt); pkt.flags |= AV_PKT_FLAG_KEY; pkt.stream_index = obj->video_st->index; pkt.data= obj->video_outbuf; // pkt.size= out_size; // pkt.data = dst_picture.data[0]; pkt.size = sizeof(AVPicture); ret = av_interleaved_write_frame(obj->oc, &pkt); } else { AVPacket pkt = { 0 }; int got_packet; av_init_packet(&pkt); /* encode the image */ ret = avcodec_encode_video2(c, &pkt, obj->picture, &got_packet); if (ret < 0) { y_errorn("Error encoding video frame: %d", ret); } /* If size is zero, it means the image was buffered. */ if (!ret && got_packet && pkt.size) { pkt.stream_index = obj->video_st->index; /* Write the compressed frame to the media file. */ ret = av_interleaved_write_frame(obj->oc, &pkt); } else { ret = 0; } } #else int out_size = avcodec_encode_video(c, obj->video_outbuf, obj->video_outbuf_size, obj->picture); /* if zero size, it means the image was buffered */ if (out_size > 0) { AVPacket pkt; av_init_packet(&pkt); if (c->coded_frame->pts != AV_NOPTS_VALUE) pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, obj->video_st->time_base); if(c->coded_frame->key_frame) pkt.flags |= AV_PKT_FLAG_KEY; pkt.stream_index= obj->video_st->index; pkt.data= obj->video_outbuf; pkt.size= out_size; /* write the compressed frame in the media file */ ret = av_interleaved_write_frame(obj->oc, &pkt); } #endif if (ret != 0) y_errorn("Error while writing video frame: %d", ret); /* return [] */ ypush_nil(); }