1 /*****************************************************************************
2 * image.c : wrapper for image reading/writing facilities
3 *****************************************************************************
4 * Copyright (C) 2004-2007 VLC authors and VideoLAN
7 * Author: Gildas Bazin <gbazin@videolan.org>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
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 Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
26 * This file contains the functions to handle the image_handler_t type
29 /*****************************************************************************
31 *****************************************************************************/
39 #include <vlc_common.h>
40 #include <vlc_codec.h>
42 #include <vlc_filter.h>
44 #include <vlc_image.h>
45 #include <vlc_stream.h>
49 #include <vlc_modules.h>
51 static picture_t
*ImageRead( image_handler_t
*, block_t
*,
52 video_format_t
*, video_format_t
* );
53 static picture_t
*ImageReadUrl( image_handler_t
*, const char *,
54 video_format_t
*, video_format_t
* );
55 static block_t
*ImageWrite( image_handler_t
*, picture_t
*,
56 video_format_t
*, video_format_t
* );
57 static int ImageWriteUrl( image_handler_t
*, picture_t
*,
58 video_format_t
*, video_format_t
*, const char * );
60 static picture_t
*ImageConvert( image_handler_t
*, picture_t
*,
61 video_format_t
*, video_format_t
* );
62 static picture_t
*ImageFilter( image_handler_t
*, picture_t
*,
63 video_format_t
*, const char *psz_module
);
65 static decoder_t
*CreateDecoder( vlc_object_t
*, video_format_t
* );
66 static void DeleteDecoder( decoder_t
* );
67 static encoder_t
*CreateEncoder( vlc_object_t
*, video_format_t
*,
69 static void DeleteEncoder( encoder_t
* );
70 static filter_t
*CreateFilter( vlc_object_t
*, es_format_t
*,
71 video_format_t
*, const char * );
72 static void DeleteFilter( filter_t
* );
74 vlc_fourcc_t
image_Type2Fourcc( const char * );
75 vlc_fourcc_t
image_Ext2Fourcc( const char * );
76 /*static const char *Fourcc2Ext( vlc_fourcc_t );*/
78 #undef image_HandlerCreate
80 * Create an image_handler_t instance
83 image_handler_t
*image_HandlerCreate( vlc_object_t
*p_this
)
85 image_handler_t
*p_image
= calloc( 1, sizeof(image_handler_t
) );
89 p_image
->p_parent
= p_this
;
91 p_image
->pf_read
= ImageRead
;
92 p_image
->pf_read_url
= ImageReadUrl
;
93 p_image
->pf_write
= ImageWrite
;
94 p_image
->pf_write_url
= ImageWriteUrl
;
95 p_image
->pf_convert
= ImageConvert
;
96 p_image
->pf_filter
= ImageFilter
;
102 * Delete the image_handler_t instance
105 void image_HandlerDelete( image_handler_t
*p_image
)
107 if( !p_image
) return;
109 if( p_image
->p_dec
) DeleteDecoder( p_image
->p_dec
);
110 if( p_image
->p_enc
) DeleteEncoder( p_image
->p_enc
);
111 if( p_image
->p_filter
) DeleteFilter( p_image
->p_filter
);
122 static picture_t
*ImageRead( image_handler_t
*p_image
, block_t
*p_block
,
123 video_format_t
*p_fmt_in
,
124 video_format_t
*p_fmt_out
)
126 picture_t
*p_pic
= NULL
, *p_tmp
;
128 /* Check if we can reuse the current decoder */
129 if( p_image
->p_dec
&&
130 p_image
->p_dec
->fmt_in
.i_codec
!= p_fmt_in
->i_chroma
)
132 DeleteDecoder( p_image
->p_dec
);
136 /* Start a decoder */
137 if( !p_image
->p_dec
)
139 p_image
->p_dec
= CreateDecoder( p_image
->p_parent
, p_fmt_in
);
140 if( !p_image
->p_dec
) return NULL
;
143 p_block
->i_pts
= p_block
->i_dts
= mdate();
144 while( (p_tmp
= p_image
->p_dec
->pf_decode_video( p_image
->p_dec
, &p_block
))
148 picture_Release( p_pic
);
154 msg_Warn( p_image
->p_parent
, "no image decoded" );
158 if( !p_fmt_out
->i_chroma
)
159 p_fmt_out
->i_chroma
= p_image
->p_dec
->fmt_out
.video
.i_chroma
;
160 if( !p_fmt_out
->i_width
&& p_fmt_out
->i_height
)
161 p_fmt_out
->i_width
= (int64_t)p_image
->p_dec
->fmt_out
.video
.i_width
*
162 p_image
->p_dec
->fmt_out
.video
.i_sar_num
*
163 p_fmt_out
->i_height
/
164 p_image
->p_dec
->fmt_out
.video
.i_height
/
165 p_image
->p_dec
->fmt_out
.video
.i_sar_den
;
167 if( !p_fmt_out
->i_height
&& p_fmt_out
->i_width
)
168 p_fmt_out
->i_height
= (int64_t)p_image
->p_dec
->fmt_out
.video
.i_height
*
169 p_image
->p_dec
->fmt_out
.video
.i_sar_den
*
171 p_image
->p_dec
->fmt_out
.video
.i_width
/
172 p_image
->p_dec
->fmt_out
.video
.i_sar_num
;
173 if( !p_fmt_out
->i_width
)
174 p_fmt_out
->i_width
= p_image
->p_dec
->fmt_out
.video
.i_width
;
175 if( !p_fmt_out
->i_height
)
176 p_fmt_out
->i_height
= p_image
->p_dec
->fmt_out
.video
.i_height
;
178 /* Check if we need chroma conversion or resizing */
179 if( p_image
->p_dec
->fmt_out
.video
.i_chroma
!= p_fmt_out
->i_chroma
||
180 p_image
->p_dec
->fmt_out
.video
.i_width
!= p_fmt_out
->i_width
||
181 p_image
->p_dec
->fmt_out
.video
.i_height
!= p_fmt_out
->i_height
)
183 if( p_image
->p_filter
)
184 if( p_image
->p_filter
->fmt_in
.video
.i_chroma
!=
185 p_image
->p_dec
->fmt_out
.video
.i_chroma
||
186 p_image
->p_filter
->fmt_out
.video
.i_chroma
!= p_fmt_out
->i_chroma
)
188 /* We need to restart a new filter */
189 DeleteFilter( p_image
->p_filter
);
190 p_image
->p_filter
= 0;
194 if( !p_image
->p_filter
)
197 CreateFilter( p_image
->p_parent
, &p_image
->p_dec
->fmt_out
,
200 if( !p_image
->p_filter
)
202 picture_Release( p_pic
);
208 /* Filters should handle on-the-fly size changes */
209 p_image
->p_filter
->fmt_in
= p_image
->p_dec
->fmt_out
;
210 p_image
->p_filter
->fmt_out
= p_image
->p_dec
->fmt_out
;
211 p_image
->p_filter
->fmt_out
.i_codec
= p_fmt_out
->i_chroma
;
212 p_image
->p_filter
->fmt_out
.video
= *p_fmt_out
;
215 p_pic
= p_image
->p_filter
->pf_video_filter( p_image
->p_filter
, p_pic
);
216 *p_fmt_out
= p_image
->p_filter
->fmt_out
.video
;
218 else *p_fmt_out
= p_image
->p_dec
->fmt_out
.video
;
223 static picture_t
*ImageReadUrl( image_handler_t
*p_image
, const char *psz_url
,
224 video_format_t
*p_fmt_in
,
225 video_format_t
*p_fmt_out
)
229 stream_t
*p_stream
= NULL
;
232 p_stream
= stream_UrlNew( p_image
->p_parent
, psz_url
);
236 msg_Dbg( p_image
->p_parent
, "could not open %s for reading",
241 i_size
= stream_Size( p_stream
);
243 p_block
= block_New( p_image
->p_parent
, i_size
);
245 stream_Read( p_stream
, p_block
->p_buffer
, i_size
);
247 if( !p_fmt_in
->i_chroma
)
249 char *psz_mime
= NULL
;
250 stream_Control( p_stream
, STREAM_GET_CONTENT_TYPE
, &psz_mime
);
252 p_fmt_in
->i_chroma
= image_Mime2Fourcc( psz_mime
);
255 stream_Delete( p_stream
);
257 if( !p_fmt_in
->i_chroma
)
259 /* Try to guess format from file name */
260 p_fmt_in
->i_chroma
= image_Ext2Fourcc( psz_url
);
263 p_pic
= ImageRead( p_image
, p_block
, p_fmt_in
, p_fmt_out
);
273 static block_t
*ImageWrite( image_handler_t
*p_image
, picture_t
*p_pic
,
274 video_format_t
*p_fmt_in
,
275 video_format_t
*p_fmt_out
)
279 /* Check if we can reuse the current encoder */
280 if( p_image
->p_enc
&&
281 ( p_image
->p_enc
->fmt_out
.i_codec
!= p_fmt_out
->i_chroma
||
282 p_image
->p_enc
->fmt_out
.video
.i_width
!= p_fmt_out
->i_width
||
283 p_image
->p_enc
->fmt_out
.video
.i_height
!= p_fmt_out
->i_height
) )
285 DeleteEncoder( p_image
->p_enc
);
289 /* Start an encoder */
290 if( !p_image
->p_enc
)
292 p_image
->p_enc
= CreateEncoder( p_image
->p_parent
,
293 p_fmt_in
, p_fmt_out
);
294 if( !p_image
->p_enc
) return NULL
;
297 /* Check if we need chroma conversion or resizing */
298 if( p_image
->p_enc
->fmt_in
.video
.i_chroma
!= p_fmt_in
->i_chroma
||
299 p_image
->p_enc
->fmt_in
.video
.i_width
!= p_fmt_in
->i_width
||
300 p_image
->p_enc
->fmt_in
.video
.i_height
!= p_fmt_in
->i_height
)
302 picture_t
*p_tmp_pic
;
304 if( p_image
->p_filter
)
305 if( p_image
->p_filter
->fmt_in
.video
.i_chroma
!= p_fmt_in
->i_chroma
||
306 p_image
->p_filter
->fmt_out
.video
.i_chroma
!=
307 p_image
->p_enc
->fmt_in
.video
.i_chroma
)
309 /* We need to restart a new filter */
310 DeleteFilter( p_image
->p_filter
);
311 p_image
->p_filter
= 0;
315 if( !p_image
->p_filter
)
318 es_format_Init( &fmt_in
, VIDEO_ES
, p_fmt_in
->i_chroma
);
319 fmt_in
.video
= *p_fmt_in
;
322 CreateFilter( p_image
->p_parent
, &fmt_in
,
323 &p_image
->p_enc
->fmt_in
.video
, NULL
);
325 if( !p_image
->p_filter
)
332 /* Filters should handle on-the-fly size changes */
333 p_image
->p_filter
->fmt_in
.i_codec
= p_fmt_in
->i_chroma
;
334 p_image
->p_filter
->fmt_out
.video
= *p_fmt_in
;
335 p_image
->p_filter
->fmt_out
.i_codec
=p_image
->p_enc
->fmt_in
.i_codec
;
336 p_image
->p_filter
->fmt_out
.video
= p_image
->p_enc
->fmt_in
.video
;
339 picture_Hold( p_pic
);
342 p_image
->p_filter
->pf_video_filter( p_image
->p_filter
, p_pic
);
344 if( likely(p_tmp_pic
!= NULL
) )
346 p_block
= p_image
->p_enc
->pf_encode_video( p_image
->p_enc
,
348 p_image
->p_filter
->pf_video_buffer_del( p_image
->p_filter
,
356 p_block
= p_image
->p_enc
->pf_encode_video( p_image
->p_enc
, p_pic
);
361 msg_Dbg( p_image
->p_parent
, "no image encoded" );
368 static int ImageWriteUrl( image_handler_t
*p_image
, picture_t
*p_pic
,
369 video_format_t
*p_fmt_in
, video_format_t
*p_fmt_out
,
370 const char *psz_url
)
375 if( !p_fmt_out
->i_chroma
)
377 /* Try to guess format from file name */
378 p_fmt_out
->i_chroma
= image_Ext2Fourcc( psz_url
);
381 file
= vlc_fopen( psz_url
, "wb" );
384 msg_Err( p_image
->p_parent
, "%s: %m", psz_url
);
388 p_block
= ImageWrite( p_image
, p_pic
, p_fmt_in
, p_fmt_out
);
393 if( fwrite( p_block
->p_buffer
, p_block
->i_buffer
, 1, file
) != 1 )
395 block_Release( p_block
);
398 if( fclose( file
) && !err
)
404 msg_Err( p_image
->p_parent
, "%s: %m", psz_url
);
407 return err
? VLC_EGENERIC
: VLC_SUCCESS
;
411 * Convert an image to a different format
415 static picture_t
*ImageConvert( image_handler_t
*p_image
, picture_t
*p_pic
,
416 video_format_t
*p_fmt_in
,
417 video_format_t
*p_fmt_out
)
421 if( !p_fmt_out
->i_width
&& !p_fmt_out
->i_height
&&
422 p_fmt_out
->i_sar_num
&& p_fmt_out
->i_sar_den
&&
423 p_fmt_out
->i_sar_num
* p_fmt_in
->i_sar_den
!=
424 p_fmt_out
->i_sar_den
* p_fmt_in
->i_sar_num
)
427 p_fmt_in
->i_sar_num
* (int64_t)p_fmt_out
->i_sar_den
*
428 p_fmt_in
->i_width
/ p_fmt_in
->i_sar_den
/ p_fmt_out
->i_sar_num
;
429 p_fmt_out
->i_visible_width
=
430 p_fmt_in
->i_sar_num
* (int64_t)p_fmt_out
->i_sar_den
*
431 p_fmt_in
->i_visible_width
/ p_fmt_in
->i_sar_den
/
432 p_fmt_out
->i_sar_num
;
435 if( !p_fmt_out
->i_chroma
) p_fmt_out
->i_chroma
= p_fmt_in
->i_chroma
;
436 if( !p_fmt_out
->i_width
)
437 p_fmt_out
->i_width
= p_fmt_out
->i_visible_width
= p_fmt_in
->i_width
;
438 if( !p_fmt_out
->i_height
)
439 p_fmt_out
->i_height
= p_fmt_out
->i_visible_height
= p_fmt_in
->i_height
;
440 if( !p_fmt_out
->i_sar_num
) p_fmt_out
->i_sar_num
= p_fmt_in
->i_sar_num
;
441 if( !p_fmt_out
->i_sar_den
) p_fmt_out
->i_sar_den
= p_fmt_in
->i_sar_den
;
443 if( p_image
->p_filter
)
444 if( p_image
->p_filter
->fmt_in
.video
.i_chroma
!= p_fmt_in
->i_chroma
||
445 p_image
->p_filter
->fmt_out
.video
.i_chroma
!= p_fmt_out
->i_chroma
)
447 /* We need to restart a new filter */
448 DeleteFilter( p_image
->p_filter
);
449 p_image
->p_filter
= NULL
;
453 if( !p_image
->p_filter
)
456 es_format_Init( &fmt_in
, VIDEO_ES
, p_fmt_in
->i_chroma
);
457 fmt_in
.video
= *p_fmt_in
;
460 CreateFilter( p_image
->p_parent
, &fmt_in
, p_fmt_out
, NULL
);
462 if( !p_image
->p_filter
)
469 /* Filters should handle on-the-fly size changes */
470 p_image
->p_filter
->fmt_in
.video
= *p_fmt_in
;
471 p_image
->p_filter
->fmt_out
.video
= *p_fmt_out
;
474 picture_Hold( p_pic
);
476 p_pif
= p_image
->p_filter
->pf_video_filter( p_image
->p_filter
, p_pic
);
478 if( p_fmt_in
->i_chroma
== p_fmt_out
->i_chroma
&&
479 p_fmt_in
->i_width
== p_fmt_out
->i_width
&&
480 p_fmt_in
->i_height
== p_fmt_out
->i_height
)
482 /* Duplicate image */
483 picture_Release( p_pif
); /* XXX: Better fix must be possible */
484 p_pif
= p_image
->p_filter
->pf_video_buffer_new( p_image
->p_filter
);
486 picture_Copy( p_pif
, p_pic
);
493 * Filter an image with a psz_module filter
497 static picture_t
*ImageFilter( image_handler_t
*p_image
, picture_t
*p_pic
,
498 video_format_t
*p_fmt
, const char *psz_module
)
501 if( !p_image
->p_filter
)
504 es_format_Init( &fmt
, VIDEO_ES
, p_fmt
->i_chroma
);
508 CreateFilter( p_image
->p_parent
, &fmt
, &fmt
.video
, psz_module
);
510 if( !p_image
->p_filter
)
517 /* Filters should handle on-the-fly size changes */
518 p_image
->p_filter
->fmt_in
.video
= *p_fmt
;
519 p_image
->p_filter
->fmt_out
.video
= *p_fmt
;
522 picture_Hold( p_pic
);
524 return p_image
->p_filter
->pf_video_filter( p_image
->p_filter
, p_pic
);
533 vlc_fourcc_t i_codec
;
538 { VLC_CODEC_JPEG
, "jpeg" },
539 { VLC_CODEC_JPEG
, "jpg" },
540 { VLC_CODEC_JPEGLS
, "ljpg" },
541 { VLC_CODEC_PNG
, "png" },
542 { VLC_CODEC_PGM
, "pgm" },
543 { VLC_CODEC_PGMYUV
, "pgmyuv" },
544 { VLC_FOURCC('p','b','m',' '), "pbm" },
545 { VLC_FOURCC('p','a','m',' '), "pam" },
546 { VLC_CODEC_TARGA
, "tga" },
547 { VLC_CODEC_BMP
, "bmp" },
548 { VLC_CODEC_PNM
, "pnm" },
549 { VLC_FOURCC('x','p','m',' '), "xpm" },
550 { VLC_FOURCC('x','c','f',' '), "xcf" },
551 { VLC_CODEC_PCX
, "pcx" },
552 { VLC_CODEC_GIF
, "gif" },
553 { VLC_CODEC_TIFF
, "tif" },
554 { VLC_CODEC_TIFF
, "tiff" },
555 { VLC_FOURCC('l','b','m',' '), "lbm" },
556 { VLC_CODEC_PPM
, "ppm" },
560 vlc_fourcc_t
image_Type2Fourcc( const char *psz_type
)
564 for( i
= 0; ext_table
[i
].i_codec
; i
++ )
565 if( !strcasecmp( ext_table
[i
].psz_ext
, psz_type
) )
566 return ext_table
[i
].i_codec
;
571 vlc_fourcc_t
image_Ext2Fourcc( const char *psz_name
)
573 psz_name
= strrchr( psz_name
, '.' );
574 if( !psz_name
) return 0;
577 return image_Type2Fourcc( psz_name
);
581 static const char *Fourcc2Ext( vlc_fourcc_t i_codec )
585 for( i = 0; ext_table[i].i_codec != 0; i++ )
587 if( ext_table[i].i_codec == i_codec ) return ext_table[i].psz_ext;
596 vlc_fourcc_t i_codec
;
597 const char *psz_mime
;
600 { VLC_CODEC_BMP
, "image/bmp" },
601 { VLC_CODEC_BMP
, "image/x-bmp" },
602 { VLC_CODEC_BMP
, "image/x-bitmap" },
603 { VLC_CODEC_BMP
, "image/x-ms-bmp" },
604 { VLC_CODEC_PNM
, "image/x-portable-anymap" },
605 { VLC_CODEC_PNM
, "image/x-portable-bitmap" },
606 { VLC_CODEC_PNM
, "image/x-portable-graymap" },
607 { VLC_CODEC_PNM
, "image/x-portable-pixmap" },
608 { VLC_CODEC_GIF
, "image/gif" },
609 { VLC_CODEC_JPEG
, "image/jpeg" },
610 { VLC_CODEC_PCX
, "image/pcx" },
611 { VLC_CODEC_PNG
, "image/png" },
612 { VLC_CODEC_TIFF
, "image/tiff" },
613 { VLC_CODEC_TARGA
, "image/x-tga" },
614 { VLC_FOURCC('x','p','m',' '), "image/x-xpixmap" },
618 vlc_fourcc_t
image_Mime2Fourcc( const char *psz_mime
)
621 for( i
= 0; mime_table
[i
].i_codec
; i
++ )
622 if( !strcmp( psz_mime
, mime_table
[i
].psz_mime
) )
623 return mime_table
[i
].i_codec
;
628 static picture_t
*video_new_buffer( decoder_t
*p_dec
)
630 p_dec
->fmt_out
.video
.i_chroma
= p_dec
->fmt_out
.i_codec
;
631 return picture_NewFromFormat( &p_dec
->fmt_out
.video
);
634 static void video_del_buffer( decoder_t
*p_dec
, picture_t
*p_pic
)
637 picture_Release( p_pic
);
640 static void video_link_picture( decoder_t
*p_dec
, picture_t
*p_pic
)
643 picture_Hold( p_pic
);
646 static void video_unlink_picture( decoder_t
*p_dec
, picture_t
*p_pic
)
649 picture_Release( p_pic
);
652 static decoder_t
*CreateDecoder( vlc_object_t
*p_this
, video_format_t
*fmt
)
656 p_dec
= vlc_custom_create( p_this
, sizeof( *p_dec
), "image decoder" );
660 p_dec
->p_module
= NULL
;
661 es_format_Init( &p_dec
->fmt_in
, VIDEO_ES
, fmt
->i_chroma
);
662 es_format_Init( &p_dec
->fmt_out
, VIDEO_ES
, 0 );
663 p_dec
->fmt_in
.video
= *fmt
;
664 p_dec
->b_pace_control
= true;
666 p_dec
->pf_vout_buffer_new
= video_new_buffer
;
667 p_dec
->pf_vout_buffer_del
= video_del_buffer
;
668 p_dec
->pf_picture_link
= video_link_picture
;
669 p_dec
->pf_picture_unlink
= video_unlink_picture
;
671 /* Find a suitable decoder module */
672 p_dec
->p_module
= module_need( p_dec
, "decoder", "$codec", false );
673 if( !p_dec
->p_module
)
675 msg_Err( p_dec
, "no suitable decoder module for fourcc `%4.4s'. "
676 "VLC probably does not support this image format.",
677 (char*)&p_dec
->fmt_in
.i_codec
);
679 DeleteDecoder( p_dec
);
686 static void DeleteDecoder( decoder_t
* p_dec
)
688 if( p_dec
->p_module
) module_unneed( p_dec
, p_dec
->p_module
);
690 es_format_Clean( &p_dec
->fmt_in
);
691 es_format_Clean( &p_dec
->fmt_out
);
693 if( p_dec
->p_description
)
694 vlc_meta_Delete( p_dec
->p_description
);
696 vlc_object_release( p_dec
);
700 static encoder_t
*CreateEncoder( vlc_object_t
*p_this
, video_format_t
*fmt_in
,
701 video_format_t
*fmt_out
)
705 p_enc
= sout_EncoderCreate( p_this
);
709 p_enc
->p_module
= NULL
;
710 es_format_Init( &p_enc
->fmt_in
, VIDEO_ES
, fmt_in
->i_chroma
);
711 p_enc
->fmt_in
.video
= *fmt_in
;
712 if( fmt_out
->i_width
> 0 && fmt_out
->i_height
> 0 )
714 p_enc
->fmt_in
.video
.i_width
= fmt_out
->i_width
;
715 p_enc
->fmt_in
.video
.i_height
= fmt_out
->i_height
;
717 if( fmt_out
->i_visible_width
> 0 &&
718 fmt_out
->i_visible_height
> 0 )
720 p_enc
->fmt_in
.video
.i_visible_width
= fmt_out
->i_visible_width
;
721 p_enc
->fmt_in
.video
.i_visible_height
= fmt_out
->i_visible_height
;
725 p_enc
->fmt_in
.video
.i_visible_width
= fmt_out
->i_width
;
726 p_enc
->fmt_in
.video
.i_visible_height
= fmt_out
->i_height
;
729 else if( fmt_out
->i_sar_num
&& fmt_out
->i_sar_den
&&
730 fmt_out
->i_sar_num
* fmt_in
->i_sar_den
!=
731 fmt_out
->i_sar_den
* fmt_in
->i_sar_num
)
733 p_enc
->fmt_in
.video
.i_width
=
734 fmt_in
->i_sar_num
* (int64_t)fmt_out
->i_sar_den
* fmt_in
->i_width
/
735 fmt_in
->i_sar_den
/ fmt_out
->i_sar_num
;
736 p_enc
->fmt_in
.video
.i_visible_width
=
737 fmt_in
->i_sar_num
* (int64_t)fmt_out
->i_sar_den
*
738 fmt_in
->i_visible_width
/ fmt_in
->i_sar_den
/ fmt_out
->i_sar_num
;
741 p_enc
->fmt_in
.video
.i_frame_rate
= 25;
742 p_enc
->fmt_in
.video
.i_frame_rate_base
= 1;
744 es_format_Init( &p_enc
->fmt_out
, VIDEO_ES
, fmt_out
->i_chroma
);
745 p_enc
->fmt_out
.video
= *fmt_out
;
746 p_enc
->fmt_out
.video
.i_width
= p_enc
->fmt_in
.video
.i_width
;
747 p_enc
->fmt_out
.video
.i_height
= p_enc
->fmt_in
.video
.i_height
;
749 /* Find a suitable decoder module */
750 p_enc
->p_module
= module_need( p_enc
, "encoder", NULL
, false );
751 if( !p_enc
->p_module
)
753 msg_Err( p_enc
, "no suitable encoder module for fourcc `%4.4s'.\n"
754 "VLC probably does not support this image format.",
755 (char*)&p_enc
->fmt_out
.i_codec
);
757 DeleteEncoder( p_enc
);
760 p_enc
->fmt_in
.video
.i_chroma
= p_enc
->fmt_in
.i_codec
;
765 static void DeleteEncoder( encoder_t
* p_enc
)
767 if( p_enc
->p_module
) module_unneed( p_enc
, p_enc
->p_module
);
769 es_format_Clean( &p_enc
->fmt_in
);
770 es_format_Clean( &p_enc
->fmt_out
);
772 vlc_object_release( p_enc
);
776 static filter_t
*CreateFilter( vlc_object_t
*p_this
, es_format_t
*p_fmt_in
,
777 video_format_t
*p_fmt_out
,
778 const char *psz_module
)
782 p_filter
= vlc_custom_create( p_this
, sizeof(filter_t
), "filter" );
783 p_filter
->pf_video_buffer_new
=
784 (picture_t
*(*)(filter_t
*))video_new_buffer
;
785 p_filter
->pf_video_buffer_del
=
786 (void (*)(filter_t
*, picture_t
*))video_del_buffer
;
788 p_filter
->fmt_in
= *p_fmt_in
;
789 p_filter
->fmt_out
= *p_fmt_in
;
790 p_filter
->fmt_out
.i_codec
= p_fmt_out
->i_chroma
;
791 p_filter
->fmt_out
.video
= *p_fmt_out
;
792 p_filter
->p_module
= module_need( p_filter
, "video filter2",
795 if( !p_filter
->p_module
)
797 msg_Dbg( p_filter
, "no video filter found" );
798 DeleteFilter( p_filter
);
805 static void DeleteFilter( filter_t
* p_filter
)
807 if( p_filter
->p_module
) module_unneed( p_filter
, p_filter
->p_module
);
809 es_format_Clean( &p_filter
->fmt_in
);
810 es_format_Clean( &p_filter
->fmt_out
);
812 vlc_object_release( p_filter
);