VLC 4.0.0-dev
Loading...
Searching...
No Matches
vlc_filter.h
Go to the documentation of this file.
1/*****************************************************************************
2 * vlc_filter.h: filter related structures and functions
3 *****************************************************************************
4 * Copyright (C) 1999-2014 VLC authors and VideoLAN
5 *
6 * Authors: Gildas Bazin <gbazin@videolan.org>
7 * Antoine Cellerier <dionoea at videolan dot org>
8 * RĂ©mi Denis-Courmont
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25#ifndef VLC_FILTER_H
26#define VLC_FILTER_H 1
27
28#include <vlc_es.h>
29#include <vlc_picture.h>
30#include <vlc_codec.h>
31
34
35/**
36 * \defgroup filter Filters
37 * \ingroup output
38 * Audio, video, text filters
39 * @{
40 * \file
41 * Filter modules interface
42 */
43
46 picture_t *(*buffer_new)(filter_t *);
47 vlc_decoder_device * (*hold_device)(vlc_object_t *, void *sys);
48};
49
52 struct
53 {
54 void (*on_changed)(filter_t *,
55 const struct vlc_audio_loudness *loudness);
57};
58
61 subpicture_t *(*buffer_new)(filter_t *);
62};
63
64typedef struct filter_owner_t
66 union
67 {
68 const struct filter_video_callbacks *video;
71 };
72
73 /* Input attachments
74 * XXX use filter_GetInputAttachments */
75 int (*pf_get_attachments)( filter_t *, input_attachment_t ***, int * );
77 void *sys;
80struct vlc_mouse_t;
81
84 /* Operation depending on the type of filter. */
85 union
86 {
87 /** Filter a picture (video filter) */
88 picture_t * (*filter_video)(filter_t *, picture_t *);
90 /** Filter an audio block (audio filter) */
91 block_t * (*filter_audio)(filter_t *, block_t *);
93 /** Blend a subpicture onto a picture (video blending) */
94 void (*blend_video)(filter_t *, picture_t *, const picture_t *,
95 int, int, int);
96
97 /** Generate a subpicture (sub source) */
98 subpicture_t *(*source_sub)(filter_t *, vlc_tick_t);
100 /** Filter a subpicture (sub filter) */
101 subpicture_t *(*filter_sub)(filter_t *, subpicture_t *);
103 /** Render text (text renderer)
104 *
105 * \return a picture-based region or NULL
106 */
107 subpicture_region_t * (*render)(filter_t *,
109 };
110
111 union
112 {
113 /* TODO: video filter drain */
114 /** Drain (audio filter) */
115 block_t *(*drain_audio)(filter_t *);
116 };
117
118 /** Flush
119 *
120 * Flush (i.e. discard) any internal buffer in a video or audio filter.
121 */
122 void (*flush)(filter_t *);
124 /** Change viewpoint
125 *
126 * Pass a new viewpoint to audio filters. Filters like the spatialaudio one
127 * used for Ambisonics rendering will change its output according to this
128 * viewpoint.
129 */
130 void (*change_viewpoint)(filter_t *, const vlc_viewpoint_t *);
132 /** Filter mouse state (video filter).
133 *
134 * If non-NULL, you must convert from output to input formats:
135 * - If VLC_SUCCESS is returned, the mouse state is propagated.
136 * - Otherwise, the mouse change is not propagated.
137 * If NULL, the mouse state is considered unchanged and will be
138 * propagated. */
139 int (*video_mouse)(filter_t *, struct vlc_mouse_t *,
140 const struct vlc_mouse_t *p_old);
141
142 /** Close the filter and release its resources. */
143 void (*close)(filter_t *);
145
146typedef int (*vlc_filter_open)(filter_t *);
148
149#define set_deinterlace_callback( activate ) \
150 { \
151 vlc_filter_open open__ = activate; \
152 (void) open__; \
153 set_callback(activate) \
154 } \
155 set_capability( "video filter", 0 ) \
156 add_shortcut( "deinterlace" )
157
158#define set_callback_video_filter( activate ) \
159 { \
160 vlc_filter_open open__ = activate; \
161 (void) open__; \
162 set_callback(activate) \
163 } \
164 set_capability( "video filter", 0 )
165
166#define set_callback_video_converter( activate, priority ) \
167 { \
168 vlc_filter_open open__ = activate; \
169 (void) open__; \
170 set_callback(activate) \
171 } \
172 set_capability( "video converter", priority )
173
174#define set_callback_text_renderer( activate, priority ) \
175 { \
176 vlc_filter_open open__ = activate; \
177 (void) open__; \
178 set_callback(activate) \
179 } \
180 set_capability( "text renderer", priority )
181
182#define set_callback_sub_filter( activate ) \
183 { \
184 vlc_filter_open open__ = activate; \
185 (void) open__; \
186 set_callback(activate) \
187 } \
188 set_capability( "sub filter", 0 )
189
190#define set_callback_sub_source( activate, priority ) \
191 { \
192 vlc_filter_open open__ = activate; \
193 (void) open__; \
194 set_callback(activate) \
195 } \
196 set_capability( "sub source", priority )
197
198#define set_callback_video_blending( activate, priority ) \
199 { \
200 vlc_filter_open open__ = activate; \
201 (void) open__; \
202 set_callback(activate) \
203 } \
204 set_capability( "video blending", priority )
205
206/** Structure describing a filter
207 * @warning BIG FAT WARNING : the code relies on the first 3 members of
208 * filter_t and decoder_t to be the same, so if you have anything to add,
209 * do it at the end of the structure.
210 */
211struct filter_t
213 struct vlc_object_t obj;
215 /* Module properties */
217 void *p_sys;
219 /* Input format */
221 vlc_video_context *vctx_in; // video filter, set by owner
223 /* Output format of filter */
225 vlc_video_context *vctx_out; // video filter, handled by the filter
228 /* Name of the "video filter" shortcut that is requested, can be NULL */
229 const char * psz_name;
230 /* Filter configuration */
231 const config_chain_t *p_cfg;
233 /* Implementation of filter API */
234 const struct vlc_filter_operations *ops;
236 /** Private structure for the owner of the filter */
239
241 const char *name, bool strict);
243
244static inline void vlc_filter_Delete(filter_t *p_filter)
246 vlc_filter_UnloadModule(p_filter);
247 vlc_object_delete(p_filter);
248}
249
250/**
251 * This function will return a new picture usable by p_filter as an output
252 * buffer. You have to release it using picture_Release or by returning
253 * it to the caller as a ops->filter_video return value.
254 * Provided for convenience.
255 *
256 * \param p_filter filter_t object
257 * \return new picture on success or NULL on failure
258 */
259static inline picture_t *filter_NewPicture( filter_t *p_filter )
261 picture_t *pic = NULL;
262 if ( p_filter->owner.video != NULL && p_filter->owner.video->buffer_new != NULL)
263 pic = p_filter->owner.video->buffer_new( p_filter );
264 if ( pic == NULL )
265 {
266 // legacy filter owners not setting a default filter_allocator
267 pic = picture_NewFromFormat( &p_filter->fmt_out.video );
268 }
269 if( pic == NULL )
270 msg_Warn( p_filter, "can't get output picture" );
271 return pic;
272}
273
274/**
275 * Flush a filter
276 *
277 * This function will flush the state of a filter (audio or video).
278 */
279static inline void filter_Flush( filter_t *p_filter )
281 if( p_filter->ops->flush != NULL )
282 p_filter->ops->flush( p_filter );
283}
284
285static inline void filter_ChangeViewpoint( filter_t *p_filter,
287{
288 if( p_filter->ops->change_viewpoint != NULL )
289 p_filter->ops->change_viewpoint( p_filter, vp );
290}
291
292static inline vlc_decoder_device * filter_HoldDecoderDevice( filter_t *p_filter )
294 if ( !p_filter->owner.video || !p_filter->owner.video->hold_device )
295 return NULL;
296
297 return p_filter->owner.video->hold_device( VLC_OBJECT(p_filter), p_filter->owner.sys );
298}
299
302{
303 if ( !p_filter->owner.video || !p_filter->owner.video->hold_device )
304 return NULL;
305
306 vlc_decoder_device *dec_dev = p_filter->owner.video->hold_device( VLC_OBJECT(p_filter),
307 p_filter->owner.sys );
308 if ( dec_dev != NULL )
309 {
310 if ( dec_dev->type == type )
311 return dec_dev;
313 }
314 return NULL;
315}
316
317/**
318 * This function will drain, then flush an audio filter.
319 */
320static inline block_t *filter_DrainAudio( filter_t *p_filter )
322 if( p_filter->ops->drain_audio )
323 return p_filter->ops->drain_audio( p_filter );
324 else
325 return NULL;
326}
327
328static inline void filter_SendAudioLoudness(filter_t *filter,
329 const struct vlc_audio_loudness *loudness)
330{
331 assert(filter->owner.audio->meter_loudness.on_changed);
332 filter->owner.audio->meter_loudness.on_changed(filter, loudness);
333}
334
335/**
336 * This function will return a new subpicture usable by p_filter as an output
337 * buffer. You have to release it using subpicture_Delete or by returning it to
338 * the caller as a ops->sub_source return value.
339 * Provided for convenience.
340 *
341 * \param p_filter filter_t object
342 * \return new subpicture
343 */
344static inline subpicture_t *filter_NewSubpicture( filter_t *p_filter )
346 subpicture_t *subpic = p_filter->owner.sub->buffer_new( p_filter );
347 if( subpic == NULL )
348 msg_Warn( p_filter, "can't get output subpicture" );
349 return subpic;
350}
351
352/**
353 * This function gives all input attachments at once.
354 *
355 * You MUST release the returned values
356 */
357static inline int filter_GetInputAttachments( filter_t *p_filter,
358 input_attachment_t ***ppp_attachment,
359 int *pi_attachment )
360{
361 if( !p_filter->owner.pf_get_attachments )
362 return VLC_EGENERIC;
363 return p_filter->owner.pf_get_attachments( p_filter,
364 ppp_attachment, pi_attachment );
365}
366
367/**
368 * This function allow dynamically changing filter variables from a different
369 * object via VLC variables mapping.
370 *
371 * It maps the filter's variables on the proxy objects and bind them with a var
372 * callback that forwards changes to the filter.
373 * This is especially useful for manipulating filter chains via a single parent
374 * object.
375 *
376 * \param obj the object to add the callback proxy to
377 * \param filter the filter object for which the callback will be proxified
378 * \param restart_cb a vlc_callback_t to call if the event means restarting the
379 * filter (i.e. an event on a non-command variable)
380 */
382 vlc_callback_t restart_cb );
383# define filter_AddProxyCallbacks(a, b, c) \
384 filter_AddProxyCallbacks(VLC_OBJECT(a), b, c)
385
386/**
387 * This function unbind the callbacks from the proxy object.
388 *
389 * \note It does not remove the mapped variable to keep track of their state.
390 *
391 * \param obj the object to remove the callback proxy from
392 * \param filter the filter object for which the callback was proxified
393 * \param restart_cb the same vlc_callback_t passed to filter_AddProxyCallbacks
394 */
396 vlc_callback_t restart_cb);
397# define filter_DelProxyCallbacks(a, b, c) \
398 filter_DelProxyCallbacks(VLC_OBJECT(a), b, c)
399
400typedef filter_t vlc_blender_t;
402/**
403 * It creates a blend filter.
404 *
405 * Only the chroma properties of the dest format is used (chroma
406 * type, rgb masks and shifts)
407 */
409
410/**
411 * It configures blend filter parameters that are allowed to changed
412 * after the creation.
413 */
414VLC_API int filter_ConfigureBlend( vlc_blender_t *, int i_dst_width, int i_dst_height, const video_format_t *p_src );
415
416/**
417 * It blends a picture into another one.
418 *
419 * The input picture is not modified and not released.
420 */
421VLC_API int filter_Blend( vlc_blender_t *, picture_t *p_dst, int i_dst_x, int i_dst_y, const picture_t *p_src, int i_alpha );
422
423/**
424 * It destroys a blend filter created by filter_NewBlend.
425 */
427
428/**
429 * Create a picture_t *(*)( filter_t *, picture_t * ) compatible wrapper
430 * using a void (*)( filter_t *, picture_t *, picture_t * ) function
431 *
432 * Currently used by the chroma video filters
433 */
434#define VIDEO_FILTER_WRAPPER_CLOSE_FILT( name, close_cb ) \
435 static picture_t *name ## _Filter ( filter_t *p_filter, \
436 picture_t *p_pic ) \
437 { \
438 picture_t *p_outpic = filter_NewPicture( p_filter ); \
439 if( p_outpic ) \
440 { \
441 name( p_filter, p_pic, p_outpic ); \
442 picture_CopyProperties( p_outpic, p_pic ); \
443 } \
444 picture_Release( p_pic ); \
445 return p_outpic; \
446 } \
447 static const struct vlc_filter_operations name ## _ops = { \
448 .filter_video = name ## _Filter, .close = close_cb, \
449 };
450
451#define VIDEO_FILTER_WRAPPER_CLOSE( name, close_cb ) \
452 static void name (filter_t *, picture_t *, picture_t *); \
453 static void close_cb (filter_t *); \
454 VIDEO_FILTER_WRAPPER_CLOSE_FILT( name, close_cb )
455
456#define VIDEO_FILTER_WRAPPER( name ) \
457 static void name (filter_t *, picture_t *, picture_t *); \
458 VIDEO_FILTER_WRAPPER_CLOSE_FILT( name, NULL )
459
460/**
461 * Wrappers to use when the filter function is not a static function
462 */
463#define VIDEO_FILTER_WRAPPER_EXT( name ) \
464 void name (filter_t *, picture_t *, picture_t *); \
465 VIDEO_FILTER_WRAPPER_CLOSE_FILT( name, NULL )
466
467#define VIDEO_FILTER_WRAPPER_CLOSE_EXT( name, close_cb ) \
468 void name (filter_t *, picture_t *, picture_t *); \
469 static void close_cb (filter_t *); \
470 VIDEO_FILTER_WRAPPER_CLOSE_FILT( name, close_cb )
471
472/**
473 * Filter chain management API
474 * The filter chain management API is used to dynamically construct filters
475 * and add them in a chain.
476 */
477
478typedef struct filter_chain_t filter_chain_t;
480/**
481 * Create new filter chain
482 *
483 * \param obj pointer to a vlc object
484 * \param psz_capability vlc capability of filters in filter chain
485 * \return pointer to a filter chain
486 */
487filter_chain_t * filter_chain_NewSPU(vlc_object_t *obj, const char *psz_capability)
489#define filter_chain_NewSPU( a, b ) filter_chain_NewSPU( VLC_OBJECT( a ), b )
491/**
492 * Creates a new video filter chain.
493 *
494 * \param obj pointer to parent VLC object
495 * \param change whether to allow changing the output format
496 * \param owner owner video buffer callbacks
497 * \return new filter chain, or NULL on error
498 */
500 const filter_owner_t *owner )
502#define filter_chain_NewVideo( a, b, c ) \
503 filter_chain_NewVideo( VLC_OBJECT( a ), b, c )
504
505/**
506 * Delete filter chain will delete all filters in the chain and free all
507 * allocated data. The pointer to the filter chain is then no longer valid.
508 *
509 * \param chain pointer to filter chain
510 */
512
513/**
514 * Reset filter chain will delete all filters in the chain and
515 * reset p_fmt_in and p_fmt_out to the new values.
516 *
517 * \param p_chain pointer to filter chain
518 * \param p_fmt_in new fmt_in params
519 * \param vctx_in new input video context
520 * \param p_fmt_out new fmt_out params
521 */
523 const es_format_t *p_fmt_in,
525 const es_format_t *p_fmt_out );
526
527/**
528 * Remove all existing filters
529 *
530 * \param p_chain pointer to filter chain
531 */
533
534/**
535 * Append a filter to the chain.
536 *
537 * \param chain filter chain to append a filter to
538 * \param name filter name
539 * \param cfg the configuration chain for the filter
540 * \param fmt_out filter output format
541 * \return a pointer to the filter or NULL on error
542 */
544 const char *name, const config_chain_t *cfg,
545 const es_format_t *fmt_out);
546
547/**
548 * Append a conversion to the chain.
549 *
550 * \param chain filter chain to append a filter to
551 * \param fmt_out filter output format
552 * \retval VLC_SUCCESS on success
553 */
555 const es_format_t *fmt_out);
556
557/**
558 * Append new filter to filter chain from string.
559 *
560 * \param chain filter chain to append a filter to
561 * \param str filters chain nul-terminated string
562 */
564 const char *str);
565
566/**
567 * Delete filter from filter chain. This function also releases the filter
568 * object and unloads the filter modules. The pointer to p_filter is no
569 * longer valid after this function successfully returns.
570 *
571 * \param chain filter chain to remove the filter from
572 * \param filter filter to remove from the chain and delete
573 *
574 * \note the filter must be created with filter_chain_AppendConverter() or
575 * filter_chain_AppendFilter().
576 */
578 filter_t *filter);
579
580/**
581 * Checks if the filter chain is empty.
582 *
583 * \param chain pointer to filter chain
584 * \return true if and only if there are no filters in this filter chain
585 */
587
588/**
589 * Checks whether the filter chain contains any video filters listening to
590 * mouse events.
591 *
592 * \param chain pointer to filter chain
593 * \return true if at least one filter listens to mouse events
594 */
596
597/**
598 * Get last output format of the last element in the filter chain.
599 *
600 * \param chain filter chain
601 */
603
604/**
605 * Get last output video context of the last element in the filter chain.
606 * \note doesn't create change the reference count
607 *
608 * \param chain filter chain
609 */
611
612/**
613 * Apply the filter chain to a video picture.
614 *
615 * \param chain pointer to filter chain
616 * \param pic picture to apply filters to
617 * \return modified picture after applying all video filters
618 */
620 picture_t *pic);
621
622/**
623 * Flush a video filter chain.
624 */
626
627/**
628 * Apply the filter chain to a mouse state.
629 *
630 * It will be applied from the output to the input. It makes sense only
631 * for a video filter chain.
632 *
633 * The vlc_mouse_t* pointers may be the same.
634 */
636 const struct vlc_mouse_t * );
637
639 int (*cb)( filter_t *, void * ), void *opaque );
640
641/** @} */
642#endif /* _VLC_FILTER_H */
#define VLC_USED
Definition fourcc_gen.c:32
#define VLC_API
Definition fourcc_gen.c:31
uint32_t vlc_fourcc_t
Definition fourcc_gen.c:33
void vlc_decoder_device_Release(vlc_decoder_device *device)
Release a decoder device.
Definition decoder_device.c:82
vlc_decoder_device_type
Decoder device type.
Definition vlc_codec.h:585
#define VLC_EGENERIC
Unspecified error.
Definition vlc_common.h:480
static void filter_ChangeViewpoint(filter_t *p_filter, const vlc_viewpoint_t *vp)
Definition vlc_filter.h:286
filter_t * filter_chain_AppendFilter(filter_chain_t *chain, const char *name, const config_chain_t *cfg, const es_format_t *fmt_out)
Append a filter to the chain.
Definition filter_chain.c:368
filter_t vlc_blender_t
Definition vlc_filter.h:401
static vlc_decoder_device * filter_HoldDecoderDeviceType(filter_t *p_filter, enum vlc_decoder_device_type type)
Definition vlc_filter.h:301
int filter_chain_AppendConverter(filter_chain_t *chain, const es_format_t *fmt_out)
Append a conversion to the chain.
Definition filter_chain.c:376
static void vlc_filter_Delete(filter_t *p_filter)
Definition vlc_filter.h:245
int filter_Blend(vlc_blender_t *, picture_t *p_dst, int i_dst_x, int i_dst_y, const picture_t *p_src, int i_alpha)
It blends a picture into another one.
Definition filter.c:167
#define filter_AddProxyCallbacks(a, b, c)
Definition vlc_filter.h:384
static int filter_GetInputAttachments(filter_t *p_filter, input_attachment_t ***ppp_attachment, int *pi_attachment)
This function gives all input attachments at once.
Definition vlc_filter.h:358
static subpicture_t * filter_NewSubpicture(filter_t *p_filter)
This function will return a new subpicture usable by p_filter as an output buffer.
Definition vlc_filter.h:345
vlc_video_context * filter_chain_GetVideoCtxOut(const filter_chain_t *chain)
Get last output video context of the last element in the filter chain.
Definition filter_chain.c:492
int filter_chain_ForEach(filter_chain_t *chain, int(*cb)(filter_t *, void *), void *opaque)
Definition filter_chain.c:450
static void filter_SendAudioLoudness(filter_t *filter, const struct vlc_audio_loudness *loudness)
Definition vlc_filter.h:329
bool filter_chain_HasMouseFilter(const filter_chain_t *chain)
Checks whether the filter chain contains any video filters listening to mouse events.
Definition filter_chain.c:468
int filter_ConfigureBlend(vlc_blender_t *, int i_dst_width, int i_dst_height, const video_format_t *p_src)
It configures blend filter parameters that are allowed to changed after the creation.
Definition filter.c:134
int filter_chain_AppendFromString(filter_chain_t *chain, const char *str)
Append new filter to filter chain from string.
Definition filter_chain.c:403
int filter_chain_MouseFilter(filter_chain_t *, struct vlc_mouse_t *, const struct vlc_mouse_t *)
Apply the filter chain to a mouse state.
vlc_blender_t * filter_NewBlend(vlc_object_t *, const video_format_t *p_dst_chroma)
It creates a blend filter.
Definition filter.c:113
#define filter_chain_NewSPU(a, b)
Definition vlc_filter.h:490
#define filter_chain_NewVideo(a, b, c)
Definition vlc_filter.h:503
static picture_t * filter_NewPicture(filter_t *p_filter)
This function will return a new picture usable by p_filter as an output buffer.
Definition vlc_filter.h:260
static vlc_decoder_device * filter_HoldDecoderDevice(filter_t *p_filter)
Definition vlc_filter.h:293
void filter_DeleteBlend(vlc_blender_t *)
It destroys a blend filter created by filter_NewBlend.
Definition filter.c:178
void filter_chain_VideoFlush(filter_chain_t *)
Flush a video filter chain.
Definition filter_chain.c:560
static block_t * filter_DrainAudio(filter_t *p_filter)
This function will drain, then flush an audio filter.
Definition vlc_filter.h:321
void filter_chain_Reset(filter_chain_t *p_chain, const es_format_t *p_fmt_in, vlc_video_context *vctx_in, const es_format_t *p_fmt_out)
Reset filter chain will delete all filters in the chain and reset p_fmt_in and p_fmt_out to the new v...
Definition filter_chain.c:265
picture_t * filter_chain_VideoFilter(filter_chain_t *chain, picture_t *pic)
Apply the filter chain to a video picture.
Definition filter_chain.c:520
void filter_chain_Clear(filter_chain_t *)
Remove all existing filters.
Definition filter_chain.c:244
static void filter_Flush(filter_t *p_filter)
Flush a filter.
Definition vlc_filter.h:280
#define filter_DelProxyCallbacks(a, b, c)
Definition vlc_filter.h:398
void vlc_filter_UnloadModule(filter_t *)
Definition filter_chain.c:103
module_t * vlc_filter_LoadModule(filter_t *, const char *cap, const char *name, bool strict)
Definition filter_chain.c:36
void filter_chain_Delete(filter_chain_t *chain)
Delete filter chain will delete all filters in the chain and free all allocated data.
Definition filter_chain.c:251
void filter_chain_DeleteFilter(filter_chain_t *chain, filter_t *filter)
Delete filter from filter chain.
Definition filter_chain.c:383
int(* vlc_filter_open)(filter_t *)
Definition vlc_filter.h:147
const es_format_t * filter_chain_GetFmtOut(const filter_chain_t *chain)
Get last output format of the last element in the filter chain.
Definition filter_chain.c:481
bool filter_chain_IsEmpty(const filter_chain_t *chain)
Checks if the filter chain is empty.
Definition filter_chain.c:463
#define msg_Warn(p_this,...)
Definition vlc_messages.h:104
int(* vlc_callback_t)(vlc_object_t *, char const *, vlc_value_t, vlc_value_t, void *)
Definition vlc_variables.h:135
#define VLC_OBJECT(x)
Type-safe vlc_object_t cast.
Definition vlc_objects.h:83
#define vlc_object_delete(obj)
Definition vlc_objects.h:128
const char name[16]
Definition httpd.c:1298
picture_t * picture_NewFromFormat(const video_format_t *restrict fmt)
Definition picture.c:272
Definition vlc_configuration.h:320
Definition vlc_es.h:633
video_format_t video
description of video format
Definition vlc_es.h:661
Definition vlc_filter.h:52
struct filter_audio_callbacks::@222 meter_loudness
void(* on_changed)(filter_t *, const struct vlc_audio_loudness *loudness)
Definition vlc_filter.h:55
Definition filter_chain.c:131
es_format_t fmt_out
Chain output format (constant)
Definition filter_chain.c:139
vlc_object_t * obj
Definition filter_chain.c:132
vlc_video_context * vctx_in
Chain input video context (set on Reset)
Definition filter_chain.c:138
Definition vlc_filter.h:66
void * sys
Definition vlc_filter.h:78
const struct filter_video_callbacks * video
Definition vlc_filter.h:69
int(* pf_get_attachments)(filter_t *, input_attachment_t ***, int *)
Definition vlc_filter.h:76
const struct filter_subpicture_callbacks * sub
Definition vlc_filter.h:71
const struct filter_audio_callbacks * audio
Definition vlc_filter.h:70
Definition vlc_filter.h:61
subpicture_t *(* buffer_new)(filter_t *)
Definition vlc_filter.h:62
Structure describing a filter.
Definition vlc_filter.h:213
es_format_t fmt_in
Definition vlc_filter.h:221
vlc_video_context * vctx_out
Definition vlc_filter.h:226
module_t * p_module
Definition vlc_filter.h:217
const char * psz_name
Definition vlc_filter.h:230
filter_owner_t owner
Private structure for the owner of the filter.
Definition vlc_filter.h:238
vlc_video_context * vctx_in
Definition vlc_filter.h:222
const struct vlc_filter_operations * ops
Definition vlc_filter.h:235
void * p_sys
Definition vlc_filter.h:218
bool b_allow_fmt_out_change
Definition vlc_filter.h:227
const config_chain_t * p_cfg
Definition vlc_filter.h:232
struct vlc_object_t obj
Definition vlc_filter.h:214
es_format_t fmt_out
Definition vlc_filter.h:225
Definition vlc_filter.h:46
vlc_decoder_device *(* hold_device)(vlc_object_t *, void *sys)
Definition vlc_filter.h:48
picture_t *(* buffer_new)(filter_t *)
Definition vlc_filter.h:47
Definition vlc_input.h:169
Internal module descriptor.
Definition modules.h:76
Video picture.
Definition vlc_picture.h:130
Video subtitle region.
Definition vlc_subpicture.h:72
Video subtitle.
Definition vlc_subpicture.h:234
video format description
Definition vlc_es.h:356
Audio loudness measurement.
Definition vlc_aout.h:667
Decoder context struct.
Definition vlc_codec.h:606
enum vlc_decoder_device_type type
Must be set from the "decoder device" module open entry point.
Definition vlc_codec.h:616
Definition vlc_filter.h:84
void(* flush)(filter_t *)
Flush.
Definition vlc_filter.h:123
void(* change_viewpoint)(filter_t *, const vlc_viewpoint_t *)
Change viewpoint.
Definition vlc_filter.h:131
block_t *(* drain_audio)(filter_t *)
Drain (audio filter)
Definition vlc_filter.h:116
void(* blend_video)(filter_t *, picture_t *, const picture_t *, int, int, int)
Blend a subpicture onto a picture (video blending)
Definition vlc_filter.h:95
void(* close)(filter_t *)
Close the filter and release its resources.
Definition vlc_filter.h:144
int(* video_mouse)(filter_t *, struct vlc_mouse_t *, const struct vlc_mouse_t *p_old)
Filter mouse state (video filter).
Definition vlc_filter.h:140
Definition vlc_frame.h:123
Mouse state.
Definition vlc_mouse.h:46
VLC object common members.
Definition vlc_objects.h:53
Definition decoder_device.c:98
Viewpoints.
Definition vlc_viewpoint.h:41
Decoder and encoder modules interface.
This file is a collection of common definitions and types.
This file defines the elementary streams format types.
This file defines picture structures and functions in vlc.
int64_t vlc_tick_t
High precision date or time interval.
Definition vlc_tick.h:48