FFmpeg
avdevice.c
Go to the documentation of this file.
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 #define E AV_OPT_FLAG_ENCODING_PARAM
31 #define D AV_OPT_FLAG_DECODING_PARAM
32 #define A AV_OPT_FLAG_AUDIO_PARAM
33 #define V AV_OPT_FLAG_VIDEO_PARAM
34 #define OFFSET(x) offsetof(AVDeviceCapabilitiesQuery, x)
35 
37  { "codec", "codec", OFFSET(codec), AV_OPT_TYPE_INT,
38  {.i64 = AV_CODEC_ID_NONE}, AV_CODEC_ID_NONE, INT_MAX, E|D|A|V },
39  { "sample_format", "sample format", OFFSET(sample_format), AV_OPT_TYPE_SAMPLE_FMT,
40  {.i64 = AV_SAMPLE_FMT_NONE}, AV_SAMPLE_FMT_NONE, INT_MAX, E|D|A },
41  { "sample_rate", "sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT,
42  {.i64 = -1}, -1, INT_MAX, E|D|A },
43  { "channels", "channels", OFFSET(channels), AV_OPT_TYPE_INT,
44  {.i64 = -1}, -1, INT_MAX, E|D|A },
45  { "channel_layout", "channel layout", OFFSET(channel_layout), AV_OPT_TYPE_CHANNEL_LAYOUT,
46  {.i64 = -1}, -1, INT_MAX, E|D|A },
47  { "pixel_format", "pixel format", OFFSET(pixel_format), AV_OPT_TYPE_PIXEL_FMT,
48  {.i64 = AV_PIX_FMT_NONE}, AV_PIX_FMT_NONE, INT_MAX, E|D|V },
49  { "window_size", "window size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE,
50  {.str = NULL}, -1, INT_MAX, E|D|V },
51  { "frame_size", "frame size", OFFSET(frame_width), AV_OPT_TYPE_IMAGE_SIZE,
52  {.str = NULL}, -1, INT_MAX, E|D|V },
53  { "fps", "fps", OFFSET(fps), AV_OPT_TYPE_RATIONAL,
54  {.dbl = -1}, -1, INT_MAX, E|D|V },
55  { NULL }
56 };
57 
58 #undef E
59 #undef D
60 #undef A
61 #undef V
62 #undef OFFSET
63 
64 unsigned avdevice_version(void)
65 {
68 }
69 
70 const char * avdevice_configuration(void)
71 {
72  return FFMPEG_CONFIGURATION;
73 }
74 
75 const char * avdevice_license(void)
76 {
77 #define LICENSE_PREFIX "libavdevice license: "
78  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
79 }
80 
82  void *data, size_t data_size)
83 {
84  if (!s->oformat || !s->oformat->control_message)
85  return AVERROR(ENOSYS);
86  return s->oformat->control_message(s, type, data, data_size);
87 }
88 
90  void *data, size_t data_size)
91 {
92  if (!s->control_message_cb)
93  return AVERROR(ENOSYS);
94  return s->control_message_cb(s, type, data, data_size);
95 }
96 
98  AVDictionary **device_options)
99 {
100  int ret;
101  av_assert0(s && caps);
102  av_assert0(s->iformat || s->oformat);
103  if ((s->oformat && !s->oformat->create_device_capabilities) ||
105  return AVERROR(ENOSYS);
106  *caps = av_mallocz(sizeof(**caps));
107  if (!(*caps))
108  return AVERROR(ENOMEM);
109  (*caps)->device_context = s;
110  if (((ret = av_opt_set_dict(s->priv_data, device_options)) < 0))
111  goto fail;
112  if (s->iformat) {
113  if ((ret = s->iformat->create_device_capabilities(s, *caps)) < 0)
114  goto fail;
115  } else {
116  if ((ret = s->oformat->create_device_capabilities(s, *caps)) < 0)
117  goto fail;
118  }
119  av_opt_set_defaults(*caps);
120  return 0;
121  fail:
122  av_freep(caps);
123  return ret;
124 }
125 
127 {
128  if (!s || !caps || !(*caps))
129  return;
130  av_assert0(s->iformat || s->oformat);
131  if (s->iformat) {
133  s->iformat->free_device_capabilities(s, *caps);
134  } else {
136  s->oformat->free_device_capabilities(s, *caps);
137  }
138  av_freep(caps);
139 }
140 
142 {
143  int ret;
144  av_assert0(s);
145  av_assert0(device_list);
146  av_assert0(s->oformat || s->iformat);
147  if ((s->oformat && !s->oformat->get_device_list) ||
148  (s->iformat && !s->iformat->get_device_list)) {
149  *device_list = NULL;
150  return AVERROR(ENOSYS);
151  }
152  *device_list = av_mallocz(sizeof(AVDeviceInfoList));
153  if (!(*device_list))
154  return AVERROR(ENOMEM);
155  /* no default device by default */
156  (*device_list)->default_device = -1;
157  if (s->oformat)
158  ret = s->oformat->get_device_list(s, *device_list);
159  else
160  ret = s->iformat->get_device_list(s, *device_list);
161  if (ret < 0)
162  avdevice_free_list_devices(device_list);
163  return ret;
164 }
165 
167  AVDeviceInfoList **device_list)
168 {
169  AVDictionary *tmp = NULL;
170  int ret;
171 
172  av_dict_copy(&tmp, options, 0);
173  if ((ret = av_opt_set_dict2(s, &tmp, AV_OPT_SEARCH_CHILDREN)) < 0)
174  goto fail;
175  ret = avdevice_list_devices(s, device_list);
176  fail:
177  av_dict_free(&tmp);
179  return ret;
180 }
181 
182 int avdevice_list_input_sources(AVInputFormat *device, const char *device_name,
183  AVDictionary *device_options, AVDeviceInfoList **device_list)
184 {
186  int ret;
187 
188  if ((ret = ff_alloc_input_device_context(&s, device, device_name)) < 0)
189  return ret;
190  return list_devices_for_context(s, device_options, device_list);
191 }
192 
193 int avdevice_list_output_sinks(AVOutputFormat *device, const char *device_name,
194  AVDictionary *device_options, AVDeviceInfoList **device_list)
195 {
197  int ret;
198 
199  if ((ret = avformat_alloc_output_context2(&s, device, device_name, NULL)) < 0)
200  return ret;
201  return list_devices_for_context(s, device_options, device_list);
202 }
203 
205 {
207  AVDeviceInfo *dev;
208  int i;
209 
210  av_assert0(device_list);
211  list = *device_list;
212  if (!list)
213  return;
214 
215  for (i = 0; i < list->nb_devices; i++) {
216  dev = list->devices[i];
217  if (dev) {
218  av_freep(&dev->device_name);
220  av_free(dev);
221  }
222  }
223  av_freep(&list->devices);
224  av_freep(device_list);
225 }
const char * avdevice_configuration(void)
Return the libavdevice build-time configuration.
Definition: avdevice.c:70
#define NULL
Definition: coverity.c:32
Structure describes basic parameters of the device.
Definition: avdevice.h:452
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
char * device_description
human friendly name
Definition: avdevice.h:454
void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s)
Free resources created by avdevice_capabilities_create()
Definition: avdevice.c:126
#define LICENSE_PREFIX
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1357
char * device_name
device name, format depends on device
Definition: avdevice.h:453
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GLint GLenum type
Definition: opengl_enc.c:104
int avdevice_list_devices(AVFormatContext *s, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:141
av_warn_unused_result int ff_alloc_input_device_context(struct AVFormatContext **avctx, struct AVInputFormat *iformat, const char *format)
Definition: utils.c:23
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int(* get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list)
Returns device list with it properties.
Definition: avformat.h:601
Format I/O context.
Definition: avformat.h:1239
int avdevice_dev_to_app_control_message(struct AVFormatContext *s, enum AVDevToAppMessageType type, void *data, size_t data_size)
Send control message from device to application.
Definition: avdevice.c:89
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s, AVDictionary **device_options)
Initialize capabilities probing API based on AVOption API.
Definition: avdevice.c:97
AVDevToAppMessageType
Message types used by avdevice_dev_to_app_control_message().
Definition: avdevice.h:198
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:204
int(* get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list)
Returns device list with it properties.
Definition: avformat.h:779
#define OFFSET(x)
Definition: avdevice.c:34
channels
Definition: aptx.h:33
Main libavdevice API header.
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1251
const char av_device_ffversion[]
Definition: avdevice.c:28
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
simple assert() macros that are a bit more flexible than ISO C assert().
int avformat_alloc_output_context2(AVFormatContext **ctx, ff_const59 AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:135
#define LIBAVDEVICE_VERSION_INT
Definition: version.h:34
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:461
#define fail()
Definition: checkasm.h:123
int avdevice_list_input_sources(AVInputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:182
#define A
Definition: avdevice.c:32
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
int avdevice_list_output_sinks(AVOutputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
Definition: avdevice.c:193
#define s(width, name)
Definition: cbs_vp9.c:257
#define E
Definition: avdevice.c:30
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1630
const AVOption av_device_capabilities[]
AVOption table used by devices to implement device capabilities API.
Definition: avdevice.c:36
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1258
int(* create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps)
Initialize device capabilities submodule.
Definition: avformat.h:785
sample_rate
Libavcodec external API header.
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1655
int(* free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps)
Free device capabilities submodule.
Definition: avformat.h:791
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
int(* control_message)(struct AVFormatContext *s, int type, void *data, size_t data_size)
Allows sending messages from application to device.
Definition: avformat.h:584
int(* free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps)
Free device capabilities submodule.
Definition: avformat.h:611
const char * avdevice_license(void)
Return the libavdevice license.
Definition: avdevice.c:75
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4382
offset must point to two consecutive integers
Definition: opt.h:235
List of devices.
Definition: avdevice.h:460
int(* create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps)
Initialize device capabilities submodule.
Definition: avformat.h:606
#define LIBAVDEVICE_VERSION_MICRO
Definition: version.h:32
const OptionDef options[]
Definition: ffmpeg_opt.c:3394
av_format_control_message control_message_cb
Callback used by devices to communicate with application.
Definition: avformat.h:1762
unsigned avdevice_version(void)
Return the LIBAVDEVICE_VERSION_INT constant.
Definition: avdevice.c:64
pixel format definitions
#define av_free(p)
void * priv_data
Format private data.
Definition: avformat.h:1267
AVAppToDevMessageType
Message types used by avdevice_app_to_dev_control_message().
Definition: avdevice.h:119
#define V
Definition: avdevice.c:33
static int list_devices_for_context(AVFormatContext *s, AVDictionary *options, AVDeviceInfoList **device_list)
Definition: avdevice.c:166
#define av_freep(p)
#define D
Definition: avdevice.c:31
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int avdevice_app_to_dev_control_message(struct AVFormatContext *s, enum AVAppToDevMessageType type, void *data, size_t data_size)
Send control message from application to device.
Definition: avdevice.c:81
int nb_devices
number of autodetected devices
Definition: avdevice.h:462
Following API allows user to probe device capabilities (supported codecs, pixel formats, sample formats, resolutions, channel counts, etc).
Definition: avdevice.h:400
int i
Definition: input.c:407
static uint8_t tmp[11]
Definition: aes_ctr.c:26