Per-call pending status and state handling

* Proper handling of incoming video calls.
* Add command /vcall for initiating video calls
* Add command /res command to set video resolution

src/audio_call.h

@@ -27,7 +27,7 @@
 
 #include "audio_device.h"
 
-typedef enum _AudioError {
+typedef enum AudioError {
     ae_None = 0,
     ae_StartingCaptureDevice = 1 << 0,
     ae_StartingOutputDevice = 1 << 1,
@@ -35,7 +35,7 @@ typedef enum _AudioError {
 } AudioError;
 
 #ifdef VIDEO
-typedef enum _VideoError {
+typedef enum VideoError {
     ve_None = 0,
     ve_StartingCaptureDevice = 1 << 0,
     ve_StartingOutputDevice = 1 << 1,
@@ -44,14 +44,27 @@ typedef enum _VideoError {
 
 #endif /* VIDEO */
 
+/* Status transitions:
+ * None -> Pending (call invitation made or received);
+ * Pending -> None (invitation rejected or failed);
+ * Pending -> Active (call starts);
+ * Active -> None (call ends).
+ */
+typedef enum CallStatus {
+    cs_None = 0,
+    cs_Pending,
+    cs_Active
+} CallStatus;
+
 typedef struct Call {
-    pthread_t ttid; /* Transmission thread id */
+    CallStatus status;
-    bool ttas, has_output; /* Transmission thread active status (0 - stopped, 1- running) */
+    uint32_t state; /* ToxAV call state, valid when `status == cs_Active` */
-    uint32_t in_idx, out_idx; /* Audio Index */
+    uint32_t in_idx, out_idx; /* Audio device index, or -1 if not open */
-#ifdef VIDEO
+    uint32_t audio_bit_rate; /* Bit rate for sending audio */
-    uint32_t vin_idx, vout_idx; /* Video Index */
+
-#endif /* VIDEO */
+    uint32_t vin_idx, vout_idx; /* Video device index, or -1 if not open */
-    pthread_mutex_t mutex;
+    uint32_t video_width, video_height;
+    uint32_t video_bit_rate; /* Bit rate for sending video; 0 for no video */
 } Call;
 
 struct CallControl {
@@ -66,19 +79,17 @@ struct CallControl {
     Call *calls;
     uint32_t max_calls;
 
-    uint32_t call_state;
-    bool pending_call;
     bool audio_enabled;
     bool video_enabled;
 
-    uint32_t audio_bit_rate;
     int32_t audio_frame_duration;
     uint32_t audio_sample_rate;
     uint8_t audio_channels;
+    uint32_t default_audio_bit_rate;
 
-    uint32_t video_bit_rate;
     int32_t video_frame_duration;
-
+    uint32_t default_video_width, default_video_height;
+    uint32_t default_video_bit_rate;
 };
 
 extern struct CallControl CallControl;
@@ -86,8 +97,12 @@ extern struct CallControl CallControl;
 /* You will have to pass pointer to first member of 'windows' declared in windows.c */
 ToxAV *init_audio(ToxWindow *self, Tox *tox);
 void terminate_audio(void);
-int start_transmission(ToxWindow *self, Call *call);
+
+bool init_call(Call *call);
+
+void place_call(ToxWindow *self);
 void stop_current_call(ToxWindow *self);
+
 void init_friend_AV(uint32_t index);
 void del_friend_AV(uint32_t index);
 

src/chat.c

@@ -101,11 +101,18 @@ static const char *chat_cmd_list[] = {
     "/sdev",
     "/mute",
     "/sense",
-    "/video",
     "/bitrate",
 
 #endif /* AUDIO */
 
+#ifdef VIDEO
+
+    "/res",
+    "/vcall",
+    "/video",
+
+#endif /* VIDEO */
+
 #ifdef PYTHON
 
     "/run",
@@ -131,9 +138,6 @@ void kill_chat_window(ToxWindow *self, Tox *m)
     StatusBar *statusbar = self->stb;
 
 #ifdef AUDIO
-#ifdef VIDEO
-    stop_video_stream(self);
-#endif /* VIDEO */
     stop_current_call(self);
 #endif /* AUDIO */
 

src/chat_commands.h

@@ -45,8 +45,9 @@ void cmd_bitrate(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SI
 #endif /* AUDIO */
 
 #ifdef VIDEO
+void cmd_vcall(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_video(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
-void cmd_ccur_video_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_res(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 #endif /* VIDEO */
 
 #endif /* CHAT_COMMANDS_H */

src/execute.c

@@ -92,7 +92,9 @@ static struct cmd_func chat_commands[] = {
     { "/bitrate",   cmd_bitrate           },
 #endif /* AUDIO */
 #ifdef VIDEO
+    { "/vcall",     cmd_vcall             },
     { "/video",     cmd_video             },
+    { "/res",       cmd_res               },
 #endif /* VIDEO */
     { NULL,         NULL                  },
 };
@@ -105,7 +107,7 @@ static struct cmd_func conference_commands[] = {
     { "/mute",      cmd_conference_mute   },
     { "/sense",     cmd_conference_sense  },
 #endif /* AUDIO */
-    { NULL,         NULL            },
+    { NULL,         NULL             },
 };
 
 

src/help.c

@@ -259,7 +259,9 @@ static void help_draw_chat(ToxWindow *self)
     wattron(win, A_BOLD);
     wprintw(win, "\n Video:\n");
     wattroff(win, A_BOLD);
-    wprintw(win, "  /video                     : Toggle video call\n");
+    wprintw(win, "  /res <width> <height>      : Set video resolution\n");
+    wprintw(win, "  /vcall                     : Video call\n");
+    wprintw(win, "  /video                     : Toggle video in call\n");
 #endif /* VIDEO */
 
     help_draw_bottom_menu(win);
@@ -375,7 +377,7 @@ void help_onKey(ToxWindow *self, wint_t key)
 
         case L'c':
 #ifdef VIDEO
-            help_init_window(self, 23, 80);
+            help_init_window(self, 25, 80);
 #elif AUDIO
             help_init_window(self, 20, 80);
 #else

src/video_call.c

@@ -40,7 +40,7 @@
 
 #ifdef VIDEO
 
-#define default_video_bit_rate 5000
+#define DEFAULT_VIDEO_BIT_RATE 5000
 
 void on_video_receive_frame(ToxAV *av, uint32_t friend_number,
                             uint16_t width, uint16_t height,
@@ -62,7 +62,7 @@ ToxAV *init_video(ToxWindow *self, Tox *tox)
     CallControl.video_errors = ve_None;
 
     CallControl.video_enabled = true;
-    CallControl.video_bit_rate = 0;
+    CallControl.default_video_bit_rate = 0;
     CallControl.video_frame_duration = 10;
 
     if (!CallControl.av) {
@@ -92,8 +92,9 @@ void terminate_video(void)
 
         stop_video_transmission(this_call, i);
 
-        if (this_call->vout_idx != -1) {
+        if (this_call->status == cs_Active && this_call->vout_idx != -1) {
             close_video_device(vdt_output, this_call->vout_idx);
+            this_call->vout_idx = -1;
         }
     }
 
@@ -108,7 +109,7 @@ void read_video_device_callback(int16_t width, int16_t height, const uint8_t *y,
     Toxav_Err_Send_Frame error;
 
     /* Drop frame if video sending is disabled */
-    if (CallControl.video_bit_rate == 0 || this_call->vin_idx == -1) {
+    if (this_call->video_bit_rate == 0 || this_call->status != cs_Active || this_call->vin_idx == -1) {
         line_info_add(CallControl.prompt, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video frame dropped.");
         return;
     }
@@ -137,18 +138,11 @@ void write_video_device_callback(uint32_t friend_number, uint16_t width, uint16_
 int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call)
 {
     if (!self || !av) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare transmission");
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to prepare video transmission");
         return -1;
     }
 
-    CallControl.video_bit_rate = default_video_bit_rate;
+    if (open_primary_video_device(vdt_input, &call->vin_idx, &call->video_width, &call->video_height) != vde_None) {
-
-    if (toxav_video_set_bit_rate(CallControl.av, self->num, CallControl.video_bit_rate, NULL) == false) {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set video bit rate");
-        return -1;
-    }
-
-    if (open_primary_video_device(vdt_input, &call->vin_idx) != vde_None) {
         line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to open input video device!");
         return -1;
     }
@@ -158,13 +152,22 @@ int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call)
         return -1;
     }
 
+    if (!toxav_video_set_bit_rate(CallControl.av, self->num, call->video_bit_rate, NULL)) {
+        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Failed to set video bit rate");
+        return -1;
+    }
+
     return 0;
 }
 
 int stop_video_transmission(Call *call, int friend_number)
 {
-    CallControl.video_bit_rate = 0;
+    if (call->status != cs_Active) {
-    toxav_video_set_bit_rate(CallControl.av, friend_number, CallControl.video_bit_rate, NULL);
+        return -1;
+    }
+
+    call->video_bit_rate = 0;
+    toxav_video_set_bit_rate(CallControl.av, friend_number, call->video_bit_rate, NULL);
 
     if (call->vin_idx != -1) {
         close_video_device(vdt_input, call->vin_idx);
@@ -200,24 +203,33 @@ void on_video_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t video_bit_rat
     UNUSED_VAR(av);
     UNUSED_VAR(user_data);
 
-    CallControl.video_bit_rate = video_bit_rate;
+    Call *call = &CallControl.calls[friend_number];
-    toxav_video_set_bit_rate(CallControl.av, friend_number, CallControl.video_bit_rate, NULL);
+    call->video_bit_rate = video_bit_rate;
+
+    /* TODO: with current toxav using one-pass VP8, the value of
+     * video_bit_rate has no effect, except to disable video if it is 0.
+     * Automatically change resolution instead? */
+    toxav_video_set_bit_rate(CallControl.av, friend_number, call->video_bit_rate, NULL);
 }
 
 void callback_recv_video_starting(uint32_t friend_number)
 {
     Call *this_call = &CallControl.calls[friend_number];
 
-    if (this_call->vout_idx != -1) {
+    if (this_call->status != cs_Active || this_call->vout_idx != -1) {
         return;
     }
 
-    open_primary_video_device(vdt_output, &this_call->vout_idx);
+    open_primary_video_device(vdt_output, &this_call->vout_idx, NULL, NULL);
 }
 void callback_recv_video_end(uint32_t friend_number)
 {
     Call *this_call = &CallControl.calls[friend_number];
 
+    if (this_call->status != cs_Active || this_call->vout_idx == -1) {
+        return;
+    }
+
     close_video_device(vdt_output, this_call->vout_idx);
     this_call->vout_idx = -1;
 }
@@ -235,12 +247,9 @@ void callback_video_starting(uint32_t friend_number)
             ToxWindow *window = get_window_ptr(i);
 
             if (window != NULL && window->is_call && window->num == friend_number) {
-                if (0 != start_video_transmission(window, CallControl.av, this_call)) {
+                if (start_video_transmission(window, CallControl.av, this_call) == 0) {
-                    line_info_add(window, NULL, NULL, NULL, SYS_MSG, 0, 0, "Error starting transmission!");
+                    line_info_add(window, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video capture starting.");
-                    return;
                 }
-
-                line_info_add(window, NULL, NULL, NULL, SYS_MSG, 0, 0, "Video capture starting.");
             }
         }
     }
@@ -258,44 +267,122 @@ void callback_video_end(uint32_t friend_number)
 /*
  * Commands from chat_commands.h
  */
+void cmd_vcall(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    UNUSED_VAR(window);
+    UNUSED_VAR(m);
+    UNUSED_VAR(argv);
+
+    if (argc != 0) {
+        print_err(self, "Unknown arguments.");
+        return;
+    }
+
+    if (!CallControl.av) {
+        print_err(self, "ToxAV not supported!");
+        return;
+    }
+
+    if (!self->stb->connection) {
+        print_err(self, "Friend is offline.");
+        return;
+    }
+
+    Call *call = &CallControl.calls[self->num];
+
+    if (call->status != cs_None) {
+        print_err(self, "Already calling.");
+        return;
+    }
+
+    init_call(call);
+
+    call->video_bit_rate = DEFAULT_VIDEO_BIT_RATE;
+
+    place_call(self);
+}
+
 void cmd_video(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     UNUSED_VAR(window);
     UNUSED_VAR(m);
     UNUSED_VAR(argv);
 
-    const char *error_str;
     Call *this_call = &CallControl.calls[self->num];
 
     if (argc != 0) {
-        error_str = "Unknown arguments.";
+        print_err(self, "Unknown arguments.");
-        goto on_error;
+        return;
     }
 
     if (!CallControl.av) {
-        error_str = "ToxAV not supported!";
+        print_err(self, "ToxAV not supported!");
-        goto on_error;
+        return;
     }
 
     if (!self->stb->connection) {
-        error_str = "Friend is offline.";
+        print_err(self, "Friend is offline.");
-        goto on_error;
+        return;
     }
 
-    if (!self->is_call) {
+    if (this_call->status != cs_Active) {
-        error_str = "Not in call!";
+        print_err(self, "Not in call!");
-        goto on_error;
+        return;
     }
 
     if (this_call->vin_idx == -1) {
+        this_call->video_bit_rate = DEFAULT_VIDEO_BIT_RATE;
         callback_video_starting(self->num);
     } else {
         callback_video_end(self->num);
     }
+}
 
-    return;
+void cmd_res(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
-on_error:
+{
-    print_err(self, error_str);
+    UNUSED_VAR(window);
+    UNUSED_VAR(m);
+
+    Call *call = &CallControl.calls[self->num];
+
+    if (argc == 0) {
+        if (call->status == cs_Active && call->vin_idx != -1) {
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0,
+                          "Resolution of current call: %u x %u",
+                          call->video_width, call->video_height);
+        } else {
+            line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0,
+                          "Initial resolution for video calls: %u x %u",
+                          CallControl.default_video_width, CallControl.default_video_height);
+        }
+
+        return;
+    }
+
+    if (argc != 2) {
+        print_err(self, "Require 0 or 2 arguments.");
+        return;
+    }
+
+    char *endw, *endh;
+    const long int width = strtol(argv[1], &endw, 10);
+    const long int height = strtol(argv[2], &endh, 10);
+
+    if (*endw || *endh || width < 0 || height < 0) {
+        print_err(self, "Invalid input");
+        return;
+    }
+
+    if (call->status == cs_Active && call->vin_idx != -1) {
+        stop_video_transmission(call, self->num);
+        call->video_width = width;
+        call->video_height = height;
+        call->video_bit_rate = DEFAULT_VIDEO_BIT_RATE;
+        start_video_transmission(self, CallControl.av, call);
+    } else {
+        CallControl.default_video_width = width;
+        CallControl.default_video_height = height;
+    }
 }
 
 void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -303,16 +390,14 @@ void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, c
     UNUSED_VAR(window);
     UNUSED_VAR(m);
 
-    const char *error_str;
-
     if (argc != 1) {
         if (argc < 1) {
-            error_str = "Type must be specified!";
+            print_err(self, "Type must be specified!");
         } else {
-            error_str = "Only one argument allowed!";
+            print_err(self, "Only one argument allowed!");
         }
 
-        goto on_error;
+        return;
     }
 
     VideoDeviceType type;
@@ -331,10 +416,6 @@ void cmd_list_video_devices(WINDOW *window, ToxWindow *self, Tox *m, int argc, c
     }
 
     print_video_devices(self, type);
-
-    return;
-on_error:
-    print_err(self, error_str);
 }
 
 /* This changes primary video device only */
@@ -343,18 +424,16 @@ void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc,
     UNUSED_VAR(window);
     UNUSED_VAR(m);
 
-    const char *error_str;
-
     if (argc != 2) {
         if (argc < 1) {
-            error_str = "Type must be specified!";
+            print_err(self, "Type must be specified!");
         } else if (argc < 2) {
-            error_str = "Must have id!";
+            print_err(self, "Must have id!");
         } else {
-            error_str = "Only two arguments allowed!";
+            print_err(self, "Only two arguments allowed!");
         }
 
-        goto on_error;
+        return;
     }
 
     VideoDeviceType type;
@@ -377,96 +456,14 @@ void cmd_change_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc,
     long int selection = strtol(argv[2], &end, 10);
 
     if (*end) {
-        error_str = "Invalid input";
+        print_err(self, "Invalid input");
-        goto on_error;
+        return;
     }
 
     if (set_primary_video_device(type, selection) == vde_InvalidSelection) {
-        error_str = "Invalid selection!";
+        print_err(self, "Invalid selection!");
-        goto on_error;
-    }
-
-    return;
-on_error:
-    print_err(self, error_str);
-}
-
-void cmd_ccur_video_device(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
-{
-    UNUSED_VAR(window);
-    UNUSED_VAR(m);
-
-    const char *error_str;
-
-    if (argc != 2) {
-        if (argc < 1) {
-            error_str = "Type must be specified!";
-        } else if (argc < 2) {
-            error_str = "Must have id!";
-        } else {
-            error_str = "Only two arguments allowed!";
-        }
-
-        goto on_error;
-    }
-
-    VideoDeviceType type;
-
-    if (strcmp(argv[1], "in") == 0) { /* Input devices */
-        type = vdt_input;
-    }
-
-    else if (strcmp(argv[1], "out") == 0) { /* Output devices */
-        type = vdt_output;
-    }
-
-    else {
-        line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid type: %s", argv[1]);
         return;
     }
-
-
-    char *end;
-    long int selection = strtol(argv[2], &end, 10);
-
-    if (*end) {
-        error_str = "Invalid input";
-        goto on_error;
-    }
-
-    if (video_selection_valid(type, selection) == vde_InvalidSelection) {
-        error_str = "Invalid selection!";
-        goto on_error;
-    }
-
-    /* If call is active, change device */
-    if (self->is_call) {
-        Call *this_call = &CallControl.calls[self->num];
-
-        if (this_call->ttas) {
-
-            if (type == vdt_output) {
-            } else {
-                /* TODO: check for failure */
-                close_video_device(vdt_input, this_call->vin_idx);
-                open_video_device(vdt_input, selection, &this_call->vin_idx);
-                register_video_device_callback(self->num, this_call->vin_idx, read_video_device_callback, &self->num);
-            }
-        }
-    }
-
-    return;
-on_error:
-    print_err(self, error_str);
-}
-
-void stop_video_stream(ToxWindow *self)
-{
-    Call *this_call = &CallControl.calls[self->num];
-
-    if (this_call && this_call->vin_idx != -1) {
-        stop_video_transmission(this_call, self->num);
-    }
 }
 
 #endif /* VIDEO */

src/video_call.h

@@ -34,7 +34,6 @@ ToxAV *init_video(ToxWindow *self, Tox *tox);
 void terminate_video(void);
 int start_video_transmission(ToxWindow *self, ToxAV *av, Call *call);
 int stop_video_transmission(Call *call, int friend_number);
-void stop_video_stream(ToxWindow *self);
 
 void callback_recv_video_starting(uint32_t friend_number);
 void callback_recv_video_end(uint32_t friend_number);

src/video_device.c

@@ -181,7 +181,7 @@ static int xioctl(int fh, unsigned long request, void *arg)
 #ifdef VIDEO
 VideoDeviceError init_video_devices(ToxAV *av_)
 #else
-VideoDeviceError init_video_devices()
+VideoDeviceError init_video_devices(void)
 #endif /* VIDEO */
 {
     size[vdt_input] = 0;
@@ -315,9 +315,10 @@ VideoDeviceError set_primary_video_device(VideoDeviceType type, int32_t selectio
     return vde_None;
 }
 
-VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t *device_idx)
+VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t *device_idx,
+        uint32_t *width, uint32_t *height)
 {
-    return open_video_device(type, primary_video_device[type], device_idx);
+    return open_video_device(type, primary_video_device[type], device_idx, width, height);
 }
 
 void get_primary_video_device_name(VideoDeviceType type, char *buf, int size)
@@ -325,7 +326,8 @@ void get_primary_video_device_name(VideoDeviceType type, char *buf, int size)
     memcpy(buf, dvideo_device_names[type], size);
 }
 
-VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx)
+VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx,
+                                   uint32_t *width, uint32_t *height)
 {
     if (size[type] <= selection || selection < 0) {
         return vde_InvalidSelection;
@@ -372,6 +374,7 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 
 #if defined(__OSX__) || defined(__APPLE__)
 
+        /* TODO: use requested resolution */
         if (osx_video_open_device(selection, &device->video_width, &device->video_height) != 0) {
             free(device);
             unlock;
@@ -405,6 +408,8 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 
         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
+        fmt.fmt.pix.width = width == NULL ? 0 : *width;
+        fmt.fmt.pix.height = height == NULL ? 0 : *height;
 
         if (-1 == xioctl(device->fd, VIDIOC_S_FMT, &fmt)) {
             close(device->fd);
@@ -543,6 +548,14 @@ VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint
 
         vpx_img_alloc(&device->input, VPX_IMG_FMT_I420, device->video_width, device->video_height, 1);
 
+        if (width != NULL) {
+            *width = device->video_width;
+        }
+
+        if (height != NULL) {
+            *height = device->video_height;
+        }
+
         video_thread_paused = false;
     } else { /* vdt_output */
 

src/video_device.h

@@ -62,9 +62,11 @@ VideoDeviceError register_video_device_callback(int32_t call_idx, uint32_t devic
 void *get_video_device_callback_data(uint32_t device_idx);
 
 VideoDeviceError set_primary_video_device(VideoDeviceType type, int32_t selection);
-VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t *device_idx);
+VideoDeviceError open_primary_video_device(VideoDeviceType type, uint32_t *device_idx,
+        uint32_t *width, uint32_t *height);
 /* Start device */
-VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx);
+VideoDeviceError open_video_device(VideoDeviceType type, int32_t selection, uint32_t *device_idx,
+                                   uint32_t *width, uint32_t *height);
 /* Stop device */
 VideoDeviceError close_video_device(VideoDeviceType type, uint32_t device_idx);