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/mem.h"
21 #include "avdevice.h"
22 #include "internal.h"
23 #include "libavformat/demux.h"
24 #include "libavformat/mux.h"
25 
27  void *data, size_t data_size)
28 {
29  if (!s->oformat || !ffofmt(s->oformat)->control_message)
30  return AVERROR(ENOSYS);
31  return ffofmt(s->oformat)->control_message(s, type, data, data_size);
32 }
33 
35  void *data, size_t data_size)
36 {
37  if (!s->control_message_cb)
38  return AVERROR(ENOSYS);
39  return s->control_message_cb(s, type, data, data_size);
40 }
41 
43 {
44  int ret;
45  av_assert0(s);
46  av_assert0(device_list);
47  av_assert0(s->oformat || s->iformat);
48  if ((s->oformat && !ffofmt(s->oformat)->get_device_list) ||
49  (s->iformat && !ffifmt(s->iformat)->get_device_list)) {
50  *device_list = NULL;
51  return AVERROR(ENOSYS);
52  }
53  *device_list = av_mallocz(sizeof(AVDeviceInfoList));
54  if (!(*device_list))
55  return AVERROR(ENOMEM);
56  /* no default device by default */
57  (*device_list)->default_device = -1;
58  if (s->oformat)
59  ret = ffofmt(s->oformat)->get_device_list(s, *device_list);
60  else
61  ret = ffifmt(s->iformat)->get_device_list(s, *device_list);
62  if (ret < 0) {
63  avdevice_free_list_devices(device_list);
64  return ret;
65  }
66  return (*device_list)->nb_devices;
67 }
68 
70  AVDeviceInfoList **device_list)
71 {
73  int ret;
74 
75  av_dict_copy(&tmp, options, 0);
77  goto fail;
78  ret = avdevice_list_devices(s, device_list);
79  fail:
80  av_dict_free(&tmp);
82  return ret;
83 }
84 
85 int avdevice_list_input_sources(const AVInputFormat *device, const char *device_name,
86  AVDictionary *device_options, AVDeviceInfoList **device_list)
87 {
89  int ret;
90 
91  if ((ret = ff_alloc_input_device_context(&s, device, device_name)) < 0)
92  return ret;
93  return list_devices_for_context(s, device_options, device_list);
94 }
95 
96 int avdevice_list_output_sinks(const AVOutputFormat *device, const char *device_name,
97  AVDictionary *device_options, AVDeviceInfoList **device_list)
98 {
100  int ret;
101 
102  if ((ret = avformat_alloc_output_context2(&s, device, device_name, NULL)) < 0)
103  return ret;
104  return list_devices_for_context(s, device_options, device_list);
105 }
106 
108 {
110  AVDeviceInfo *dev;
111  int i;
112 
113  av_assert0(device_list);
114  list = *device_list;
115  if (!list)
116  return;
117 
118  for (i = 0; i < list->nb_devices; i++) {
119  dev = list->devices[i];
120  if (dev) {
121  av_freep(&dev->device_name);
123  av_freep(&dev->media_types);
124  av_free(dev);
125  }
126  }
127  av_freep(&list->devices);
128  av_freep(device_list);
129 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:533
AVERROR
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
FFOutputFormat::get_device_list
int(* get_device_list)(AVFormatContext *s, struct AVDeviceInfoList *device_list)
Returns device list with it properties.
Definition: mux.h:135
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:334
FFOutputFormat::control_message
int(* control_message)(AVFormatContext *s, int type, void *data, size_t data_size)
Allows sending messages from application to device.
Definition: mux.h:118
avdevice_list_devices
int avdevice_list_devices(AVFormatContext *s, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:42
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVAppToDevMessageType
AVAppToDevMessageType
Message types used by avdevice_app_to_dev_control_message().
Definition: avdevice.h:125
data
const char data[16]
Definition: mxf.c:148
avdevice_dev_to_app_control_message
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:34
AVDictionary
Definition: dict.c:34
avdevice_list_output_sinks
int avdevice_list_output_sinks(const AVOutputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
Definition: avdevice.c:96
fail
#define fail()
Definition: checkasm.h:185
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
avassert.h
AVInputFormat
Definition: avformat.h:548
avdevice_list_input_sources
int avdevice_list_input_sources(const AVInputFormat *device, const char *device_name, AVDictionary *device_options, AVDeviceInfoList **device_list)
List devices.
Definition: avdevice.c:85
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
FFInputFormat::get_device_list
int(* get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list)
Returns device list with it properties.
Definition: demux.h:130
ffofmt
static const FFOutputFormat * ffofmt(const AVOutputFormat *fmt)
Definition: mux.h:167
AVDeviceInfo::media_types
enum AVMediaType * media_types
array indicating what media types(s), if any, a device can provide.
Definition: avdevice.h:336
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
list_devices_for_context
static int list_devices_for_context(AVFormatContext *s, AVDictionary *options, AVDeviceInfoList **device_list)
Definition: avdevice.c:69
NULL
#define NULL
Definition: coverity.c:32
internal.h
list
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
Definition: filter_design.txt:25
options
const OptionDef options[]
AVDeviceInfo
Structure describes basic parameters of the device.
Definition: avdevice.h:333
avdevice.h
avdevice_free_list_devices
void avdevice_free_list_devices(AVDeviceInfoList **device_list)
Convenient function to free result of avdevice_list_devices().
Definition: avdevice.c:107
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
AVDevToAppMessageType
AVDevToAppMessageType
Message types used by avdevice_dev_to_app_control_message().
Definition: avdevice.h:204
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:335
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_opt_set_dict2
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:1938
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
demux.h
ret
ret
Definition: filter_design.txt:187
AVDeviceInfoList
List of devices.
Definition: avdevice.h:343
ff_alloc_input_device_context
av_warn_unused_result int ff_alloc_input_device_context(struct AVFormatContext **avctx, const AVInputFormat *iformat, const char *format)
Definition: utils.c:25
ffifmt
static const FFInputFormat * ffifmt(const AVInputFormat *fmt)
Definition: demux.h:133
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:141
avdevice_app_to_dev_control_message
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:26
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:94
mux.h