meta-egvirt/recipes-kernel/kernel-module-virtio-video/files/include/uapi/linux/virtio_video.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Virtio Video Device
   4  *
   5  * This header is BSD licensed so anyone can use the definitions
   6  * to implement compatible drivers/servers:
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of IBM nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  22  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  26  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * Copyright (C) 2020 OpenSynergy GmbH.
  33  */
  34
  35 #ifndef _UAPI_LINUX_VIRTIO_VIDEO_H
  36 #define _UAPI_LINUX_VIRTIO_VIDEO_H
  37
  38 #include <linux/types.h>
  39 #include <linux/virtio_config.h>
  40
  41 enum virtio_video_device_type {
  42         VIRTIO_VIDEO_DEVICE_ENCODER = 0x0100,
  43         VIRTIO_VIDEO_DEVICE_DECODER,
  44         VIRTIO_VIDEO_DEVICE_CAMERA,
  45 };
  46
  47 /*
  48  * Feature bits
  49  */
  50
  51 /* Guest pages can be used for video buffers. */
  52 #define VIRTIO_VIDEO_F_RESOURCE_GUEST_PAGES 0
  53 /*
  54  * The host can process buffers even if they are non-contiguous memory such as
  55  * scatter-gather lists.
  56  */
  57 #define VIRTIO_VIDEO_F_RESOURCE_NON_CONTIG 1
  58
  59 #define VIRTIO_VIDEO_MAX_PLANES 8
  60
  61 /*
  62  * Image formats
  63  */
  64
  65 enum virtio_video_format {
  66         /* Raw formats */
  67         VIRTIO_VIDEO_FORMAT_RAW_MIN = 1,
  68         VIRTIO_VIDEO_FORMAT_ARGB8888 = VIRTIO_VIDEO_FORMAT_RAW_MIN,
  69         VIRTIO_VIDEO_FORMAT_BGRA8888,
  70         VIRTIO_VIDEO_FORMAT_RGBA8888,
  71         VIRTIO_VIDEO_FORMAT_NV12, /* 12  Y/CbCr 4:2:0  */
  72         VIRTIO_VIDEO_FORMAT_YUV420, /* 12  YUV 4:2:0     */
  73         VIRTIO_VIDEO_FORMAT_YVU420, /* 12  YVU 4:2:0     */
  74         VIRTIO_VIDEO_FORMAT_YUV422, /* 16 YUV 4:2:2 */
  75         VIRTIO_VIDEO_FORMAT_RAW_MAX = VIRTIO_VIDEO_FORMAT_YUV422,
  76
  77         /* Coded formats */
  78         VIRTIO_VIDEO_FORMAT_CODED_MIN = 0x1000,
  79         VIRTIO_VIDEO_FORMAT_MPEG2 =
  80                 VIRTIO_VIDEO_FORMAT_CODED_MIN, /* MPEG-2 Part 2 */
  81         VIRTIO_VIDEO_FORMAT_MPEG4, /* MPEG-4 Part 2 */
  82         VIRTIO_VIDEO_FORMAT_H264, /* H.264 */
  83         VIRTIO_VIDEO_FORMAT_HEVC, /* HEVC aka H.265*/
  84         VIRTIO_VIDEO_FORMAT_VP8, /* VP8 */
  85         VIRTIO_VIDEO_FORMAT_VP9, /* VP9 */
  86         VIRTIO_VIDEO_FORMAT_CODED_MAX = VIRTIO_VIDEO_FORMAT_VP9,
  87 };
  88
  89 enum virtio_video_profile {
  90         /* H.264 */
  91         VIRTIO_VIDEO_PROFILE_H264_MIN = 0x100,
  92         VIRTIO_VIDEO_PROFILE_H264_BASELINE = VIRTIO_VIDEO_PROFILE_H264_MIN,
  93         VIRTIO_VIDEO_PROFILE_H264_MAIN,
  94         VIRTIO_VIDEO_PROFILE_H264_EXTENDED,
  95         VIRTIO_VIDEO_PROFILE_H264_HIGH,
  96         VIRTIO_VIDEO_PROFILE_H264_HIGH10PROFILE,
  97         VIRTIO_VIDEO_PROFILE_H264_HIGH422PROFILE,
  98         VIRTIO_VIDEO_PROFILE_H264_HIGH444PREDICTIVEPROFILE,
  99         VIRTIO_VIDEO_PROFILE_H264_SCALABLEBASELINE,
 100         VIRTIO_VIDEO_PROFILE_H264_SCALABLEHIGH,
 101         VIRTIO_VIDEO_PROFILE_H264_STEREOHIGH,
 102         VIRTIO_VIDEO_PROFILE_H264_MULTIVIEWHIGH,
 103         VIRTIO_VIDEO_PROFILE_H264_MAX = VIRTIO_VIDEO_PROFILE_H264_MULTIVIEWHIGH,
 104
 105         /* HEVC */
 106         VIRTIO_VIDEO_PROFILE_HEVC_MIN = 0x200,
 107         VIRTIO_VIDEO_PROFILE_HEVC_MAIN = VIRTIO_VIDEO_PROFILE_HEVC_MIN,
 108         VIRTIO_VIDEO_PROFILE_HEVC_MAIN10,
 109         VIRTIO_VIDEO_PROFILE_HEVC_MAIN_STILL_PICTURE,
 110         VIRTIO_VIDEO_PROFILE_HEVC_MAX =
 111                 VIRTIO_VIDEO_PROFILE_HEVC_MAIN_STILL_PICTURE,
 112
 113         /* VP8 */
 114         VIRTIO_VIDEO_PROFILE_VP8_MIN = 0x300,
 115         VIRTIO_VIDEO_PROFILE_VP8_PROFILE0 = VIRTIO_VIDEO_PROFILE_VP8_MIN,
 116         VIRTIO_VIDEO_PROFILE_VP8_PROFILE1,
 117         VIRTIO_VIDEO_PROFILE_VP8_PROFILE2,
 118         VIRTIO_VIDEO_PROFILE_VP8_PROFILE3,
 119         VIRTIO_VIDEO_PROFILE_VP8_MAX = VIRTIO_VIDEO_PROFILE_VP8_PROFILE3,
 120
 121         /* VP9 */
 122         VIRTIO_VIDEO_PROFILE_VP9_MIN = 0x400,
 123         VIRTIO_VIDEO_PROFILE_VP9_PROFILE0 = VIRTIO_VIDEO_PROFILE_VP9_MIN,
 124         VIRTIO_VIDEO_PROFILE_VP9_PROFILE1,
 125         VIRTIO_VIDEO_PROFILE_VP9_PROFILE2,
 126         VIRTIO_VIDEO_PROFILE_VP9_PROFILE3,
 127         VIRTIO_VIDEO_PROFILE_VP9_MAX = VIRTIO_VIDEO_PROFILE_VP9_PROFILE3,
 128 };
 129
 130 enum virtio_video_level {
 131         /* H.264 */
 132         VIRTIO_VIDEO_LEVEL_H264_MIN = 0x100,
 133         VIRTIO_VIDEO_LEVEL_H264_1_0 = VIRTIO_VIDEO_LEVEL_H264_MIN,
 134         VIRTIO_VIDEO_LEVEL_H264_1_1,
 135         VIRTIO_VIDEO_LEVEL_H264_1_2,
 136         VIRTIO_VIDEO_LEVEL_H264_1_3,
 137         VIRTIO_VIDEO_LEVEL_H264_2_0,
 138         VIRTIO_VIDEO_LEVEL_H264_2_1,
 139         VIRTIO_VIDEO_LEVEL_H264_2_2,
 140         VIRTIO_VIDEO_LEVEL_H264_3_0,
 141         VIRTIO_VIDEO_LEVEL_H264_3_1,
 142         VIRTIO_VIDEO_LEVEL_H264_3_2,
 143         VIRTIO_VIDEO_LEVEL_H264_4_0,
 144         VIRTIO_VIDEO_LEVEL_H264_4_1,
 145         VIRTIO_VIDEO_LEVEL_H264_4_2,
 146         VIRTIO_VIDEO_LEVEL_H264_5_0,
 147         VIRTIO_VIDEO_LEVEL_H264_5_1,
 148         VIRTIO_VIDEO_LEVEL_H264_MAX = VIRTIO_VIDEO_LEVEL_H264_5_1,
 149 };
 150
 151 /*
 152  * Config
 153  */
 154
 155 struct virtio_video_config {
 156         __le32 version;
 157         __le32 max_caps_length;
 158         __le32 max_resp_length;
 159 };
 160
 161 /*
 162  * Commands
 163  */
 164
 165 enum virtio_video_cmd_type {
 166         /* Command */
 167         VIRTIO_VIDEO_CMD_QUERY_CAPABILITY = 0x0100,
 168         VIRTIO_VIDEO_CMD_STREAM_CREATE,
 169         VIRTIO_VIDEO_CMD_STREAM_DESTROY,
 170         VIRTIO_VIDEO_CMD_STREAM_DRAIN,
 171         VIRTIO_VIDEO_CMD_RESOURCE_ATTACH,
 172         VIRTIO_VIDEO_CMD_RESOURCE_QUEUE,
 173         VIRTIO_VIDEO_CMD_QUEUE_DETACH_RESOURCES,
 174         VIRTIO_VIDEO_CMD_QUEUE_CLEAR,
 175         VIRTIO_VIDEO_CMD_GET_PARAMS,
 176         VIRTIO_VIDEO_CMD_SET_PARAMS,
 177         VIRTIO_VIDEO_CMD_QUERY_CONTROL,
 178         VIRTIO_VIDEO_CMD_GET_CONTROL,
 179         VIRTIO_VIDEO_CMD_SET_CONTROL,
 180
 181         /* Response */
 182         VIRTIO_VIDEO_RESP_OK_NODATA = 0x0200,
 183         VIRTIO_VIDEO_RESP_OK_QUERY_CAPABILITY,
 184         VIRTIO_VIDEO_RESP_OK_RESOURCE_QUEUE,
 185         VIRTIO_VIDEO_RESP_OK_GET_PARAMS,
 186         VIRTIO_VIDEO_RESP_OK_QUERY_CONTROL,
 187         VIRTIO_VIDEO_RESP_OK_GET_CONTROL,
 188
 189         VIRTIO_VIDEO_RESP_ERR_INVALID_OPERATION = 0x0300,
 190         VIRTIO_VIDEO_RESP_ERR_OUT_OF_MEMORY,
 191         VIRTIO_VIDEO_RESP_ERR_INVALID_STREAM_ID,
 192         VIRTIO_VIDEO_RESP_ERR_INVALID_RESOURCE_ID,
 193         VIRTIO_VIDEO_RESP_ERR_INVALID_PARAMETER,
 194         VIRTIO_VIDEO_RESP_ERR_UNSUPPORTED_CONTROL,
 195 };
 196
 197 struct virtio_video_cmd_hdr {
 198         __le32 type; /* One of enum virtio_video_cmd_type */
 199         __le32 stream_id;
 200 };
 201
 202 /* VIRTIO_VIDEO_CMD_QUERY_CAPABILITY */
 203 enum virtio_video_queue_type {
 204         VIRTIO_VIDEO_QUEUE_TYPE_INPUT = 0x100,
 205         VIRTIO_VIDEO_QUEUE_TYPE_OUTPUT,
 206 };
 207
 208 struct virtio_video_query_capability {
 209         struct virtio_video_cmd_hdr hdr;
 210         __le32 queue_type; /* One of VIRTIO_VIDEO_QUEUE_TYPE_* types */
 211         __u8 padding[4];
 212 };
 213
 214 enum virtio_video_planes_layout_flag {
 215         VIRTIO_VIDEO_PLANES_LAYOUT_SINGLE_BUFFER = 1 << 0,
 216         VIRTIO_VIDEO_PLANES_LAYOUT_PER_PLANE = 1 << 1,
 217 };
 218
 219 struct virtio_video_format_range {
 220         __le32 min;
 221         __le32 max;
 222         __le32 step;
 223         __u8 padding[4];
 224 };
 225
 226 struct virtio_video_format_frame {
 227         struct virtio_video_format_range width;
 228         struct virtio_video_format_range height;
 229         __le32 num_rates;
 230         __u8 padding[4];
 231         /* Followed by struct virtio_video_format_range frame_rates[] */
 232 };
 233
 234 struct virtio_video_format_desc {
 235         __le64 mask;
 236         __le32 format; /* One of VIRTIO_VIDEO_FORMAT_* types */
 237         __le32 planes_layout; /* Bitmask with VIRTIO_VIDEO_PLANES_LAYOUT_* */
 238         __le32 plane_align;
 239         __le32 num_frames;
 240         /* Followed by struct virtio_video_format_frame frames[] */
 241 };
 242
 243 struct virtio_video_query_capability_resp {
 244         struct virtio_video_cmd_hdr hdr;
 245         __le32 num_descs;
 246         __u8 padding[4];
 247         /* Followed by struct virtio_video_format_desc descs[] */
 248 };
 249
 250 /* VIRTIO_VIDEO_CMD_STREAM_CREATE */
 251 enum virtio_video_mem_type {
 252         VIRTIO_VIDEO_MEM_TYPE_GUEST_PAGES,
 253 };
 254
 255 struct virtio_video_stream_create {
 256         struct virtio_video_cmd_hdr hdr;
 257         __le32 in_mem_type; /* One of VIRTIO_VIDEO_MEM_TYPE_* types */
 258         __le32 out_mem_type; /* One of VIRTIO_VIDEO_MEM_TYPE_* types */
 259         __le32 coded_format; /* One of VIRTIO_VIDEO_FORMAT_* types */
 260         __u8 padding[4];
 261         __u8 tag[64];
 262 };
 263
 264 /* VIRTIO_VIDEO_CMD_STREAM_DESTROY */
 265 struct virtio_video_stream_destroy {
 266         struct virtio_video_cmd_hdr hdr;
 267 };
 268
 269 /* VIRTIO_VIDEO_CMD_STREAM_DRAIN */
 270 struct virtio_video_stream_drain {
 271         struct virtio_video_cmd_hdr hdr;
 272 };
 273
 274 /* VIRTIO_VIDEO_CMD_RESOURCE_ATTACH */
 275 struct virtio_video_resource_object {
 276         __u8 uuid [16];
 277 };
 278
 279 struct virtio_video_resource_sg_entry {
 280         __le64 addr;
 281         __le32 length;
 282         __u8 padding[4];
 283 };
 284
 285 struct virtio_video_resource_sg_list {
 286         __le32 num_entries;
 287         __u8 padding[4];
 288         struct virtio_video_resource_sg_entry entries[];
 289 };
 290 #define VIRTIO_VIDEO_RESOURCE_SG_SIZE(n) \
 291         offsetof(struct virtio_video_resource_sg_list, entries[n])
 292
 293 union virtio_video_resource {
 294         struct virtio_video_resource_sg_list sg_list;
 295         struct virtio_video_resource_object object;
 296 };
 297
 298 struct virtio_video_resource_attach {
 299         __le32 cmd_type;
 300         __le32 stream_id;
 301         __le32 queue_type; /* VIRTIO_VIDEO_QUEUE_TYPE_* */
 302         __le32 resource_id;
 303         /* Followed by struct virtio_video_resource resources[] */
 304 };
 305
 306 /* VIRTIO_VIDEO_CMD_RESOURCE_QUEUE */
 307 struct virtio_video_resource_queue {
 308         __le32 cmd_type;
 309         __le32 stream_id;
 310         __le32 queue_type; /* VIRTIO_VIDEO_QUEUE_TYPE_* */
 311         __le32 resource_id;
 312         __le32 flags;      /* Bitmask with VIRTIO_VIDEO_ENQUEUE_FLAG_ * */
 313         __u8 padding[4];
 314         __le64 timestamp;
 315         __le32 data_sizes[VIRTIO_VIDEO_MAX_PLANES];
 316 };
 317
 318 enum virtio_video_dequeue_flag {
 319         VIRTIO_VIDEO_DEQUEUE_FLAG_ERR = 0,
 320         VIRTIO_VIDEO_DEQUEUE_FLAG_EOS,
 321
 322         /* Encoder only */
 323         VIRTIO_VIDEO_DEQUEUE_FLAG_KEY_FRAME,
 324         VIRTIO_VIDEO_DEQUEUE_FLAG_PFRAME,
 325         VIRTIO_VIDEO_DEQUEUE_FLAG_BFRAME,
 326 };
 327
 328 struct virtio_video_resource_queue_resp {
 329         struct virtio_video_cmd_hdr hdr;
 330         __le32 flags;
 331         __le64 timestamp;
 332         __le32 data_sizes[VIRTIO_VIDEO_MAX_PLANES];
 333 };
 334
 335 /* VIRTIO_VIDEO_CMD_QUEUE_DETACH_RESOURCES */
 336 struct virtio_video_queue_detach_resources {
 337         __le32 cmd_type;
 338         __le32 stream_id;
 339         __le32 queue_type; /* One of VIRTIO_VIDEO_QUEUE_TYPE_* types */
 340         __u8 padding[4];
 341 };
 342
 343 /* VIRTIO_VIDEO_CMD_QUEUE_CLEAR */
 344 struct virtio_video_queue_clear {
 345         struct virtio_video_cmd_hdr hdr;
 346         __le32 queue_type; /* One of VIRTIO_VIDEO_QUEUE_TYPE_* types */
 347         __u8 padding[4];
 348 };
 349
 350 /* VIRTIO_VIDEO_CMD_GET_PARAMS */
 351 struct virtio_video_plane_format {
 352         __le32 plane_size;
 353         __le32 stride;
 354 };
 355
 356 struct virtio_video_crop {
 357         __le32 left;
 358         __le32 top;
 359         __le32 width;
 360         __le32 height;
 361 };
 362
 363 struct virtio_video_params {
 364         __le32 queue_type; /* One of VIRTIO_VIDEO_QUEUE_TYPE_* types */
 365         __le32 format; /* One of VIRTIO_VIDEO_FORMAT_* types */
 366         __le32 frame_width;
 367         __le32 frame_height;
 368         __le32 min_buffers;
 369         __le32 max_buffers;
 370         struct virtio_video_crop crop;
 371         __le32 frame_rate;
 372         __le32 num_planes;
 373         struct virtio_video_plane_format plane_formats[VIRTIO_VIDEO_MAX_PLANES];
 374 };
 375
 376 struct virtio_video_get_params {
 377         struct virtio_video_cmd_hdr hdr;
 378         __le32 queue_type; /* One of VIRTIO_VIDEO_QUEUE_TYPE_* types */
 379         __u8 padding[4];
 380 };
 381
 382 struct virtio_video_get_params_resp {
 383         struct virtio_video_cmd_hdr hdr;
 384         struct virtio_video_params params;
 385 };
 386
 387 /* VIRTIO_VIDEO_CMD_SET_PARAMS */
 388 struct virtio_video_set_params {
 389         struct virtio_video_cmd_hdr hdr;
 390         struct virtio_video_params params;
 391 };
 392
 393 /* VIRTIO_VIDEO_CMD_QUERY_CONTROL */
 394 enum virtio_video_control_type {
 395         VIRTIO_VIDEO_CONTROL_BITRATE = 1,
 396         VIRTIO_VIDEO_CONTROL_PROFILE,
 397         VIRTIO_VIDEO_CONTROL_LEVEL,
 398 };
 399
 400 struct virtio_video_query_control_profile {
 401         __le32 format; /* One of VIRTIO_VIDEO_FORMAT_* */
 402         __u8 padding[4];
 403 };
 404
 405 struct virtio_video_query_control_level {
 406         __le32 format; /* One of VIRTIO_VIDEO_FORMAT_* */
 407         __u8 padding[4];
 408 };
 409
 410 struct virtio_video_query_control {
 411         struct virtio_video_cmd_hdr hdr;
 412         __le32 control; /* One of VIRTIO_VIDEO_CONTROL_* types */
 413         __u8 padding[4];
 414         /*
 415          * Followed by a value of struct virtio_video_query_control_*
 416          * in accordance with the value of control.
 417          */
 418 };
 419
 420 struct virtio_video_query_control_resp_profile {
 421         __le32 num;
 422         __u8 padding[4];
 423         /* Followed by an array le32 profiles[] */
 424 };
 425
 426 struct virtio_video_query_control_resp_level {
 427         __le32 num;
 428         __u8 padding[4];
 429         /* Followed by an array le32 level[] */
 430 };
 431
 432 struct virtio_video_query_control_resp {
 433         struct virtio_video_cmd_hdr hdr;
 434         /* Followed by one of struct virtio_video_query_control_resp_* */
 435 };
 436
 437 /* VIRTIO_VIDEO_CMD_GET_CONTROL */
 438 struct virtio_video_get_control {
 439         struct virtio_video_cmd_hdr hdr;
 440         __le32 control; /* One of VIRTIO_VIDEO_CONTROL_* types */
 441         __u8 padding[4];
 442 };
 443
 444 struct virtio_video_control_val_bitrate {
 445         __le32 bitrate;
 446         __u8 padding[4];
 447 };
 448
 449 struct virtio_video_control_val_profile {
 450         __le32 profile;
 451         __u8 padding[4];
 452 };
 453
 454 struct virtio_video_control_val_level {
 455         __le32 level;
 456         __u8 padding[4];
 457 };
 458
 459 struct virtio_video_get_control_resp {
 460         struct virtio_video_cmd_hdr hdr;
 461         /* Followed by one of struct virtio_video_control_val_* */
 462 };
 463
 464 /* VIRTIO_VIDEO_CMD_SET_CONTROL */
 465 struct virtio_video_set_control {
 466         struct virtio_video_cmd_hdr hdr;
 467         __le32 control; /* One of VIRTIO_VIDEO_CONTROL_* types */
 468         __u8 padding[4];
 469         /* Followed by one of struct virtio_video_control_val_* */
 470 };
 471
 472 struct virtio_video_set_control_resp {
 473         struct virtio_video_cmd_hdr hdr;
 474 };
 475
 476 /*
 477  * Events
 478  */
 479
 480 enum virtio_video_event_type {
 481         /* For all devices */
 482         VIRTIO_VIDEO_EVENT_ERROR = 0x0100,
 483
 484         /* For decoder only */
 485         VIRTIO_VIDEO_EVENT_DECODER_RESOLUTION_CHANGED = 0x0200,
 486 };
 487
 488 struct virtio_video_event {
 489         __le32 event_type; /* One of VIRTIO_VIDEO_EVENT_* types */
 490         __le32 stream_id;
 491 };
 492
 493 #endif /* _UAPI_LINUX_VIRTIO_VIDEO_H */