image.c 23.1 KB
Newer Older
1
2
3
/*****************************************************************************
 * image.c : wrapper for image reading/writing facilities
 *****************************************************************************
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
4
 * Copyright (C) 2004-2007 the VideoLAN team
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 * $Id$
 *
 * Author: Gildas Bazin <gbazin@videolan.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (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
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
dionoea's avatar
dionoea committed
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22
23
24
25
26
27
28
29
30
31
 *****************************************************************************/

/**
 * \file
 * This file contains the functions to handle the image_handler_t type
 */

/*****************************************************************************
 * Preamble
 *****************************************************************************/
32

33
34
35
36
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

37
38
39
#include <ctype.h>
#include <errno.h>

40
#include <vlc_common.h>
zorglub's avatar
zorglub committed
41
#include <vlc_codec.h>
42
#include <vlc_meta.h>
43
#include <vlc_filter.h>
zorglub's avatar
zorglub committed
44
#include <vlc_es.h>
45
#include <vlc_image.h>
46
#include <vlc_stream.h>
zorglub's avatar
zorglub committed
47
#include <vlc_charset.h>
48
#include <vlc_sout.h>
49
#include <libvlc.h>
50
51
52
53
54
55
56
57
58
59

static picture_t *ImageRead( image_handler_t *, block_t *,
                             video_format_t *, video_format_t * );
static picture_t *ImageReadUrl( image_handler_t *, const char *,
                                video_format_t *, video_format_t * );
static block_t *ImageWrite( image_handler_t *, picture_t *,
                            video_format_t *, video_format_t * );
static int ImageWriteUrl( image_handler_t *, picture_t *,
                          video_format_t *, video_format_t *, const char * );

60
61
static picture_t *ImageConvert( image_handler_t *, picture_t *,
                                video_format_t *, video_format_t * );
62
63
static picture_t *ImageFilter( image_handler_t *, picture_t *,
                               video_format_t *, const char *psz_module );
64

65
66
static decoder_t *CreateDecoder( vlc_object_t *, video_format_t * );
static void DeleteDecoder( decoder_t * );
67
68
69
static encoder_t *CreateEncoder( vlc_object_t *, video_format_t *,
                                 video_format_t * );
static void DeleteEncoder( encoder_t * );
70
static filter_t *CreateFilter( vlc_object_t *, es_format_t *,
71
                               video_format_t *, const char * );
72
73
static void DeleteFilter( filter_t * );

74
vlc_fourcc_t image_Ext2Fourcc( const char * );
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
75
/*static const char *Fourcc2Ext( vlc_fourcc_t );*/
76

77
78
79
80
81
82
/**
 * Create an image_handler_t instance
 *
 */
image_handler_t *__image_HandlerCreate( vlc_object_t *p_this )
{
ivoire's avatar
ivoire committed
83
84
85
    image_handler_t *p_image = calloc( 1, sizeof(image_handler_t) );
    if( !p_image )
        return NULL;
86
87
88
89
90
91
92

    p_image->p_parent = p_this;

    p_image->pf_read = ImageRead;
    p_image->pf_read_url = ImageReadUrl;
    p_image->pf_write = ImageWrite;
    p_image->pf_write_url = ImageWriteUrl;
93
    p_image->pf_convert = ImageConvert;
94
    p_image->pf_filter = ImageFilter;
95
96
97
98
99
100
101
102
103
104
105
106
107

    return p_image;
}

/**
 * Delete the image_handler_t instance
 *
 */
void image_HandlerDelete( image_handler_t *p_image )
{
    if( !p_image ) return;

    if( p_image->p_dec ) DeleteDecoder( p_image->p_dec );
108
    if( p_image->p_enc ) DeleteEncoder( p_image->p_enc );
109
110
111
    if( p_image->p_filter ) DeleteFilter( p_image->p_filter );

    free( p_image );
112
    p_image = NULL;
113
114
115
116
117
118
119
120
121
122
123
}

/**
 * Read an image
 *
 */

static picture_t *ImageRead( image_handler_t *p_image, block_t *p_block,
                             video_format_t *p_fmt_in,
                             video_format_t *p_fmt_out )
{
124
    picture_t *p_pic = NULL, *p_tmp;
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

    /* Check if we can reuse the current decoder */
    if( p_image->p_dec &&
        p_image->p_dec->fmt_in.i_codec != p_fmt_in->i_chroma )
    {
        DeleteDecoder( p_image->p_dec );
        p_image->p_dec = 0;
    }

    /* Start a decoder */
    if( !p_image->p_dec )
    {
        p_image->p_dec = CreateDecoder( p_image->p_parent, p_fmt_in );
        if( !p_image->p_dec ) return NULL;
    }

    p_block->i_pts = p_block->i_dts = mdate();
142
143
144
    while( (p_tmp = p_image->p_dec->pf_decode_video( p_image->p_dec, &p_block ))
             != NULL )
    {
145
146
        if( p_pic != NULL )
            picture_Release( p_pic );
147
148
        p_pic = p_tmp;
    }
149

150
    if( p_pic == NULL )
151
    {
152
        msg_Warn( p_image->p_parent, "no image decoded" );
153
154
155
156
157
        return 0;
    }

    if( !p_fmt_out->i_chroma )
        p_fmt_out->i_chroma = p_image->p_dec->fmt_out.video.i_chroma;
158
159
160
161
162
163
164
    if( !p_fmt_out->i_width && p_fmt_out->i_height )
        p_fmt_out->i_width = p_fmt_out->i_height
                              * p_image->p_dec->fmt_out.video.i_aspect
                              / VOUT_ASPECT_FACTOR;
    if( !p_fmt_out->i_height && p_fmt_out->i_width )
        p_fmt_out->i_height = p_fmt_out->i_width * VOUT_ASPECT_FACTOR
                               / p_image->p_dec->fmt_out.video.i_aspect;
165
166
167
168
169
170
171
172
173
174
175
176
177
    if( !p_fmt_out->i_width )
        p_fmt_out->i_width = p_image->p_dec->fmt_out.video.i_width;
    if( !p_fmt_out->i_height )
        p_fmt_out->i_height = p_image->p_dec->fmt_out.video.i_height;

    /* Check if we need chroma conversion or resizing */
    if( p_image->p_dec->fmt_out.video.i_chroma != p_fmt_out->i_chroma ||
        p_image->p_dec->fmt_out.video.i_width != p_fmt_out->i_width ||
        p_image->p_dec->fmt_out.video.i_height != p_fmt_out->i_height )
    {
        if( p_image->p_filter )
        if( p_image->p_filter->fmt_in.video.i_chroma !=
            p_image->p_dec->fmt_out.video.i_chroma ||
178
            p_image->p_filter->fmt_out.video.i_chroma != p_fmt_out->i_chroma )
179
180
181
182
183
184
185
186
187
188
189
        {
            /* We need to restart a new filter */
            DeleteFilter( p_image->p_filter );
            p_image->p_filter = 0;
        }

        /* Start a filter */
        if( !p_image->p_filter )
        {
            p_image->p_filter =
                CreateFilter( p_image->p_parent, &p_image->p_dec->fmt_out,
190
                              p_fmt_out, NULL );
191
192
193

            if( !p_image->p_filter )
            {
194
                picture_Release( p_pic );
195
196
197
                return NULL;
            }
        }
198
199
200
201
202
203
204
205
        else
        {
            /* Filters should handle on-the-fly size changes */
            p_image->p_filter->fmt_in = p_image->p_dec->fmt_out;
            p_image->p_filter->fmt_out = p_image->p_dec->fmt_out;
            p_image->p_filter->fmt_out.i_codec = p_fmt_out->i_chroma;
            p_image->p_filter->fmt_out.video = *p_fmt_out;
        }
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220

        p_pic = p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
        *p_fmt_out = p_image->p_filter->fmt_out.video;
    }
    else *p_fmt_out = p_image->p_dec->fmt_out.video;

    return p_pic;
}

static picture_t *ImageReadUrl( image_handler_t *p_image, const char *psz_url,
                                video_format_t *p_fmt_in,
                                video_format_t *p_fmt_out )
{
    block_t *p_block;
    picture_t *p_pic;
221
    stream_t *p_stream = NULL;
222
223
    int i_size;

224
    p_stream = stream_UrlNew( p_image->p_parent, psz_url );
225

226
    if( !p_stream )
227
    {
228
229
230
        msg_Dbg( p_image->p_parent, "could not open %s for reading",
                 psz_url );
        return NULL;
231
232
    }

233
234
    i_size = stream_Size( p_stream );

235
    p_block = block_New( p_image->p_parent, i_size );
236

237
238
    stream_Read( p_stream, p_block->p_buffer, i_size );
    stream_Delete( p_stream );
239

240
241
242
    if( !p_fmt_in->i_chroma )
    {
        /* Try to guess format from file name */
243
        p_fmt_in->i_chroma = image_Ext2Fourcc( psz_url );
244
245
    }

246
247
248
249
250
251
252
253
254
255
256
257
258
259
    p_pic = ImageRead( p_image, p_block, p_fmt_in, p_fmt_out );

    return p_pic;
}

/**
 * Write an image
 *
 */

static block_t *ImageWrite( image_handler_t *p_image, picture_t *p_pic,
                            video_format_t *p_fmt_in,
                            video_format_t *p_fmt_out )
{
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
    block_t *p_block;

    /* Check if we can reuse the current encoder */
    if( p_image->p_enc &&
        ( p_image->p_enc->fmt_out.i_codec != p_fmt_out->i_chroma ||
          p_image->p_enc->fmt_out.video.i_width != p_fmt_out->i_width ||
          p_image->p_enc->fmt_out.video.i_height != p_fmt_out->i_height ) )
    {
        DeleteEncoder( p_image->p_enc );
        p_image->p_enc = 0;
    }

    /* Start an encoder */
    if( !p_image->p_enc )
    {
        p_image->p_enc = CreateEncoder( p_image->p_parent,
                                        p_fmt_in, p_fmt_out );
        if( !p_image->p_enc ) return NULL;
    }

    /* Check if we need chroma conversion or resizing */
    if( p_image->p_enc->fmt_in.video.i_chroma != p_fmt_in->i_chroma ||
        p_image->p_enc->fmt_in.video.i_width != p_fmt_in->i_width ||
        p_image->p_enc->fmt_in.video.i_height != p_fmt_in->i_height )
    {
285
        picture_t *p_tmp_pic;
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305

        if( p_image->p_filter )
        if( p_image->p_filter->fmt_in.video.i_chroma != p_fmt_in->i_chroma ||
            p_image->p_filter->fmt_out.video.i_chroma !=
            p_image->p_enc->fmt_in.video.i_chroma )
        {
            /* We need to restart a new filter */
            DeleteFilter( p_image->p_filter );
            p_image->p_filter = 0;
        }

        /* Start a filter */
        if( !p_image->p_filter )
        {
            es_format_t fmt_in;
            es_format_Init( &fmt_in, VIDEO_ES, p_fmt_in->i_chroma );
            fmt_in.video = *p_fmt_in;

            p_image->p_filter =
                CreateFilter( p_image->p_parent, &fmt_in,
306
                              &p_image->p_enc->fmt_in.video, NULL );
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

            if( !p_image->p_filter )
            {
                return NULL;
            }
        }
        else
        {
            /* Filters should handle on-the-fly size changes */
            p_image->p_filter->fmt_in.i_codec = p_fmt_in->i_chroma;
            p_image->p_filter->fmt_out.video = *p_fmt_in;
            p_image->p_filter->fmt_out.i_codec =p_image->p_enc->fmt_in.i_codec;
            p_image->p_filter->fmt_out.video = p_image->p_enc->fmt_in.video;
        }

dionoea's avatar
dionoea committed
322
        picture_Hold( p_pic );
323

324
325
        p_tmp_pic =
            p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
326

327
328
329
330
331
332
333
334
        p_block = p_image->p_enc->pf_encode_video( p_image->p_enc, p_tmp_pic );

        p_image->p_filter->pf_vout_buffer_del( p_image->p_filter, p_tmp_pic );
    }
    else
    {
        p_block = p_image->p_enc->pf_encode_video( p_image->p_enc, p_pic );
    }
335
336
337
338
339
340
341
342

    if( !p_block )
    {
        msg_Dbg( p_image->p_parent, "no image encoded" );
        return 0;
    }

    return p_block;
343
344
345
346
347
348
}

static int ImageWriteUrl( image_handler_t *p_image, picture_t *p_pic,
                          video_format_t *p_fmt_in, video_format_t *p_fmt_out,
                          const char *psz_url )
{
349
350
351
352
353
354
    block_t *p_block;
    FILE *file;

    if( !p_fmt_out->i_chroma )
    {
        /* Try to guess format from file name */
355
        p_fmt_out->i_chroma = image_Ext2Fourcc( psz_url );
356
357
    }

358
    file = utf8_fopen( psz_url, "wb" );
359
360
    if( !file )
    {
361
        msg_Err( p_image->p_parent, "%s: %m", psz_url );
362
363
364
365
366
        return VLC_EGENERIC;
    }

    p_block = ImageWrite( p_image, p_pic, p_fmt_in, p_fmt_out );

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
367
    int err = 0;
368
369
    if( p_block )
    {
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
370
371
        if( fwrite( p_block->p_buffer, p_block->i_buffer, 1, file ) != 1 )
            err = errno;
372
373
374
        block_Release( p_block );
    }

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
375
376
377
378
    if( fclose( file ) && !err )
        err = errno;

    if( err )
379
380
381
382
    {
       errno = err;
       msg_Err( p_image->p_parent, "%s: %m", psz_url );
    }
383

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
384
    return err ? VLC_EGENERIC : VLC_SUCCESS;
385
386
}

387
388
389
390
391
392
393
394
395
396
397
/**
 * Convert an image to a different format
 *
 */

static picture_t *ImageConvert( image_handler_t *p_image, picture_t *p_pic,
                                video_format_t *p_fmt_in,
                                video_format_t *p_fmt_out )
{
    picture_t *p_pif;

398
399
400
401
402
403
404
405
406
407
408
409
410
411
    if( !p_fmt_out->i_width && !p_fmt_out->i_height &&
        p_fmt_out->i_sar_num && p_fmt_out->i_sar_den &&
        p_fmt_out->i_sar_num * p_fmt_in->i_sar_den !=
        p_fmt_out->i_sar_den * p_fmt_in->i_sar_num )
    {
        p_fmt_out->i_width =
            p_fmt_in->i_sar_num * (int64_t)p_fmt_out->i_sar_den *
            p_fmt_in->i_width / p_fmt_in->i_sar_den / p_fmt_out->i_sar_num;
        p_fmt_out->i_visible_width =
            p_fmt_in->i_sar_num * (int64_t)p_fmt_out->i_sar_den *
            p_fmt_in->i_visible_width / p_fmt_in->i_sar_den /
            p_fmt_out->i_sar_num;
    }

412
    if( !p_fmt_out->i_chroma ) p_fmt_out->i_chroma = p_fmt_in->i_chroma;
413
414
415
416
417
418
419
    if( !p_fmt_out->i_width )
        p_fmt_out->i_width = p_fmt_out->i_visible_width = p_fmt_in->i_width;
    if( !p_fmt_out->i_height )
        p_fmt_out->i_height = p_fmt_out->i_visible_height = p_fmt_in->i_height;
    if( !p_fmt_out->i_sar_num ) p_fmt_out->i_sar_num = p_fmt_in->i_sar_num;
    if( !p_fmt_out->i_sar_den ) p_fmt_out->i_sar_den = p_fmt_in->i_sar_den;
    if( !p_fmt_out->i_aspect ) p_fmt_out->i_aspect = p_fmt_in->i_aspect;
420
421
422
423
424
425
426

    if( p_image->p_filter )
    if( p_image->p_filter->fmt_in.video.i_chroma != p_fmt_in->i_chroma ||
        p_image->p_filter->fmt_out.video.i_chroma != p_fmt_out->i_chroma )
    {
        /* We need to restart a new filter */
        DeleteFilter( p_image->p_filter );
427
        p_image->p_filter = NULL;
428
429
430
431
432
433
434
435
436
437
    }

    /* Start a filter */
    if( !p_image->p_filter )
    {
        es_format_t fmt_in;
        es_format_Init( &fmt_in, VIDEO_ES, p_fmt_in->i_chroma );
        fmt_in.video = *p_fmt_in;

        p_image->p_filter =
438
            CreateFilter( p_image->p_parent, &fmt_in, p_fmt_out, NULL );
439
440
441
442
443
444
445
446
447
448
449
450
451

        if( !p_image->p_filter )
        {
            return NULL;
        }
    }
    else
    {
        /* Filters should handle on-the-fly size changes */
        p_image->p_filter->fmt_in.video = *p_fmt_in;
        p_image->p_filter->fmt_out.video = *p_fmt_out;
    }

dionoea's avatar
dionoea committed
452
    picture_Hold( p_pic );
453

454
455
456
457
458
459
460
    p_pif = p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );

    if( p_fmt_in->i_chroma == p_fmt_out->i_chroma &&
        p_fmt_in->i_width == p_fmt_out->i_width &&
        p_fmt_in->i_height == p_fmt_out->i_height )
    {
        /* Duplicate image */
461
        picture_Release( p_pif ); /* XXX: Better fix must be possible */
462
        p_pif = p_image->p_filter->pf_vout_buffer_new( p_image->p_filter );
463
464
        if( p_pif )
            picture_Copy( p_pif, p_pic );
465
466
467
468
469
    }

    return p_pif;
}

470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
/**
 * Filter an image with a psz_module filter
 *
 */

static picture_t *ImageFilter( image_handler_t *p_image, picture_t *p_pic,
                               video_format_t *p_fmt, const char *psz_module )
{
    /* Start a filter */
    if( !p_image->p_filter )
    {
        es_format_t fmt;
        es_format_Init( &fmt, VIDEO_ES, p_fmt->i_chroma );
        fmt.video = *p_fmt;

        p_image->p_filter =
            CreateFilter( p_image->p_parent, &fmt, &fmt.video, psz_module );

        if( !p_image->p_filter )
        {
            return NULL;
        }
    }
    else
    {
        /* Filters should handle on-the-fly size changes */
        p_image->p_filter->fmt_in.video = *p_fmt;
        p_image->p_filter->fmt_out.video = *p_fmt;
    }

dionoea's avatar
dionoea committed
500
    picture_Hold( p_pic );
501

502
    return p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
503
504
}

505
506
507
508
/**
 * Misc functions
 *
 */
509
static const struct
510
511
{
    vlc_fourcc_t i_codec;
512
    const char *psz_ext;
513
514
515
516
517
518
519
520
521
522
523

} ext_table[] =
{
    { VLC_FOURCC('j','p','e','g'), "jpeg" },
    { VLC_FOURCC('j','p','e','g'), "jpg"  },
    { VLC_FOURCC('l','j','p','g'), "ljpg" },
    { VLC_FOURCC('p','n','g',' '), "png" },
    { VLC_FOURCC('p','g','m',' '), "pgm" },
    { VLC_FOURCC('p','g','m','y'), "pgmyuv" },
    { VLC_FOURCC('p','b','m',' '), "pbm" },
    { VLC_FOURCC('p','a','m',' '), "pam" },
524
525
526
527
528
529
530
531
532
533
    { VLC_FOURCC('t','g','a',' '), "tga" },
    { VLC_FOURCC('b','m','p',' '), "bmp" },
    { VLC_FOURCC('p','n','m',' '), "pnm" },
    { VLC_FOURCC('x','p','m',' '), "xpm" },
    { VLC_FOURCC('x','c','f',' '), "xcf" },
    { VLC_FOURCC('p','c','x',' '), "pcx" },
    { VLC_FOURCC('g','i','f',' '), "gif" },
    { VLC_FOURCC('t','i','f','f'), "tif" },
    { VLC_FOURCC('t','i','f','f'), "tiff" },
    { VLC_FOURCC('l','b','m',' '), "lbm" },
534
535
536
    { 0, NULL }
};

537
vlc_fourcc_t image_Ext2Fourcc( const char *psz_name )
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
{
    int i;

    psz_name = strrchr( psz_name, '.' );
    if( !psz_name ) return 0;
    psz_name++;

    for( i = 0; ext_table[i].i_codec; i++ )
    {
        int j;
        for( j = 0; toupper(ext_table[i].psz_ext[j]) == toupper(psz_name[j]);
             j++ )
        {
            if( !ext_table[i].psz_ext[j] && !psz_name[j] )
                return ext_table[i].i_codec;
        }
    }

    return 0;
}

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
559
/*
560
561
562
563
564
565
566
567
568
569
570
static const char *Fourcc2Ext( vlc_fourcc_t i_codec )
{
    int i;

    for( i = 0; ext_table[i].i_codec != 0; i++ )
    {
        if( ext_table[i].i_codec == i_codec ) return ext_table[i].psz_ext;
    }

    return NULL;
}
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
571
*/
572

573
574
static picture_t *video_new_buffer( decoder_t *p_dec )
{
575
    p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
576
577
578
579
    return picture_New( p_dec->fmt_out.video.i_chroma,
                        p_dec->fmt_out.video.i_width,
                        p_dec->fmt_out.video.i_height,
                        p_dec->fmt_out.video.i_aspect );
580
581
582
583
}

static void video_del_buffer( decoder_t *p_dec, picture_t *p_pic )
{
584
585
586
587
588
    if( p_pic->i_refcount != 1 )
        msg_Err( p_dec, "invalid picture reference count" );

    p_pic->i_refcount = 0;
    picture_Delete( p_pic );
589
590
591
592
}

static void video_link_picture( decoder_t *p_dec, picture_t *p_pic )
{
593
    (void)p_dec;
dionoea's avatar
dionoea committed
594
    picture_Hold( p_pic );
595
596
597
598
}

static void video_unlink_picture( decoder_t *p_dec, picture_t *p_pic )
{
599
600
    (void)p_dec;
    picture_Release( p_pic );
601
602
603
604
605
606
607
608
609
610
611
}

static decoder_t *CreateDecoder( vlc_object_t *p_this, video_format_t *fmt )
{
    decoder_t *p_dec;

    p_dec = vlc_object_create( p_this, VLC_OBJECT_DECODER );
    if( p_dec == NULL )
        return NULL;

    p_dec->p_module = NULL;
612
613
    es_format_Init( &p_dec->fmt_in, VIDEO_ES, fmt->i_chroma );
    es_format_Init( &p_dec->fmt_out, VIDEO_ES, 0 );
614
    p_dec->fmt_in.video = *fmt;
615
    p_dec->b_pace_control = true;
616
617
618
619
620
621
622
623
624

    p_dec->pf_vout_buffer_new = video_new_buffer;
    p_dec->pf_vout_buffer_del = video_del_buffer;
    p_dec->pf_picture_link    = video_link_picture;
    p_dec->pf_picture_unlink  = video_unlink_picture;

    vlc_object_attach( p_dec, p_this );

    /* Find a suitable decoder module */
625
    p_dec->p_module = module_need( p_dec, "decoder", "$codec", false );
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
    if( !p_dec->p_module )
    {
        msg_Err( p_dec, "no suitable decoder module for fourcc `%4.4s'.\n"
                 "VLC probably does not support this image format.",
                 (char*)&p_dec->fmt_in.i_codec );

        DeleteDecoder( p_dec );
        return NULL;
    }

    return p_dec;
}

static void DeleteDecoder( decoder_t * p_dec )
{
    vlc_object_detach( p_dec );

643
    if( p_dec->p_module ) module_unneed( p_dec, p_dec->p_module );
644
645
646

    es_format_Clean( &p_dec->fmt_in );
    es_format_Clean( &p_dec->fmt_out );
647
648
649

    if( p_dec->p_description )
        vlc_meta_Delete( p_dec->p_description );
650

651
    vlc_object_release( p_dec );
652
    p_dec = NULL;
653
654
}

655
656
657
658
659
static encoder_t *CreateEncoder( vlc_object_t *p_this, video_format_t *fmt_in,
                                 video_format_t *fmt_out )
{
    encoder_t *p_enc;

660
    p_enc = sout_EncoderCreate( p_this );
661
662
663
664
665
666
667
668
669
670
    if( p_enc == NULL )
        return NULL;

    p_enc->p_module = NULL;
    es_format_Init( &p_enc->fmt_in, VIDEO_ES, fmt_in->i_chroma );
    p_enc->fmt_in.video = *fmt_in;
    if( fmt_out->i_width > 0 && fmt_out->i_height > 0 )
    {
        p_enc->fmt_in.video.i_width = fmt_out->i_width;
        p_enc->fmt_in.video.i_height = fmt_out->i_height;
671
672
673
674
675
676
677
678
679
680
681
682

        if( fmt_out->i_visible_width > 0 &&
            fmt_out->i_visible_height > 0 )
        {
            p_enc->fmt_in.video.i_visible_width = fmt_out->i_visible_width;
            p_enc->fmt_in.video.i_visible_height = fmt_out->i_visible_height;
        }
        else
        {
            p_enc->fmt_in.video.i_visible_width = fmt_out->i_width;
            p_enc->fmt_in.video.i_visible_height = fmt_out->i_height;
        }
683
    }
684
    else if( fmt_out->i_sar_num && fmt_out->i_sar_den &&
685
             fmt_out->i_sar_num * fmt_in->i_sar_den !=
686
687
688
             fmt_out->i_sar_den * fmt_in->i_sar_num )
    {
        p_enc->fmt_in.video.i_width =
689
            fmt_in->i_sar_num * (int64_t)fmt_out->i_sar_den * fmt_in->i_width /
690
            fmt_in->i_sar_den / fmt_out->i_sar_num;
691
692
693
        p_enc->fmt_in.video.i_visible_width =
            fmt_in->i_sar_num * (int64_t)fmt_out->i_sar_den *
            fmt_in->i_visible_width / fmt_in->i_sar_den / fmt_out->i_sar_num;
694
695
    }

696
697
698
699
700
701
702
703
704
705
706
    p_enc->fmt_in.video.i_frame_rate = 25;
    p_enc->fmt_in.video.i_frame_rate_base = 1;

    es_format_Init( &p_enc->fmt_out, VIDEO_ES, fmt_out->i_chroma );
    p_enc->fmt_out.video = *fmt_out;
    p_enc->fmt_out.video.i_width = p_enc->fmt_in.video.i_width;
    p_enc->fmt_out.video.i_height = p_enc->fmt_in.video.i_height;

    vlc_object_attach( p_enc, p_this );

    /* Find a suitable decoder module */
707
    p_enc->p_module = module_need( p_enc, "encoder", NULL, false );
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
    if( !p_enc->p_module )
    {
        msg_Err( p_enc, "no suitable encoder module for fourcc `%4.4s'.\n"
                 "VLC probably does not support this image format.",
                 (char*)&p_enc->fmt_out.i_codec );

        DeleteEncoder( p_enc );
        return NULL;
    }
    p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;

    return p_enc;
}

static void DeleteEncoder( encoder_t * p_enc )
{
    vlc_object_detach( p_enc );

726
    if( p_enc->p_module ) module_unneed( p_enc, p_enc->p_module );
727
728
729
730

    es_format_Clean( &p_enc->fmt_in );
    es_format_Clean( &p_enc->fmt_out );

731
    vlc_object_release( p_enc );
732
    p_enc = NULL;
733
734
}

735
static filter_t *CreateFilter( vlc_object_t *p_this, es_format_t *p_fmt_in,
736
737
                               video_format_t *p_fmt_out,
                               const char *psz_module )
738
{
739
    static const char typename[] = "filter";
740
741
    filter_t *p_filter;

742
743
    p_filter = vlc_custom_create( p_this, sizeof(filter_t),
                                  VLC_OBJECT_GENERIC, typename );
744
745
746
747
748
749
750
751
752
753
754
    vlc_object_attach( p_filter, p_this );

    p_filter->pf_vout_buffer_new =
        (picture_t *(*)(filter_t *))video_new_buffer;
    p_filter->pf_vout_buffer_del =
        (void (*)(filter_t *, picture_t *))video_del_buffer;

    p_filter->fmt_in = *p_fmt_in;
    p_filter->fmt_out = *p_fmt_in;
    p_filter->fmt_out.i_codec = p_fmt_out->i_chroma;
    p_filter->fmt_out.video = *p_fmt_out;
755
    p_filter->p_module = module_need( p_filter, "video filter2",
756
                                      psz_module, false );
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771

    if( !p_filter->p_module )
    {
        msg_Dbg( p_filter, "no video filter found" );
        DeleteFilter( p_filter );
        return NULL;
    }

    return p_filter;
}

static void DeleteFilter( filter_t * p_filter )
{
    vlc_object_detach( p_filter );

772
    if( p_filter->p_module ) module_unneed( p_filter, p_filter->p_module );
773
774
775
776

    es_format_Clean( &p_filter->fmt_in );
    es_format_Clean( &p_filter->fmt_out );

777
    vlc_object_release( p_filter );
778
}