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