virtualbox+guest: Update to version 4.2.8.

The tarball for this version is missing the file VRDEVideoIn.h, which is added
through the missing_files_4.2.8.patch and extracted from Subversion, revision
44528.

Upstream changelog(s) can be found at the usual place:

https://www.virtualbox.org/wiki/Changelog

Signed-off-by: aszlig <aszlig@redmoonstudios.org>

3 files changed, 1001 insertions, 6 deletions

diff --git a/pkgs/applications/virtualization/virtualbox/default.nix b/pkgs/applications/virtualization/virtualbox/default.nix
index ea98d1ce7a9d..d95d97688c3a 100644
--- a/pkgs/applications/virtualization/virtualbox/default.nix
+++ b/pkgs/applications/virtualization/virtualbox/default.nix
@@ -11,8 +11,8 @@ with stdenv.lib;
 
 let
 
-  version = "4.2.6";
-  extpackRevision = "82870";
+  version = "4.2.8";
+  extpackRevision = "83876";
 
   forEachModule = action: ''
     for mod in \
@@ -35,7 +35,7 @@ let
     name = "Oracle_VM_VirtualBox_Extension_Pack-${version}-${extpackRevision}"
          + ".vbox-extpack";
     # Has to be base16 because it's used as an input to VBoxExtPackHelperApp!
-    sha256 = "f0113688a76efa0426c27c5541c78506b18637025c35aa682ecc6eeed5d56582";
+    sha256 = "fa579416f382b58c4e93d3740d076ceba728e28d987e51aced5865a46cb9111c";
     url = "https://www.virtualbox.org/wiki/Downloads";
   };
 
@@ -44,7 +44,7 @@ in stdenv.mkDerivation {
 
   src = fetchurl {
     url = "http://download.virtualbox.org/virtualbox/${version}/VirtualBox-${version}.tar.bz2";
-    sha256 = "54526091bc2aa66b88ca878dd9ecc4466f96d607db2f6678a9d673ecf6646ae3";
+    sha256 = "bc9185e0c300d61e2a6c8ac48b4bea6a0a456c9ba11d1fbadf2d1e6ca063f2b4";
   };
 
   buildInputs =
@@ -54,6 +54,8 @@ in stdenv.mkDerivation {
     ++ optional javaBindings jdk
     ++ optional pythonBindings python;
 
+  patches = singleton ./missing_files_4.2.8.patch;
+
   prePatch = ''
     set -x
     MODULES_BUILD_DIR=`echo ${kernel}/lib/modules/*/build`
diff --git a/pkgs/applications/virtualization/virtualbox/guest-additions/default.nix b/pkgs/applications/virtualization/virtualbox/guest-additions/default.nix
index 7a79a73c6b95..f648cb3c7377 100644
--- a/pkgs/applications/virtualization/virtualbox/guest-additions/default.nix
+++ b/pkgs/applications/virtualization/virtualbox/guest-additions/default.nix
@@ -2,14 +2,14 @@
 , libX11, libXt, libXext, libXmu, libXcomposite, libXfixes, libXrandr, libXcursor
 , dbus }:
 
-let version = "4.2.6"; in
+let version = "4.2.8"; in
 
 stdenv.mkDerivation {
   name = "VirtualBox-GuestAdditions-${version}-${kernel.version}";
 
   src = fetchurl {
     url = "http://download.virtualbox.org/virtualbox/${version}/VBoxGuestAdditions_${version}.iso";
-    sha256 = "1lry4hjjk8p69km1bi3mpmyarlnxz9izs2c0s8pq5rjzv1bd7bxr";
+    sha256 = "04a5402d8dcdefc83ffb2785351ddc57758781a3759137974469189392ae4ad5";
   };
 
   KERN_DIR = "${kernel}/lib/modules/*/build";
diff --git a/pkgs/applications/virtualization/virtualbox/missing_files_4.2.8.patch b/pkgs/applications/virtualization/virtualbox/missing_files_4.2.8.patch
new file mode 100644
index 000000000000..6cb1560dd698
--- /dev/null
+++ b/pkgs/applications/virtualization/virtualbox/missing_files_4.2.8.patch
@@ -0,0 +1,993 @@
+Index: VRDEVideoIn.h
+===================================================================
+diff --git a/include/VBox/RemoteDesktop/VRDEVideoIn.h b/include/VBox/RemoteDesktop/VRDEVideoIn.h
+new file mode 10644
+--- /dev/null	(revision 0)
++++ b/include/VBox/RemoteDesktop/VRDEVideoIn.h	(revision 44528)
+@@ -0,0 +1,986 @@
++/** @file
++ * VBox Remote Desktop Extension (VRDE) - Video Input interface.
++ */
++
++/*
++ * Copyright (C) 2012-2013 Oracle Corporation
++ *
++ * This file is part of VirtualBox Open Source Edition (OSE), as
++ * available from http://www.virtualbox.org. This file is free software;
++ * you can redistribute it and/or modify it under the terms of the GNU
++ * General Public License (GPL) as published by the Free Software
++ * Foundation, in version 2 as it comes in the "COPYING" file of the
++ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
++ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
++ *
++ * The contents of this file may alternatively be used under the terms
++ * of the Common Development and Distribution License Version 1.0
++ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
++ * VirtualBox OSE distribution, in which case the provisions of the
++ * CDDL are applicable instead of those of the GPL.
++ *
++ * You may elect to license modified versions of this file under the
++ * terms and conditions of either the GPL or the CDDL or both.
++ */
++
++#ifndef ___VBox_RemoteDesktop_VRDEVideoIn_h
++#define ___VBox_RemoteDesktop_VRDEVideoIn_h
++
++
++/* Define VRDE_VIDEOIN_WITH_VRDEINTERFACE to include the server VRDE interface parts. */
++
++#ifdef VRDE_VIDEOIN_WITH_VRDEINTERFACE
++#include <VBox/RemoteDesktop/VRDE.h>
++#endif /* VRDE_VIDEOIN_WITH_VRDEINTERFACE */
++
++#ifdef AssertCompileSize
++#define ASSERTSIZE(type, size) AssertCompileSize(type, size);
++#else
++#define ASSERTSIZE(type, size)
++#endif /* AssertCompileSize */
++
++
++/*
++ * Interface for accessing a video camera device on the client.
++ *
++ * Async callbacks are used for providing feedback, reporting errors, etc.
++ *
++ * Initial version supports: Camera + Processing Unit + Streaming Control.
++ *
++ * There are 2 modes:
++ * 1) The virtual WebCam is already attached to the guest.
++ * 2) The virtual WebCam will be attached when the client has it.
++ *
++ * Initially the mode 1 is supported.
++ *
++ * Mode 1 details:
++ * The WebCam has some fixed functionality, according to the descriptors,
++ * which has been already read by the guest. So some of functions will
++ * not work if the client does not support them.
++ *
++ * Mode 2 details:
++ * Virtual WebCam descriptors are built from the client capabilities.
++ *
++ * Similarly to the smartcard, the server will inform the ConsoleVRDE that there is a WebCam.
++ * ConsoleVRDE creates a VRDEVIDEOIN handle and forwards virtual WebCam requests to it.
++ *
++ * Interface with VBox.
++ *
++ *   Virtual WebCam         ConsoleVRDE                VRDE
++ *
++ *                                                 Negotiate <->
++ *                                              <- VideoInDeviceNotify(Attached, DeviceId)
++ *                       -> GetDeviceDesc
++ *                                              <- DeviceDesc
++ * 2                     <- CreateCamera
++ * 2  CameraCreated ->
++ *
++ *    CameraRequest ->      Request ->
++ *    Response <-        <- Response            <- Response
++ *    Frame <-           <- Frame               <- Frame
++ *                                              <- VideoInDeviceNotify(Detached, DeviceId)
++ *
++ * Unsupported requests fail.
++ * The Device Description received from the client may be used to validate WebCam requests
++ * in the ConsoleVRDE code, for example filter out unsupported requests.
++ *
++ */
++
++/* All structures in this file are packed.
++ * Everything is little-endian.
++ */
++#pragma pack(1)
++
++/*
++ * The interface supports generic video input descriptors, capabilities and controls:
++ *   * Descriptors
++ *     + Interface
++ *       - Input, Camera Terminal
++ *       - Processing Unit
++ *     + Video Streaming
++ *       - Input Header
++ *       - Payload Format
++ *       - Video Frame
++ *       - Still Image Frame
++ *   * Video Control requests
++ *     + Interface
++ *       - Power Mode
++ *     + Unit and Terminal
++ *       camera
++ *       - Scanning Mode (interlaced, progressive)
++ *       - Auto-Exposure Mode
++ *       - Auto-Exposure Priority
++ *       - Exposure Time Absolute, Relative
++ *       - Focus Absolute, Relative, Auto
++ *       - Iris Absolute, Relative
++ *       - Zoom Absolute, Relative
++ *       - PanTilt Absolute, Relative
++ *       - Roll Absolute, Relative
++ *       - Privacy
++ *       processing
++ *       - Backlight Compensation
++ *       - Brightness
++ *       - Contrast
++ *       - Gain
++ *       - Power Line Frequency
++ *       - Hue Manual, Auto
++ *       - Saturation
++ *       - Sharpness
++ *       - Gamma
++ *       - White Balance Temperature Manual, Auto
++ *       - White Balance Component Manual, Auto
++ *       - Digital Multiplier
++ *       - Digital Multiplier Limit
++ *   * Video Streaming requests
++ *     + Interface
++ *       - Synch Delay
++ *       - Still Image Trigger
++ *       - Generate Key Frame
++ *       - Update Frame Segment
++ *       - Stream Error Code
++ *
++ *
++ * Notes:
++ *   * still capture uses a method similar to method 2, because the still frame will
++ *     be send instead of video over the channel.
++ *     Also the method 2 can be in principle emulated by both 1 and 3 on the client.
++ *     However the client can initiate a still frame transfer, similar to hardware button trigger.
++ *   * all control changes are async.
++ *   * probe/commit are not used. The server can select a supported format/frame from the list.
++ *   * no color matching. sRGB is the default.
++ *   * most of constants are the same as in USB Video Class spec, but they are not the same and
++ *     should be always converted.
++ */
++
++/*
++ * The DEVICEDEC describes the device and provides a list of supported formats:
++ *     VRDEVIDEOINDEVICEDESC
++ *     VRDEVIDEOINFORMATDESC[0];
++ *     VRDEVIDEOINFRAMEDESC[0..N-1]
++ *     VRDEVIDEOINFORMATDESC[1];
++ *     VRDEVIDEOINFRAMEDESC[0..M-1]
++ *     ...
++ */
++
++typedef struct VRDEVIDEOINDEVICEDESC
++{
++    uint16_t u16ObjectiveFocalLengthMin;
++    uint16_t u16ObjectiveFocalLengthMax;
++    uint16_t u16OcularFocalLength;
++    uint16_t u16MaxMultiplier;
++    uint32_t fu32CameraControls;     /* VRDE_VIDEOIN_F_CT_CTRL_* */
++    uint32_t fu32ProcessingControls; /* VRDE_VIDEOIN_F_PU_CTRL_* */
++    uint8_t fu8DeviceCaps;           /* VRDE_VIDEOIN_F_DEV_CAP_* */
++    uint8_t u8NumFormats;            /* Number of following VRDEVIDEOINFORMATDESC structures. */
++    uint16_t cbExt;                  /* Size of the optional extended description. */
++    /* An extended description may follow. */
++    /* An array of VRDEVIDEOINFORMATDESC follows. */
++} VRDEVIDEOINDEVICEDESC;
++
++/* VRDEVIDEOINDEVICEDESC::fu32CameraControls */
++#define VRDE_VIDEOIN_F_CT_CTRL_SCANNING_MODE            0x00000001 /* D0: Scanning Mode */
++#define VRDE_VIDEOIN_F_CT_CTRL_AE_MODE                  0x00000002 /* D1: Auto-Exposure Mode */
++#define VRDE_VIDEOIN_F_CT_CTRL_AE_PRIORITY              0x00000004 /* D2: Auto-Exposure Priority */
++#define VRDE_VIDEOIN_F_CT_CTRL_EXPOSURE_TIME_ABSOLUTE   0x00000008 /* D3: Exposure Time (Absolute) */
++#define VRDE_VIDEOIN_F_CT_CTRL_EXPOSURE_TIME_RELATIVE   0x00000010 /* D4: Exposure Time (Relative) */
++#define VRDE_VIDEOIN_F_CT_CTRL_FOCUS_ABSOLUTE           0x00000020 /* D5: Focus (Absolute) */
++#define VRDE_VIDEOIN_F_CT_CTRL_FOCUS_RELATIVE           0x00000040 /* D6: Focus (Relative) */
++#define VRDE_VIDEOIN_F_CT_CTRL_IRIS_ABSOLUTE            0x00000080 /* D7: Iris (Absolute) */
++#define VRDE_VIDEOIN_F_CT_CTRL_IRIS_RELATIVE            0x00000100 /* D8: Iris (Relative) */
++#define VRDE_VIDEOIN_F_CT_CTRL_ZOOM_ABSOLUTE            0x00000200 /* D9: Zoom (Absolute) */
++#define VRDE_VIDEOIN_F_CT_CTRL_ZOOM_RELATIVE            0x00000400 /* D10: Zoom (Relative) */
++#define VRDE_VIDEOIN_F_CT_CTRL_PANTILT_ABSOLUTE         0x00000800 /* D11: PanTilt (Absolute) */
++#define VRDE_VIDEOIN_F_CT_CTRL_PANTILT_RELATIVE         0x00001000 /* D12: PanTilt (Relative) */
++#define VRDE_VIDEOIN_F_CT_CTRL_ROLL_ABSOLUTE            0x00002000 /* D13: Roll (Absolute) */
++#define VRDE_VIDEOIN_F_CT_CTRL_ROLL_RELATIVE            0x00004000 /* D14: Roll (Relative) */
++#define VRDE_VIDEOIN_F_CT_CTRL_RESERVED1                0x00008000 /* D15: Reserved */
++#define VRDE_VIDEOIN_F_CT_CTRL_RESERVED2                0x00010000 /* D16: Reserved */
++#define VRDE_VIDEOIN_F_CT_CTRL_FOCUS_AUTO               0x00020000 /* D17: Focus, Auto */
++#define VRDE_VIDEOIN_F_CT_CTRL_PRIVACY                  0x00040000 /* D18: Privacy */
++
++/* VRDEVIDEOINDEVICEDESC::fu32ProcessingControls */
++#define VRDE_VIDEOIN_F_PU_CTRL_BRIGHTNESS                0x00000001 /* D0: Brightness */
++#define VRDE_VIDEOIN_F_PU_CTRL_CONTRAST                  0x00000002 /* D1: Contrast */
++#define VRDE_VIDEOIN_F_PU_CTRL_HUE                       0x00000004 /* D2: Hue */
++#define VRDE_VIDEOIN_F_PU_CTRL_SATURATION                0x00000008 /* D3: Saturation */
++#define VRDE_VIDEOIN_F_PU_CTRL_SHARPNESS                 0x00000010 /* D4: Sharpness */
++#define VRDE_VIDEOIN_F_PU_CTRL_GAMMA                     0x00000020 /* D5: Gamma */
++#define VRDE_VIDEOIN_F_PU_CTRL_WHITE_BALANCE_TEMPERATURE 0x00000040 /* D6: White Balance Temperature */
++#define VRDE_VIDEOIN_F_PU_CTRL_WHITE_BALANCE_COMPONENT   0x00000080 /* D7: White Balance Component */
++#define VRDE_VIDEOIN_F_PU_CTRL_BACKLIGHT_COMPENSATION    0x00000100 /* D8: Backlight Compensation */
++#define VRDE_VIDEOIN_F_PU_CTRL_GAIN                      0x00000200 /* D9: Gain */
++#define VRDE_VIDEOIN_F_PU_CTRL_POWER_LINE_FREQUENCY      0x00000400 /* D10: Power Line Frequency */
++#define VRDE_VIDEOIN_F_PU_CTRL_HUE_AUTO                  0x00000800 /* D11: Hue, Auto */
++#define VRDE_VIDEOIN_F_PU_CTRL_WHITE_BALANCE_TEMPERATURE_AUTO 0x00001000 /* D12: White Balance Temperature, Auto */
++#define VRDE_VIDEOIN_F_PU_CTRL_WHITE_BALANCE_COMPONENT_AUTO   0x00002000 /* D13: White Balance Component, Auto */
++#define VRDE_VIDEOIN_F_PU_CTRL_DIGITAL_MULTIPLIER        0x00004000 /* D14: Digital Multiplier */
++#define VRDE_VIDEOIN_F_PU_CTRL_DIGITAL_MULTIPLIER_LIMIT  0x00008000 /* D15: Digital Multiplier Limit */
++
++/* VRDEVIDEOINDEVICEDESC::fu8DeviceCaps */
++#define VRDE_VIDEOIN_F_DEV_CAP_DYNAMICCHANGE   0x01 /* Whether dynamic format change is supported. */
++#define VRDE_VIDEOIN_F_DEV_CAP_TRIGGER         0x02 /* Whether hardware triggering is supported. */
++#define VRDE_VIDEOIN_F_DEV_CAP_TRIGGER_USAGE   0x04 /* 0 - still image, 1 - generic button event.*/
++
++/* The video format descriptor. */
++typedef struct VRDEVIDEOINFORMATDESC
++{
++    uint16_t cbFormat;     /* Size of the structure including cbFormat and format specific data. */
++    uint8_t u8FormatId;    /* The unique identifier of the format on the client. */
++    uint8_t u8FormatType;  /* MJPEG etc. VRDE_VIDEOIN_FORMAT_* */
++    uint8_t u8FormatFlags; /* VRDE_VIDEOIN_F_FMT_* */ 
++    uint8_t u8NumFrames;   /* Number of following VRDEVIDEOINFRAMEDESC structures. */
++    uint16_t u16Reserved;  /* Must be set to 0. */
++    /* Other format specific data may follow. */
++    /* An array of VRDEVIDEOINFRAMEDESC follows. */
++} VRDEVIDEOINFORMATDESC;
++
++/* VRDEVIDEOINFORMATDESC::u8FormatType */
++#define VRDE_VIDEOIN_FORMAT_UNCOMPRESSED 0x04
++#define VRDE_VIDEOIN_FORMAT_MJPEG        0x06
++#define VRDE_VIDEOIN_FORMAT_MPEG2TS      0x0A
++#define VRDE_VIDEOIN_FORMAT_DV           0x0C
++#define VRDE_VIDEOIN_FORMAT_FRAME_BASED  0x10
++#define VRDE_VIDEOIN_FORMAT_STREAM_BASED 0x12
++
++/* VRDEVIDEOINFORMATDESC::u8FormatFlags. */
++#define VRDE_VIDEOIN_F_FMT_GENERATEKEYFRAME   0x01 /* Supports Generate Key Frame */
++#define VRDE_VIDEOIN_F_FMT_UPDATEFRAMESEGMENT 0x02 /* Supports Update Frame Segment */
++#define VRDE_VIDEOIN_F_FMT_COPYPROTECT        0x04 /* If duplication should be restricted. */
++#define VRDE_VIDEOIN_F_FMT_COMPQUALITY        0x08 /* If the format supports an adjustable compression quality. */
++
++typedef struct VRDEVIDEOINFRAMEDESC
++{
++    uint16_t cbFrame;      /* Size of the structure including cbFrame and frame specific data. */
++    uint8_t  u8FrameId;    /* The unique identifier of the frame for the corresponding format on the client. */
++    uint8_t  u8FrameFlags;
++    uint16_t u16Width;
++    uint16_t u16Height;
++    uint32_t u32NumFrameIntervals; /* The number of supported frame intervals. */
++    uint32_t u32MinFrameInterval;  /* Shortest frame interval supported (at highest frame rate), in 100ns units. */
++    uint32_t u32MaxFrameInterval;  /* Longest frame interval supported (at lowest frame rate), in 100ns units. */
++    /* Supported frame intervals (in 100ns units) follow if VRDE_VIDEOIN_F_FRM_DISCRETE_INTERVALS is set.
++     * uint32_t au32FrameIntervals[u32NumFrameIntervals];
++     */
++    /* Other frame specific data may follow. */
++} VRDEVIDEOINFRAMEDESC;
++
++/* VRDEVIDEOINFRAMEDESC::u8FrameFlags. */
++#define VRDE_VIDEOIN_F_FRM_STILL              0x01 /* If still images are supported for this frame. */
++#define VRDE_VIDEOIN_F_FRM_DISCRETE_INTERVALS 0x02 /* If the discrete intervals list is included. */
++
++/*
++ * Controls.
++ *
++ * The same structures are used for both SET and GET requests.
++ * Requests are async. A callback is invoked, when the client returns a reply.
++ * A control change notification also uses these structures.
++ *
++ * If a control request can not be fulfilled, then VRDE_VIDEOIN_CTRLHDR_F_FAIL
++ * will be set and u8Status contains the error code. This replaces the VC_REQUEST_ERROR_CODE_CONTROL.
++ */
++
++typedef struct VRDEVIDEOINCTRLHDR
++{
++    uint16_t u16ControlSelector; /* VRDE_VIDEOIN_CTRLSEL_* */
++    uint16_t u16RequestType;     /* VRDE_VIDEOIN_CTRLREQ_* */
++    uint16_t u16ParmSize;        /* The size of the control specific parameters. */
++    uint8_t u8Flags;             /* VRDE_VIDEOIN_CTRLHDR_F_* */
++    uint8_t u8Status;            /* VRDE_VIDEOIN_CTRLHDR_STATUS_* */
++    /* Control specific data follows. */
++} VRDEVIDEOINCTRLHDR;
++
++/* Control request types: VRDEVIDEOINCTRLHDR::u16RequestType. */
++#define VRDE_VIDEOIN_CTRLREQ_UNDEFINED 0x00
++#define VRDE_VIDEOIN_CTRLREQ_SET_CUR   0x01
++#define VRDE_VIDEOIN_CTRLREQ_GET_CUR   0x81
++#define VRDE_VIDEOIN_CTRLREQ_GET_MIN   0x82
++#define VRDE_VIDEOIN_CTRLREQ_GET_MAX   0x83
++#define VRDE_VIDEOIN_CTRLREQ_GET_RES   0x84
++#define VRDE_VIDEOIN_CTRLREQ_GET_LEN   0x85
++#define VRDE_VIDEOIN_CTRLREQ_GET_INFO  0x86
++#define VRDE_VIDEOIN_CTRLREQ_GET_DEF   0x87
++
++/* VRDEVIDEOINCTRLHDR::u8Flags */
++#define VRDE_VIDEOIN_CTRLHDR_F_NOTIFY 0x01 /* Control change notification, the attribute is derived from u16RequestType and F_FAIL. */
++#define VRDE_VIDEOIN_CTRLHDR_F_FAIL   0x02 /* The operation failed. Error code is in u8Status. */
++
++/* VRDEVIDEOINCTRLHDR::u8Status if the VRDE_VIDEOIN_CTRLHDR_F_FAIL is set. */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_SUCCESS        0x00 /**/
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_NOTREADY       0x01 /* Not ready */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_WRONGSTATE     0x02 /* Wrong state */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_POWER          0x03 /* Power */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_OUTOFRANGE     0x04 /* Out of range */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_INVALIDUNIT    0x05 /* Invalid unit */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_INVALIDCONTROL 0x06 /* Invalid control */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_INVALIDREQUEST 0x07 /* Invalid Request */
++#define VRDE_VIDEOIN_CTRLHDR_STATUS_UNKNOWN        0xFF /* Unknown */
++
++/* Control selectors. 16 bit. High byte is the category. Low byte is the identifier.*/
++#ifdef RT_MAKE_U16
++#define VRDE_VIDEOIN_CTRLSEL_MAKE(Lo, Hi) RT_MAKE_U16(Lo, Hi)
++#else
++#define VRDE_VIDEOIN_CTRLSEL_MAKE(Lo, Hi) ((uint16_t)( (uint16_t)((uint8_t)(Hi)) << 8 | (uint8_t)(Lo) ))
++#endif
++
++#define VRDE_VIDEOIN_CTRLSEL_VC(a) VRDE_VIDEOIN_CTRLSEL_MAKE(a, 0x01)
++#define VRDE_VIDEOIN_CTRLSEL_CT(a) VRDE_VIDEOIN_CTRLSEL_MAKE(a, 0x02)
++#define VRDE_VIDEOIN_CTRLSEL_PU(a) VRDE_VIDEOIN_CTRLSEL_MAKE(a, 0x03)
++#define VRDE_VIDEOIN_CTRLSEL_VS(a) VRDE_VIDEOIN_CTRLSEL_MAKE(a, 0x04)
++#define VRDE_VIDEOIN_CTRLSEL_HW(a) VRDE_VIDEOIN_CTRLSEL_MAKE(a, 0x05)
++
++#define VRDE_VIDEOIN_CTRLSEL_VC_VIDEO_POWER_MODE_CONTROL   VRDE_VIDEOIN_CTRLSEL_VC(0x01)
++
++#define VRDE_VIDEOIN_CTRLSEL_CT_UNDEFINED                 VRDE_VIDEOIN_CTRLSEL_CT(0x00)
++#define VRDE_VIDEOIN_CTRLSEL_CT_SCANNING_MODE             VRDE_VIDEOIN_CTRLSEL_CT(0x01)
++#define VRDE_VIDEOIN_CTRLSEL_CT_AE_MODE                   VRDE_VIDEOIN_CTRLSEL_CT(0x02)
++#define VRDE_VIDEOIN_CTRLSEL_CT_AE_PRIORITY               VRDE_VIDEOIN_CTRLSEL_CT(0x03)
++#define VRDE_VIDEOIN_CTRLSEL_CT_EXPOSURE_TIME_ABSOLUTE    VRDE_VIDEOIN_CTRLSEL_CT(0x04)
++#define VRDE_VIDEOIN_CTRLSEL_CT_EXPOSURE_TIME_RELATIVE    VRDE_VIDEOIN_CTRLSEL_CT(0x05)
++#define VRDE_VIDEOIN_CTRLSEL_CT_FOCUS_ABSOLUTE            VRDE_VIDEOIN_CTRLSEL_CT(0x06)
++#define VRDE_VIDEOIN_CTRLSEL_CT_FOCUS_RELATIVE            VRDE_VIDEOIN_CTRLSEL_CT(0x07)
++#define VRDE_VIDEOIN_CTRLSEL_CT_FOCUS_AUTO                VRDE_VIDEOIN_CTRLSEL_CT(0x08)
++#define VRDE_VIDEOIN_CTRLSEL_CT_IRIS_ABSOLUTE             VRDE_VIDEOIN_CTRLSEL_CT(0x09)
++#define VRDE_VIDEOIN_CTRLSEL_CT_IRIS_RELATIVE             VRDE_VIDEOIN_CTRLSEL_CT(0x0A)
++#define VRDE_VIDEOIN_CTRLSEL_CT_ZOOM_ABSOLUTE             VRDE_VIDEOIN_CTRLSEL_CT(0x0B)
++#define VRDE_VIDEOIN_CTRLSEL_CT_ZOOM_RELATIVE             VRDE_VIDEOIN_CTRLSEL_CT(0x0C)
++#define VRDE_VIDEOIN_CTRLSEL_CT_PANTILT_ABSOLUTE          VRDE_VIDEOIN_CTRLSEL_CT(0x0D)
++#define VRDE_VIDEOIN_CTRLSEL_CT_PANTILT_RELATIVE          VRDE_VIDEOIN_CTRLSEL_CT(0x0E)
++#define VRDE_VIDEOIN_CTRLSEL_CT_ROLL_ABSOLUTE             VRDE_VIDEOIN_CTRLSEL_CT(0x0F)
++#define VRDE_VIDEOIN_CTRLSEL_CT_ROLL_RELATIVE             VRDE_VIDEOIN_CTRLSEL_CT(0x10)
++#define VRDE_VIDEOIN_CTRLSEL_CT_PRIVACY                   VRDE_VIDEOIN_CTRLSEL_CT(0x11)
++
++#define VRDE_VIDEOIN_CTRLSEL_PU_UNDEFINED                 VRDE_VIDEOIN_CTRLSEL_PU(0x00)
++#define VRDE_VIDEOIN_CTRLSEL_PU_BACKLIGHT_COMPENSATION    VRDE_VIDEOIN_CTRLSEL_PU(0x01)
++#define VRDE_VIDEOIN_CTRLSEL_PU_BRIGHTNESS                VRDE_VIDEOIN_CTRLSEL_PU(0x02)
++#define VRDE_VIDEOIN_CTRLSEL_PU_CONTRAST                  VRDE_VIDEOIN_CTRLSEL_PU(0x03)
++#define VRDE_VIDEOIN_CTRLSEL_PU_GAIN                      VRDE_VIDEOIN_CTRLSEL_PU(0x04)
++#define VRDE_VIDEOIN_CTRLSEL_PU_POWER_LINE_FREQUENCY      VRDE_VIDEOIN_CTRLSEL_PU(0x05)
++#define VRDE_VIDEOIN_CTRLSEL_PU_HUE                       VRDE_VIDEOIN_CTRLSEL_PU(0x06)
++#define VRDE_VIDEOIN_CTRLSEL_PU_SATURATION                VRDE_VIDEOIN_CTRLSEL_PU(0x07)
++#define VRDE_VIDEOIN_CTRLSEL_PU_SHARPNESS                 VRDE_VIDEOIN_CTRLSEL_PU(0x08)
++#define VRDE_VIDEOIN_CTRLSEL_PU_GAMMA                     VRDE_VIDEOIN_CTRLSEL_PU(0x09)
++#define VRDE_VIDEOIN_CTRLSEL_PU_WHITE_BALANCE_TEMPERATURE VRDE_VIDEOIN_CTRLSEL_PU(0x0A)
++#define VRDE_VIDEOIN_CTRLSEL_PU_WHITE_BALANCE_TEMPERATURE_AUTO VRDE_VIDEOIN_CTRLSEL_PU(0x0B)
++#define VRDE_VIDEOIN_CTRLSEL_PU_WHITE_BALANCE_COMPONENT   VRDE_VIDEOIN_CTRLSEL_PU(0x0C)
++#define VRDE_VIDEOIN_CTRLSEL_PU_WHITE_BALANCE_COMPONENT_AUTO VRDE_VIDEOIN_CTRLSEL_PU(0x0D)
++#define VRDE_VIDEOIN_CTRLSEL_PU_DIGITAL_MULTIPLIER        VRDE_VIDEOIN_CTRLSEL_PU(0x0E)
++#define VRDE_VIDEOIN_CTRLSEL_PU_DIGITAL_MULTIPLIER_LIMIT  VRDE_VIDEOIN_CTRLSEL_PU(0x0F)
++#define VRDE_VIDEOIN_CTRLSEL_PU_HUE_AUTO                  VRDE_VIDEOIN_CTRLSEL_PU(0x10)
++#define VRDE_VIDEOIN_CTRLSEL_PU_ANALOG_VIDEO_STANDARD     VRDE_VIDEOIN_CTRLSEL_PU(0x11)
++#define VRDE_VIDEOIN_CTRLSEL_PU_ANALOG_LOCK_STATUS        VRDE_VIDEOIN_CTRLSEL_PU(0x12)
++
++#define VRDE_VIDEOIN_CTRLSEL_VS_UNDEFINED                 VRDE_VIDEOIN_CTRLSEL_VS(0x00)
++#define VRDE_VIDEOIN_CTRLSEL_VS_START                     VRDE_VIDEOIN_CTRLSEL_VS(0x01)
++#define VRDE_VIDEOIN_CTRLSEL_VS_STOP                      VRDE_VIDEOIN_CTRLSEL_VS(0x02)
++#define VRDE_VIDEOIN_CTRLSEL_VS_STILL_IMAGE_TRIGGER       VRDE_VIDEOIN_CTRLSEL_VS(0x05)
++#define VRDE_VIDEOIN_CTRLSEL_VS_STREAM_ERROR_CODE         VRDE_VIDEOIN_CTRLSEL_VS(0x06)
++#define VRDE_VIDEOIN_CTRLSEL_VS_GENERATE_KEY_FRAME        VRDE_VIDEOIN_CTRLSEL_VS(0x07)
++#define VRDE_VIDEOIN_CTRLSEL_VS_UPDATE_FRAME_SEGMENT      VRDE_VIDEOIN_CTRLSEL_VS(0x08)
++#define VRDE_VIDEOIN_CTRLSEL_VS_SYNCH_DELAY               VRDE_VIDEOIN_CTRLSEL_VS(0x09)
++
++#define VRDE_VIDEOIN_CTRLSEL_HW_BUTTON                    VRDE_VIDEOIN_CTRLSEL_HW(0x01)
++
++typedef struct VRDEVIDEOINCTRL_VIDEO_POWER_MODE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8DevicePowerMode;
++} VRDEVIDEOINCTRL_VIDEO_POWER_MODE;
++
++typedef struct VRDEVIDEOINCTRL_CT_SCANNING_MODE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8ScanningMode;
++} VRDEVIDEOINCTRL_CT_SCANNING_MODE;
++
++typedef struct VRDEVIDEOINCTRL_CT_AE_MODE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8AutoExposureMode;
++} VRDEVIDEOINCTRL_CT_AE_MODE;
++
++typedef struct VRDEVIDEOINCTRL_CT_AE_PRIORITY
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8AutoExposurePriority;
++} VRDEVIDEOINCTRL_CT_AE_PRIORITY;
++
++typedef struct VRDEVIDEOINCTRL_CT_EXPOSURE_TIME_ABSOLUTE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint32_t u32ExposureTimeAbsolute;
++} VRDEVIDEOINCTRL_CT_EXPOSURE_TIME_ABSOLUTE;
++
++typedef struct VRDEVIDEOINCTRL_CT_EXPOSURE_TIME_RELATIVE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8ExposureTimeRelative;
++} VRDEVIDEOINCTRL_CT_EXPOSURE_TIME_RELATIVE;
++
++typedef struct VRDEVIDEOINCTRL_CT_FOCUS_ABSOLUTE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16FocusAbsolute;
++} VRDEVIDEOINCTRL_CT_FOCUS_ABSOLUTE;
++
++typedef struct VRDEVIDEOINCTRL_CT_FOCUS_RELATIVE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8FocusRelative;
++    uint8_t u8Speed;
++} VRDEVIDEOINCTRL_CT_FOCUS_RELATIVE;
++
++typedef struct VRDEVIDEOINCTRL_CT_FOCUS_AUTO
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8FocusAuto;
++} VRDEVIDEOINCTRL_CT_FOCUS_AUTO;
++
++typedef struct VRDEVIDEOINCTRL_CT_IRIS_ABSOLUTE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16IrisAbsolute;
++} VRDEVIDEOINCTRL_CT_IRIS_ABSOLUTE;
++
++typedef struct VRDEVIDEOINCTRL_CT_IRIS_RELATIVE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8IrisRelative;
++} VRDEVIDEOINCTRL_CT_IRIS_RELATIVE;
++
++typedef struct VRDEVIDEOINCTRL_CT_ZOOM_ABSOLUTE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16ZoomAbsolute;
++} VRDEVIDEOINCTRL_CT_ZOOM_ABSOLUTE;
++
++typedef struct VRDEVIDEOINCTRL_CT_ZOOM_RELATIVE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8Zoom;
++    uint8_t u8DigitalZoom;
++    uint8_t u8Speed;
++} VRDEVIDEOINCTRL_CT_ZOOM_RELATIVE;
++
++typedef struct VRDEVIDEOINCTRL_CT_PANTILT_ABSOLUTE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint32_t u32PanAbsolute;
++    uint32_t u32TiltAbsolute;
++} VRDEVIDEOINCTRL_CT_PANTILT_ABSOLUTE;
++
++typedef struct VRDEVIDEOINCTRL_CT_PANTILT_RELATIVE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8PanRelative;
++    uint8_t u8PanSpeed;
++    uint8_t u8TiltRelative;
++    uint8_t u8TiltSpeed;
++} VRDEVIDEOINCTRL_CT_PANTILT_RELATIVE;
++
++typedef struct VRDEVIDEOINCTRL_CT_ROLL_ABSOLUTE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16RollAbsolute;
++} VRDEVIDEOINCTRL_CT_ROLL_ABSOLUTE;
++
++typedef struct VRDEVIDEOINCTRL_CT_ROLL_RELATIVE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8RollRelative;
++    uint8_t u8Speed;
++} VRDEVIDEOINCTRL_CT_ROLL_RELATIVE;
++
++typedef struct VRDEVIDEOINCTRL_CT_PRIVACY_MODE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8Privacy;
++} VRDEVIDEOINCTRL_CT_PRIVACY_MODE;
++
++typedef struct VRDEVIDEOINCTRL_PU_BACKLIGHT_COMPENSATION
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16BacklightCompensation;
++} VRDEVIDEOINCTRL_PU_BACKLIGHT_COMPENSATION;
++
++typedef struct VRDEVIDEOINCTRL_PU_BRIGHTNESS
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Brightness;
++} VRDEVIDEOINCTRL_PU_BRIGHTNESS;
++
++typedef struct VRDEVIDEOINCTRL_PU_CONTRAST
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Contrast;
++} VRDEVIDEOINCTRL_PU_CONTRAST;
++
++typedef struct VRDEVIDEOINCTRL_PU_GAIN
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Gain;
++} VRDEVIDEOINCTRL_PU_GAIN;
++
++typedef struct VRDEVIDEOINCTRL_PU_POWER_LINE_FREQUENCY
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16PowerLineFrequency;
++} VRDEVIDEOINCTRL_PU_POWER_LINE_FREQUENCY;
++
++typedef struct VRDEVIDEOINCTRL_PU_HUE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Hue;
++} VRDEVIDEOINCTRL_PU_HUE;
++
++typedef struct VRDEVIDEOINCTRL_PU_HUE_AUTO
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8HueAuto;
++} VRDEVIDEOINCTRL_PU_HUE_AUTO;
++
++typedef struct VRDEVIDEOINCTRL_PU_SATURATION
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Saturation;
++} VRDEVIDEOINCTRL_PU_SATURATION;
++
++typedef struct VRDEVIDEOINCTRL_PU_SHARPNESS
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Sharpness;
++} VRDEVIDEOINCTRL_PU_SHARPNESS;
++
++typedef struct VRDEVIDEOINCTRL_PU_GAMMA
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Gamma;
++} VRDEVIDEOINCTRL_PU_GAMMA;
++
++typedef struct VRDEVIDEOINCTRL_PU_WHITE_BALANCE_TEMPERATURE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16WhiteBalanceTemperature;
++} VRDEVIDEOINCTRL_PU_WHITE_BALANCE_TEMPERATURE;
++
++typedef struct VRDEVIDEOINCTRL_PU_WHITE_BALANCE_TEMPERATURE_AUTO
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8WhiteBalanceTemperatureAuto;
++} VRDEVIDEOINCTRL_PU_WHITE_BALANCE_TEMPERATURE_AUTO;
++
++typedef struct VRDEVIDEOINCTRL_PU_WHITE_BALANCE_COMPONENT
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16WhiteBalanceBlue;
++    uint16_t u16WhiteBalanceRed;
++} VRDEVIDEOINCTRL_PU_WHITE_BALANCE_COMPONENT;
++
++typedef struct VRDEVIDEOINCTRL_PU_WHITE_BALANCE_COMPONENT_AUTO
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8WhiteBalanceComponentAuto;
++} VRDEVIDEOINCTRL_PU_WHITE_BALANCE_COMPONENT_AUTO;
++
++typedef struct VRDEVIDEOINCTRL_PU_DIGITAL_MULTIPLIER
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16MultiplierStep;
++} VRDEVIDEOINCTRL_PU_DIGITAL_MULTIPLIER;
++
++typedef struct VRDEVIDEOINCTRL_PU_DIGITAL_MULTIPLIER_LIMIT
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16MultiplierLimit;
++} VRDEVIDEOINCTRL_PU_DIGITAL_MULTIPLIER_LIMIT;
++
++typedef struct VRDEVIDEOINCTRL_PU_ANALOG_VIDEO_STANDARD
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8VideoStandard;
++} VRDEVIDEOINCTRL_PU_ANALOG_VIDEO_STANDARD;
++
++typedef struct VRDEVIDEOINCTRL_PU_ANALOG_LOCK_STATUS
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8Status;
++} VRDEVIDEOINCTRL_PU_ANALOG_LOCK_STATUS;
++
++/* Start sending video frames with this format. */
++#define VRDEVIDEOINCTRL_F_VS_START_FID 0x01
++#define VRDEVIDEOINCTRL_F_VS_START_EOF 0x02
++
++typedef struct VRDEVIDEOINCTRL_VS_START
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8FormatId;             /* The format id on the client: VRDEVIDEOINFORMATDESC::u8FormatId. */
++    uint8_t u8FramingInfo;          /* VRDEVIDEOINCTRL_F_VS_START_*. Set by the client. */
++    uint16_t u16Width;
++    uint16_t u16Height;
++    uint32_t u32FrameInterval;      /* Frame interval in 100 ns units, 0 means a still image capture.
++                                     * The client may choose a different interval if this value is
++                                     * not supported.
++                                     */
++    uint16_t u16CompQuality;        /* 0 .. 10000 = 0 .. 100%.
++                                     * Applicable if the format has VRDE_VIDEOIN_F_FMT_COMPQUALITY,
++                                     * otherwise this field is ignored.
++                                     */
++    uint16_t u16Delay;              /* Latency in ms from video data capture to presentation on the channel.
++                                     * Set by the client, read by the server.
++                                     */
++    uint32_t u32ClockFrequency;     /* @todo just all clocks in 100ns units? */
++} VRDEVIDEOINCTRL_VS_START;
++
++/* Stop sending video frames. */
++typedef struct VRDEVIDEOINCTRL_VS_STOP
++{
++    VRDEVIDEOINCTRLHDR hdr;
++} VRDEVIDEOINCTRL_VS_STOP;
++
++typedef struct VRDEVIDEOINCTRL_VS_SYNCH_DELAY
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint16_t u16Delay;
++} VRDEVIDEOINCTRL_VS_SYNCH_DELAY;
++
++typedef struct VRDEVIDEOINCTRL_VS_STILL_IMAGE_TRIGGER
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8Trigger;
++} VRDEVIDEOINCTRL_VS_STILL_IMAGE_TRIGGER;
++
++typedef struct VRDEVIDEOINCTRL_VS_GENERATE_KEY_FRAME
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8GenerateKeyFrame;
++} VRDEVIDEOINCTRL_VS_GENERATE_KEY_FRAME;
++
++typedef struct VRDEVIDEOINCTRL_VS_UPDATE_FRAME_SEGMENT
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8StartFrameSegment;
++    uint8_t u8EndFrameSegment;
++} VRDEVIDEOINCTRL_VS_UPDATE_FRAME_SEGMENT;
++
++typedef struct VRDEVIDEOINCTRL_VS_STREAM_ERROR_CODE
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8StreamErrorCode;
++} VRDEVIDEOINCTRL_VS_STREAM_ERROR_CODE;
++
++/* A hardware button was pressed/released on the device. */
++typedef struct VRDEVIDEOINCTRL_HW_BUTTON
++{
++    VRDEVIDEOINCTRLHDR hdr;
++    uint8_t u8Pressed;
++} VRDEVIDEOINCTRL_CT_HW_BUTTON;
++
++/*
++ * Payload transfers. How frames are sent to the server:
++ * the client send a PAYLOAD packet, which has the already set format.
++ * The server enables the transfers by sending VRDEVIDEOINCTRL_VS_START.
++ */
++
++/* Payload header */
++typedef struct VRDEVIDEOINPAYLOADHDR
++{
++    uint8_t u8HeaderLength;       /* Entire header. */
++    uint8_t u8HeaderInfo;         /* VRDE_VIDEOIN_PAYLOAD_F_* */
++    uint32_t u32PresentationTime; /* @todo define this */
++    uint32_t u32SourceTimeClock;  /* @todo At the moment when the frame was sent to the channel.
++                                   * Allows the server to measure clock drift.
++                                   */
++    uint16_t u16Reserved;         /* @todo */
++} VRDEVIDEOINPAYLOADHDR;
++
++/* VRDEVIDEOINPAYLOADHDR::u8HeaderInfo */
++#define VRDE_VIDEOIN_PAYLOAD_F_FID     0x01 /* Frame ID */
++#define VRDE_VIDEOIN_PAYLOAD_F_EOF     0x02 /* End of Frame */
++#define VRDE_VIDEOIN_PAYLOAD_F_PTS     0x04 /* Presentation Time */
++#define VRDE_VIDEOIN_PAYLOAD_F_SCR     0x08 /* Source Clock Reference */
++#define VRDE_VIDEOIN_PAYLOAD_F_RES     0x10 /* Reserved */
++#define VRDE_VIDEOIN_PAYLOAD_F_STI     0x20 /* Still Image */
++#define VRDE_VIDEOIN_PAYLOAD_F_ERR     0x40 /* Error */
++#define VRDE_VIDEOIN_PAYLOAD_F_EOH     0x80 /* End of header */
++
++
++/*
++ * The network channel specification.
++ */
++
++/*
++ * The protocol uses a dynamic RDP channel.
++ * Everything is little-endian.
++ */
++
++#define VRDE_VIDEOIN_CHANNEL "RVIDEOIN"
++
++/* Major functions. */
++#define VRDE_VIDEOIN_FN_NEGOTIATE  0x0000 /* Version and capabilities check. */
++#define VRDE_VIDEOIN_FN_NOTIFY     0x0001 /* Device attach/detach from the client. */
++#define VRDE_VIDEOIN_FN_DEVICEDESC 0x0002 /* Query device description. */
++#define VRDE_VIDEOIN_FN_CONTROL    0x0003 /* Control the device and start/stop video input. */
++#define VRDE_VIDEOIN_FN_CONTROL_NOTIFY 0x0004 /* The client reports a control change, etc. */
++#define VRDE_VIDEOIN_FN_FRAME      0x0005 /* Frame from the client. */
++
++/* Status codes. */
++#define VRDE_VIDEOIN_STATUS_SUCCESS       0 /* Function completed successfully. */
++#define VRDE_VIDEOIN_STATUS_FAILED        1 /* Failed for some reason. */
++
++typedef struct VRDEVIDEOINMSGHDR
++{
++    uint32_t u32Length;     /* The length of the message in bytes, including the header. */
++    uint32_t u32DeviceId;   /* The client's device id. */
++    uint32_t u32MessageId;  /* Unique id assigned by the server. The client must send a reply with the same id.
++                             * If the client initiates a request, then this must be set to 0, because there is
++                             * currently no client requests, which would require a response from the server.
++                             */
++    uint16_t u16FunctionId; /* VRDE_VIDEOIN_FN_* */
++    uint16_t u16Status;     /* The result of a request. VRDE_VIDEOIN_STATUS_*. */
++} VRDEVIDEOINMSGHDR;
++ASSERTSIZE(VRDEVIDEOINMSGHDR, 16)
++
++/*
++ * VRDE_VIDEOIN_FN_NEGOTIATE
++ *
++ * Sent by the server when the channel is established and the client replies with its capabilities. 
++ */
++#define VRDE_VIDEOIN_NEGOTIATE_VERSION 1
++
++#define VRDE_VIDEOIN_NEGOTIATE_CAP_VOID 0
++
++typedef struct VRDEVIDEOINMSG_NEGOTIATE
++{
++    VRDEVIDEOINMSGHDR hdr;
++    uint32_t u32Version;       /* VRDE_VIDEOIN_NEGOTIATE_VERSION */
++    uint32_t fu32Capabilities; /* VRDE_VIDEOIN_NEGOTIATE_CAP_* */
++} VRDEVIDEOINMSG_NEGOTIATE;
++
++/*
++ * VRDE_VIDEOIN_FN_NOTIFY
++ *
++ * Sent by the client when a webcam is attached or detached.
++ * The client must send the ATTACH notification for each webcam, which is
++ * already connected to the client when the VIDEOIN channel is established.
++ */
++#define VRDE_VIDEOIN_NOTIFY_ATTACH 0
++#define VRDE_VIDEOIN_NOTIFY_DETACH 1
++
++typedef struct VRDEVIDEOINMSG_NOTIFY
++{
++    VRDEVIDEOINMSGHDR hdr;
++    uint32_t u32NotifyEvent; /* VRDE_VIDEOIN_NOTIFY_* */
++    /* Event specific data may follow. The underlying protocol provides the length of the message. */
++} VRDEVIDEOINMSG_NOTIFY;
++
++/*
++ * VRDE_VIDEOIN_FN_DEVICEDESC
++ *
++ * The server queries the description of a device.
++ */
++typedef struct VRDEVIDEOINMSG_DEVICEDESC_REQ
++{
++    VRDEVIDEOINMSGHDR hdr;
++} VRDEVIDEOINMSG_DEVICEDESC_REQ;
++
++typedef struct VRDEVIDEOINMSG_DEVICEDESC_RSP
++{
++    VRDEVIDEOINMSGHDR hdr;
++    VRDEVIDEOINDEVICEDESC Device;
++    /* 
++     * VRDEVIDEOINFORMATDESC[0]
++     * VRDEVIDEOINFRAMEDESC[0]
++     * ...
++     * VRDEVIDEOINFRAMEDESC[n]
++     * VRDEVIDEOINFORMATDESC[1]
++     * VRDEVIDEOINFRAMEDESC[0]
++     * ...
++     * VRDEVIDEOINFRAMEDESC[m]
++     * ...
++     */
++} VRDEVIDEOINMSG_DEVICEDESC_RSP;
++
++/*
++ * VRDE_VIDEOIN_FN_CONTROL
++ * VRDE_VIDEOIN_FN_CONTROL_NOTIFY
++ *
++ * Either sent by the server or by the client as a notification/response.
++ * If sent by the client as a notification, then hdr.u32MessageId must be 0.
++ */
++typedef struct VRDEVIDEOINMSG_CONTROL
++{
++    VRDEVIDEOINMSGHDR hdr;
++    VRDEVIDEOINCTRLHDR Control;
++    /* Control specific data may follow. */
++} VRDEVIDEOINMSG_CONTROL;
++
++/*
++ * VRDE_VIDEOIN_FN_FRAME
++ *
++ * The client sends a video/still frame in the already specified format.
++ * hdr.u32MessageId must be 0.
++ */
++typedef struct VRDEVIDEOINMSG_FRAME
++{
++    VRDEVIDEOINMSGHDR hdr;
++    VRDEVIDEOINPAYLOADHDR Payload;
++    /* The frame data follow. */
++} VRDEVIDEOINMSG_FRAME;
++
++
++#ifdef VRDE_VIDEOIN_WITH_VRDEINTERFACE
++/*
++ * The application interface between VirtualBox and the VRDE server.
++ */
++
++#define VRDE_VIDEOIN_INTERFACE_NAME "VIDEOIN"
++
++typedef struct VRDEVIDEOINDEVICEHANDLE
++{
++    uint32_t u32ClientId;
++    uint32_t u32DeviceId;
++} VRDEVIDEOINDEVICEHANDLE;
++
++/* The VRDE server video input interface entry points. Interface version 1. */
++typedef struct VRDEVIDEOININTERFACE
++{
++    /* The header. */
++    VRDEINTERFACEHDR header;
++
++    /* Tell the server that this device will be used and associate a context with the device.
++     *
++     * @param hServer The VRDE server instance.
++     * @param pDeviceHandle The device reported by ATTACH notification.
++     * @param pvDeviceCtx The caller context associated with the pDeviceHandle.
++     *
++     * @return IPRT status code.
++     */
++    DECLR3CALLBACKMEMBER(int, VRDEVideoInDeviceAttach, (HVRDESERVER hServer,
++                                                        const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle,
++                                                        void *pvDeviceCtx));
++
++    /* This device will be not be used anymore. The device context must not be used by the server too.
++     *
++     * @param hServer The VRDE server instance.
++     * @param pDeviceHandle The device reported by ATTACH notification.
++     *
++     * @return IPRT status code.
++     */
++    DECLR3CALLBACKMEMBER(int, VRDEVideoInDeviceDetach, (HVRDESERVER hServer,
++                                                        const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle));
++
++    /* Get a device description.
++     *
++     * @param hServer The VRDE server instance.
++     * @param pvUser  The callers context of this request.
++     * @param pDeviceHandle The device reported by ATTACH notification.
++     *
++     * @return IPRT status code.
++     */
++    DECLR3CALLBACKMEMBER(int, VRDEVideoInGetDeviceDesc, (HVRDESERVER hServer,
++                                                         void *pvUser,
++                                                         const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle));
++
++    /* Submit a set/get control request.
++     *
++     * @param hServer The VRDE server instance.
++     * @param pvUser  The callers context of this request.
++     * @param pDeviceHandle The device reported by ATTACH notification.
++     * @param pReq  The request.
++     * @param cbReq Size of the request.
++     *
++     * @return IPRT status code.
++     */
++    DECLR3CALLBACKMEMBER(int, VRDEVideoInControl, (HVRDESERVER hServer,
++                                                   void *pvUser,
++                                                   const VRDEVIDEOINDEVICEHANDLE *pDeviceHandle,
++                                                   const VRDEVIDEOINCTRLHDR *pReq,
++                                                   uint32_t cbReq));
++
++} VRDEVIDEOININTERFACE;
++
++
++/*
++ * Notifications.
++ * Data structures: pvData of VRDEVIDEOINCALLBACKS::VRDECallbackVideoInNotify.
++ */
++typedef struct VRDEVIDEOINNOTIFYATTACH
++{
++   VRDEVIDEOINDEVICEHANDLE deviceHandle;
++} VRDEVIDEOINNOTIFYATTACH;
++
++typedef struct VRDEVIDEOINNOTIFYDETACH
++{
++   VRDEVIDEOINDEVICEHANDLE deviceHandle;
++} VRDEVIDEOINNOTIFYDETACH;
++
++
++/* Video input interface callbacks. */
++typedef struct VRDEVIDEOINCALLBACKS
++{
++    /** The header. */
++    VRDEINTERFACEHDR header;
++
++    /* Notifications.
++     *
++     * @param pvCallback The callbacks context specified in VRDEGetInterface.
++     * @param u32EventId The notification identifier: VRDE_VIDEOIN_NOTIFY_*.
++     * @param pvData     The notification specific data.
++     * @param cbData     The size of buffer pointed by pvData.
++     */
++    DECLR3CALLBACKMEMBER(void, VRDECallbackVideoInNotify,(void *pvCallback,
++                                                          uint32_t u32Id,
++                                                          const void *pvData,
++                                                          uint32_t cbData));
++
++    /* Device description received from the client.
++     *
++     * @param pvCallback The callbacks context specified in VRDEGetInterface.
++     * @param rcRequest  The result code of the request.
++     * @param pDeviceCtx The device context associated with the device in VRDEVideoInGetDeviceDesc.
++     * @param pvUser     The pvUser parameter of VRDEVideoInGetDeviceDesc.
++     * @param pDeviceDesc The device description.
++     * @param cbDeviceDesc The size of buffer pointed by pDevice.
++     */
++    DECLR3CALLBACKMEMBER(void, VRDECallbackVideoInDeviceDesc,(void *pvCallback,
++                                                              int rcRequest,
++                                                              void *pDeviceCtx,
++                                                              void *pvUser,
++                                                              const VRDEVIDEOINDEVICEDESC *pDeviceDesc,
++                                                              uint32_t cbDeviceDesc));
++
++    /* Control response or notification.
++     *
++     * @param pvCallback The callbacks context specified in VRDEGetInterface.
++     * @param rcRequest  The result code of the request.
++     * @param pDeviceCtx The device context associated with the device in VRDEVideoInGetDeviceDesc.
++     * @param pvUser     The pvUser parameter of VRDEVideoInControl. NULL if this is a notification.
++     * @param pControl   The control information.
++     * @param cbControl  The size of buffer pointed by pControl.
++     */
++    DECLR3CALLBACKMEMBER(void, VRDECallbackVideoInControl,(void *pvCallback,
++                                                           int rcRequest,
++                                                           void *pDeviceCtx,
++                                                           void *pvUser,
++                                                           const VRDEVIDEOINCTRLHDR *pControl,
++                                                           uint32_t cbControl));
++
++    /* Frame which was received from the client.
++     *
++     * @param pvCallback The callbacks context specified in VRDEGetInterface.
++     * @param rcRequest  The result code of the request.
++     * @param pDeviceCtx The device context associated with the device in VRDEVideoInGetDeviceDesc.
++     * @param pFrame     The frame data.
++     * @param cbFrame    The size of buffer pointed by pFrame.
++     */
++    DECLR3CALLBACKMEMBER(void, VRDECallbackVideoInFrame,(void *pvCallback,
++                                                         int rcRequest,
++                                                         void *pDeviceCtx,
++                                                         const VRDEVIDEOINPAYLOADHDR *pFrame,
++                                                         uint32_t cbFrame));
++
++} VRDEVIDEOINCALLBACKS;
++#endif /* VRDE_VIDEOIN_WITH_VRDEINTERFACE */
++
++#pragma pack()
++
++#endif