static int v4l2_case_take_pic(void* user_ptr, int test_num) { FUNC_ENTER() BLTS_DEBUG("Test number %i:\n", test_num); v4l2_data* data = (v4l2_data*)user_ptr; if(!open_device (data->device)) { BLTS_ERROR("Can't open device %s\n", data->device->dev_name); return -1; } if(init_device (data->device, data->device->requested_format.fmt.pix.width, data->device->requested_format.fmt.pix.height)) { if(data->snapshot_filename != NULL) { free(data->snapshot_filename); data->snapshot_filename = NULL; } data->snapshot_filename = create_picture_filename(data->device); BLTS_DEBUG("Filename to create: '%s'\n", data->snapshot_filename); BLTS_DEBUG("Maximum resolution is: %ix%i\n", data->device->format.fmt.pix.width, data->device->format.fmt.pix.height); if(!start_capturing (data->device)) goto err; if(!mainloop (data->device, 0)) goto err; BLTS_DEBUG("Taking picture %s\n", data->snapshot_filename); if(!do_snapshot (data->device, data->snapshot_filename)) goto err; // ensure that image is actual JPEG if(read_jpeg_image(data->snapshot_filename)) { BLTS_DEBUG("Error, image %s is not JPEG standard.\n", data->snapshot_filename); return -1; } stop_capturing (data->device); uninit_device (data->device); } else { BLTS_ERROR("Can't initialize device\n"); goto err; } close_device (data->device); FUNC_LEAVE() return 0; err: stop_capturing(data->device); uninit_device(data->device); close_device(data->device); FUNC_LEAVE() return -1; }
static int v4l2_run_stream(v4l2_data *data, int do_crop) { int loops = 50; int screen_height = SCREEN_WIDTH; int screen_width = SCREEN_HEIGHT; if (!open_device(data->device)) { BLTS_DEBUG("Can't open device %s\n", data->device->dev_name); return -1; } data->device->use_streaming = 1; if (init_device(data->device, screen_width, screen_height)) { int w = data->device->format.fmt.pix.width; int h = data->device->format.fmt.pix.height; xvideo_init(w, h, 0); if (!start_capturing(data->device)) goto err; if (do_crop) { if (!crop_corners(data->device, loops)) goto err; } else { if (!stream_image_xv(data->device, loops)) goto err; } stop_capturing(data->device); uninit_device(data->device); } else { close_device(data->device); BLTS_DEBUG("Could not open device\n"); data->device->use_streaming = 0; return -1; } data->device->use_streaming = 0; close_device(data->device); xvideo_deinit(); return 0; err: data->device->use_streaming = 0; stop_capturing(data->device); uninit_device(data->device); close_device(data->device); xvideo_deinit(); return -1; }
void life_cycle() { fprintf(stderr, "Beginning life cycle\n"); if (!dev_name) { if (vendor >= 0 || product >= 0) { if (vendor < 0 || product < 0) { err("Either give both vendor and product ID or none"); } int dev_id = find_camera(vendor, product); if (dev_id >= 0) { snprintf(dev_name_buf, FULLNAME_MAX_LEN, "/dev/video%d", dev_id); dev_name = &dev_name_buf[0]; } else { err("Could not find device"); } } else { dev_name = "/dev/video0"; } } fprintf(stderr, "Using device %s\n", dev_name); open_device(); init_device(); start_capturing(); mainloop(); stop_capturing(); uninit_device(); close_device(); fprintf(stderr, "Finishing life cycle\n"); }
void camera_uninit(int *fd, camera_buffer *camera_buffers, int camera_count){ int i; for (i=0;i<camera_count;i++){ stop_capturing(fd[i]); uninit_device(&camera_buffers[i]); close_device(&fd[i]); } }
void v4l2_close(struct camera *cam) { stop_capturing(cam); uninit_camera(cam); close_camera(cam); free(cam); close_file(); close_encoder(); }
void V4L2W_finalize(V4L2WHandler_t * handle) { stop_capturing (handle); uninit_device (handle); close_device (handle); free(handle->outimg); free(handle); }
int videodev_stop (void) { printf("videocapture: exit\n"); stop_capturing(); close_device(); uninit_device(); SDL_FreeSurface(data_sf); free(buffer_sdl); return 0; }
int ExitImage() { stop_capturing(); uninit_device(); close_device(); printf ("ExitImage success\n"); return (0); }
void video_cleanup( IMAGE_CONTEXT *v1, IMAGE_CONTEXT *v2 ) { stop_capturing(); uninit_device(); close_device(); image_destroy( v1 ); image_destroy( v2 ); }
int main(int argc, char **argv) { int ret = 0; #ifdef TEST_CONTROLS if (argc != 8) { printf ("%s width height num_of_frames bright contrast saturation sharpness\n", argv[0]); printf("EX) $ %s 640 480 3 0 0 0 24612 \n", argv[0]); goto err; } #else if (argc != 4) { printf ("%s width height num_of_frames bright contrast saturation sharpness\n", argv[0]); printf("EX) $ %s 640 480 3\n", argv[0]); goto err; } #endif g_pix_width = atoi(argv[1]); g_pix_height = atoi(argv[2]); g_file_count = atoi(argv[3]) + 1; #ifdef TEST_CONTROLS g_brightness = atoi(argv[4]); g_contrast = atoi(argv[5]); g_saturation = atoi(argv[6]); g_sharpness = atoi(argv[7]); #endif g_img_buf = malloc(g_pix_width * g_pix_height * 3 * sizeof(char)); open_device(); set_input_chann(0); init_v4l2_device(); ret = init_mmap(&n_buffers); if (ret) errno_exit("init_mmap error !!!"); #ifdef TEST_CONTROLS start_control_testing(); #endif start_capturing(buffers); mainloop(); stop_capturing(); close_mmap(); close_device(); free(g_img_buf); exit(EXIT_SUCCESS); err: return ret; }
void Webcam::close_device() { if( isStreaming() ) stop_capturing(); if( fd != -1 ) close(fd); //assure fd=-1; }
static int test_frame_rate(v4l2_dev_data *dev, float* fps, float* calculated_fps) { int loops = 100; int screen_height = SCREEN_WIDTH; int screen_width = SCREEN_HEIGHT; dev->use_streaming = 1; if (init_device(dev, screen_width, screen_height)) { xvideo_init(dev->format.fmt.pix.width, dev->format.fmt.pix.height, 0); if (!start_capturing(dev)) goto err; if (!stream_image_xv(dev, loops)) goto err; *calculated_fps = dev->calculated_frame_rate; stop_capturing(dev); uninit_device(dev); xvideo_deinit(); } else { close_device(dev); BLTS_DEBUG("Could not open device\n"); dev->use_streaming = 0; return -1; } return 0; err: dev->use_streaming = 0; stop_capturing(dev); uninit_device(dev); xvideo_deinit(); return -1; }
void video_close() { pthread_cancel(video_thread); stop_capturing(); uninit_device(); close_device(); if(save) fclose(file_fd); }
static int v4l2_case_read_with_poll(void* user_ptr, int test_num) { v4l2_data* data = (v4l2_data*)user_ptr; if (!open_device(data->device)) { BLTS_ERROR("Can't open device %s\n", data->device->dev_name); return -1; } if (!init_device(data->device, data->device->requested_format.fmt.pix.width, data->device->requested_format.fmt.pix.height)) { BLTS_ERROR("Can't initialize device\n"); goto err; } BLTS_DEBUG("Resolution used: %ix%i\n", data->device->format.fmt.pix.width, data->device->format.fmt.pix.height); if (!start_capturing(data->device)) goto err; BLTS_DEBUG("Starting polled reads\n"); if (!mainloop(data->device, LOOPS)) goto err; stop_capturing(data->device); uninit_device(data->device); if (!close_device(data->device)) return -1; return 0; err: stop_capturing(data->device); uninit_device(data->device); close_device(data->device); return -1; }
int main() { int fd; fd = open_camer_device(); init_camer_device(fd); start_capturing(fd); mainloop(fd); stop_capturing(fd); uninit_camer_device(fd); close_camer_device(fd); return 0; }
int pointit_destroy_cap(void) { if (stop_capturing() != 0) return -1; if (uninit_device() != 0) return -1; if (close_device() != 0) return -1; #ifdef POINTIT_SDL free_sdl_surf(); #endif free(rgb_img); return 0; }
int main(int argc, char *argv[]) { //strcpy(output_file, argv[1]); open_device(); // ビデオバイスをオープン init_device(); // ビデオデバイスを初期化 start_capturing(); // 画像キャプチャ開始 mainloop(); // メインループ処理 stop_capturing(); // 画像キャプチャ停止 uninit_device(); // 初期化前の状態に戻す close_device(); // ビデオデバイスをクローズ return 0; }
void video_driver::restart_video () { stop_capturing (); uninit_device (); close_device (); open_device (); init_device (); start_capturing (); }
void stop_camera(int* fd, int* rgb_buffer, int* y_buffer) { stop_capturing(*fd); uninit_device(); close_device(fd); if(rgb_buffer) { free(rgb_buffer); } if(y_buffer) { free(y_buffer); } }
static int v4l2_case_measure_resolution(void* user_ptr, int test_num) { v4l2_data* data = (v4l2_data*)user_ptr; BLTS_DEBUG("Test number %i:\n", test_num); if(!open_device (data->device)) { BLTS_DEBUG("Can't open device %s\n", data->device->dev_name); return -1; } if(init_device (data->device, data->device->requested_format.fmt.pix.width, data->device->requested_format.fmt.pix.height)) { BLTS_DEBUG("Resolution gained: %ix%i\n", data->device->format.fmt.pix.width, data->device->format.fmt.pix.height); if(!start_capturing (data->device)) goto err; if(!mainloop(data->device, LOOPS)) goto err; stop_capturing (data->device); uninit_device (data->device); } else { BLTS_DEBUG("Can't initialize device\n"); goto err; } close_device (data->device); return 0; err: stop_capturing(data->device); uninit_device(data->device); close_device(data->device); return -1; }
int main() { open_device(); init_device(); init_mmap(); start_capturing(); mainloop(); stop_capturing(); uninit_mmap(); close_device(); return EXIT_SUCCESS; }
/** The DeInitialization function */ OMX_ERRORTYPE omx_videosrc_component_Deinit(OMX_COMPONENTTYPE *openmaxStandComp) { omx_videosrc_component_PrivateType* omx_videosrc_component_Private = openmaxStandComp->pComponentPrivate; DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__); stop_capturing(omx_videosrc_component_Private); /** closing input file */ omx_videosrc_component_Private->videoReady = OMX_FALSE; tsem_reset(omx_videosrc_component_Private->videoSyncSem); return OMX_ErrorNone; }
static void destructor(void *arg) { struct vidsrc_st *st = arg; if (st->run) { st->run = false; pthread_join(st->thread, NULL); } stop_capturing(st); uninit_device(st); if (st->fd >= 0) v4l2_close(st->fd); }
void* startcapture(void* dev) { can_stop = 1; capture* d = get_cap(); dev_name = d->device; wigth = d->weigth; heigth = d->height; open_device(); init_device(); start_capturing(); mainloop(d->refresh); stop_capturing(); uninit_device(); close_device(); return 0; }
int internal_main( output_callback_func_ptr callback_ptr ) { output = OUTPUT_CALLBACK; output_callback_ptr = callback_ptr; device_open(); init_device(); start_capturing(); capture_loop(); stop_capturing(); uninit_device(); device_close(); return 0; }
void usb_cam_camera_shutdown(void) { stop_capturing(); uninit_device(); close_device(); if (avcodec_context) { avcodec_close(avcodec_context); av_free(avcodec_context); avcodec_context = NULL; } if (avframe_camera) av_free(avframe_camera); avframe_camera = NULL; if (avframe_rgb) av_free(avframe_rgb); avframe_rgb = NULL; }
int main(int argc, char **argv) { dev_name = "/dev/video"; for (;;) { int index; int c; c = getopt_long(argc, argv, short_options, long_options, &index); if (-1 == c) break; switch (c) { case 0: /* getopt_long() flag */ break; case 'd': dev_name = optarg; break; case 'h': usage(stdout, argc, argv); exit(EXIT_SUCCESS); case 'm': io = IO_METHOD_MMAP; break; case 'r': io = IO_METHOD_READ; break; case 'u': io = IO_METHOD_USERPTR; break; default: usage(stderr, argc, argv); exit(EXIT_FAILURE); } } open_device(); init_device(); start_capturing(); mainloop(); stop_capturing(); uninit_device(); close_device(); fputc('\n', stdout); exit(EXIT_SUCCESS); return 0; }
V4LCapture::~V4LCapture() { if(param.replay_mode) { free(buffers->start); free(buffers); }else{ stop_capturing(); uninit_device(); close_device(); } if(video_rec){ fclose(video_rec); } if(time_rec){ fclose(time_rec); } if(dev_name){ free(dev_name); } };
static void enc_destructor(void *arg) { struct videnc_state *st = arg; if (st->fd >=0 ) { info("v4l2_codec: encoder stats" " (keyframes:%u, deltaframes:%u)\n", st->stats.n_key, st->stats.n_delta); } stop_capturing(st->fd); if (st->buffer) munmap(st->buffer, st->buffer_len); if (st->fd >= 0) { fd_close(st->fd); close(st->fd); } }
static void finalize (GObject *object) { GeglProperties *o = GEGL_PROPERTIES (object); if (o->user_data) { Priv *p = (Priv*)o->user_data; if (p->fd) { stop_capturing(p); uninit_device (p); close_device (p); p->fd = 0; } g_clear_pointer (&o->user_data, g_free); } G_OBJECT_CLASS (gegl_op_parent_class)->finalize (object); }