Move media-ctl to git://linuxtv.org/v4l-utils.git
[media-ctl.git] / src / mediactl.h
1 /*
2  * Media controller interface library
3  *
4  * Copyright (C) 2010-2011 Ideas on board SPRL
5  *
6  * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser General Public License as published
10  * by the Free Software Foundation; either version 2.1 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program. If not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #ifndef __MEDIA_H__
23 #define __MEDIA_H__
24
25 #include <linux/media.h>
26
27 struct media_link {
28         struct media_pad *source;
29         struct media_pad *sink;
30         struct media_link *twin;
31         __u32 flags;
32         __u32 padding[3];
33 };
34
35 struct media_pad {
36         struct media_entity *entity;
37         __u32 index;
38         __u32 flags;
39         __u32 padding[3];
40 };
41
42 struct media_device;
43 struct media_entity;
44
45 /**
46  * @brief Create a new media device.
47  * @param devnode - device node path.
48  *
49  * Create a media device instance for the given device node and return it. The
50  * device node is not accessed by this function, device node access errors will
51  * not be caught and reported here. The media device needs to be enumerated
52  * before it can be accessed, see media_device_enumerate().
53  *
54  * Media devices are reference-counted, see media_device_ref() and
55  * media_device_unref() for more information.
56  *
57  * @return A pointer to the new media device or NULL if memory cannot be
58  * allocated.
59  */
60 struct media_device *media_device_new(const char *devnode);
61
62 /**
63  * @brief Create a new emulated media device.
64  * @param info - device information.
65  *
66  * Emulated media devices are userspace-only objects not backed by a kernel
67  * media device. They are created for ALSA and V4L2 devices that are not
68  * associated with a media controller device.
69  *
70  * Only device query functions are available for media devices. Enumerating or
71  * setting up links is invalid.
72  *
73  * @return A pointer to the new media device or NULL if memory cannot be
74  * allocated.
75  */
76 struct media_device *media_device_new_emulated(struct media_device_info *info);
77
78 /**
79  * @brief Take a reference to the device.
80  * @param media - device instance.
81  *
82  * Media devices are reference-counted. Taking a reference to a device prevents
83  * it from being freed until all references are released. The reference count is
84  * initialized to 1 when the device is created.
85  *
86  * @return A pointer to @a media.
87  */
88 struct media_device *media_device_ref(struct media_device *media);
89
90 /**
91  * @brief Release a reference to the device.
92  * @param media - device instance.
93  *
94  * Release a reference to the media device. When the reference count reaches 0
95  * this function frees the device.
96  */
97 void media_device_unref(struct media_device *media);
98
99 /**
100  * @brief Add an entity to an existing media device
101  * @param media - device instance.
102  * @param desc - description of the entity to be added
103  * @param devnode - device node corresponding to the entity
104  *
105  * Entities are usually created and added to media devices automatically when
106  * the media device is enumerated through the media controller API. However,
107  * when an emulated media device (thus not backed with a kernel-side media
108  * controller device) is created, entities need to be manually added.
109  *
110  * Entities can also be manually added to a successfully enumerated media device
111  * to group several functions provided by separate kernel devices. The most
112  * common use case is to group the audio and video functions of a USB webcam in
113  * a single media device. Those functions are exposed through separate USB
114  * interfaces and handled through unrelated kernel drivers, they must thus be
115  * manually added to the same media device.
116  *
117  * This function adds a new entity to the given media device and initializes it
118  * from the given entity description and device node name. Only the following
119  * fields of the description are copied over to the new entity:
120  *
121  * - type
122  * - flags (MEDIA_ENT_FL_DEFAULT only)
123  * - name
124  * - v4l, fb, alsa or dvb (depending on the device type)
125  *
126  * All other fields of the newly created entity id are initialized to 0,
127  * including the entity ID.
128  *
129  * @return Zero on success or -ENOMEM if memory cannot be allocated.
130  */
131 int media_device_add_entity(struct media_device *media,
132                             const struct media_entity_desc *desc,
133                             const char *devnode);
134
135 /**
136  * @brief Set a handler for debug messages.
137  * @param media - device instance.
138  * @param debug_handler - debug message handler
139  * @param debug_priv - first argument to debug message handler
140  *
141  * Set a handler for debug messages that will be called whenever
142  * debugging information is to be printed. The handler expects an
143  * fprintf-like function.
144  */
145 void media_debug_set_handler(
146         struct media_device *media, void (*debug_handler)(void *, ...),
147         void *debug_priv);
148
149 /**
150  * @brief Enumerate the device topology
151  * @param media - device instance.
152  *
153  * Enumerate the media device entities, pads and links. Calling this function is
154  * mandatory before accessing the media device contents.
155  *
156  * @return Zero on success or a negative error code on failure.
157  */
158 int media_device_enumerate(struct media_device *media);
159
160 /**
161  * @brief Locate the pad at the other end of a link.
162  * @param pad - sink pad at one end of the link.
163  *
164  * Locate the source pad connected to @a pad through an enabled link. As only one
165  * link connected to a sink pad can be enabled at a time, the connected source
166  * pad is guaranteed to be unique.
167  *
168  * @return A pointer to the connected source pad, or NULL if all links connected
169  * to @a pad are disabled. Return NULL also if @a pad is not a sink pad.
170  */
171 struct media_pad *media_entity_remote_source(struct media_pad *pad);
172
173 /**
174  * @brief Get information about a media entity
175  * @param entity - media entity.
176  *
177  * The information structure is owned by the media entity object and will be
178  * freed when the object is destroyed.
179  *
180  * @return A pointer to the media entity information
181  */
182 const struct media_entity_desc *media_entity_get_info(struct media_entity *entity);
183
184 /**
185  * @brief Get an entity pad
186  * @param entity - media entity.
187  * @param index - pad index.
188  *
189  * This function returns a pointer to the pad object identified by its index
190  * for the given entity. If the pad index is out of bounds it will return NULL.
191  *
192  * @return A pointer to the pad
193  */
194 const struct media_pad *media_entity_get_pad(struct media_entity *entity,
195                                              unsigned int index);
196
197 /**
198  * @brief Get the number of links
199  * @param entity - media entity.
200  *
201  * This function returns the total number of links that originate from or arrive
202  * at the the media entity.
203  *
204  * @return The number of links for the entity
205  */
206 unsigned int media_entity_get_links_count(struct media_entity *entity);
207
208 /**
209  * @brief Get an entity link
210  * @param entity - media entity.
211  * @param index - link index.
212  *
213  * This function returns a pointer to the link object identified by its index
214  * for the given entity. If the link index is out of bounds it will return NULL.
215  *
216  * @return A pointer to the link
217  */
218 const struct media_link *media_entity_get_link(struct media_entity *entity,
219                                                unsigned int index);
220
221 /**
222  * @brief Get the device node name for an entity
223  * @param entity - media entity.
224  *
225  * This function returns the full path and name to the device node corresponding
226  * to the given entity.
227  *
228  * @return A pointer to the device node name or NULL if the entity has no
229  * associated device node
230  */
231 const char *media_entity_get_devname(struct media_entity *entity);
232
233 /**
234  * @brief Get the type of an entity.
235  * @param entity - the entity.
236  *
237  * @return The type of @a entity.
238  */
239 static inline unsigned int media_entity_type(struct media_entity *entity)
240 {
241         return media_entity_get_info(entity)->type & MEDIA_ENT_TYPE_MASK;
242 }
243
244 /**
245  * @brief Find an entity by its name.
246  * @param media - media device.
247  * @param name - entity name.
248  * @param length - size of @a name.
249  *
250  * Search for an entity with a name equal to @a name.
251  *
252  * @return A pointer to the entity if found, or NULL otherwise.
253  */
254 struct media_entity *media_get_entity_by_name(struct media_device *media,
255         const char *name, size_t length);
256
257 /**
258  * @brief Find an entity by its ID.
259  * @param media - media device.
260  * @param id - entity ID.
261  *
262  * This function searches for an entity based on its ID using an exact match or
263  * next ID method based on the given @a id. If @a id is ORed with
264  * MEDIA_ENT_ID_FLAG_NEXT, the function will return the entity with the smallest
265  * ID larger than @a id. Otherwise it will return the entity with an ID equal to
266  * @a id.
267  *
268  * @return A pointer to the entity if found, or NULL otherwise.
269  */
270 struct media_entity *media_get_entity_by_id(struct media_device *media,
271         __u32 id);
272
273 /**
274  * @brief Get the number of entities
275  * @param media - media device.
276  *
277  * This function returns the total number of entities in the media device. If
278  * entities haven't been enumerated yet it will return 0.
279  *
280  * @return The number of entities in the media device
281  */
282 unsigned int media_get_entities_count(struct media_device *media);
283
284 /**
285  * @brief Get the entities
286  * @param media - media device.
287  *
288  * This function returns a pointer to the array of entities for the media
289  * device. If entities haven't been enumerated yet it will return NULL.
290  *
291  * The array of entities is owned by the media device object and will be freed
292  * when the media object is destroyed.
293  *
294  * @return A pointer to an array of entities
295  */
296 struct media_entity *media_get_entity(struct media_device *media, unsigned int index);
297
298 /**
299  * @brief Get the default entity for a given type
300  * @param media - media device.
301  * @param type - entity type.
302  *
303  * This function returns the default entity of the requested type. @a type must
304  * be one of
305  *
306  *      MEDIA_ENT_T_DEVNODE_V4L
307  *      MEDIA_ENT_T_DEVNODE_FB
308  *      MEDIA_ENT_T_DEVNODE_ALSA
309  *      MEDIA_ENT_T_DEVNODE_DVB
310  *
311  * @return A pointer to the default entity for the type if it exists, or NULL
312  * otherwise.
313  */
314 struct media_entity *media_get_default_entity(struct media_device *media,
315                                               unsigned int type);
316
317 /**
318  * @brief Get the media device information
319  * @param media - media device.
320  *
321  * The information structure is owned by the media device object and will be freed
322  * when the media object is destroyed.
323  *
324  * @return A pointer to the media device information
325  */
326 const struct media_device_info *media_get_info(struct media_device *media);
327
328 /**
329  * @brief Get the media device node name
330  * @param media - media device.
331  *
332  * The device node name string is owned by the media device object and will be
333  * freed when the media object is destroyed.
334  *
335  * @return A pointer to the media device node name
336  */
337 const char *media_get_devnode(struct media_device *media);
338
339 /**
340  * @brief Configure a link.
341  * @param media - media device.
342  * @param source - source pad at the link origin.
343  * @param sink - sink pad at the link target.
344  * @param flags - configuration flags.
345  *
346  * Locate the link between @a source and @a sink, and configure it by applying
347  * the new @a flags.
348  *
349  * Only the MEDIA_LINK_FLAG_ENABLED flag is writable.
350  *
351  * @return 0 on success, -1 on failure:
352  *         -ENOENT: link not found
353  *         - other error codes returned by MEDIA_IOC_SETUP_LINK
354  */
355 int media_setup_link(struct media_device *media,
356         struct media_pad *source, struct media_pad *sink,
357         __u32 flags);
358
359 /**
360  * @brief Reset all links to the disabled state.
361  * @param media - media device.
362  *
363  * Disable all links in the media device. This function is usually used after
364  * opening a media device to reset all links to a known state.
365  *
366  * @return 0 on success, or a negative error code on failure.
367  */
368 int media_reset_links(struct media_device *media);
369
370 /**
371  * @brief Parse string to a pad on the media device.
372  * @param media - media device.
373  * @param p - input string
374  * @param endp - pointer to string where parsing ended
375  *
376  * Parse NULL terminated string describing a pad and return its struct
377  * media_pad instance.
378  *
379  * @return Pointer to struct media_pad on success, NULL on failure.
380  */
381 struct media_pad *media_parse_pad(struct media_device *media,
382                                   const char *p, char **endp);
383
384 /**
385  * @brief Parse string to a link on the media device.
386  * @param media - media device.
387  * @param p - input string
388  * @param endp - pointer to p where parsing ended
389  *
390  * Parse NULL terminated string p describing a link and return its struct
391  * media_link instance.
392  *
393  * @return Pointer to struct media_link on success, NULL on failure.
394  */
395 struct media_link *media_parse_link(struct media_device *media,
396                                     const char *p, char **endp);
397
398 /**
399  * @brief Parse string to a link on the media device and set it up.
400  * @param media - media device.
401  * @param p - input string
402  *
403  * Parse NULL terminated string p describing a link and its configuration
404  * and configure the link.
405  *
406  * @return 0 on success, or a negative error code on failure.
407  */
408 int media_parse_setup_link(struct media_device *media,
409                            const char *p, char **endp);
410
411 /**
412  * @brief Parse string to link(s) on the media device and set it up.
413  * @param media - media device.
414  * @param p - input string
415  *
416  * Parse NULL terminated string p describing link(s) separated by
417  * commas (,) and configure the link(s).
418  *
419  * @return 0 on success, or a negative error code on failure.
420  */
421 int media_parse_setup_links(struct media_device *media, const char *p);
422
423 #endif