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();
}
