vlc_filter.h 15.3 KB
Newer Older
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
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
10 11 12
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
13 14 15 16
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
17 18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
19
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
20 21 22
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23
 *****************************************************************************/
24

25 26
#ifndef VLC_FILTER_H
#define VLC_FILTER_H 1
27

28 29
#include <vlc_es.h>

30
/**
31
 * \defgroup filter Filters
32
 * \ingroup output
33 34
 * Audio, video, text filters
 * @{
35
 * \file
36
 * Filter modules interface
37 38 39 40
 */

typedef struct filter_owner_sys_t filter_owner_sys_t;

41
struct filter_video_callbacks
42
{
43 44
    picture_t *(*buffer_new)(filter_t *);
};
45

46 47 48 49 50 51 52
struct filter_subpicture_callbacks
{
    subpicture_t *(*buffer_new)(filter_t *);
};

typedef struct filter_owner_t
{
53 54
    union
    {
55 56
        const struct filter_video_callbacks *video;
        const struct filter_subpicture_callbacks *sub;
57
    };
58
    void *sys;
59 60
} filter_owner_t;

61
struct vlc_mouse_t;
62

63
/** Structure describing a filter
64
 * @warning BIG FAT WARNING : the code relies on the first 4 members of
65 66
 * filter_t and decoder_t to be the same, so if you have anything to add,
 * do it at the end of the structure.
67
 */
68 69
struct filter_t
{
70
    struct vlc_common_members obj;
71 72 73

    /* Module properties */
    module_t *          p_module;
74
    void               *p_sys;
75

76 77 78 79 80
    /* Input format */
    es_format_t         fmt_in;

    /* Output format of filter */
    es_format_t         fmt_out;
81
    bool                b_allow_fmt_out_change;
82

83 84
    /* Name of the "video filter" shortcut that is requested, can be NULL */
    const char *        psz_name;
85
    /* Filter configuration */
86
    config_chain_t *    p_cfg;
87

88 89
    union
    {
90 91
        /** Filter a picture (video filter) */
        picture_t * (*pf_video_filter)( filter_t *, picture_t * );
92

93 94
        /** Filter an audio block (audio filter) */
        block_t * (*pf_audio_filter)( filter_t *, block_t * );
95

96 97 98
        /** Blend a subpicture onto a picture (blend) */
        void (*pf_video_blend)( filter_t *,  picture_t *, const picture_t *,
                                 int, int, int );
99

100 101
        /** Generate a subpicture (sub source) */
        subpicture_t *(*pf_sub_source)( filter_t *, mtime_t );
102

103 104
        /** Filter a subpicture (sub filter) */
        subpicture_t *(*pf_sub_filter)( filter_t *, subpicture_t * );
105

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
        /** Render text (text render) */
        int (*pf_render)( filter_t *, subpicture_region_t *,
                          subpicture_region_t *, const vlc_fourcc_t * );
    };

    union
    {
        /* TODO: video filter drain */
        /** Drain (audio filter) */
        block_t *(*pf_audio_drain) ( filter_t * );
    };

    /** Flush
     *
     * Flush (i.e. discard) any internal buffer in a video or audio filter.
     */
    void (*pf_flush)( filter_t * );
123

124 125 126 127 128 129 130 131
    /** Change viewpoint
     *
     * Pass a new viewpoint to audio filters. Filters like the spatialaudio one
     * used for Ambisonics rendering will change its output according to this
     * viewpoint.
     */
    void (*pf_change_viewpoint)( filter_t *, const vlc_viewpoint_t * );

132 133 134 135 136 137 138 139 140
    union
    {
        /** Filter mouse state (video filter).
         *
         * If non-NULL, you must convert from output to input formats:
         * - If VLC_SUCCESS is returned, the mouse state is propagated.
         * - Otherwise, the mouse change is not propagated.
         * If NULL, the mouse state is considered unchanged and will be
         * propagated. */
141 142 143 144 145 146
        int (*pf_video_mouse)( filter_t *, struct vlc_mouse_t *,
                               const struct vlc_mouse_t *p_old,
                               const struct vlc_mouse_t *p_new );
        int (*pf_sub_mouse)( filter_t *, const struct vlc_mouse_t *p_old,
                             const struct vlc_mouse_t *p_new,
                             const video_format_t * );
147
    };
148 149 150 151 152

    /* Input attachments
     * XXX use filter_GetInputAttachments */
    int (*pf_get_attachments)( filter_t *, input_attachment_t ***, int * );

153
    /* Private structure for the owner of the decoder */
154
    filter_owner_t      owner;
155 156
};

157 158
/**
 * This function will return a new picture usable by p_filter as an output
159
 * buffer. You have to release it using picture_Release or by returning
160 161
 * it to the caller as a pf_video_filter return value.
 * Provided for convenience.
162 163 164
 *
 * \param p_filter filter_t object
 * \return new picture on success or NULL on failure
165 166 167
 */
static inline picture_t *filter_NewPicture( filter_t *p_filter )
{
168
    picture_t *pic = p_filter->owner.video->buffer_new( p_filter );
169
    if( pic == NULL )
170
        msg_Warn( p_filter, "can't get output picture" );
171
    return pic;
172 173
}

174
/**
175 176 177
 * Flush a filter
 *
 * This function will flush the state of a filter (audio or video).
178
 */
179
static inline void filter_Flush( filter_t *p_filter )
180
{
181 182
    if( p_filter->pf_flush != NULL )
        p_filter->pf_flush( p_filter );
183 184
}

185 186 187 188 189 190 191
static inline void filter_ChangeViewpoint( filter_t *p_filter,
                                           const vlc_viewpoint_t *vp)
{
    if( p_filter->pf_change_viewpoint != NULL )
        p_filter->pf_change_viewpoint( p_filter, vp );
}

192 193 194 195 196 197 198 199 200 201 202
/**
 * This function will drain, then flush an audio filter.
 */
static inline block_t *filter_DrainAudio( filter_t *p_filter )
{
    if( p_filter->pf_audio_drain )
        return p_filter->pf_audio_drain( p_filter );
    else
        return NULL;
}

203 204
/**
 * This function will return a new subpicture usable by p_filter as an output
205 206
 * buffer. You have to release it using subpicture_Delete or by returning it to
 * the caller as a pf_sub_source return value.
207
 * Provided for convenience.
208 209 210
 *
 * \param p_filter filter_t object
 * \return new subpicture
211 212 213
 */
static inline subpicture_t *filter_NewSubpicture( filter_t *p_filter )
{
214
    subpicture_t *subpic = p_filter->owner.sub->buffer_new( p_filter );
215
    if( subpic == NULL )
216
        msg_Warn( p_filter, "can't get output subpicture" );
217
    return subpic;
218 219
}

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
/**
 * This function gives all input attachments at once.
 *
 * You MUST release the returned values
 */
static inline int filter_GetInputAttachments( filter_t *p_filter,
                                              input_attachment_t ***ppp_attachment,
                                              int *pi_attachment )
{
    if( !p_filter->pf_get_attachments )
        return VLC_EGENERIC;
    return p_filter->pf_get_attachments( p_filter,
                                         ppp_attachment, pi_attachment );
}

235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
/**
 * This function duplicates every variables from the filter, and adds a proxy
 * callback to trigger filter events from obj.
 *
 * \param restart_cb a vlc_callback_t to call if the event means restarting the
 * filter (i.e. an event on a non-command variable)
 */
VLC_API void filter_AddProxyCallbacks( vlc_object_t *obj, filter_t *filter,
                                       vlc_callback_t restart_cb );
# define filter_AddProxyCallbacks(a, b, c) \
    filter_AddProxyCallbacks(VLC_OBJECT(a), b, c)

/**
 * This function removes the callbacks previously added to every duplicated
 * variables, and removes them afterward.
 *
 * \param restart_cb the same vlc_callback_t passed to filter_AddProxyCallbacks
 */
VLC_API void filter_DelProxyCallbacks( vlc_object_t *obj, filter_t *filter,
                                       vlc_callback_t restart_cb);
# define filter_DelProxyCallbacks(a, b, c) \
    filter_DelProxyCallbacks(VLC_OBJECT(a), b, c)

258
/**
259 260 261 262
 * It creates a blend filter.
 *
 * Only the chroma properties of the dest format is used (chroma
 * type, rgb masks and shifts)
263
 */
264
VLC_API filter_t * filter_NewBlend( vlc_object_t *, const video_format_t *p_dst_chroma ) VLC_USED;
265 266 267 268 269

/**
 * It configures blend filter parameters that are allowed to changed
 * after the creation.
 */
270
VLC_API int filter_ConfigureBlend( filter_t *, int i_dst_width, int i_dst_height, const video_format_t *p_src );
271 272 273 274 275 276

/**
 * It blends a picture into another one.
 *
 * The input picture is not modified and not released.
 */
277
VLC_API int filter_Blend( filter_t *, picture_t *p_dst, int i_dst_x, int i_dst_y, const picture_t *p_src, int i_alpha );
278 279 280 281

/**
 * It destroys a blend filter created by filter_NewBlend.
 */
282
VLC_API void filter_DeleteBlend( filter_t * );
283

284 285 286 287 288 289 290 291 292 293
/**
 * Create a picture_t *(*)( filter_t *, picture_t * ) compatible wrapper
 * using a void (*)( filter_t *, picture_t *, picture_t * ) function
 *
 * Currently used by the chroma video filters
 */
#define VIDEO_FILTER_WRAPPER( name )                                    \
    static picture_t *name ## _Filter ( filter_t *p_filter,             \
                                        picture_t *p_pic )              \
    {                                                                   \
294
        picture_t *p_outpic = filter_NewPicture( p_filter );            \
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
295
        if( p_outpic )                                                  \
296
        {                                                               \
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
297 298
            name( p_filter, p_pic, p_outpic );                          \
            picture_CopyProperties( p_outpic, p_pic );                  \
299
        }                                                               \
300
        picture_Release( p_pic );                                       \
301 302 303
        return p_outpic;                                                \
    }

304 305
/**
 * Filter chain management API
306 307
 * The filter chain management API is used to dynamically construct filters
 * and add them in a chain.
308 309 310 311
 */

typedef struct filter_chain_t filter_chain_t;

312 313 314 315 316 317 318
/**
 * Create new filter chain
 *
 * \param p_object pointer to a vlc object
 * \param psz_capability vlc capability of filters in filter chain
 * \return pointer to a filter chain
 */
319
filter_chain_t * filter_chain_New( vlc_object_t *, const char *, enum es_format_category_e )
320
VLC_USED;
321
#define filter_chain_New( a, b, c ) filter_chain_New( VLC_OBJECT( a ), b, c )
322 323 324 325 326 327 328 329 330 331 332 333 334 335

/**
 * Creates a new video filter chain.
 *
 * \param obj pointer to parent VLC object
 * \param change whether to allow changing the output format
 * \param owner owner video buffer callbacks
 * \return new filter chain, or NULL on error
 */
VLC_API filter_chain_t * filter_chain_NewVideo( vlc_object_t *obj, bool change,
                                                const filter_owner_t *owner )
VLC_USED;
#define filter_chain_NewVideo( a, b, c ) \
        filter_chain_NewVideo( VLC_OBJECT( a ), b, c )
336 337 338 339 340 341 342

/**
 * Delete filter chain will delete all filters in the chain and free all
 * allocated data. The pointer to the filter chain is then no longer valid.
 *
 * \param p_chain pointer to filter chain
 */
343
VLC_API void filter_chain_Delete( filter_chain_t * );
344 345 346 347 348 349

/**
 * Reset filter chain will delete all filters in the chain and
 * reset p_fmt_in and p_fmt_out to the new values.
 *
 * \param p_chain pointer to filter chain
350 351
 * \param p_fmt_in new fmt_in params, may be NULL to leave input fmt unchanged
 * \param p_fmt_out new fmt_out params, may be NULL to leave output fmt unchanged
352
 */
353
VLC_API void filter_chain_Reset( filter_chain_t *, const es_format_t *, const es_format_t * );
354

355
/**
356
 * Append a filter to the chain.
357
 *
358 359 360 361 362
 * \param chain filter chain to append a filter to
 * \param name filter name
 * \param fmt_in filter input format
 * \param fmt_out filter output format
 * \return a pointer to the filter or NULL on error
363
 */
364 365 366
VLC_API filter_t *filter_chain_AppendFilter(filter_chain_t *chain,
    const char *name, config_chain_t *cfg, const es_format_t *fmt_in,
    const es_format_t *fmt_out);
367

368 369 370 371 372 373
/**
 * Append a conversion to the chain.
 *
 * \param chain filter chain to append a filter to
 * \param fmt_in filter input format
 * \param fmt_out filter output format
374 375
 * \retval 0 on success
 * \retval -1 on failure
376
 */
377
VLC_API int filter_chain_AppendConverter(filter_chain_t *chain,
378 379
    const es_format_t *fmt_in, const es_format_t *fmt_out);

380 381 382
/**
 * Append new filter to filter chain from string.
 *
383 384
 * \param chain filter chain to append a filter to
 * \param str filters chain nul-terminated string
385
 */
386 387
VLC_API int filter_chain_AppendFromString(filter_chain_t *chain,
                                          const char *str);
388 389 390 391 392 393

/**
 * Delete filter from filter chain. This function also releases the filter
 * object and unloads the filter modules. The pointer to p_filter is no
 * longer valid after this function successfully returns.
 *
394 395
 * \param chain filter chain to remove the filter from
 * \param filter filter to remove from the chain and delete
396
 */
397 398
VLC_API void filter_chain_DeleteFilter(filter_chain_t *chain,
                                       filter_t *filter);
399

400
/**
401
 * Checks if the filter chain is empty.
402
 *
403
 * \param chain pointer to filter chain
404
 * \return true if and only if there are no filters in this filter chain
405
 */
406
VLC_API bool filter_chain_IsEmpty(const filter_chain_t *chain);
407 408

/**
409
 * Get last output format of the last element in the filter chain.
410
 *
411
 * \param chain filter chain
412
 */
413
VLC_API const es_format_t *filter_chain_GetFmtOut(filter_chain_t *chain);
414 415

/**
416 417
 * Apply the filter chain to a video picture.
 *
418 419
 * \param chain pointer to filter chain
 * \param pic picture to apply filters to
420
 * \return modified picture after applying all video filters
421
 */
422 423
VLC_API picture_t *filter_chain_VideoFilter(filter_chain_t *chain,
                                            picture_t *pic);
424

425 426 427
/**
 * Flush a video filter chain.
 */
428
VLC_API void filter_chain_VideoFlush( filter_chain_t * );
429

430
/**
431
 * Generate subpictures from a chain of subpicture source "filters".
432
 *
433
 * \param chain filter chain
434 435
 * \param display_date of subpictures
 */
436 437
void filter_chain_SubSource(filter_chain_t *chain, spu_t *,
                            mtime_t display_date);
438

439 440 441
/**
 * Apply filter chain to subpictures.
 *
442 443
 * \param chain filter chain
 * \param subpic subpicture to apply filters on
444 445
 * \return modified subpicture after applying all subpicture filters
 */
446 447
VLC_API subpicture_t *filter_chain_SubFilter(filter_chain_t *chain,
                                             subpicture_t *subpic);
448

449 450 451 452 453 454 455 456
/**
 * Apply the filter chain to a mouse state.
 *
 * It will be applied from the output to the input. It makes sense only
 * for a video filter chain.
 *
 * The vlc_mouse_t* pointers may be the same.
 */
457 458
VLC_API int filter_chain_MouseFilter( filter_chain_t *, struct vlc_mouse_t *,
                                      const struct vlc_mouse_t * );
459

460 461 462
/**
 * Inform the filter chain of mouse state.
 *
463
 * It makes sense only for a sub source chain.
464
 */
465 466 467
VLC_API int filter_chain_MouseEvent( filter_chain_t *,
                                     const struct vlc_mouse_t *,
                                     const video_format_t * );
468

469 470 471
int filter_chain_ForEach( filter_chain_t *chain,
                          int (*cb)( filter_t *, void * ), void *opaque );

472
/** @} */
473
#endif /* _VLC_FILTER_H */