git.sesse.net Git - vlc/blob - src/misc/image.c

   1 /*****************************************************************************
   2  * image.c : wrapper for image reading/writing facilities
   3  *****************************************************************************
   4  * Copyright (C) 2004-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Author: Gildas Bazin <gbazin@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /**
  25  * \file
  26  * This file contains the functions to handle the image_handler_t type
  27  */
  28
  29 /*****************************************************************************
  30  * Preamble
  31  *****************************************************************************/
  32
  33 #ifdef HAVE_CONFIG_H
  34 # include "config.h"
  35 #endif
  36
  37 #include <ctype.h>
  38 #include <errno.h>
  39
  40 #include <vlc_common.h>
  41 #include <vlc_codec.h>
  42 #include <vlc_filter.h>
  43 #include <vlc_es.h>
  44 #include <vlc_image.h>
  45 #include <vlc_stream.h>
  46 #include <vlc_charset.h>
  47
  48 static picture_t *ImageRead( image_handler_t *, block_t *,
  49                              video_format_t *, video_format_t * );
  50 static picture_t *ImageReadUrl( image_handler_t *, const char *,
  51                                 video_format_t *, video_format_t * );
  52 static block_t *ImageWrite( image_handler_t *, picture_t *,
  53                             video_format_t *, video_format_t * );
  54 static int ImageWriteUrl( image_handler_t *, picture_t *,
  55                           video_format_t *, video_format_t *, const char * );
  56
  57 static picture_t *ImageConvert( image_handler_t *, picture_t *,
  58                                 video_format_t *, video_format_t * );
  59 static picture_t *ImageFilter( image_handler_t *, picture_t *,
  60                                video_format_t *, const char *psz_module );
  61
  62 static decoder_t *CreateDecoder( vlc_object_t *, video_format_t * );
  63 static void DeleteDecoder( decoder_t * );
  64 static encoder_t *CreateEncoder( vlc_object_t *, video_format_t *,
  65                                  video_format_t * );
  66 static void DeleteEncoder( encoder_t * );
  67 static filter_t *CreateFilter( vlc_object_t *, es_format_t *,
  68                                video_format_t *, const char * );
  69 static void DeleteFilter( filter_t * );
  70
  71 static vlc_fourcc_t Ext2Fourcc( const char * );
  72 /*static const char *Fourcc2Ext( vlc_fourcc_t );*/
  73
  74 /**
  75  * Create an image_handler_t instance
  76  *
  77  */
  78 image_handler_t *__image_HandlerCreate( vlc_object_t *p_this )
  79 {
  80     image_handler_t *p_image = malloc( sizeof(image_handler_t) );
  81
  82     memset( p_image, 0, sizeof(image_handler_t) );
  83     p_image->p_parent = p_this;
  84
  85     p_image->pf_read = ImageRead;
  86     p_image->pf_read_url = ImageReadUrl;
  87     p_image->pf_write = ImageWrite;
  88     p_image->pf_write_url = ImageWriteUrl;
  89     p_image->pf_convert = ImageConvert;
  90     p_image->pf_filter = ImageFilter;
  91
  92     return p_image;
  93 }
  94
  95 /**
  96  * Delete the image_handler_t instance
  97  *
  98  */
  99 void image_HandlerDelete( image_handler_t *p_image )
 100 {
 101     if( !p_image ) return;
 102
 103     if( p_image->p_dec ) DeleteDecoder( p_image->p_dec );
 104     if( p_image->p_enc ) DeleteEncoder( p_image->p_enc );
 105     if( p_image->p_filter ) DeleteFilter( p_image->p_filter );
 106
 107     free( p_image );
 108     p_image = NULL;
 109 }
 110
 111 /**
 112  * Read an image
 113  *
 114  */
 115
 116 static picture_t *ImageRead( image_handler_t *p_image, block_t *p_block,
 117                              video_format_t *p_fmt_in,
 118                              video_format_t *p_fmt_out )
 119 {
 120     picture_t *p_pic = NULL, *p_tmp;
 121
 122     /* Check if we can reuse the current decoder */
 123     if( p_image->p_dec &&
 124         p_image->p_dec->fmt_in.i_codec != p_fmt_in->i_chroma )
 125     {
 126         DeleteDecoder( p_image->p_dec );
 127         p_image->p_dec = 0;
 128     }
 129
 130     /* Start a decoder */
 131     if( !p_image->p_dec )
 132     {
 133         p_image->p_dec = CreateDecoder( p_image->p_parent, p_fmt_in );
 134         if( !p_image->p_dec ) return NULL;
 135     }
 136
 137     p_block->i_pts = p_block->i_dts = mdate();
 138     while( (p_tmp = p_image->p_dec->pf_decode_video( p_image->p_dec, &p_block ))
 139              != NULL )
 140     {
 141         if ( p_pic != NULL )
 142             p_pic->pf_release( p_pic );
 143         p_pic = p_tmp;
 144     }
 145
 146     if( p_pic == NULL )
 147     {
 148         msg_Warn( p_image->p_parent, "no image decoded" );
 149         return 0;
 150     }
 151
 152     if( !p_fmt_out->i_chroma )
 153         p_fmt_out->i_chroma = p_image->p_dec->fmt_out.video.i_chroma;
 154     if( !p_fmt_out->i_width && p_fmt_out->i_height )
 155         p_fmt_out->i_width = p_fmt_out->i_height
 156                               * p_image->p_dec->fmt_out.video.i_aspect
 157                               / VOUT_ASPECT_FACTOR;
 158     if( !p_fmt_out->i_height && p_fmt_out->i_width )
 159         p_fmt_out->i_height = p_fmt_out->i_width * VOUT_ASPECT_FACTOR
 160                                / p_image->p_dec->fmt_out.video.i_aspect;
 161     if( !p_fmt_out->i_width )
 162         p_fmt_out->i_width = p_image->p_dec->fmt_out.video.i_width;
 163     if( !p_fmt_out->i_height )
 164         p_fmt_out->i_height = p_image->p_dec->fmt_out.video.i_height;
 165
 166     /* Check if we need chroma conversion or resizing */
 167     if( p_image->p_dec->fmt_out.video.i_chroma != p_fmt_out->i_chroma ||
 168         p_image->p_dec->fmt_out.video.i_width != p_fmt_out->i_width ||
 169         p_image->p_dec->fmt_out.video.i_height != p_fmt_out->i_height )
 170     {
 171         if( p_image->p_filter )
 172         if( p_image->p_filter->fmt_in.video.i_chroma !=
 173             p_image->p_dec->fmt_out.video.i_chroma ||
 174             p_image->p_filter->fmt_out.video.i_chroma != p_fmt_out->i_chroma )
 175         {
 176             /* We need to restart a new filter */
 177             DeleteFilter( p_image->p_filter );
 178             p_image->p_filter = 0;
 179         }
 180
 181         /* Start a filter */
 182         if( !p_image->p_filter )
 183         {
 184             p_image->p_filter =
 185                 CreateFilter( p_image->p_parent, &p_image->p_dec->fmt_out,
 186                               p_fmt_out, NULL );
 187
 188             if( !p_image->p_filter )
 189             {
 190                 p_pic->pf_release( p_pic );
 191                 return NULL;
 192             }
 193         }
 194         else
 195         {
 196             /* Filters should handle on-the-fly size changes */
 197             p_image->p_filter->fmt_in = p_image->p_dec->fmt_out;
 198             p_image->p_filter->fmt_out = p_image->p_dec->fmt_out;
 199             p_image->p_filter->fmt_out.i_codec = p_fmt_out->i_chroma;
 200             p_image->p_filter->fmt_out.video = *p_fmt_out;
 201         }
 202
 203         p_pic = p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
 204         *p_fmt_out = p_image->p_filter->fmt_out.video;
 205     }
 206     else *p_fmt_out = p_image->p_dec->fmt_out.video;
 207
 208     return p_pic;
 209 }
 210
 211 static picture_t *ImageReadUrl( image_handler_t *p_image, const char *psz_url,
 212                                 video_format_t *p_fmt_in,
 213                                 video_format_t *p_fmt_out )
 214 {
 215     block_t *p_block;
 216     picture_t *p_pic;
 217     stream_t *p_stream = NULL;
 218     int i_size;
 219
 220     p_stream = stream_UrlNew( p_image->p_parent, psz_url );
 221
 222     if( !p_stream )
 223     {
 224         msg_Dbg( p_image->p_parent, "could not open %s for reading",
 225                  psz_url );
 226         return NULL;
 227     }
 228
 229     i_size = stream_Size( p_stream );
 230
 231     p_block = block_New( p_image->p_parent, i_size );
 232
 233     stream_Read( p_stream, p_block->p_buffer, i_size );
 234     stream_Delete( p_stream );
 235
 236     if( !p_fmt_in->i_chroma )
 237     {
 238         /* Try to guess format from file name */
 239         p_fmt_in->i_chroma = Ext2Fourcc( psz_url );
 240     }
 241
 242     p_pic = ImageRead( p_image, p_block, p_fmt_in, p_fmt_out );
 243
 244     return p_pic;
 245 }
 246
 247 /**
 248  * Write an image
 249  *
 250  */
 251
 252 static block_t *ImageWrite( image_handler_t *p_image, picture_t *p_pic,
 253                             video_format_t *p_fmt_in,
 254                             video_format_t *p_fmt_out )
 255 {
 256     block_t *p_block;
 257
 258     /* Check if we can reuse the current encoder */
 259     if( p_image->p_enc &&
 260         ( p_image->p_enc->fmt_out.i_codec != p_fmt_out->i_chroma ||
 261           p_image->p_enc->fmt_out.video.i_width != p_fmt_out->i_width ||
 262           p_image->p_enc->fmt_out.video.i_height != p_fmt_out->i_height ) )
 263     {
 264         DeleteEncoder( p_image->p_enc );
 265         p_image->p_enc = 0;
 266     }
 267
 268     /* Start an encoder */
 269     if( !p_image->p_enc )
 270     {
 271         p_image->p_enc = CreateEncoder( p_image->p_parent,
 272                                         p_fmt_in, p_fmt_out );
 273         if( !p_image->p_enc ) return NULL;
 274     }
 275
 276     /* Check if we need chroma conversion or resizing */
 277     if( p_image->p_enc->fmt_in.video.i_chroma != p_fmt_in->i_chroma ||
 278         p_image->p_enc->fmt_in.video.i_width != p_fmt_in->i_width ||
 279         p_image->p_enc->fmt_in.video.i_height != p_fmt_in->i_height )
 280     {
 281         picture_t *p_tmp_pic;
 282
 283         if( p_image->p_filter )
 284         if( p_image->p_filter->fmt_in.video.i_chroma != p_fmt_in->i_chroma ||
 285             p_image->p_filter->fmt_out.video.i_chroma !=
 286             p_image->p_enc->fmt_in.video.i_chroma )
 287         {
 288             /* We need to restart a new filter */
 289             DeleteFilter( p_image->p_filter );
 290             p_image->p_filter = 0;
 291         }
 292
 293         /* Start a filter */
 294         if( !p_image->p_filter )
 295         {
 296             es_format_t fmt_in;
 297             es_format_Init( &fmt_in, VIDEO_ES, p_fmt_in->i_chroma );
 298             fmt_in.video = *p_fmt_in;
 299
 300             p_image->p_filter =
 301                 CreateFilter( p_image->p_parent, &fmt_in,
 302                               &p_image->p_enc->fmt_in.video, NULL );
 303
 304             if( !p_image->p_filter )
 305             {
 306                 return NULL;
 307             }
 308         }
 309         else
 310         {
 311             /* Filters should handle on-the-fly size changes */
 312             p_image->p_filter->fmt_in.i_codec = p_fmt_in->i_chroma;
 313             p_image->p_filter->fmt_out.video = *p_fmt_in;
 314             p_image->p_filter->fmt_out.i_codec =p_image->p_enc->fmt_in.i_codec;
 315             p_image->p_filter->fmt_out.video = p_image->p_enc->fmt_in.video;
 316         }
 317
 318         p_pic->i_refcount++; /* pf_video_filter() will call pf_release() */
 319         p_tmp_pic =
 320             p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
 321
 322         p_block = p_image->p_enc->pf_encode_video( p_image->p_enc, p_tmp_pic );
 323
 324         p_image->p_filter->pf_vout_buffer_del( p_image->p_filter, p_tmp_pic );
 325     }
 326     else
 327     {
 328         p_block = p_image->p_enc->pf_encode_video( p_image->p_enc, p_pic );
 329     }
 330
 331     if( !p_block )
 332     {
 333         msg_Dbg( p_image->p_parent, "no image encoded" );
 334         return 0;
 335     }
 336
 337     return p_block;
 338 }
 339
 340 static int ImageWriteUrl( image_handler_t *p_image, picture_t *p_pic,
 341                           video_format_t *p_fmt_in, video_format_t *p_fmt_out,
 342                           const char *psz_url )
 343 {
 344     block_t *p_block;
 345     FILE *file;
 346
 347     if( !p_fmt_out->i_chroma )
 348     {
 349         /* Try to guess format from file name */
 350         p_fmt_out->i_chroma = Ext2Fourcc( psz_url );
 351     }
 352
 353     file = utf8_fopen( psz_url, "wb" );
 354     if( !file )
 355     {
 356         msg_Err( p_image->p_parent, "%s: %m", psz_url );
 357         return VLC_EGENERIC;
 358     }
 359
 360     p_block = ImageWrite( p_image, p_pic, p_fmt_in, p_fmt_out );
 361
 362     int err = 0;
 363     if( p_block )
 364     {
 365         if( fwrite( p_block->p_buffer, p_block->i_buffer, 1, file ) != 1 )
 366             err = errno;
 367         block_Release( p_block );
 368     }
 369
 370     if( fclose( file ) && !err )
 371         err = errno;
 372
 373     if( err )
 374     {
 375        errno = err;
 376        msg_Err( p_image->p_parent, "%s: %m", psz_url );
 377     }
 378
 379     return err ? VLC_EGENERIC : VLC_SUCCESS;
 380 }
 381
 382 /**
 383  * Convert an image to a different format
 384  *
 385  */
 386
 387 static picture_t *ImageConvert( image_handler_t *p_image, picture_t *p_pic,
 388                                 video_format_t *p_fmt_in,
 389                                 video_format_t *p_fmt_out )
 390 {
 391     picture_t *p_pif;
 392
 393     if( !p_fmt_out->i_width && !p_fmt_out->i_height &&
 394         p_fmt_out->i_sar_num && p_fmt_out->i_sar_den &&
 395         p_fmt_out->i_sar_num * p_fmt_in->i_sar_den !=
 396         p_fmt_out->i_sar_den * p_fmt_in->i_sar_num )
 397     {
 398         p_fmt_out->i_width =
 399             p_fmt_in->i_sar_num * (int64_t)p_fmt_out->i_sar_den *
 400             p_fmt_in->i_width / p_fmt_in->i_sar_den / p_fmt_out->i_sar_num;
 401         p_fmt_out->i_visible_width =
 402             p_fmt_in->i_sar_num * (int64_t)p_fmt_out->i_sar_den *
 403             p_fmt_in->i_visible_width / p_fmt_in->i_sar_den /
 404             p_fmt_out->i_sar_num;
 405     }
 406
 407     if( !p_fmt_out->i_chroma ) p_fmt_out->i_chroma = p_fmt_in->i_chroma;
 408     if( !p_fmt_out->i_width )
 409         p_fmt_out->i_width = p_fmt_out->i_visible_width = p_fmt_in->i_width;
 410     if( !p_fmt_out->i_height )
 411         p_fmt_out->i_height = p_fmt_out->i_visible_height = p_fmt_in->i_height;
 412     if( !p_fmt_out->i_sar_num ) p_fmt_out->i_sar_num = p_fmt_in->i_sar_num;
 413     if( !p_fmt_out->i_sar_den ) p_fmt_out->i_sar_den = p_fmt_in->i_sar_den;
 414     if( !p_fmt_out->i_aspect ) p_fmt_out->i_aspect = p_fmt_in->i_aspect;
 415
 416     if( p_image->p_filter )
 417     if( p_image->p_filter->fmt_in.video.i_chroma != p_fmt_in->i_chroma ||
 418         p_image->p_filter->fmt_out.video.i_chroma != p_fmt_out->i_chroma )
 419     {
 420         /* We need to restart a new filter */
 421         DeleteFilter( p_image->p_filter );
 422         p_image->p_filter = NULL;
 423     }
 424
 425     /* Start a filter */
 426     if( !p_image->p_filter )
 427     {
 428         es_format_t fmt_in;
 429         es_format_Init( &fmt_in, VIDEO_ES, p_fmt_in->i_chroma );
 430         fmt_in.video = *p_fmt_in;
 431
 432         p_image->p_filter =
 433             CreateFilter( p_image->p_parent, &fmt_in, p_fmt_out, NULL );
 434
 435         if( !p_image->p_filter )
 436         {
 437             return NULL;
 438         }
 439     }
 440     else
 441     {
 442         /* Filters should handle on-the-fly size changes */
 443         p_image->p_filter->fmt_in.video = *p_fmt_in;
 444         p_image->p_filter->fmt_out.video = *p_fmt_out;
 445     }
 446
 447     p_pic->i_refcount++; /* pf_video_filter() will call pf_release() */
 448     p_pif = p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
 449
 450     if( p_fmt_in->i_chroma == p_fmt_out->i_chroma &&
 451         p_fmt_in->i_width == p_fmt_out->i_width &&
 452         p_fmt_in->i_height == p_fmt_out->i_height )
 453     {
 454         /* Duplicate image */
 455         p_pif->pf_release( p_pif ); /* XXX: Better fix must be possible */
 456         p_pif = p_image->p_filter->pf_vout_buffer_new( p_image->p_filter );
 457         if( p_pif ) vout_CopyPicture( p_image->p_parent, p_pif, p_pic );
 458     }
 459
 460     return p_pif;
 461 }
 462
 463 /**
 464  * Filter an image with a psz_module filter
 465  *
 466  */
 467
 468 static picture_t *ImageFilter( image_handler_t *p_image, picture_t *p_pic,
 469                                video_format_t *p_fmt, const char *psz_module )
 470 {
 471     /* Start a filter */
 472     if( !p_image->p_filter )
 473     {
 474         es_format_t fmt;
 475         es_format_Init( &fmt, VIDEO_ES, p_fmt->i_chroma );
 476         fmt.video = *p_fmt;
 477
 478         p_image->p_filter =
 479             CreateFilter( p_image->p_parent, &fmt, &fmt.video, psz_module );
 480
 481         if( !p_image->p_filter )
 482         {
 483             return NULL;
 484         }
 485     }
 486     else
 487     {
 488         /* Filters should handle on-the-fly size changes */
 489         p_image->p_filter->fmt_in.video = *p_fmt;
 490         p_image->p_filter->fmt_out.video = *p_fmt;
 491     }
 492
 493     p_pic->i_refcount++; /* pf_video_filter() will call pf_release() */
 494     return p_image->p_filter->pf_video_filter( p_image->p_filter, p_pic );
 495 }
 496
 497 /**
 498  * Misc functions
 499  *
 500  */
 501 static struct
 502 {
 503     vlc_fourcc_t i_codec;
 504     const char *psz_ext;
 505
 506 } ext_table[] =
 507 {
 508     { VLC_FOURCC('j','p','e','g'), "jpeg" },
 509     { VLC_FOURCC('j','p','e','g'), "jpg"  },
 510     { VLC_FOURCC('l','j','p','g'), "ljpg" },
 511     { VLC_FOURCC('p','n','g',' '), "png" },
 512     { VLC_FOURCC('p','g','m',' '), "pgm" },
 513     { VLC_FOURCC('p','g','m','y'), "pgmyuv" },
 514     { VLC_FOURCC('p','b','m',' '), "pbm" },
 515     { VLC_FOURCC('p','a','m',' '), "pam" },
 516     { VLC_FOURCC('t','g','a',' '), "tga" },
 517     { VLC_FOURCC('b','m','p',' '), "bmp" },
 518     { VLC_FOURCC('p','n','m',' '), "pnm" },
 519     { VLC_FOURCC('x','p','m',' '), "xpm" },
 520     { VLC_FOURCC('x','c','f',' '), "xcf" },
 521     { VLC_FOURCC('p','c','x',' '), "pcx" },
 522     { VLC_FOURCC('g','i','f',' '), "gif" },
 523     { VLC_FOURCC('t','i','f','f'), "tif" },
 524     { VLC_FOURCC('t','i','f','f'), "tiff" },
 525     { VLC_FOURCC('l','b','m',' '), "lbm" },
 526     { 0, NULL }
 527 };
 528
 529 static vlc_fourcc_t Ext2Fourcc( const char *psz_name )
 530 {
 531     int i;
 532
 533     psz_name = strrchr( psz_name, '.' );
 534     if( !psz_name ) return 0;
 535     psz_name++;
 536
 537     for( i = 0; ext_table[i].i_codec; i++ )
 538     {
 539         int j;
 540         for( j = 0; toupper(ext_table[i].psz_ext[j]) == toupper(psz_name[j]);
 541              j++ )
 542         {
 543             if( !ext_table[i].psz_ext[j] && !psz_name[j] )
 544                 return ext_table[i].i_codec;
 545         }
 546     }
 547
 548     return 0;
 549 }
 550
 551 /*
 552 static const char *Fourcc2Ext( vlc_fourcc_t i_codec )
 553 {
 554     int i;
 555
 556     for( i = 0; ext_table[i].i_codec != 0; i++ )
 557     {
 558         if( ext_table[i].i_codec == i_codec ) return ext_table[i].psz_ext;
 559     }
 560
 561     return NULL;
 562 }
 563 */
 564
 565 static void video_release_buffer( picture_t *p_pic )
 566 {
 567     if( --p_pic->i_refcount > 0 ) return;
 568
 569     free( p_pic->p_data_orig );
 570     free( p_pic->p_sys );
 571     free( p_pic );
 572 }
 573
 574 static picture_t *video_new_buffer( decoder_t *p_dec )
 575 {
 576     picture_t *p_pic = malloc( sizeof(picture_t) );
 577
 578     p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
 579     vout_AllocatePicture( VLC_OBJECT(p_dec), p_pic,
 580                           p_dec->fmt_out.video.i_chroma,
 581                           p_dec->fmt_out.video.i_width,
 582                           p_dec->fmt_out.video.i_height,
 583                           p_dec->fmt_out.video.i_aspect );
 584
 585     if( !p_pic->i_planes )
 586     {
 587         free( p_pic );
 588         return 0;
 589     }
 590
 591     p_pic->i_refcount = 1;
 592     p_pic->pf_release = video_release_buffer;
 593     p_pic->i_status = RESERVED_PICTURE;
 594     p_pic->p_sys = NULL;
 595
 596     return p_pic;
 597 }
 598
 599 static void video_del_buffer( decoder_t *p_dec, picture_t *p_pic )
 600 {
 601     (void)p_dec;
 602     free( p_pic->p_data_orig );
 603     free( p_pic->p_sys );
 604     free( p_pic );
 605 }
 606
 607 static void video_link_picture( decoder_t *p_dec, picture_t *p_pic )
 608 {
 609     (void)p_dec;
 610     p_pic->i_refcount++;
 611 }
 612
 613 static void video_unlink_picture( decoder_t *p_dec, picture_t *p_pic )
 614 {
 615     (void)p_dec; (void)p_pic;
 616     video_release_buffer( p_pic );
 617 }
 618
 619 static decoder_t *CreateDecoder( vlc_object_t *p_this, video_format_t *fmt )
 620 {
 621     decoder_t *p_dec;
 622
 623     p_dec = vlc_object_create( p_this, VLC_OBJECT_DECODER );
 624     if( p_dec == NULL )
 625         return NULL;
 626
 627     p_dec->p_module = NULL;
 628     es_format_Init( &p_dec->fmt_in, VIDEO_ES, fmt->i_chroma );
 629     es_format_Init( &p_dec->fmt_out, VIDEO_ES, 0 );
 630     p_dec->fmt_in.video = *fmt;
 631     p_dec->b_pace_control = true;
 632
 633     p_dec->pf_vout_buffer_new = video_new_buffer;
 634     p_dec->pf_vout_buffer_del = video_del_buffer;
 635     p_dec->pf_picture_link    = video_link_picture;
 636     p_dec->pf_picture_unlink  = video_unlink_picture;
 637
 638     vlc_object_attach( p_dec, p_this );
 639
 640     /* Find a suitable decoder module */
 641     p_dec->p_module = module_Need( p_dec, "decoder", "$codec", 0 );
 642     if( !p_dec->p_module )
 643     {
 644         msg_Err( p_dec, "no suitable decoder module for fourcc `%4.4s'.\n"
 645                  "VLC probably does not support this image format.",
 646                  (char*)&p_dec->fmt_in.i_codec );
 647
 648         DeleteDecoder( p_dec );
 649         return NULL;
 650     }
 651
 652     return p_dec;
 653 }
 654
 655 static void DeleteDecoder( decoder_t * p_dec )
 656 {
 657     vlc_object_detach( p_dec );
 658
 659     if( p_dec->p_module ) module_Unneed( p_dec, p_dec->p_module );
 660
 661     es_format_Clean( &p_dec->fmt_in );
 662     es_format_Clean( &p_dec->fmt_out );
 663
 664     vlc_object_release( p_dec );
 665     p_dec = NULL;
 666 }
 667
 668 static encoder_t *CreateEncoder( vlc_object_t *p_this, video_format_t *fmt_in,
 669                                  video_format_t *fmt_out )
 670 {
 671     encoder_t *p_enc;
 672
 673     p_enc = vlc_object_create( p_this, VLC_OBJECT_ENCODER );
 674     if( p_enc == NULL )
 675         return NULL;
 676
 677     p_enc->p_module = NULL;
 678     es_format_Init( &p_enc->fmt_in, VIDEO_ES, fmt_in->i_chroma );
 679     p_enc->fmt_in.video = *fmt_in;
 680     if( fmt_out->i_width > 0 && fmt_out->i_height > 0 )
 681     {
 682         p_enc->fmt_in.video.i_width = fmt_out->i_width;
 683         p_enc->fmt_in.video.i_height = fmt_out->i_height;
 684
 685         if( fmt_out->i_visible_width > 0 &&
 686             fmt_out->i_visible_height > 0 )
 687         {
 688             p_enc->fmt_in.video.i_visible_width = fmt_out->i_visible_width;
 689             p_enc->fmt_in.video.i_visible_height = fmt_out->i_visible_height;
 690         }
 691         else
 692         {
 693             p_enc->fmt_in.video.i_visible_width = fmt_out->i_width;
 694             p_enc->fmt_in.video.i_visible_height = fmt_out->i_height;
 695         }
 696     }
 697     else if( fmt_out->i_sar_num && fmt_out->i_sar_den &&
 698              fmt_out->i_sar_num * fmt_in->i_sar_den !=
 699              fmt_out->i_sar_den * fmt_in->i_sar_num )
 700     {
 701         p_enc->fmt_in.video.i_width =
 702             fmt_in->i_sar_num * (int64_t)fmt_out->i_sar_den * fmt_in->i_width /
 703             fmt_in->i_sar_den / fmt_out->i_sar_num;
 704         p_enc->fmt_in.video.i_visible_width =
 705             fmt_in->i_sar_num * (int64_t)fmt_out->i_sar_den *
 706             fmt_in->i_visible_width / fmt_in->i_sar_den / fmt_out->i_sar_num;
 707     }
 708
 709     p_enc->fmt_in.video.i_frame_rate = 25;
 710     p_enc->fmt_in.video.i_frame_rate_base = 1;
 711
 712     es_format_Init( &p_enc->fmt_out, VIDEO_ES, fmt_out->i_chroma );
 713     p_enc->fmt_out.video = *fmt_out;
 714     p_enc->fmt_out.video.i_width = p_enc->fmt_in.video.i_width;
 715     p_enc->fmt_out.video.i_height = p_enc->fmt_in.video.i_height;
 716
 717     vlc_object_attach( p_enc, p_this );
 718
 719     /* Find a suitable decoder module */
 720     p_enc->p_module = module_Need( p_enc, "encoder", 0, 0 );
 721     if( !p_enc->p_module )
 722     {
 723         msg_Err( p_enc, "no suitable encoder module for fourcc `%4.4s'.\n"
 724                  "VLC probably does not support this image format.",
 725                  (char*)&p_enc->fmt_out.i_codec );
 726
 727         DeleteEncoder( p_enc );
 728         return NULL;
 729     }
 730     p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
 731
 732     return p_enc;
 733 }
 734
 735 static void DeleteEncoder( encoder_t * p_enc )
 736 {
 737     vlc_object_detach( p_enc );
 738
 739     if( p_enc->p_module ) module_Unneed( p_enc, p_enc->p_module );
 740
 741     es_format_Clean( &p_enc->fmt_in );
 742     es_format_Clean( &p_enc->fmt_out );
 743
 744     vlc_object_release( p_enc );
 745     p_enc = NULL;
 746 }
 747
 748 static filter_t *CreateFilter( vlc_object_t *p_this, es_format_t *p_fmt_in,
 749                                video_format_t *p_fmt_out,
 750                                const char *psz_module )
 751 {
 752     filter_t *p_filter;
 753
 754     p_filter = vlc_object_create( p_this, VLC_OBJECT_FILTER );
 755     vlc_object_attach( p_filter, p_this );
 756
 757     p_filter->pf_vout_buffer_new =
 758         (picture_t *(*)(filter_t *))video_new_buffer;
 759     p_filter->pf_vout_buffer_del =
 760         (void (*)(filter_t *, picture_t *))video_del_buffer;
 761
 762     p_filter->fmt_in = *p_fmt_in;
 763     p_filter->fmt_out = *p_fmt_in;
 764     p_filter->fmt_out.i_codec = p_fmt_out->i_chroma;
 765     p_filter->fmt_out.video = *p_fmt_out;
 766     p_filter->p_module = module_Need( p_filter, "video filter2",
 767                                       psz_module, 0 );
 768
 769     if( !p_filter->p_module )
 770     {
 771         msg_Dbg( p_filter, "no video filter found" );
 772         DeleteFilter( p_filter );
 773         return NULL;
 774     }
 775
 776     return p_filter;
 777 }
 778
 779 static void DeleteFilter( filter_t * p_filter )
 780 {
 781     vlc_object_detach( p_filter );
 782
 783     if( p_filter->p_module ) module_Unneed( p_filter, p_filter->p_module );
 784
 785     es_format_Clean( &p_filter->fmt_in );
 786     es_format_Clean( &p_filter->fmt_out );
 787
 788     vlc_object_release( p_filter );
 789 }