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