* transcode: use mp1v/mpgv for mpeg1 and mp2v for mpeg2 video encoding.
[vlc.git] / modules / stream_out / transcode.c
1 /*****************************************************************************
2  * transcode.c
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VideoLAN
5  * $Id: transcode.c,v 1.31 2003/08/26 18:01:16 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include <vlc/input.h>
32 #include <vlc/sout.h>
33
34 /* ffmpeg header */
35 #ifdef HAVE_FFMPEG_AVCODEC_H
36 #   include <ffmpeg/avcodec.h>
37 #else
38 #   include <avcodec.h>
39 #endif
40
41 /* vorbis header */
42 #ifdef HAVE_VORBIS_VORBISENC_H
43 #   include <vorbis/vorbisenc.h>
44 #   ifndef OV_ECTL_RATEMANAGE_AVG
45 #       define OV_ECTL_RATEMANAGE_AVG 0x0
46 #   endif
47 #endif
48
49 /*****************************************************************************
50  * Exported prototypes
51  *****************************************************************************/
52 static int      Open    ( vlc_object_t * );
53 static void     Close   ( vlc_object_t * );
54
55 static sout_stream_id_t *Add ( sout_stream_t *, sout_format_t * );
56 static int               Del ( sout_stream_t *, sout_stream_id_t * );
57 static int               Send( sout_stream_t *, sout_stream_id_t *, sout_buffer_t* );
58
59 static int  transcode_audio_ffmpeg_new    ( sout_stream_t *, sout_stream_id_t * );
60 static void transcode_audio_ffmpeg_close  ( sout_stream_t *, sout_stream_id_t * );
61 static int  transcode_audio_ffmpeg_process( sout_stream_t *, sout_stream_id_t *, sout_buffer_t *, sout_buffer_t ** );
62
63 static int  transcode_video_ffmpeg_new    ( sout_stream_t *, sout_stream_id_t * );
64 static void transcode_video_ffmpeg_close  ( sout_stream_t *, sout_stream_id_t * );
65 static int  transcode_video_ffmpeg_process( sout_stream_t *, sout_stream_id_t *, sout_buffer_t *, sout_buffer_t ** );
66
67 static int  transcode_video_ffmpeg_getframebuf( struct AVCodecContext *, AVFrame *);
68
69 /*****************************************************************************
70  * Module descriptor
71  *****************************************************************************/
72 vlc_module_begin();
73     set_description( _("Transcode stream") );
74     set_capability( "sout stream", 50 );
75     add_shortcut( "transcode" );
76     set_callbacks( Open, Close );
77 vlc_module_end();
78
79 struct sout_stream_sys_t
80 {
81     sout_stream_t   *p_out;
82
83     vlc_fourcc_t    i_acodec;   /* codec audio (0 if not transcode) */
84     int             i_sample_rate;
85     int             i_channels;
86     int             i_abitrate;
87
88     vlc_fourcc_t    i_vcodec;   /*    "   video  " "   "      " */
89     int             i_vbitrate;
90     int             i_vtolerance;
91     int             i_width;
92     int             i_height;
93     int             i_b_frames;
94     int             i_key_int;
95     int             i_qmin;
96     int             i_qmax;
97     vlc_bool_t      i_hq;
98     vlc_bool_t      b_deinterlace;
99
100     int             i_crop_top;
101     int             i_crop_bottom;
102     int             i_crop_right;
103     int             i_crop_left;
104
105     mtime_t         i_input_pts;
106     mtime_t         i_output_pts;
107     mtime_t         i_last_ref_pts;
108
109     mtime_t         i_buggy_pts_detect;
110 };
111
112 /*****************************************************************************
113  * Open:
114  *****************************************************************************/
115 static int Open( vlc_object_t *p_this )
116 {
117     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
118     sout_stream_sys_t *p_sys;
119     char *codec;
120
121     p_sys = malloc( sizeof( sout_stream_sys_t ) );
122     p_sys->p_out = sout_stream_new( p_stream->p_sout, p_stream->psz_next );
123
124     p_sys->i_acodec      = 0;
125     p_sys->i_sample_rate = 0;
126     p_sys->i_channels    = 0;
127     p_sys->i_abitrate    = 0;
128
129     p_sys->i_vcodec     = 0;
130     p_sys->i_vbitrate   = 0;
131     p_sys->i_vtolerance = -1;
132     p_sys->i_width      = 0;
133     p_sys->i_height     = 0;
134     p_sys->i_key_int    = -1;
135     p_sys->i_b_frames   = 0;
136     p_sys->i_qmin       = 2;
137     p_sys->i_qmax       = 31;
138 #if LIBAVCODEC_BUILD >= 4673
139     p_sys->i_hq         = FF_MB_DECISION_SIMPLE;
140 #else
141     p_sys->i_hq         = VLC_FALSE;
142 #endif
143     p_sys->b_deinterlace= VLC_FALSE;
144
145     p_sys->i_crop_top   = 0;
146     p_sys->i_crop_bottom= 0;
147     p_sys->i_crop_right = 0;
148     p_sys->i_crop_left  = 0;
149
150     if( ( codec = sout_cfg_find_value( p_stream->p_cfg, "acodec" ) ) )
151     {
152         char fcc[4] = "    ";
153         char *val;
154
155         memcpy( fcc, codec, strlen( codec ) );
156
157         p_sys->i_acodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
158
159         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "samplerate" ) ) )
160         {
161             p_sys->i_sample_rate = atoi( val );
162         }
163         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "channels" ) ) )
164         {
165             p_sys->i_channels = atoi( val );
166         }
167         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "ab" ) ) )
168         {
169             p_sys->i_abitrate = atoi( val );
170             if( p_sys->i_abitrate < 4000 )
171             {
172                 p_sys->i_abitrate *= 1000;
173             }
174         }
175
176         msg_Dbg( p_stream, "codec audio=%4.4s %dHz %d channels %dKb/s", fcc,
177                  p_sys->i_sample_rate, p_sys->i_channels,
178                  p_sys->i_abitrate / 1024 );
179     }
180
181     if( ( codec = sout_cfg_find_value( p_stream->p_cfg, "vcodec" ) ) )
182     {
183         char fcc[4] = "    ";
184         char *val;
185
186         memcpy( fcc, codec, strlen( codec ) );
187
188         p_sys->i_vcodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
189
190         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "width" ) ) )
191         {
192             p_sys->i_width = atoi( val );
193         }
194         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "height" ) ) )
195         {
196             p_sys->i_height = atoi( val );
197         }
198         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "vb" ) ) )
199         {
200             p_sys->i_vbitrate = atoi( val );
201             if( p_sys->i_vbitrate < 16000 )
202             {
203                 p_sys->i_vbitrate *= 1000;
204             }
205         }
206         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "vt" ) ) )
207         {
208             p_sys->i_vtolerance = atoi( val );
209         }
210         if( sout_cfg_find( p_stream->p_cfg, "deinterlace" ) )
211         {
212             p_sys->b_deinterlace = VLC_TRUE;
213         }
214         /* crop */
215         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "croptop" ) ) )
216         {
217             p_sys->i_crop_top = atoi( val );
218         }
219         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "cropbottom" ) ) )
220         {
221             p_sys->i_crop_bottom = atoi( val );
222         }
223         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "cropleft" ) ) )
224         {
225             p_sys->i_crop_left = atoi( val );
226         }
227         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "cropright" ) ) )
228         {
229             p_sys->i_crop_right = atoi( val );
230         }
231         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "keyint" ) ) )
232         {
233             p_sys->i_key_int    = atoi( val );
234         }
235         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "bframes" ) ) )
236         {
237             p_sys->i_b_frames   = atoi( val );
238         }
239 #if LIBAVCODEC_BUILD >= 4673
240         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "hq" ) ) )
241         {
242             if( !strcmp( val, "rd" ) )
243             {
244                 p_sys->i_hq = FF_MB_DECISION_RD;
245             }
246             else if( !strcmp( val, "bits" ) )
247             {
248                 p_sys->i_hq = FF_MB_DECISION_BITS;
249             }
250             else if( !strcmp( val, "simple" ) )
251             {
252                 p_sys->i_hq = FF_MB_DECISION_SIMPLE;
253             }
254             else
255             {
256                 p_sys->i_hq = FF_MB_DECISION_RD;
257             }
258         }
259 #else
260         if( sout_cfg_find( p_stream->p_cfg, "hq" ) )
261         {
262             p_sys->i_hq = VLC_TRUE;
263         }
264 #endif
265         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "qmin" ) ) )
266         {
267             p_sys->i_qmin   = atoi( val );
268         }
269         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "qmax" ) ) )
270         {
271             p_sys->i_qmax   = atoi( val );
272         }
273
274         msg_Dbg( p_stream, "codec video=%4.4s %dx%d %dkb/s",
275                  fcc,
276                  p_sys->i_width, p_sys->i_height,
277                  p_sys->i_vbitrate / 1024 );
278     }
279
280     if( !p_sys->p_out )
281     {
282         msg_Err( p_stream, "cannot create chain" );
283         free( p_sys );
284         return VLC_EGENERIC;
285     }
286     p_stream->pf_add    = Add;
287     p_stream->pf_del    = Del;
288     p_stream->pf_send   = Send;
289
290     p_stream->p_sys     = p_sys;
291
292     avcodec_init();
293     avcodec_register_all();
294
295     /* ffmpeg needs some padding at the end of each buffer */
296     p_stream->p_sout->i_padding += FF_INPUT_BUFFER_PADDING_SIZE;
297
298     return VLC_SUCCESS;
299 }
300
301 /*****************************************************************************
302  * Close:
303  *****************************************************************************/
304
305 static void Close( vlc_object_t * p_this )
306 {
307     sout_stream_t       *p_stream = (sout_stream_t*)p_this;
308     sout_stream_sys_t   *p_sys = p_stream->p_sys;
309
310     sout_stream_delete( p_sys->p_out );
311     free( p_sys );
312 }
313
314 struct sout_stream_id_t
315 {
316     vlc_fourcc_t  b_transcode;
317     sout_format_t f_src;        /* only if transcoding */
318     sout_format_t f_dst;        /*  "   "      " */
319
320     /* id of the out stream */
321     void *id;
322
323     /* ffmpeg part */
324     AVCodec         *ff_dec;
325     AVCodecContext  *ff_dec_c;
326
327
328     vlc_fourcc_t    b_enc_inited;
329     AVCodec         *ff_enc;
330     AVCodecContext  *ff_enc_c;
331
332     mtime_t         i_dts;
333     mtime_t         i_length;
334
335     int             i_buffer_in;
336     int             i_buffer_in_pos;
337     uint8_t         *p_buffer_in;
338
339     int             i_buffer;
340     int             i_buffer_pos;
341     uint8_t         *p_buffer;
342
343     int             i_buffer_out;
344     int             i_buffer_out_pos;
345     uint8_t         *p_buffer_out;
346
347     AVFrame         *p_ff_pic;
348     AVFrame         *p_ff_pic_tmp0; /* to do deinterlace */
349     AVFrame         *p_ff_pic_tmp1; /* to do pix conversion */
350     AVFrame         *p_ff_pic_tmp2; /* to do resample */
351
352     ImgReSampleContext *p_vresample;
353
354 #ifdef HAVE_VORBIS_VORBISENC_H
355
356     /* Vorbis part */
357     vorbis_info      *p_vi;
358     vorbis_dsp_state *p_vd;
359     vorbis_block     *p_vb;
360     vorbis_comment   *p_vc;
361     int              i_last_block_size;
362     int              i_samples_delay;
363     vlc_bool_t       b_headers_sent;
364 #endif
365 };
366
367
368 static sout_stream_id_t * Add( sout_stream_t *p_stream, sout_format_t *p_fmt )
369 {
370     sout_stream_sys_t   *p_sys = p_stream->p_sys;
371     sout_stream_id_t    *id;
372
373     id = malloc( sizeof( sout_stream_id_t ) );
374     id->i_dts = 0;
375     id->id = NULL;
376     if( p_fmt->i_cat == AUDIO_ES && p_sys->i_acodec != 0 )
377     {
378         msg_Dbg( p_stream,
379                  "creating audio transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
380                  (char*)&p_fmt->i_fourcc,
381                  (char*)&p_sys->i_acodec );
382
383         /* src format */
384         memcpy( &id->f_src, p_fmt, sizeof( sout_format_t ) );
385
386         /* create dst format */
387         id->f_dst.i_cat    = AUDIO_ES;
388         id->f_dst.i_fourcc = p_sys->i_acodec;
389         id->f_dst.i_sample_rate = p_sys->i_sample_rate  > 0 ? p_sys->i_sample_rate : id->f_src.i_sample_rate;
390         id->f_dst.i_channels    = p_sys->i_channels > 0 ? p_sys->i_channels : id->f_src.i_channels;
391         id->f_dst.i_bitrate     = p_sys->i_abitrate > 0 ? p_sys->i_abitrate : 64000;
392         id->f_dst.i_block_align = 0;
393         id->f_dst.i_extra_data  = 0;
394         id->f_dst.p_extra_data  = NULL;
395
396         /* build decoder -> filter -> encoder */
397         if( transcode_audio_ffmpeg_new( p_stream, id ) )
398         {
399             msg_Err( p_stream, "cannot create audio chain" );
400             free( id );
401             return NULL;
402         }
403
404         /* open output stream */
405         id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
406         id->b_transcode = VLC_TRUE;
407
408         if( id->id == NULL )
409         {
410             free( id );
411             return NULL;
412         }
413     }
414     else if( p_fmt->i_cat == VIDEO_ES && p_sys->i_vcodec != 0 )
415     {
416         msg_Dbg( p_stream,
417                  "creating video transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
418                  (char*)&p_fmt->i_fourcc,
419                  (char*)&p_sys->i_vcodec );
420
421         memcpy( &id->f_src, p_fmt, sizeof( sout_format_t ) );
422
423         /* create dst format */
424         id->f_dst.i_cat         = VIDEO_ES;
425         id->f_dst.i_fourcc      = p_sys->i_vcodec;
426         id->f_dst.i_width       = p_sys->i_width ; /* > 0 ? p_sys->i_width : id->f_src.i_width; */
427         id->f_dst.i_height      = p_sys->i_height; /* > 0 ? p_sys->i_height: id->f_src.i_height; */
428         id->f_dst.i_bitrate     = p_sys->i_vbitrate > 0 ? p_sys->i_vbitrate : 800*1000;
429         id->f_dst.i_extra_data  = 0;
430         id->f_dst.p_extra_data  = NULL;
431
432         /* build decoder -> filter -> encoder */
433         if( transcode_video_ffmpeg_new( p_stream, id ) )
434         {
435             msg_Err( p_stream, "cannot create video chain" );
436             free( id );
437             return NULL;
438         }
439 #if 0
440         /* open output stream */
441         id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
442 #endif
443         id->b_transcode = VLC_TRUE;
444     }
445     else
446     {
447         msg_Dbg( p_stream, "not transcoding a stream (fcc=`%4.4s')", (char*)&p_fmt->i_fourcc );
448         id->id = p_sys->p_out->pf_add( p_sys->p_out, p_fmt );
449         id->b_transcode = VLC_FALSE;
450
451         if( id->id == NULL )
452         {
453             free( id );
454             return NULL;
455         }
456     }
457
458     return id;
459 }
460
461 static int     Del      ( sout_stream_t *p_stream, sout_stream_id_t *id )
462 {
463     sout_stream_sys_t   *p_sys = p_stream->p_sys;
464
465     if( id->b_transcode )
466     {
467         if( id->f_src.i_cat == AUDIO_ES )
468         {
469             transcode_audio_ffmpeg_close( p_stream, id );
470         }
471         else if( id->f_src.i_cat == VIDEO_ES )
472         {
473             transcode_video_ffmpeg_close( p_stream, id );
474         }
475     }
476
477     if( id->id ) p_sys->p_out->pf_del( p_sys->p_out, id->id );
478     free( id );
479
480     return VLC_SUCCESS;
481 }
482
483 static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
484                  sout_buffer_t *p_buffer )
485 {
486     sout_stream_sys_t   *p_sys = p_stream->p_sys;
487
488     if( id->b_transcode )
489     {
490         sout_buffer_t *p_buffer_out;
491         if( id->f_src.i_cat == AUDIO_ES )
492         {
493             transcode_audio_ffmpeg_process( p_stream, id, p_buffer, &p_buffer_out );
494         }
495         else if( id->f_src.i_cat == VIDEO_ES )
496         {
497             transcode_video_ffmpeg_process( p_stream, id, p_buffer, &p_buffer_out );
498         }
499         sout_BufferDelete( p_stream->p_sout, p_buffer );
500
501         if( p_buffer_out )
502         {
503             return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer_out );
504         }
505         return VLC_SUCCESS;
506     }
507     else if( id->id != NULL )
508     {
509         return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer );
510     }
511     else
512     {
513         sout_BufferDelete( p_stream->p_sout, p_buffer );
514         return VLC_EGENERIC;
515     }
516 }
517
518 /****************************************************************************
519  * ffmpeg decoder reencocdr part
520  ****************************************************************************/
521
522 static struct
523 {
524     vlc_fourcc_t i_fcc;
525     int          i_ff_codec;
526 } fourcc_to_ff_code[] =
527 {
528     /* audio */
529     { VLC_FOURCC( 'm', 'p', 'g', 'a' ), CODEC_ID_MP2 },
530     { VLC_FOURCC( 'm', 'p', '3', ' ' ), CODEC_ID_MP3LAME },
531     { VLC_FOURCC( 'a', '5', '2', ' ' ), CODEC_ID_AC3 },
532     { VLC_FOURCC( 'a', 'c', '3', ' ' ), CODEC_ID_AC3 },
533     { VLC_FOURCC( 'w', 'm', 'a', '1' ), CODEC_ID_WMAV1 },
534     { VLC_FOURCC( 'w', 'm', 'a', '2' ), CODEC_ID_WMAV2 },
535     { VLC_FOURCC( 'v', 'o', 'r', 'b' ), CODEC_ID_VORBIS },
536     { VLC_FOURCC( 'a', 'l', 'a', 'w' ), CODEC_ID_PCM_ALAW },
537
538     /* video */
539     { VLC_FOURCC( 'm', 'p', 'g', 'v' ), CODEC_ID_MPEG1VIDEO },
540     { VLC_FOURCC( 'm', 'p', '1', 'v' ), CODEC_ID_MPEG1VIDEO },
541 #if LIBAVCODEC_BUILD >= 4676
542     { VLC_FOURCC( 'm', 'p', '2', 'v' ), CODEC_ID_MPEG2VIDEO },
543 #endif
544     { VLC_FOURCC( 'm', 'p', '4', 'v'),  CODEC_ID_MPEG4 },
545     { VLC_FOURCC( 'D', 'I', 'V', '1' ), CODEC_ID_MSMPEG4V1 },
546     { VLC_FOURCC( 'D', 'I', 'V', '2' ), CODEC_ID_MSMPEG4V2 },
547     { VLC_FOURCC( 'D', 'I', 'V', '3' ), CODEC_ID_MSMPEG4V3 },
548     { VLC_FOURCC( 'H', '2', '6', '3' ), CODEC_ID_H263 },
549     { VLC_FOURCC( 'I', '2', '6', '3' ), CODEC_ID_H263I },
550     { VLC_FOURCC( 'h', 'u', 'f', 'f' ), CODEC_ID_HUFFYUV },
551     { VLC_FOURCC( 'W', 'M', 'V', '1' ), CODEC_ID_WMV1 },
552     { VLC_FOURCC( 'W', 'M', 'V', '2' ), CODEC_ID_WMV2 },
553     { VLC_FOURCC( 'M', 'J', 'P', 'G' ), CODEC_ID_MJPEG },
554     { VLC_FOURCC( 'm', 'j', 'p', 'b' ), CODEC_ID_MJPEGB },
555     { VLC_FOURCC( 'd', 'v', 's', 'l' ), CODEC_ID_DVVIDEO },
556     { VLC_FOURCC( 'S', 'V', 'Q', '1' ), CODEC_ID_SVQ1 },
557 #if LIBAVCODEC_BUILD >= 4666
558     { VLC_FOURCC( 'S', 'V', 'Q', '3' ), CODEC_ID_SVQ3 },
559 #endif
560
561     /* raw video code, only used for 'encoding' */
562     { VLC_FOURCC( 'I', '4', '2', '0' ), CODEC_ID_RAWVIDEO },
563     { VLC_FOURCC( 'I', '4', '2', '2' ), CODEC_ID_RAWVIDEO },
564     { VLC_FOURCC( 'I', '4', '4', '4' ), CODEC_ID_RAWVIDEO },
565     { VLC_FOURCC( 'R', 'V', '1', '5' ), CODEC_ID_RAWVIDEO },
566     { VLC_FOURCC( 'R', 'V', '1', '6' ), CODEC_ID_RAWVIDEO },
567     { VLC_FOURCC( 'R', 'V', '2', '4' ), CODEC_ID_RAWVIDEO },
568     { VLC_FOURCC( 'R', 'V', '3', '2' ), CODEC_ID_RAWVIDEO },
569     { VLC_FOURCC( 'Y', 'U', 'Y', '2' ), CODEC_ID_RAWVIDEO },
570
571     { VLC_FOURCC(   0,   0,   0,   0 ), 0 }
572 };
573
574 static inline int get_ff_codec( vlc_fourcc_t i_fcc )
575 {
576     int i;
577
578     for( i = 0; fourcc_to_ff_code[i].i_fcc != 0; i++ )
579     {
580         if( fourcc_to_ff_code[i].i_fcc == i_fcc )
581         {
582             return fourcc_to_ff_code[i].i_ff_codec;
583         }
584     }
585
586     return 0;
587 }
588
589 static inline int get_ff_chroma( vlc_fourcc_t i_chroma )
590 {
591     switch( i_chroma )
592     {
593         case VLC_FOURCC( 'I', '4', '2', '0' ):
594             return PIX_FMT_YUV420P;
595         case VLC_FOURCC( 'I', '4', '2', '2' ):
596             return PIX_FMT_YUV422P;
597         case VLC_FOURCC( 'I', '4', '4', '4' ):
598             return PIX_FMT_YUV444P;
599         case VLC_FOURCC( 'R', 'V', '1', '5' ):
600             return PIX_FMT_RGB555;
601         case VLC_FOURCC( 'R', 'V', '1', '6' ):
602             return PIX_FMT_RGB565;
603         case VLC_FOURCC( 'R', 'V', '2', '4' ):
604             return PIX_FMT_RGB24;
605         case VLC_FOURCC( 'R', 'V', '3', '2' ):
606             return PIX_FMT_RGBA32;
607         case VLC_FOURCC( 'G', 'R', 'E', 'Y' ):
608             return PIX_FMT_GRAY8;
609         case VLC_FOURCC( 'Y', 'U', 'Y', '2' ):
610             return PIX_FMT_YUV422;
611         default:
612             return 0;
613     }
614 }
615
616 static int transcode_audio_ffmpeg_new( sout_stream_t *p_stream,
617                                        sout_stream_id_t *id )
618 {
619     int i_ff_codec;
620
621     if( id->f_src.i_fourcc == VLC_FOURCC('s','1','6','l') ||
622         id->f_src.i_fourcc == VLC_FOURCC('s','1','6','b') ||
623         id->f_src.i_fourcc == VLC_FOURCC('s','8',' ',' ') ||
624         id->f_src.i_fourcc == VLC_FOURCC('u','8',' ',' ') )
625     {
626         id->ff_dec = NULL;
627
628         id->ff_dec_c = avcodec_alloc_context();
629         id->ff_dec_c->sample_rate = id->f_src.i_sample_rate;
630         id->ff_dec_c->channels    = id->f_src.i_channels;
631         id->ff_dec_c->block_align = id->f_src.i_block_align;
632         id->ff_dec_c->bit_rate    = id->f_src.i_bitrate;
633     }
634     else
635     {
636         /* find decoder */
637         i_ff_codec = get_ff_codec( id->f_src.i_fourcc );
638         if( i_ff_codec == 0 )
639         {
640             msg_Err( p_stream, "cannot find decoder id" );
641             return VLC_EGENERIC;
642         }
643
644         id->ff_dec = avcodec_find_decoder( i_ff_codec );
645         if( !id->ff_dec )
646         {
647             msg_Err( p_stream, "cannot find decoder (avcodec)" );
648             return VLC_EGENERIC;
649         }
650
651         id->ff_dec_c = avcodec_alloc_context();
652         id->ff_dec_c->sample_rate = id->f_src.i_sample_rate;
653         id->ff_dec_c->channels    = id->f_src.i_channels;
654         id->ff_dec_c->block_align = id->f_src.i_block_align;
655         id->ff_dec_c->bit_rate    = id->f_src.i_bitrate;
656
657         id->ff_dec_c->extradata_size = id->f_src.i_extra_data;
658         id->ff_dec_c->extradata      = id->f_src.p_extra_data;
659         if( avcodec_open( id->ff_dec_c, id->ff_dec ) )
660         {
661             msg_Err( p_stream, "cannot open decoder" );
662             return VLC_EGENERIC;
663         }
664     }
665
666     /* find encoder */
667     id->i_buffer_in      = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
668     id->i_buffer_in_pos = 0;
669     id->p_buffer_in      = malloc( id->i_buffer_in );
670
671     id->i_buffer     = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
672     id->i_buffer_pos = 0;
673     id->p_buffer     = malloc( id->i_buffer );
674
675     id->i_buffer_out     = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
676     id->i_buffer_out_pos = 0;
677     id->p_buffer_out     = malloc( id->i_buffer_out );
678
679     /* Sanity check for audio channels */
680     id->f_dst.i_channels = __MIN( id->f_dst.i_channels, id->f_src.i_channels );
681
682 #ifdef HAVE_VORBIS_VORBISENC_H
683     if( id->f_dst.i_fourcc == VLC_FOURCC('v','o','r','b') )
684     {
685         id->p_vi = (vorbis_info *)malloc( sizeof(vorbis_info) );
686         id->p_vd = (vorbis_dsp_state *)malloc( sizeof(vorbis_dsp_state) );
687         id->p_vb = (vorbis_block *)malloc( sizeof(vorbis_block) );
688         id->p_vc = (vorbis_comment *)malloc( sizeof(vorbis_comment) );
689
690         vorbis_info_init( id->p_vi );
691
692         if( vorbis_encode_setup_managed( id->p_vi, id->f_dst.i_channels,
693               id->f_dst.i_sample_rate, -1, id->f_dst.i_bitrate, -1 ) ||
694             vorbis_encode_ctl( id->p_vi, OV_ECTL_RATEMANAGE_AVG, NULL ) ||
695              vorbis_encode_setup_init( id->p_vi ) ){}
696
697         /* add a comment */
698         vorbis_comment_init( id->p_vc);
699         vorbis_comment_add_tag( id->p_vc, "ENCODER", "VLC media player");
700
701         /* set up the analysis state and auxiliary encoding storage */
702         vorbis_analysis_init( id->p_vd, id->p_vi );
703         vorbis_block_init( id->p_vd, id->p_vb );
704
705         id->b_headers_sent = VLC_FALSE;
706         id->i_last_block_size = 0;
707         id->i_samples_delay = 0;
708
709         return VLC_SUCCESS;
710     }
711 #endif
712
713     i_ff_codec = get_ff_codec( id->f_dst.i_fourcc );
714     if( i_ff_codec == 0 )
715     {
716         msg_Err( p_stream, "cannot find encoder id" );
717         return VLC_EGENERIC;
718     }
719
720     id->ff_enc = avcodec_find_encoder( i_ff_codec );
721     if( !id->ff_enc )
722     {
723         msg_Err( p_stream, "cannot find encoder (avcodec)" );
724         return VLC_EGENERIC;
725     }
726
727     /* Hack for mp3 transcoding support */
728     if( id->f_dst.i_fourcc == VLC_FOURCC( 'm','p','3',' ' ) )
729     {
730         id->f_dst.i_fourcc = VLC_FOURCC( 'm','p','g','a' );
731     }
732
733     id->ff_enc_c = avcodec_alloc_context();
734     id->ff_enc_c->bit_rate    = id->f_dst.i_bitrate;
735     id->ff_enc_c->sample_rate = id->f_dst.i_sample_rate;
736     id->ff_enc_c->channels    = id->f_dst.i_channels;
737
738     if( avcodec_open( id->ff_enc_c, id->ff_enc ) )
739     {
740         if( id->ff_enc_c->channels > 2 )
741         {
742             id->ff_enc_c->channels = 2;
743             id->f_dst.i_channels   = 2;
744             if( avcodec_open( id->ff_enc_c, id->ff_enc ) )
745             {
746                 msg_Err( p_stream, "cannot open encoder" );
747                 return VLC_EGENERIC;
748             }
749             msg_Warn( p_stream, "stereo mode selected (codec limitation)" );
750         }
751         else
752         {
753             msg_Err( p_stream, "cannot open encoder" );
754             return VLC_EGENERIC;
755         }
756     }
757
758     return VLC_SUCCESS;
759 }
760
761 static void transcode_audio_ffmpeg_close( sout_stream_t *p_stream,
762                                           sout_stream_id_t *id )
763 {
764     if( id->ff_dec )
765     {
766         avcodec_close( id->ff_dec_c );
767     }
768
769 #ifdef HAVE_VORBIS_VORBISENC_H
770     if( id->f_dst.i_fourcc == VLC_FOURCC('v','o','r','b') )
771     {
772         vorbis_block_clear( id->p_vb );
773         vorbis_dsp_clear( id->p_vd );
774         vorbis_comment_clear( id->p_vc );
775         vorbis_info_clear( id->p_vi );  /* must be called last */
776
777         free( id->p_vi );
778         free( id->p_vd );
779         free( id->p_vb );
780         free( id->p_vc );
781     }
782     else
783 #endif
784         avcodec_close( id->ff_enc_c );
785
786     free( id->ff_dec_c );
787     if( id->f_dst.i_fourcc != VLC_FOURCC('v','o','r','b') )
788         free( id->ff_enc_c );
789
790     free( id->p_buffer_in );
791     free( id->p_buffer );
792     free( id->p_buffer_out );
793 }
794
795 static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
796                                            sout_stream_id_t *id,
797                                            sout_buffer_t *in,
798                                            sout_buffer_t **out )
799 {
800     vlc_bool_t b_again = VLC_FALSE;
801
802     *out = NULL;
803
804     /* gather data into p_buffer_in */
805 #ifdef HAVE_VORBIS_VORBISENC_H
806     if( id->f_dst.i_fourcc == VLC_FOURCC( 'v', 'o', 'r', 'b' ) )
807     id->i_dts = in->i_dts -
808                 (mtime_t)1000000 * (mtime_t)id->i_samples_delay /
809                 (mtime_t)id->f_dst.i_sample_rate;
810     else
811 #endif
812     id->i_dts = in->i_dts -
813                 (mtime_t)1000000 *
814                 (mtime_t)(id->i_buffer_pos / 2 / id->ff_dec_c->channels )/
815                 (mtime_t)id->ff_dec_c->sample_rate;
816
817     if( id->i_buffer_in_pos + (int)in->i_size > id->i_buffer_in )
818     {
819         /* extend buffer_in */
820         id->i_buffer_in = id->i_buffer_in_pos + in->i_size + 1024;
821         id->p_buffer_in = realloc( id->p_buffer_in, id->i_buffer_in );
822     }
823     memcpy( &id->p_buffer_in[id->i_buffer_in_pos],
824             in->p_buffer, in->i_size );
825     id->i_buffer_in_pos += in->i_size;
826
827     do
828     {
829         int i_buffer_pos;
830
831         /* decode as much data as possible */
832         if( id->ff_dec )
833         {
834             for( ;; )
835             {
836                 int i_buffer_size;
837                 int i_used;
838
839                 i_buffer_size = id->i_buffer - id->i_buffer_pos;
840
841                 i_used = avcodec_decode_audio( id->ff_dec_c,
842                          (int16_t*)&id->p_buffer[id->i_buffer_pos],
843                          &i_buffer_size, id->p_buffer_in,
844                          id->i_buffer_in_pos );
845
846                 /* msg_Warn( p_stream, "avcodec_decode_audio: %d used",
847                              i_used ); */
848                 id->i_buffer_pos += i_buffer_size;
849
850                 if( i_used < 0 )
851                 {
852                     msg_Warn( p_stream, "error");
853                     id->i_buffer_in_pos = 0;
854                     break;
855                 }
856                 else if( i_used < id->i_buffer_in_pos )
857                 {
858                     memmove( id->p_buffer_in,
859                              &id->p_buffer_in[i_used],
860                              id->i_buffer_in - i_used );
861                     id->i_buffer_in_pos -= i_used;
862                 }
863                 else
864                 {
865                     id->i_buffer_in_pos = 0;
866                     break;
867                 }
868
869                 if( id->i_buffer_pos >= AVCODEC_MAX_AUDIO_FRAME_SIZE )
870                 {
871                     /* buffer full */
872                     b_again = VLC_TRUE;
873                     break;
874                 }
875             }
876         }
877         else
878         {
879             int16_t *sout  = (int16_t*)&id->p_buffer[id->i_buffer_pos];
880             int     i_used = 0;
881
882             if( id->f_src.i_fourcc == VLC_FOURCC( 's', '8', ' ', ' ' ) )
883             {
884                 int8_t *sin = (int8_t*)id->p_buffer_in;
885                 int     i_samples = __MIN( ( id->i_buffer - id->i_buffer_pos )
886                                            / 2, id->i_buffer_in_pos );
887                 i_used = i_samples;
888                 while( i_samples > 0 )
889                 {
890                     *sout++ = ( *sin++ ) << 8;
891                     i_samples--;
892                 }
893             }
894             else if( id->f_src.i_fourcc == VLC_FOURCC( 'u', '8', ' ', ' ' ) )
895             {
896                 int8_t *sin = (int8_t*)id->p_buffer_in;
897                 int     i_samples = __MIN( ( id->i_buffer - id->i_buffer_pos )
898                                            / 2, id->i_buffer_in_pos );
899                 i_used = i_samples;
900                 while( i_samples > 0 )
901                 {
902                     *sout++ = ( *sin++ - 128 ) << 8;
903                     i_samples--;
904                 }
905             }
906             else if( id->f_src.i_fourcc == VLC_FOURCC( 's', '1', '6', 'l' ) )
907             {
908                 int     i_samples = __MIN( ( id->i_buffer - id->i_buffer_pos )
909                                            / 2, id->i_buffer_in_pos / 2);
910 #ifdef WORDS_BIGENDIAN
911                 uint8_t *sin = (uint8_t*)id->p_buffer_in;
912                 i_used = i_samples * 2;
913                 while( i_samples > 0 )
914                 {
915                     uint8_t tmp[2];
916
917                     tmp[1] = *sin++;
918                     tmp[0] = *sin++;
919                     *sout++ = *(int16_t*)tmp;
920                     i_samples--;
921                 }
922
923 #else
924                 memcpy( sout, id->p_buffer_in, i_samples * 2 );
925                 sout += i_samples;
926                 i_used = i_samples * 2;
927 #endif
928             }
929             else if( id->f_src.i_fourcc == VLC_FOURCC( 's', '1', '6', 'b' ) )
930             {
931                 int     i_samples = __MIN( ( id->i_buffer - id->i_buffer_pos )
932                                            / 2, id->i_buffer_in_pos / 2);
933 #ifdef WORDS_BIGENDIAN
934                 memcpy( sout, id->p_buffer_in, i_samples * 2 );
935                 sout += i_samples;
936                 i_used = i_samples * 2;
937 #else
938                 uint8_t *sin = (uint8_t*)id->p_buffer_in;
939                 i_used = i_samples * 2;
940                 while( i_samples > 0 )
941                 {
942                     uint8_t tmp[2];
943
944                     tmp[1] = *sin++;
945                     tmp[0] = *sin++;
946                     *sout++ = *(int16_t*)tmp;
947                     i_samples--;
948                 }
949 #endif
950             }
951
952             id->i_buffer_pos = (uint8_t*)sout - id->p_buffer;
953             if( i_used < id->i_buffer_in_pos )
954             {
955                 memmove( id->p_buffer_in,
956                          &id->p_buffer_in[i_used],
957                          id->i_buffer_in - i_used );
958             }
959             id->i_buffer_in_pos -= i_used;
960         }
961
962         i_buffer_pos = id->i_buffer_pos;
963
964         /* encode as much data as possible */
965
966 #ifdef HAVE_VORBIS_VORBISENC_H
967         if( id->i_buffer_pos == 0 );
968         else if( id->f_dst.i_fourcc == VLC_FOURCC( 'v', 'o', 'r', 'b' ) )
969         {
970             float **buffer;
971             int i, j, i_samples;
972             sout_buffer_t *p_out;
973             ogg_packet op;
974
975             if( !id->b_headers_sent )
976             {
977                 ogg_packet header[3];
978                 vorbis_analysis_headerout( id->p_vd, id->p_vc,
979                                            &header[0], &header[1], &header[2]);
980                 for( i = 0; i < 3; i++ )
981                 {
982                     p_out = sout_BufferNew( p_stream->p_sout, header[i].bytes);
983                     memcpy( p_out->p_buffer, header[i].packet,
984                             header[i].bytes );
985
986                     p_out->i_size = header[i].bytes;
987                     p_out->i_length = 0;
988
989                     p_out->i_dts = p_out->i_pts = 0;
990
991                     sout_BufferChain( out, p_out );
992                 }
993                 id->b_headers_sent = VLC_TRUE;
994             }
995
996             i_samples = id->i_buffer_pos / id->f_src.i_channels / 2;
997             id->i_samples_delay += i_samples;
998             id->i_buffer_pos = 0;
999
1000             buffer = vorbis_analysis_buffer( id->p_vd, i_samples );
1001
1002             /* convert samples to float and uninterleave */
1003             for( i = 0; i < id->f_dst.i_channels; i++ )
1004             {
1005                 for( j = 0 ; j < i_samples ; j++ )
1006                 {
1007                     buffer[i][j]= ((float)( ((int16_t *)id->p_buffer)
1008                                   [j*id->f_src.i_channels + i ] ))/ 32768.f;
1009                 }
1010             }
1011
1012             vorbis_analysis_wrote( id->p_vd, i_samples );
1013
1014             while( vorbis_analysis_blockout( id->p_vd, id->p_vb ) == 1 )
1015             {
1016                 vorbis_analysis( id->p_vb, NULL );
1017                 vorbis_bitrate_addblock( id->p_vb );
1018
1019                 while( vorbis_bitrate_flushpacket( id->p_vd, &op ) )
1020                 {
1021                     int i_block_size;
1022                     p_out = sout_BufferNew( p_stream->p_sout, op.bytes );
1023                     memcpy( p_out->p_buffer, op.packet, op.bytes );
1024
1025                     i_block_size = vorbis_packet_blocksize( id->p_vi, &op );
1026
1027                     if( i_block_size < 0 ) i_block_size = 0;
1028                     i_samples = ( id->i_last_block_size +
1029                                   i_block_size ) >> 2;
1030                     id->i_last_block_size = i_block_size;
1031
1032                     p_out->i_size = op.bytes;
1033                     p_out->i_length = (mtime_t)1000000 *
1034                       (mtime_t)i_samples /
1035                       (mtime_t)id->f_dst.i_sample_rate;
1036
1037                     //msg_Err( p_stream, "i_dts: %lld", id->i_dts );
1038
1039                     /* FIXME */
1040                     p_out->i_dts = id->i_dts;
1041                     p_out->i_pts = id->i_dts;
1042
1043                     id->i_samples_delay -= i_samples;
1044
1045                     /* update dts */
1046                     id->i_dts += p_out->i_length;
1047                     sout_BufferChain( out, p_out );
1048
1049                 }
1050             }
1051         }
1052         else
1053 #endif
1054
1055         for( ;; )
1056         {
1057             int i_frame_size = id->ff_enc_c->frame_size * 2 *
1058                                  id->ff_dec_c->channels;
1059             int i_out_size, i, j;
1060             sout_buffer_t *p_out;
1061             int16_t *p_buffer = (int16_t *)(id->p_buffer + i_buffer_pos -
1062                                             id->i_buffer_pos);
1063
1064             if( id->i_buffer_pos < i_frame_size )
1065             {
1066                 break;
1067             }
1068
1069             if( id->ff_dec_c->channels != id->ff_enc_c->channels )
1070             {
1071                 /* dumb downmixing */
1072                 for( i = 0; i < id->ff_enc_c->frame_size; i++ )
1073                 {
1074                     for( j = 0 ; j < id->f_dst.i_channels; j++ )
1075                     {
1076                         p_buffer[i*id->f_dst.i_channels+j] = p_buffer[i*id->f_src.i_channels+j];
1077                     }
1078                 }
1079             }
1080
1081             /* msg_Warn( p_stream, "avcodec_encode_audio: frame size%d",
1082                          i_frame_size); */
1083             i_out_size = avcodec_encode_audio( id->ff_enc_c,
1084                            id->p_buffer_out, id->i_buffer_out, p_buffer );
1085
1086             if( i_out_size <= 0 )
1087             {
1088                 break;
1089             }
1090
1091             id->i_buffer_pos -= i_frame_size;
1092
1093             p_out = sout_BufferNew( p_stream->p_sout, i_out_size );
1094             memcpy( p_out->p_buffer, id->p_buffer_out, i_out_size );
1095             p_out->i_size = i_out_size;
1096             p_out->i_length = (mtime_t)1000000 *
1097                               (mtime_t)id->ff_enc_c->frame_size /
1098                               (mtime_t)id->ff_enc_c->sample_rate;
1099
1100             /* FIXME */
1101             p_out->i_dts = id->i_dts;
1102             p_out->i_pts = id->i_dts;
1103
1104             /* update dts */
1105             id->i_dts += p_out->i_length;
1106
1107            /* msg_Warn( p_stream, "frame dts=%lld len %lld out=%d",
1108                         p_out->i_dts, p_out->i_length, i_out_size ); */
1109
1110             sout_BufferChain( out, p_out );
1111         }
1112
1113         /* Copy the remaining raw samples */
1114         if( id->i_buffer_pos != 0 )
1115         {
1116             memmove( id->p_buffer,
1117                      &id->p_buffer[i_buffer_pos - id->i_buffer_pos],
1118                      id->i_buffer_pos );
1119         }
1120
1121     } while( b_again );
1122
1123     return VLC_SUCCESS;
1124 }
1125
1126
1127 /*
1128  * video
1129  */
1130 static int transcode_video_ffmpeg_new( sout_stream_t *p_stream,
1131                                        sout_stream_id_t *id )
1132 {
1133     sout_stream_sys_t   *p_sys = p_stream->p_sys;
1134
1135     int i_ff_codec;
1136
1137     if( id->f_src.i_fourcc == VLC_FOURCC( 'I', '4', '2', '0' ) ||
1138         id->f_src.i_fourcc == VLC_FOURCC( 'I', '4', '2', '2' ) ||
1139         id->f_src.i_fourcc == VLC_FOURCC( 'I', '4', '4', '4' ) ||
1140         id->f_src.i_fourcc == VLC_FOURCC( 'Y', 'U', 'Y', '2' ) ||
1141         id->f_src.i_fourcc == VLC_FOURCC( 'R', 'V', '1', '5' ) ||
1142         id->f_src.i_fourcc == VLC_FOURCC( 'R', 'V', '1', '6' ) ||
1143         id->f_src.i_fourcc == VLC_FOURCC( 'R', 'V', '2', '4' ) ||
1144         id->f_src.i_fourcc == VLC_FOURCC( 'R', 'V', '3', '2' ) ||
1145         id->f_src.i_fourcc == VLC_FOURCC( 'G', 'R', 'E', 'Y' ) )
1146     {
1147         id->ff_dec   = NULL;
1148         id->ff_dec_c            = avcodec_alloc_context();
1149         id->ff_dec_c->width     = id->f_src.i_width;
1150         id->ff_dec_c->height    = id->f_src.i_height;
1151         id->ff_dec_c->pix_fmt   = get_ff_chroma( id->f_src.i_fourcc );
1152     }
1153     else
1154     {
1155         /* find decoder */
1156         i_ff_codec = get_ff_codec( id->f_src.i_fourcc );
1157         if( i_ff_codec == 0 )
1158         {
1159             msg_Err( p_stream, "cannot find decoder" );
1160             return VLC_EGENERIC;
1161         }
1162
1163         id->ff_dec = avcodec_find_decoder( i_ff_codec );
1164         if( !id->ff_dec )
1165         {
1166             msg_Err( p_stream, "cannot find decoder" );
1167             return VLC_EGENERIC;
1168         }
1169
1170         id->ff_dec_c = avcodec_alloc_context();
1171         id->ff_dec_c->width         = id->f_src.i_width;
1172         id->ff_dec_c->height        = id->f_src.i_height;
1173         /* id->ff_dec_c->bit_rate      = id->f_src.i_bitrate; */
1174         id->ff_dec_c->extradata_size= id->f_src.i_extra_data;
1175         id->ff_dec_c->extradata     = id->f_src.p_extra_data;
1176         id->ff_dec_c->workaround_bugs = FF_BUG_AUTODETECT;
1177         id->ff_dec_c->error_resilience= -1;
1178         id->ff_dec_c->get_buffer    = transcode_video_ffmpeg_getframebuf;
1179         id->ff_dec_c->opaque        = p_sys;
1180
1181         if( avcodec_open( id->ff_dec_c, id->ff_dec ) < 0 )
1182         {
1183             msg_Err( p_stream, "cannot open decoder" );
1184             return VLC_EGENERIC;
1185         }
1186
1187         if( i_ff_codec == CODEC_ID_MPEG4 && id->ff_dec_c->extradata_size > 0 )
1188         {
1189             int b_gotpicture;
1190             AVFrame frame;
1191             uint8_t *p_vol = malloc( id->ff_dec_c->extradata_size +
1192                                      FF_INPUT_BUFFER_PADDING_SIZE );
1193
1194             memcpy( p_vol, id->ff_dec_c->extradata,
1195                     id->ff_dec_c->extradata_size );
1196             memset( p_vol + id->ff_dec_c->extradata_size, 0,
1197                     FF_INPUT_BUFFER_PADDING_SIZE );
1198
1199             avcodec_decode_video( id->ff_dec_c, &frame, &b_gotpicture,
1200                                   id->ff_dec_c->extradata,
1201                                   id->ff_dec_c->extradata_size );
1202             free( p_vol );
1203         }
1204     }
1205
1206
1207     /* find encoder */
1208     i_ff_codec = get_ff_codec( id->f_dst.i_fourcc );
1209     if( i_ff_codec == 0 )
1210     {
1211         msg_Err( p_stream, "cannot find encoder" );
1212         return VLC_EGENERIC;
1213     }
1214
1215     id->ff_enc = avcodec_find_encoder( i_ff_codec );
1216     if( !id->ff_enc )
1217     {
1218         msg_Err( p_stream, "cannot find encoder" );
1219         return VLC_EGENERIC;
1220     }
1221
1222     if( id->f_dst.i_fourcc == VLC_FOURCC( 'm','p','1','v' )||
1223         id->f_dst.i_fourcc == VLC_FOURCC( 'm','p','2','v' ) )
1224     {
1225         id->f_dst.i_fourcc = VLC_FOURCC( 'm','p','g','v' );
1226     }
1227
1228     id->ff_enc_c = avcodec_alloc_context();
1229     id->ff_enc_c->width          = id->f_dst.i_width;
1230     id->ff_enc_c->height         = id->f_dst.i_height;
1231     id->ff_enc_c->bit_rate       = id->f_dst.i_bitrate;
1232
1233     if( id->ff_dec )
1234     {
1235         id->ff_enc_c->frame_rate     = id->ff_dec_c->frame_rate;
1236 #if LIBAVCODEC_BUILD >= 4662
1237         id->ff_enc_c->frame_rate_base= id->ff_dec_c->frame_rate_base;
1238 #endif
1239     }
1240     else
1241     {
1242 #if LIBAVCODEC_BUILD >= 4662
1243         id->ff_enc_c->frame_rate     = 25 ; /* FIXME as it break mpeg */
1244         id->ff_enc_c->frame_rate_base= 1;
1245 #else
1246         id->ff_enc_c->frame_rate     = 25 * FRAME_RATE_BASE;
1247 #endif
1248     }
1249
1250     id->ff_enc_c->gop_size       = p_sys->i_key_int >= 0 ? p_sys->i_key_int : 50;
1251     id->ff_enc_c->max_b_frames   = __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES );
1252     id->ff_enc_c->b_frame_strategy = 0;
1253     id->ff_enc_c->b_quant_factor = 2.0;
1254
1255     if( p_sys->i_vtolerance >= 0 )
1256     {
1257         id->ff_enc_c->bit_rate_tolerance = p_sys->i_vtolerance;
1258     }
1259     id->ff_enc_c->qmin           = p_sys->i_qmin;
1260     id->ff_enc_c->qmax           = p_sys->i_qmax;
1261
1262 #if LIBAVCODEC_BUILD >= 4673
1263     id->ff_enc_c->mb_decision = p_sys->i_hq;
1264 #else
1265     if( p_sys->i_hq )
1266     {
1267         id->ff_enc_c->flags      |= CODEC_FLAG_HQ;
1268     }
1269 #endif
1270
1271     if( i_ff_codec == CODEC_ID_RAWVIDEO )
1272     {
1273         id->ff_enc_c->pix_fmt = get_ff_chroma( id->f_dst.i_fourcc );
1274     }
1275     /* XXX open it only when we have the first frame */
1276     id->b_enc_inited     = VLC_FALSE;
1277     id->i_buffer_in      = 0;
1278     id->i_buffer_in_pos  = 0;
1279     id->p_buffer_in      = NULL;
1280
1281     id->i_buffer     = 3*1024*1024;
1282     id->i_buffer_pos = 0;
1283     id->p_buffer     = malloc( id->i_buffer );
1284
1285     id->i_buffer_out     = 0;
1286     id->i_buffer_out_pos = 0;
1287     id->p_buffer_out     = NULL;
1288
1289     id->p_ff_pic         = avcodec_alloc_frame();
1290     id->p_ff_pic_tmp0    = NULL;
1291     id->p_ff_pic_tmp1    = NULL;
1292     id->p_ff_pic_tmp2    = NULL;
1293     id->p_vresample      = NULL;
1294
1295     p_sys->i_last_ref_pts = 0;
1296     p_sys->i_buggy_pts_detect = 0;
1297
1298     return VLC_SUCCESS;
1299 }
1300
1301 static void transcode_video_ffmpeg_close ( sout_stream_t *p_stream, sout_stream_id_t *id )
1302 {
1303     if( id->ff_dec )
1304     {
1305         avcodec_close( id->ff_dec_c );
1306     }
1307     if( id->b_enc_inited )
1308     {
1309         avcodec_close( id->ff_enc_c );
1310     }
1311
1312     if( id->p_ff_pic)
1313     {
1314         free( id->p_ff_pic );
1315     }
1316
1317     if( id->p_ff_pic_tmp0 )
1318     {
1319         free( id->p_ff_pic_tmp0->data[0] );
1320         free( id->p_ff_pic_tmp0 );
1321     }
1322     if( id->p_ff_pic_tmp1)
1323     {
1324         free( id->p_ff_pic_tmp1->data[0] );
1325         free( id->p_ff_pic_tmp1 );
1326     }
1327     if( id->p_ff_pic_tmp2)
1328     {
1329         free( id->p_ff_pic_tmp2->data[0] );
1330         free( id->p_ff_pic_tmp2 );
1331     }
1332     if( id->p_vresample )
1333     {
1334         free( id->p_vresample );
1335     }
1336
1337     free( id->ff_dec_c );
1338     free( id->ff_enc_c );
1339
1340     free( id->p_buffer );
1341 }
1342
1343 static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
1344                sout_stream_id_t *id, sout_buffer_t *in, sout_buffer_t **out )
1345 {
1346     sout_stream_sys_t   *p_sys = p_stream->p_sys;
1347     int     i_used;
1348     int     i_out;
1349     int     b_gotpicture;
1350     AVFrame *frame;
1351
1352     int     i_data;
1353     uint8_t *p_data;
1354
1355     *out = NULL;
1356
1357     i_data = in->i_size;
1358     p_data = in->p_buffer;
1359
1360     for( ;; )
1361     {
1362         /* decode frame */
1363         frame = id->p_ff_pic;
1364         p_sys->i_input_pts = in->i_pts;
1365         if( id->ff_dec )
1366         {
1367             i_used = avcodec_decode_video( id->ff_dec_c, frame,
1368                                            &b_gotpicture,
1369                                            p_data, i_data );
1370         }
1371         else
1372         {
1373             /* raw video */
1374             avpicture_fill( (AVPicture*)frame,
1375                             p_data,
1376                             id->ff_dec_c->pix_fmt,
1377                             id->ff_dec_c->width, id->ff_dec_c->height );
1378             i_used = i_data;
1379             b_gotpicture = 1;
1380
1381             /* Set PTS */
1382             frame->pts = p_sys->i_input_pts;
1383         }
1384
1385         if( i_used < 0 )
1386         {
1387             msg_Warn( p_stream, "error");
1388             return VLC_EGENERIC;
1389         }
1390         i_data -= i_used;
1391         p_data += i_used;
1392
1393         if( !b_gotpicture )
1394         {
1395             return VLC_SUCCESS;
1396         }
1397
1398         /* Get the pts of the decoded frame if any, otherwise keep the
1399          * interpolated one */
1400         if( frame->pts > 0 )
1401         {
1402             p_sys->i_output_pts = frame->pts;
1403         }
1404
1405         if( !id->b_enc_inited )
1406         {
1407             /* XXX hack because of copy packetizer and mpeg4video that can failed
1408                detecting size */
1409             if( id->ff_enc_c->width <= 0 )
1410             {
1411                 id->ff_enc_c->width    =
1412                     id->f_dst.i_width  = id->ff_dec_c->width - p_sys->i_crop_left - p_sys->i_crop_right;
1413             }
1414             if( id->ff_enc_c->height <= 0 )
1415             {
1416                 id->ff_enc_c->height   =
1417                     id->f_dst.i_height = id->ff_dec_c->height - p_sys->i_crop_top - p_sys->i_crop_bottom;
1418             }
1419
1420             if( avcodec_open( id->ff_enc_c, id->ff_enc ) )
1421             {
1422                 msg_Err( p_stream, "cannot open encoder" );
1423                 return VLC_EGENERIC;
1424             }
1425
1426             if( !( id->id = p_stream->p_sys->p_out->pf_add( p_stream->p_sys->p_out, &id->f_dst ) ) )
1427             {
1428                 msg_Err( p_stream, "cannot add this stream" );
1429                 transcode_video_ffmpeg_close( p_stream, id );
1430                 id->b_transcode = VLC_FALSE;
1431                 return VLC_EGENERIC;
1432             }
1433             id->b_enc_inited = VLC_TRUE;
1434         }
1435
1436
1437         /* deinterlace */
1438         if( p_stream->p_sys->b_deinterlace )
1439         {
1440             if( id->p_ff_pic_tmp0 == NULL )
1441             {
1442                 int     i_size;
1443                 uint8_t *buf;
1444                 id->p_ff_pic_tmp0 = avcodec_alloc_frame();
1445                 i_size = avpicture_get_size( id->ff_dec_c->pix_fmt,
1446                                              id->ff_dec_c->width, id->ff_dec_c->height );
1447
1448                 buf = malloc( i_size );
1449
1450                 avpicture_fill( (AVPicture*)id->p_ff_pic_tmp0, buf,
1451                                 id->ff_enc_c->pix_fmt,
1452                                 id->ff_dec_c->width, id->ff_dec_c->height );
1453             }
1454
1455             avpicture_deinterlace( (AVPicture*)id->p_ff_pic_tmp0, (AVPicture*)frame,
1456                                    id->ff_dec_c->pix_fmt,
1457                                    id->ff_dec_c->width, id->ff_dec_c->height );
1458
1459             frame = id->p_ff_pic_tmp0;
1460         }
1461
1462         /* convert pix format */
1463         if( id->ff_dec_c->pix_fmt != id->ff_enc_c->pix_fmt )
1464         {
1465             if( id->p_ff_pic_tmp1 == NULL )
1466             {
1467                 int     i_size;
1468                 uint8_t *buf;
1469                 id->p_ff_pic_tmp1 = avcodec_alloc_frame();
1470                 i_size = avpicture_get_size( id->ff_enc_c->pix_fmt,
1471                                              id->ff_dec_c->width, id->ff_dec_c->height );
1472
1473                 buf = malloc( i_size );
1474
1475                 avpicture_fill( (AVPicture*)id->p_ff_pic_tmp1, buf,
1476                                 id->ff_enc_c->pix_fmt,
1477                                 id->ff_dec_c->width, id->ff_dec_c->height );
1478             }
1479
1480             img_convert( (AVPicture*)id->p_ff_pic_tmp1, id->ff_enc_c->pix_fmt,
1481                          (AVPicture*)frame,             id->ff_dec_c->pix_fmt,
1482                          id->ff_dec_c->width, id->ff_dec_c->height );
1483
1484             frame = id->p_ff_pic_tmp1;
1485         }
1486
1487         /* convert size and crop */
1488         if( id->ff_dec_c->width  != id->ff_enc_c->width ||
1489             id->ff_dec_c->height != id->ff_enc_c->height ||
1490             p_sys->i_crop_top > 0 || p_sys->i_crop_bottom > 0 ||
1491             p_sys->i_crop_left > 0 || p_sys->i_crop_right )
1492         {
1493             if( id->p_ff_pic_tmp2 == NULL )
1494             {
1495                 int     i_size;
1496                 uint8_t *buf;
1497                 id->p_ff_pic_tmp2 = avcodec_alloc_frame();
1498                 i_size = avpicture_get_size( id->ff_enc_c->pix_fmt,
1499                                              id->ff_enc_c->width, id->ff_enc_c->height );
1500
1501                 buf = malloc( i_size );
1502
1503                 avpicture_fill( (AVPicture*)id->p_ff_pic_tmp2, buf,
1504                                 id->ff_enc_c->pix_fmt,
1505                                 id->ff_enc_c->width, id->ff_enc_c->height );
1506
1507                 id->p_vresample =
1508                     img_resample_full_init( id->ff_enc_c->width, id->ff_enc_c->height,
1509                                             id->ff_dec_c->width, id->ff_dec_c->height,
1510                                             p_stream->p_sys->i_crop_top,
1511                                             p_stream->p_sys->i_crop_bottom,
1512                                             p_stream->p_sys->i_crop_left,
1513                                             p_stream->p_sys->i_crop_right );
1514             }
1515
1516             img_resample( id->p_vresample, (AVPicture*)id->p_ff_pic_tmp2,
1517                           (AVPicture*)frame );
1518
1519             frame = id->p_ff_pic_tmp2;
1520         }
1521
1522         /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
1523         if( id->f_dst.i_fourcc == VLC_FOURCC( 'm', 'p', 'g', 'v' ) )
1524             frame->pts = p_sys->i_output_pts;
1525         else
1526             frame->pts = 0;
1527
1528         /* Interpolate the next PTS
1529          * (needed by the mpeg video packetizer which can send pts <= 0 ) */
1530         if( id->ff_dec_c && id->ff_dec_c->frame_rate > 0 )
1531         {
1532             p_sys->i_output_pts += I64C(1000000) * (2 + frame->repeat_pict) *
1533               id->ff_dec_c->frame_rate_base / (2 * id->ff_dec_c->frame_rate);
1534         }
1535
1536         /* Let ffmpeg select the frame type */
1537         frame->pict_type = 0;
1538
1539         i_out = avcodec_encode_video( id->ff_enc_c, id->p_buffer,
1540                                       id->i_buffer, frame );
1541         if( i_out > 0 )
1542         {
1543             sout_buffer_t *p_out;
1544             p_out = sout_BufferNew( p_stream->p_sout, i_out );
1545
1546             memcpy( p_out->p_buffer, id->p_buffer, i_out );
1547
1548             p_out->i_size   = i_out;
1549
1550             if( id->ff_enc_c->coded_frame->pts != 0 &&
1551                 p_sys->i_buggy_pts_detect != id->ff_enc_c->coded_frame->pts )
1552             {
1553                 p_sys->i_buggy_pts_detect = id->ff_enc_c->coded_frame->pts;
1554
1555                 /* FIXME, 3-2 pulldown is not handled correctly */
1556                 p_out->i_length = in->i_length;
1557                 p_out->i_pts    = id->ff_enc_c->coded_frame->pts;
1558
1559                 if( !id->ff_enc_c->delay ||
1560                     ( id->ff_enc_c->coded_frame->pict_type != FF_I_TYPE &&
1561                       id->ff_enc_c->coded_frame->pict_type != FF_P_TYPE ) )
1562                 {
1563                     p_out->i_dts    = p_out->i_pts;
1564                 }
1565                 else
1566                 {
1567                     if( p_sys->i_last_ref_pts )
1568                     {
1569                         p_out->i_dts = p_sys->i_last_ref_pts;
1570                     }
1571                     else
1572                     {
1573                         /* Let's put something sensible */
1574                         p_out->i_dts = p_out->i_pts;
1575                     }
1576
1577                     p_sys->i_last_ref_pts = p_out->i_pts;
1578                 }
1579             }
1580             else
1581             {
1582                 /* Buggy libavcodec which doesn't update coded_frame->pts
1583                  * correctly */
1584                 p_out->i_length = in->i_length;
1585                 p_out->i_dts    = in->i_dts;
1586                 p_out->i_pts    = in->i_dts;
1587             }
1588
1589             sout_BufferChain( out, p_out );
1590         }
1591
1592         if( i_data <= 0 )
1593         {
1594             return VLC_SUCCESS;
1595         }
1596     }
1597
1598     return VLC_SUCCESS;
1599 }
1600
1601 /*****************************************************************************
1602  * transcode_video_ffmpeg_getframebuf:
1603  *
1604  * Callback used by ffmpeg to get a frame buffer.
1605  * We use it to get the right PTS for each decoded picture.
1606  *****************************************************************************/
1607 static int transcode_video_ffmpeg_getframebuf(struct AVCodecContext *p_context,
1608                                               AVFrame *p_frame)
1609 {
1610     sout_stream_sys_t *p_sys = (sout_stream_sys_t *)p_context->opaque;
1611
1612     /* Set PTS */
1613     p_frame->pts = p_sys->i_input_pts;
1614
1615     return avcodec_default_get_buffer( p_context, p_frame );
1616 }