git.sesse.net Git - ffmpeg/blob - libavdevice/avdevice.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "libavutil/avassert.h"
  20 #include "libavutil/samplefmt.h"
  21 #include "libavutil/pixfmt.h"
  22 #include "libavcodec/avcodec.h"
  23 #include "avdevice.h"
  24 #include "internal.h"
  25 #include "config.h"
  26
  27 #include "libavutil/ffversion.h"
  28 const char av_device_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
  29
  30 #if FF_API_DEVICE_CAPABILITIES
  31 const AVOption av_device_capabilities[] = {
  32     { NULL }
  33 };
  34 #endif
  35
  36 unsigned avdevice_version(void)
  37 {
  38     av_assert0(LIBAVDEVICE_VERSION_MICRO >= 100);
  39     return LIBAVDEVICE_VERSION_INT;
  40 }
  41
  42 const char * avdevice_configuration(void)
  43 {
  44     return FFMPEG_CONFIGURATION;
  45 }
  46
  47 const char * avdevice_license(void)
  48 {
  49 #define LICENSE_PREFIX "libavdevice license: "
  50     return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
  51 }
  52
  53 int avdevice_app_to_dev_control_message(struct AVFormatContext *s, enum AVAppToDevMessageType type,
  54                                         void *data, size_t data_size)
  55 {
  56     if (!s->oformat || !s->oformat->control_message)
  57         return AVERROR(ENOSYS);
  58     return s->oformat->control_message(s, type, data, data_size);
  59 }
  60
  61 int avdevice_dev_to_app_control_message(struct AVFormatContext *s, enum AVDevToAppMessageType type,
  62                                         void *data, size_t data_size)
  63 {
  64     if (!s->control_message_cb)
  65         return AVERROR(ENOSYS);
  66     return s->control_message_cb(s, type, data, data_size);
  67 }
  68
  69 #if FF_API_DEVICE_CAPABILITIES
  70 int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
  71                                  AVDictionary **device_options)
  72 {
  73     return AVERROR(ENOSYS);
  74 }
  75
  76 void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s)
  77 {
  78     return;
  79 }
  80 #endif
  81
  82 int avdevice_list_devices(AVFormatContext *s, AVDeviceInfoList **device_list)
  83 {
  84     int ret;
  85     av_assert0(s);
  86     av_assert0(device_list);
  87     av_assert0(s->oformat || s->iformat);
  88     if ((s->oformat && !s->oformat->get_device_list) ||
  89         (s->iformat && !s->iformat->get_device_list)) {
  90         *device_list = NULL;
  91         return AVERROR(ENOSYS);
  92     }
  93     *device_list = av_mallocz(sizeof(AVDeviceInfoList));
  94     if (!(*device_list))
  95         return AVERROR(ENOMEM);
  96     /* no default device by default */
  97     (*device_list)->default_device = -1;
  98     if (s->oformat)
  99         ret = s->oformat->get_device_list(s, *device_list);
 100     else
 101         ret = s->iformat->get_device_list(s, *device_list);
 102     if (ret < 0)
 103         avdevice_free_list_devices(device_list);
 104     return ret;
 105 }
 106
 107 static int list_devices_for_context(AVFormatContext *s, AVDictionary *options,
 108                                     AVDeviceInfoList **device_list)
 109 {
 110     AVDictionary *tmp = NULL;
 111     int ret;
 112
 113     av_dict_copy(&tmp, options, 0);
 114     if ((ret = av_opt_set_dict2(s, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
 115         goto fail;
 116     ret = avdevice_list_devices(s, device_list);
 117   fail:
 118     av_dict_free(&tmp);
 119     avformat_free_context(s);
 120     return ret;
 121 }
 122
 123 int avdevice_list_input_sources(AVInputFormat *device, const char *device_name,
 124                                 AVDictionary *device_options, AVDeviceInfoList **device_list)
 125 {
 126     AVFormatContext *s = NULL;
 127     int ret;
 128
 129     if ((ret = ff_alloc_input_device_context(&s, device, device_name)) < 0)
 130         return ret;
 131     return list_devices_for_context(s, device_options, device_list);
 132 }
 133
 134 int avdevice_list_output_sinks(AVOutputFormat *device, const char *device_name,
 135                                AVDictionary *device_options, AVDeviceInfoList **device_list)
 136 {
 137     AVFormatContext *s = NULL;
 138     int ret;
 139
 140     if ((ret = avformat_alloc_output_context2(&s, device, device_name, NULL)) < 0)
 141         return ret;
 142     return list_devices_for_context(s, device_options, device_list);
 143 }
 144
 145 void avdevice_free_list_devices(AVDeviceInfoList **device_list)
 146 {
 147     AVDeviceInfoList *list;
 148     AVDeviceInfo *dev;
 149     int i;
 150
 151     av_assert0(device_list);
 152     list = *device_list;
 153     if (!list)
 154         return;
 155
 156     for (i = 0; i < list->nb_devices; i++) {
 157         dev = list->devices[i];
 158         if (dev) {
 159             av_freep(&dev->device_name);
 160             av_freep(&dev->device_description);
 161             av_free(dev);
 162         }
 163     }
 164     av_freep(&list->devices);
 165     av_freep(device_list);
 166 }