a126b9f32766318dcf818534a54452a41f1d96f7
[vlc.git] / modules / codec / ffmpeg / encoder.c
1 /*****************************************************************************
2  * encoder.c: video and audio encoder using the ffmpeg library
3  *****************************************************************************
4  * Copyright (C) 1999-2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *          Christophe Massiot <massiot@via.ecp.fr>
10  * Part of the file Copyright (C) FFMPEG Project Developers
11  * (mpeg4_default matrixes)
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27
28 /*****************************************************************************
29  * Preamble
30  *****************************************************************************/
31 #ifdef HAVE_CONFIG_H
32 # include "config.h"
33 #endif
34
35 #include <vlc/vlc.h>
36 #include <vlc_vout.h>
37 #include <vlc_aout.h>
38 #include <vlc_sout.h>
39 #include <vlc_codec.h>
40 #include <vlc_interface.h>
41
42 /* ffmpeg header */
43 #define HAVE_MMX 1
44 #ifdef HAVE_FFMPEG_AVCODEC_H
45 #   include <ffmpeg/avcodec.h>
46 #else
47 #   include <avcodec.h>
48 #endif
49
50 #include "ffmpeg.h"
51
52 #define HURRY_UP_GUARD1 (450000)
53 #define HURRY_UP_GUARD2 (300000)
54 #define HURRY_UP_GUARD3 (100000)
55
56 #define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
57
58 /*****************************************************************************
59  * Local prototypes
60  *****************************************************************************/
61 int  E_(OpenEncoder) ( vlc_object_t * );
62 void E_(CloseEncoder)( vlc_object_t * );
63
64 static block_t *EncodeVideo( encoder_t *, picture_t * );
65 static block_t *EncodeAudio( encoder_t *, aout_buffer_t * );
66
67 struct thread_context_t;
68 static int FfmpegThread( struct thread_context_t *p_context );
69 static int FfmpegExecute( AVCodecContext *s,
70                           int (*pf_func)(AVCodecContext *c2, void *arg2),
71                           void **arg, int *ret, int count );
72
73 /*****************************************************************************
74  * thread_context_t : for multithreaded encoding
75  *****************************************************************************/
76 struct thread_context_t
77 {
78     VLC_COMMON_MEMBERS
79
80     AVCodecContext  *p_context;
81     int             (* pf_func)(AVCodecContext *c, void *arg);
82     void            *arg;
83     int             i_ret;
84
85     vlc_mutex_t     lock;
86     vlc_cond_t      cond;
87     vlc_bool_t      b_work, b_done;
88 };
89
90 /*****************************************************************************
91  * encoder_sys_t : ffmpeg encoder descriptor
92  *****************************************************************************/
93 struct encoder_sys_t
94 {
95     /*
96      * Ffmpeg properties
97      */
98     AVCodec         *p_codec;
99     AVCodecContext  *p_context;
100
101     /*
102      * Common properties
103      */
104     char *p_buffer;
105     char *p_buffer_out;
106
107     /*
108      * Video properties
109      */
110     mtime_t i_last_ref_pts;
111     mtime_t i_buggy_pts_detect;
112     mtime_t i_last_pts;
113     vlc_bool_t b_inited;
114
115     /*
116      * Audio properties
117      */
118     int i_frame_size;
119     int i_samples_delay;
120     mtime_t i_pts;
121
122     /* Encoding settings */
123     int        i_key_int;
124     int        i_b_frames;
125     int        i_vtolerance;
126     int        i_qmin;
127     int        i_qmax;
128     int        i_hq;
129     vlc_bool_t b_strict_rc;
130     int        i_rc_buffer_size;
131     float      f_rc_buffer_aggressivity;
132     vlc_bool_t b_pre_me;
133     vlc_bool_t b_hurry_up;
134     vlc_bool_t b_interlace, b_interlace_me;
135     float      f_i_quant_factor;
136     int        i_noise_reduction;
137     vlc_bool_t b_mpeg4_matrix;
138     vlc_bool_t b_trellis;
139     int        i_quality; /* for VBR */
140     float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
141     int        i_luma_elim, i_chroma_elim;
142
143     /* Used to work around stupid timestamping behaviour in libavcodec */
144     uint64_t i_framenum;
145     mtime_t  pi_delay_pts[MAX_FRAME_DELAY];
146 };
147
148 static const char *ppsz_enc_options[] = {
149     "keyint", "bframes", "vt", "qmin", "qmax", "hq", "strict-rc",
150     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
151     "interlace", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
152     "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
153     "p-masking", "border-masking", "luma-elim-threshold",
154     "chroma-elim-threshold", NULL
155 };
156
157 static const uint16_t mpa_bitrate_tab[2][15] =
158 {
159     {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
160     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
161 };
162
163 static const uint16_t mpa_freq_tab[6] =
164 { 44100, 48000, 32000, 22050, 24000, 16000 };
165
166 static const uint16_t mpeg4_default_intra_matrix[64] = {
167   8, 17, 18, 19, 21, 23, 25, 27,
168  17, 18, 19, 21, 23, 25, 27, 28,
169  20, 21, 22, 23, 24, 26, 28, 30,
170  21, 22, 23, 24, 26, 28, 30, 32,
171  22, 23, 24, 26, 28, 30, 32, 35,
172  23, 24, 26, 28, 30, 32, 35, 38,
173  25, 26, 28, 30, 32, 35, 38, 41,
174  27, 28, 30, 32, 35, 38, 41, 45,
175 };
176
177 static const uint16_t mpeg4_default_non_intra_matrix[64] = {
178  16, 17, 18, 19, 20, 21, 22, 23,
179  17, 18, 19, 20, 21, 22, 23, 24,
180  18, 19, 20, 21, 22, 23, 24, 25,
181  19, 20, 21, 22, 23, 24, 26, 27,
182  20, 21, 22, 23, 25, 26, 27, 28,
183  21, 22, 23, 24, 26, 27, 28, 30,
184  22, 23, 24, 26, 27, 28, 30, 31,
185  23, 24, 25, 27, 28, 30, 31, 33,
186 };
187
188
189 /*****************************************************************************
190  * OpenEncoder: probe the encoder
191  *****************************************************************************/
192
193 int E_(OpenEncoder)( vlc_object_t *p_this )
194 {
195     encoder_t *p_enc = (encoder_t *)p_this;
196     encoder_sys_t *p_sys = p_enc->p_sys;
197     AVCodecContext *p_context;
198     AVCodec *p_codec;
199     int i_codec_id, i_cat;
200     const char *psz_namecodec;
201     vlc_value_t val;
202
203     if( !E_(GetFfmpegCodec)( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
204                              &psz_namecodec ) )
205     {
206         if( E_(GetFfmpegChroma)( p_enc->fmt_out.i_codec ) < 0 )
207         {
208             /* handed chroma output */
209             return VLC_EGENERIC;
210         }
211         i_cat      = VIDEO_ES;
212         i_codec_id = CODEC_ID_RAWVIDEO;
213         psz_namecodec = "Raw video";
214     }
215
216     if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
217     {
218         msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
219         intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
220                         _("\"%s\" is no video encoder."), psz_namecodec );
221         return VLC_EGENERIC;
222     }
223
224     if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
225     {
226         msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
227         intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
228                         _("\"%s\" is no audio encoder."), psz_namecodec );
229         return VLC_EGENERIC;
230     }
231
232     /* Initialization must be done before avcodec_find_encoder() */
233     E_(InitLibavcodec)(p_this);
234
235     p_codec = avcodec_find_encoder( i_codec_id );
236     if( !p_codec )
237     {
238         msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
239         intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
240                         _("VLC could not find encoder \"%s\"."), psz_namecodec );
241         return VLC_EGENERIC;
242     }
243
244     /* Allocate the memory needed to store the encoder's structure */
245     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
246     {
247         msg_Err( p_enc, "out of memory" );
248         return VLC_EGENERIC;
249     }
250     memset( p_sys, 0, sizeof(encoder_sys_t) );
251     p_enc->p_sys = p_sys;
252     p_sys->p_codec = p_codec;
253
254     p_enc->pf_encode_video = EncodeVideo;
255     p_enc->pf_encode_audio = EncodeAudio;
256
257     p_sys->p_buffer_out = NULL;
258     p_sys->p_buffer = NULL;
259
260     p_sys->p_context = p_context = avcodec_alloc_context();
261     p_context->debug = config_GetInt( p_enc, "ffmpeg-debug" );
262     p_context->opaque = (void *)p_this;
263
264     /* Set CPU capabilities */
265     unsigned i_cpu = vlc_CPU();
266     p_context->dsp_mask = 0;
267     if( !(i_cpu & CPU_CAPABILITY_MMX) )
268     {
269         p_context->dsp_mask |= FF_MM_MMX;
270     }
271     if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
272     {
273         p_context->dsp_mask |= FF_MM_MMXEXT;
274     }
275     if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
276     {
277         p_context->dsp_mask |= FF_MM_3DNOW;
278     }
279     if( !(i_cpu & CPU_CAPABILITY_SSE) )
280     {
281         p_context->dsp_mask |= FF_MM_SSE;
282         p_context->dsp_mask |= FF_MM_SSE2;
283     }
284
285     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
286
287     var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
288     p_sys->i_key_int = val.i_int;
289
290     var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
291     p_sys->i_b_frames = val.i_int;
292
293     var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
294     p_sys->i_vtolerance = val.i_int;
295
296     var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
297     p_sys->b_interlace = val.b_bool;
298
299     var_Get( p_enc, ENC_CFG_PREFIX "interlace-me", &val );
300     p_sys->b_interlace_me = val.b_bool;
301
302     var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
303     p_sys->b_pre_me = val.b_bool;
304
305     var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
306     p_sys->b_hurry_up = val.b_bool;
307     if( p_sys->b_hurry_up )
308     {
309         /* hurry up mode needs noise reduction, even small */
310         p_sys->i_noise_reduction = 1;
311     }
312
313     var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val );
314     p_sys->b_strict_rc = val.b_bool;
315     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
316     p_sys->i_rc_buffer_size = val.i_int;
317     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
318     p_sys->f_rc_buffer_aggressivity = val.f_float;
319
320     var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
321     p_sys->f_i_quant_factor = val.f_float;
322
323     var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
324     p_sys->i_noise_reduction = val.i_int;
325
326     var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
327     p_sys->b_mpeg4_matrix = val.b_bool;
328
329     var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
330     if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
331     p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
332
333     var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
334     if( val.psz_string && *val.psz_string )
335     {
336         if( !strcmp( val.psz_string, "rd" ) )
337             p_sys->i_hq = FF_MB_DECISION_RD;
338         else if( !strcmp( val.psz_string, "bits" ) )
339             p_sys->i_hq = FF_MB_DECISION_BITS;
340         else if( !strcmp( val.psz_string, "simple" ) )
341             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
342         else
343             p_sys->i_hq = FF_MB_DECISION_RD;
344     }
345     else
346         p_sys->i_hq = FF_MB_DECISION_RD;
347     if( val.psz_string ) free( val.psz_string );
348
349     var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
350     p_sys->i_qmin = val.i_int;
351     var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
352     p_sys->i_qmax = val.i_int;
353     var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
354     p_sys->b_trellis = val.b_bool;
355
356     var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
357     if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
358     p_context->strict_std_compliance = val.i_int;
359
360     var_Get( p_enc, ENC_CFG_PREFIX "lumi-masking", &val );
361     p_sys->f_lumi_masking = val.f_float;
362     var_Get( p_enc, ENC_CFG_PREFIX "dark-masking", &val );
363     p_sys->f_dark_masking = val.f_float;
364     var_Get( p_enc, ENC_CFG_PREFIX "p-masking", &val );
365     p_sys->f_p_masking = val.f_float;
366     var_Get( p_enc, ENC_CFG_PREFIX "border-masking", &val );
367     p_sys->f_border_masking = val.f_float;
368     var_Get( p_enc, ENC_CFG_PREFIX "luma-elim-threshold", &val );
369     p_sys->i_luma_elim = val.i_int;
370     var_Get( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold", &val );
371     p_sys->i_chroma_elim = val.i_int;
372
373     if( p_enc->fmt_in.i_cat == VIDEO_ES )
374     {
375         int i_aspect_num, i_aspect_den;
376
377         if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
378         {
379             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
380                       p_enc->fmt_in.video.i_height );
381             free( p_sys );
382             return VLC_EGENERIC;
383         }
384
385         p_context->width = p_enc->fmt_in.video.i_width;
386         p_context->height = p_enc->fmt_in.video.i_height;
387         if( p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v')
388              && (p_context->width > 720 || p_context->height > 576) )
389             p_context->level = 4; /* High level */
390
391         p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
392         p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
393
394         /* Defaults from ffmpeg.c */
395         p_context->qblur = 0.5;
396         p_context->qcompress = 0.5;
397         p_context->b_quant_offset = 1.25;
398         p_context->b_quant_factor = 1.25;
399         p_context->i_quant_offset = 0.0;
400         p_context->i_quant_factor = -0.8;
401
402         p_context->lumi_masking = p_sys->f_lumi_masking;
403         p_context->dark_masking = p_sys->f_dark_masking;
404         p_context->p_masking = p_sys->f_p_masking;
405         p_context->border_masking = p_sys->f_border_masking;
406         p_context->luma_elim_threshold = p_sys->i_luma_elim;
407         p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
408
409         if( p_sys->i_key_int > 0 )
410             p_context->gop_size = p_sys->i_key_int;
411         p_context->max_b_frames =
412             __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
413         p_context->b_frame_strategy = 0;
414         if( !p_context->max_b_frames  &&
415             (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
416                p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
417             p_context->flags |= CODEC_FLAG_LOW_DELAY;
418
419         av_reduce( &i_aspect_num, &i_aspect_den,
420                    p_enc->fmt_in.video.i_aspect,
421                    VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
422         av_reduce( &p_context->sample_aspect_ratio.num,
423                    &p_context->sample_aspect_ratio.den,
424                    i_aspect_num * (int64_t)p_context->height,
425                    i_aspect_den * (int64_t)p_context->width, 1 << 30 );
426
427         p_sys->p_buffer_out = malloc( p_context->height * p_context->width * 3 );
428
429         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
430         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
431         if( p_codec->pix_fmts )
432         {
433             const enum PixelFormat *p = p_codec->pix_fmts;
434             for( ; *p != -1; p++ )
435             {
436                 if( *p == p_context->pix_fmt ) break;
437             }
438             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
439             p_enc->fmt_in.i_codec = E_(GetVlcChroma)( p_context->pix_fmt );
440         }
441
442         if ( p_sys->b_strict_rc )
443         {
444             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
445             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
446             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
447             /* This is from ffmpeg's ffmpeg.c : */
448             p_context->rc_initial_buffer_occupancy
449                 = p_sys->i_rc_buffer_size * 3/4;
450             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
451         }
452
453         if ( p_sys->f_i_quant_factor != 0.0 )
454             p_context->i_quant_factor = p_sys->f_i_quant_factor;
455
456         p_context->noise_reduction = p_sys->i_noise_reduction;
457
458         if ( p_sys->b_mpeg4_matrix )
459         {
460             p_context->intra_matrix = mpeg4_default_intra_matrix;
461             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
462         }
463
464         if ( p_sys->b_pre_me )
465         {
466             p_context->pre_me = 1;
467             p_context->me_pre_cmp = FF_CMP_CHROMA;
468         }
469
470         if ( p_sys->b_interlace )
471         {
472             if ( p_context->height <= 280 )
473             {
474                 if ( p_context->height != 16 || p_context->width != 16 )
475                     msg_Warn( p_enc,
476                         "disabling interlaced video because height=%d <= 280",
477                         p_context->height );
478             }
479             else
480             {
481                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
482                 if ( p_sys->b_interlace_me )
483                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
484             }
485         }
486
487         if ( p_sys->b_trellis )
488             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
489
490         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
491             p_context->flags |= CODEC_FLAG_QSCALE;
492
493         if ( p_enc->i_threads >= 1 )
494             p_context->thread_count = p_enc->i_threads;
495
496         if( p_sys->i_vtolerance > 0 )
497             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
498
499         /* usually if someone sets bitrate, he likes more to get that bitrate over quality 
500          * should help 'normal' user to get asked bitrate
501          */
502         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
503         {
504             p_sys->i_qmax = 51;
505             p_sys->i_qmin = 3;
506         }
507
508         if( p_sys->i_qmin > 0 )
509         {
510             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
511             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
512         }
513         if( p_sys->i_qmax > 0 )
514         {
515             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
516             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
517         }
518         p_context->max_qdiff = 3;
519
520         p_context->mb_decision = p_sys->i_hq;
521
522         if( p_sys->i_quality )
523         {
524             p_context->flags |= CODEC_FLAG_QSCALE;
525             p_context->global_quality = p_sys->i_quality;
526         }
527     }
528     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
529     {
530         /* work around bug in libmp3lame encoding */
531         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
532             p_enc->fmt_in.audio.i_channels = 2;
533
534         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
535         p_context->sample_rate = p_enc->fmt_in.audio.i_rate;
536         p_context->channels    = p_enc->fmt_in.audio.i_channels;
537     }
538
539     /* Misc parameters */
540     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
541
542     if( i_codec_id == CODEC_ID_RAWVIDEO )
543     {
544         /* XXX: hack: Force same codec (will be handled by transcode) */
545         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
546         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
547     }
548
549     /* Make sure we get extradata filled by the encoder */
550     p_context->extradata_size = 0;
551     p_context->extradata = NULL;
552     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
553
554     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
555
556     if( avcodec_open( p_context, p_codec ) )
557     {
558         vlc_mutex_unlock( lock );
559         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
560              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
561                || i_codec_id == CODEC_ID_MP3) )
562         {
563             if( p_context->channels > 2 )
564             {
565                 p_context->channels = 2;
566                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
567                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
568             }
569
570             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
571             {
572                 int i_frequency, i;
573
574                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
575                 {
576                     if ( p_enc->fmt_out.audio.i_rate
577                             == mpa_freq_tab[i_frequency] )
578                         break;
579                 }
580                 if ( i_frequency == 6 )
581                 {
582                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
583                              p_enc->fmt_out.audio.i_rate );
584                     free( p_sys );
585                     return VLC_EGENERIC;
586                 }
587
588                 for ( i = 1; i < 14; i++ )
589                 {
590                     if ( p_enc->fmt_out.i_bitrate / 1000
591                           <= mpa_bitrate_tab[i_frequency / 3][i] )
592                         break;
593                 }
594                 if ( p_enc->fmt_out.i_bitrate / 1000
595                       != mpa_bitrate_tab[i_frequency / 3][i] )
596                 {
597                     msg_Warn( p_enc,
598                               "MPEG audio doesn't support bitrate=%d, using %d",
599                               p_enc->fmt_out.i_bitrate,
600                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
601                     p_enc->fmt_out.i_bitrate =
602                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
603                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
604                 }
605             }
606
607             p_context->codec = NULL;
608             vlc_mutex_lock( lock );
609             if( avcodec_open( p_context, p_codec ) )
610             {
611                 vlc_mutex_unlock( lock );
612                 msg_Err( p_enc, "cannot open encoder" );
613                 intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
614                                 _("VLC could not open the encoder.") );
615                 free( p_sys );
616                 return VLC_EGENERIC;
617             }
618         }
619         else
620         {
621             msg_Err( p_enc, "cannot open encoder" );
622             intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
623                             _("VLC could not open the encoder.") );
624             free( p_sys );
625             return VLC_EGENERIC;
626         }
627     }
628     vlc_mutex_unlock( lock);
629
630     p_enc->fmt_out.i_extra = p_context->extradata_size;
631     if( p_enc->fmt_out.i_extra )
632     {
633         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
634         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
635                 p_enc->fmt_out.i_extra );
636     }
637     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
638
639     if( p_enc->fmt_in.i_cat == AUDIO_ES )
640     {
641         p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
642         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
643         p_sys->p_buffer = malloc( p_sys->i_frame_size );
644         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
645     }
646
647     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
648
649     return VLC_SUCCESS;
650 }
651
652 /****************************************************************************
653  * Ffmpeg threading system
654  ****************************************************************************/
655 static int FfmpegThread( struct thread_context_t *p_context )
656 {
657     while ( !p_context->b_die && !p_context->b_error )
658     {
659         vlc_mutex_lock( &p_context->lock );
660         while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
661         {
662             vlc_cond_wait( &p_context->cond, &p_context->lock );
663         }
664         p_context->b_work = 0;
665         vlc_mutex_unlock( &p_context->lock );
666         if ( p_context->b_die || p_context->b_error )
667             break;
668
669         if ( p_context->pf_func )
670         {
671             p_context->i_ret = p_context->pf_func( p_context->p_context,
672                                                    p_context->arg );
673         }
674
675         vlc_mutex_lock( &p_context->lock );
676         p_context->b_done = 1;
677         vlc_cond_signal( &p_context->cond );
678         vlc_mutex_unlock( &p_context->lock );
679     }
680
681     return 0;
682 }
683
684 static int FfmpegExecute( AVCodecContext *s,
685                           int (*pf_func)(AVCodecContext *c2, void *arg2),
686                           void **arg, int *ret, int count )
687 {
688     struct thread_context_t ** pp_contexts =
689                          (struct thread_context_t **)s->thread_opaque;
690     int i;
691
692     /* Note, we can be certain that this is not called with the same
693      * AVCodecContext by different threads at the same time */
694     for ( i = 0; i < count; i++ )
695     {
696         vlc_mutex_lock( &pp_contexts[i]->lock );
697         pp_contexts[i]->arg = arg[i];
698         pp_contexts[i]->pf_func = pf_func;
699         pp_contexts[i]->i_ret = 12345;
700         pp_contexts[i]->b_work = 1;
701         vlc_cond_signal( &pp_contexts[i]->cond );
702         vlc_mutex_unlock( &pp_contexts[i]->lock );
703     }
704     for ( i = 0; i < count; i++ )
705     {
706         vlc_mutex_lock( &pp_contexts[i]->lock );
707         while ( !pp_contexts[i]->b_done )
708         {
709             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
710         }
711         pp_contexts[i]->b_done = 0;
712         pp_contexts[i]->pf_func = NULL;
713         vlc_mutex_unlock( &pp_contexts[i]->lock );
714
715         if ( ret )
716         {
717             ret[i] = pp_contexts[i]->i_ret;
718         }
719     }
720
721     return 0;
722 }
723
724 /****************************************************************************
725  * EncodeVideo: the whole thing
726  ****************************************************************************/
727 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
728 {
729     encoder_sys_t *p_sys = p_enc->p_sys;
730     AVFrame frame;
731     int i_out, i_plane;
732
733     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
734     {
735         struct thread_context_t ** pp_contexts;
736         int i;
737
738         p_sys->b_inited = 1;
739         pp_contexts = malloc( sizeof(struct thread_context_t *)
740                                  * p_enc->i_threads );
741         p_sys->p_context->thread_opaque = (void *)pp_contexts;
742
743         for ( i = 0; i < p_enc->i_threads; i++ )
744         {
745             pp_contexts[i] = vlc_object_create( p_enc,
746                                      sizeof(struct thread_context_t) );
747             pp_contexts[i]->p_context = p_sys->p_context;
748             vlc_mutex_init( p_enc, &pp_contexts[i]->lock );
749             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
750             pp_contexts[i]->b_work = 0;
751             pp_contexts[i]->b_done = 0;
752             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
753                                     VLC_THREAD_PRIORITY_VIDEO, VLC_FALSE ) )
754             {
755                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
756                 return NULL;
757             }
758         }
759
760         p_sys->p_context->execute = FfmpegExecute;
761     }
762
763     memset( &frame, 0, sizeof( AVFrame ) );
764     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
765     {
766         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
767         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
768     }
769
770     /* Let ffmpeg select the frame type */
771     frame.pict_type = 0;
772
773     frame.repeat_pict = p_pict->i_nb_fields - 2;
774     frame.interlaced_frame = !p_pict->b_progressive;
775     frame.top_field_first = !!p_pict->b_top_field_first;
776
777     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
778     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
779     {
780         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
781
782         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
783         {
784             mtime_t current_date = mdate();
785
786             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
787             {
788                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
789                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
790                 msg_Dbg( p_enc, "hurry up mode 3" );
791             }
792             else
793             {
794                 p_sys->p_context->mb_decision = p_sys->i_hq;
795
796                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
797                 {
798                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
799                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
800                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
801                     msg_Dbg( p_enc, "hurry up mode 2" );
802                 }
803                 else
804                 {
805                     if ( p_sys->b_trellis )
806                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
807
808                     p_sys->p_context->noise_reduction =
809                         p_sys->i_noise_reduction;
810                 }
811             }
812
813             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
814             {
815                 frame.pict_type = FF_P_TYPE;
816                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
817             }
818         }
819     }
820     else
821     {
822         frame.pts = (int64_t)AV_NOPTS_VALUE;
823     }
824
825     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
826     {
827         if ( p_sys->i_last_pts == frame.pts )
828         {
829             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
830                       "same PTS (" I64Fd ")", frame.pts );
831             return NULL;
832         }
833         else if ( p_sys->i_last_pts > frame.pts )
834         {
835             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
836                       "past (current: " I64Fd ", last: "I64Fd")",
837                       frame.pts, p_sys->i_last_pts );
838             return NULL;
839         }
840         else
841         {
842             p_sys->i_last_pts = frame.pts;
843         }
844     }
845
846     frame.quality = p_sys->i_quality;
847
848     /* Ugly work-around for stupid libavcodec behaviour */
849     p_sys->i_framenum++;
850     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
851     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
852         p_enc->fmt_in.video.i_frame_rate_base;
853     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
854     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
855     /* End work-around */
856
857     i_out = avcodec_encode_video( p_sys->p_context, (uint8_t*)p_sys->p_buffer_out,
858                                   p_sys->p_context->height * p_sys->p_context->width * 3, &frame );
859
860     if( i_out > 0 )
861     {
862         block_t *p_block = block_New( p_enc, i_out );
863         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
864
865         /* FIXME, 3-2 pulldown is not handled correctly */
866         p_block->i_length = I64C(1000000) *
867             p_enc->fmt_in.video.i_frame_rate_base /
868                 p_enc->fmt_in.video.i_frame_rate;
869
870         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
871         {
872             /* No delay -> output pts == input pts */
873             p_block->i_pts = p_block->i_dts = p_pict->date;
874         }
875         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
876             p_sys->p_context->coded_frame->pts != 0 &&
877             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
878         {
879             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
880             p_block->i_pts = p_sys->p_context->coded_frame->pts;
881
882             /* Ugly work-around for stupid libavcodec behaviour */
883             {
884                 int64_t i_framenum = p_block->i_pts *
885                     p_enc->fmt_in.video.i_frame_rate /
886                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
887
888                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
889             }
890             /* End work-around */
891
892             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
893                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
894             {
895                 p_block->i_dts = p_block->i_pts;
896             }
897             else
898             {
899                 if( p_sys->i_last_ref_pts )
900                 {
901                     p_block->i_dts = p_sys->i_last_ref_pts;
902                 }
903                 else
904                 {
905                     /* Let's put something sensible */
906                     p_block->i_dts = p_block->i_pts;
907                 }
908
909                 p_sys->i_last_ref_pts = p_block->i_pts;
910             }
911         }
912         else
913         {
914             /* Buggy libavcodec which doesn't update coded_frame->pts
915              * correctly */
916             p_block->i_dts = p_block->i_pts = p_pict->date;
917         }
918
919         switch ( p_sys->p_context->coded_frame->pict_type )
920         {
921         case FF_I_TYPE:
922             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
923             break;
924         case FF_P_TYPE:
925             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
926             break;
927         case FF_B_TYPE:
928             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
929             break;
930         }
931
932         return p_block;
933     }
934
935     return NULL;
936 }
937
938 /****************************************************************************
939  * EncodeAudio: the whole thing
940  ****************************************************************************/
941 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
942 {
943     encoder_sys_t *p_sys = p_enc->p_sys;
944     block_t *p_block, *p_chain = NULL;
945
946     uint8_t *p_buffer = p_aout_buf->p_buffer;
947     int i_samples = p_aout_buf->i_nb_samples;
948     int i_samples_delay = p_sys->i_samples_delay;
949
950     p_sys->i_pts = p_aout_buf->start_date -
951                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
952                 (mtime_t)p_enc->fmt_in.audio.i_rate;
953
954     p_sys->i_samples_delay += i_samples;
955
956     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
957     {
958         int16_t *p_samples;
959         int i_out;
960
961         if( i_samples_delay )
962         {
963             /* Take care of the left-over from last time */
964             int i_delay_size = i_samples_delay * 2 *
965                                  p_sys->p_context->channels;
966             int i_size = p_sys->i_frame_size - i_delay_size;
967
968             p_samples = (int16_t *)p_sys->p_buffer;
969             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
970             p_buffer -= i_delay_size;
971             i_samples += i_samples_delay;
972             i_samples_delay = 0;
973         }
974         else
975         {
976             p_samples = (int16_t *)p_buffer;
977         }
978
979         i_out = avcodec_encode_audio( p_sys->p_context, (uint8_t *)p_sys->p_buffer_out,
980                                       2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
981                                       p_samples );
982
983 #if 0
984         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
985 #endif
986         if( i_out < 0 ) break;
987
988         p_buffer += p_sys->i_frame_size;
989         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
990         i_samples -= p_sys->p_context->frame_size;
991
992         if( i_out == 0 ) continue;
993
994         p_block = block_New( p_enc, i_out );
995         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
996
997         p_block->i_length = (mtime_t)1000000 *
998             (mtime_t)p_sys->p_context->frame_size /
999             (mtime_t)p_sys->p_context->sample_rate;
1000
1001         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1002
1003         /* Update pts */
1004         p_sys->i_pts += p_block->i_length;
1005         block_ChainAppend( &p_chain, p_block );
1006     }
1007
1008     /* Backup the remaining raw samples */
1009     if( i_samples )
1010     {
1011         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1012                 p_sys->p_context->channels, p_buffer,
1013                 i_samples * 2 * p_sys->p_context->channels );
1014     }
1015
1016     return p_chain;
1017 }
1018
1019 /*****************************************************************************
1020  * CloseEncoder: ffmpeg encoder destruction
1021  *****************************************************************************/
1022 void E_(CloseEncoder)( vlc_object_t *p_this )
1023 {
1024     encoder_t *p_enc = (encoder_t *)p_this;
1025     encoder_sys_t *p_sys = p_enc->p_sys;
1026
1027     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1028     {
1029         int i;
1030         struct thread_context_t ** pp_contexts =
1031                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1032         for ( i = 0; i < p_enc->i_threads; i++ )
1033         {
1034             vlc_object_kill( pp_contexts[i] );
1035             vlc_cond_signal( &pp_contexts[i]->cond );
1036             vlc_thread_join( pp_contexts[i] );
1037             vlc_mutex_destroy( &pp_contexts[i]->lock );
1038             vlc_cond_destroy( &pp_contexts[i]->cond );
1039             vlc_object_destroy( pp_contexts[i] );
1040         }
1041
1042         free( pp_contexts );
1043     }
1044
1045     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
1046     avcodec_close( p_sys->p_context );
1047     vlc_mutex_unlock( lock );
1048     av_free( p_sys->p_context );
1049
1050     if( p_sys->p_buffer ) free( p_sys->p_buffer );
1051     if( p_sys->p_buffer_out ) free( p_sys->p_buffer_out );
1052
1053     free( p_sys );
1054 }