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