avcodec/codec: add doxy to AVCodec.decode()
[ffmpeg.git] / 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 }