lavd: add device capabilities API

Provides API to query device capabilities.
Each device must implement callbacks to benefit from this API.

Signed-off-by: Lukasz Marek <lukasz.m.luki@gmail.com>

3 files changed, 210 insertions, 1 deletions

diff --git a/libavdevice/avdevice.c b/libavdevice/avdevice.c
index ea14c7a286..bc79ca7030 100644
--- a/libavdevice/avdevice.c
+++ b/libavdevice/avdevice.c
@@ -17,9 +17,46 @@
  */
 
 #include "libavutil/avassert.h"
+#include "libavutil/samplefmt.h"
+#include "libavutil/pixfmt.h"
+#include "libavcodec/avcodec.h"
 #include "avdevice.h"
 #include "config.h"
 
+#define E AV_OPT_FLAG_ENCODING_PARAM
+#define D AV_OPT_FLAG_DECODING_PARAM
+#define A AV_OPT_FLAG_AUDIO_PARAM
+#define V AV_OPT_FLAG_VIDEO_PARAM
+#define OFFSET(x) offsetof(AVDeviceCapabilitiesQuery, x)
+
+const AVOption av_device_capabilities[] = {
+    { "codec", "codec", OFFSET(codec), AV_OPT_TYPE_INT,
+        {.i64 = AV_CODEC_ID_NONE}, AV_CODEC_ID_NONE, INT_MAX, E|D|A|V },
+    { "sample_format", "sample format", OFFSET(sample_format), AV_OPT_TYPE_INT,
+        {.i64 = AV_SAMPLE_FMT_NONE}, -1, INT_MAX, E|D|A },
+    { "sample_rate", "sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT,
+        {.i64 = -1}, -1, INT_MAX, E|D|A },
+    { "channels", "channels", OFFSET(channels), AV_OPT_TYPE_INT,
+        {.i64 = -1}, -1, INT_MAX, E|D|A },
+    { "channel_layout", "channel layout", OFFSET(channel_layout), AV_OPT_TYPE_INT64,
+        {.i64 = -1}, -1, INT_MAX, E|D|A },
+    { "pixel_format", "pixel format", OFFSET(pixel_format), AV_OPT_TYPE_INT,
+        {.i64 = AV_PIX_FMT_NONE}, -1, INT_MAX, E|D|V },
+    { "window_size", "window size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE,
+        {.str = NULL}, -1, INT_MAX, E|D|V },
+    { "frame_size", "frame size", OFFSET(frame_width), AV_OPT_TYPE_IMAGE_SIZE,
+        {.str = NULL}, -1, INT_MAX, E|D|V },
+    { "fps", "fps", OFFSET(fps), AV_OPT_TYPE_RATIONAL,
+        {.dbl = -1}, -1, INT_MAX, E|D|V },
+    { NULL }
+};
+
+#undef E
+#undef D
+#undef A
+#undef V
+#undef OFFSET
+
 unsigned avdevice_version(void)
 {
     av_assert0(LIBAVDEVICE_VERSION_MICRO >= 100);
@@ -99,6 +136,50 @@ int avdevice_dev_to_app_control_message(struct AVFormatContext *s, enum AVDevToA
     return s->control_message_cb(s, type, data, data_size);
 }
 
+int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
+                                 AVDictionary **device_options)
+{
+    int ret;
+    av_assert0(s && caps);
+    av_assert0(s->iformat || s->oformat);
+    if ((s->oformat && !s->oformat->create_device_capabilities) ||
+        (s->iformat && !s->iformat->create_device_capabilities))
+        return AVERROR(ENOSYS);
+    *caps = av_mallocz(sizeof(**caps));
+    if (!(*caps))
+        return AVERROR(ENOMEM);
+    (*caps)->device_context = s;
+    if (((ret = av_opt_set_dict(s->priv_data, device_options)) < 0))
+        goto fail;
+    if (s->iformat) {
+        if ((ret = s->iformat->create_device_capabilities(s, *caps)) < 0)
+            goto fail;
+    } else {
+        if ((ret = s->oformat->create_device_capabilities(s, *caps)) < 0)
+            goto fail;
+    }
+    av_opt_set_defaults(*caps);
+    return 0;
+  fail:
+    av_freep(caps);
+    return ret;
+}
+
+void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s)
+{
+    if (!s || !caps || !(*caps))
+        return;
+    av_assert0(s->iformat || s->oformat);
+    if (s->iformat) {
+        if (s->iformat->free_device_capabilities)
+            s->iformat->free_device_capabilities(s, *caps);
+    } else {
+        if (s->oformat->free_device_capabilities)
+            s->oformat->free_device_capabilities(s, *caps);
+    }
+    av_freep(caps);
+}
+
 int avdevice_list_devices(AVFormatContext *s, AVDeviceInfoList **device_list)
 {
     int ret;
diff --git a/libavdevice/avdevice.h b/libavdevice/avdevice.h
index 8b78067133..e194663ee3 100644
--- a/libavdevice/avdevice.h
+++ b/libavdevice/avdevice.h
@@ -43,6 +43,9 @@
  * @}
  */
 
+#include "libavutil/log.h"
+#include "libavutil/opt.h"
+#include "libavutil/dict.h"
 #include "libavformat/avformat.h"
 
 /**
@@ -228,6 +231,131 @@ int avdevice_dev_to_app_control_message(struct AVFormatContext *s,
                                         void *data, size_t data_size);
 
 /**
+ * Following API allows user to probe device capabilities (supported codecs,
+ * pixel formats, sample formats, resolutions, channel counts, etc).
+ * It is build on top op AVOption API.
+ * Queried capabilities allows to set up converters of video or audio
+ * parameters that fit to the device.
+ *
+ * List of capablities that can be queried:
+ *  - Capabilities valid for both audio and video devices:
+ *    - codec:          supported audio/video codecs.
+ *                      type: AV_OPT_TYPE_INT (AVCodecID value)
+ *  - Capabilities valid for audio devices:
+ *    - sample_format:  supported sample formats.
+ *                      type: AV_OPT_TYPE_INT (AVSampleFormat value)
+ *    - sample_rate:    supported sample rates.
+ *                      type: AV_OPT_TYPE_INT
+ *    - channels:       supported number of channels.
+ *                      type: AV_OPT_TYPE_INT
+ *    - channel_layout: supported channel layouts.
+ *                      type: AV_OPT_TYPE_INT64
+ *  - Capabilities valid for video devices:
+ *    - pixel_format:   supported pixel formats.
+ *                      type: AV_OPT_TYPE_INT (AVPixelFormat value)
+ *    - window_size:    supported window sizes (describes size of the window size presented to the user).
+ *                      type: AV_OPT_TYPE_IMAGE_SIZE
+ *    - frame_size:     supported frame sizes (describes size of provided video frames).
+ *                      type: AV_OPT_TYPE_IMAGE_SIZE
+ *    - fps:            supported fps values
+ *                      type: AV_OPT_TYPE_RATIONAL
+ *
+ * Value of the capability may be set by user using av_opt_set() function
+ * and AVDeviceCapabilitiesQuery object. Following queries will
+ * limit results to the values matching already set capabilities.
+ * For example, setting a codec may impact number of formats or fps values
+ * returned during next query. Setting invalid value may limit results to zero.
+ *
+ * Example of the usage basing on opengl output device:
+ *
+ * @code
+ *  AVFormatContext *oc = NULL;
+ *  AVDeviceCapabilitiesQuery *caps = NULL;
+ *  AVOptionRanges *ranges;
+ *  int ret;
+ *
+ *  if ((ret = avformat_alloc_output_context2(&oc, NULL, "opengl", NULL)) < 0)
+ *      goto fail;
+ *  if (avdevice_capabilities_create(&caps, oc, NULL) < 0)
+ *      goto fail;
+ *
+ *  //query codecs
+ *  if (av_opt_query_ranges(&ranges, caps, "codec", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
+ *      goto fail;
+ *  //pick codec here and set it
+ *  av_opt_set(caps, "codec", AV_CODEC_ID_RAWVIDEO, 0);
+ *
+ *  //query format
+ *  if (av_opt_query_ranges(&ranges, caps, "pixel_format", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
+ *      goto fail;
+ *  //pick format here and set it
+ *  av_opt_set(caps, "pixel_format", AV_PIX_FMT_YUV420P, 0);
+ *
+ *  //query and set more capabilities
+ *
+ * fail:
+ *  //clean up code
+ *  avdevice_capabilities_free(&query, oc);
+ *  avformat_free_context(oc);
+ * @endcode
+ */
+
+/**
+ * Structure describes device capabilites.
+ *
+ * It is used by devices in conjuntion with av_device_capabilities AVOption table
+ * to implement capabilities probing API based on AVOption API. Should not be used directly.
+ */
+typedef struct AVDeviceCapabilitiesQuery {
+    const AVClass *class;
+    AVFormatContext *device_context;
+    enum AVCodecID codec;
+    enum AVSampleFormat sample_format;
+    enum AVPixelFormat pixel_format;
+    int sample_rate;
+    int channels;
+    int64_t channel_layout;
+    int window_width;
+    int window_height;
+    int frame_width;
+    int frame_height;
+    AVRational fps;
+} AVDeviceCapabilitiesQuery;
+
+/**
+ * AVOption table used by devices to implement device capabilites API. Should not be used by a user.
+ */
+extern const AVOption av_device_capabilities[];
+
+/**
+ * Initialize capabilities probing API based on AVOption API.
+ *
+ * avdevice_capabilities_free() must be called when query capabilities API is
+ * not used anymore.
+ *
+ * @param[out] caps      Device capabilities data. Pointer to a NULL pointer must be passed.
+ * @param s              Context of the device.
+ * @param device_options An AVDictionary filled with device-private options.
+ *                       On return this parameter will be destroyed and replaced with a dict
+ *                       containing options that were not found. May be NULL.
+ *                       The same options must be passed later to avformat_write_header() for output
+ *                       devices or avformat_open_input() for input devices, or at any other place
+ *                       that affects device-private options.
+ *
+ * @return >= 0 on success, negative otherwise.
+ */
+int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
+                                 AVDictionary **device_options);
+
+/**
+ * Free resources created by avdevice_capabilities_create()
+ *
+ * @param caps Device capabilities data to be freed.
+ * @param s    Context of the device.
+ */
+void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s);
+
+/**
  * Structure describes basic parameters of the device.
  */
 typedef struct AVDeviceInfo {
diff --git a/libavdevice/version.h b/libavdevice/version.h
index 15096ab6cc..8829a60af2 100644
--- a/libavdevice/version.h
+++ b/libavdevice/version.h
@@ -28,7 +28,7 @@
 #include "libavutil/version.h"
 
 #define LIBAVDEVICE_VERSION_MAJOR  55
-#define LIBAVDEVICE_VERSION_MINOR  11
+#define LIBAVDEVICE_VERSION_MINOR  12
 #define LIBAVDEVICE_VERSION_MICRO 100
 
 #define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \