Use the right declaration for threaded functions.
[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( GetFfmpegChroma( p_enc->fmt_out.i_codec ) < 0 )
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_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
464         if( p_codec->pix_fmts )
465         {
466             const enum PixelFormat *p = p_codec->pix_fmts;
467             for( ; *p != -1; p++ )
468             {
469                 if( *p == p_context->pix_fmt ) break;
470             }
471             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
472             p_enc->fmt_in.i_codec = GetVlcChroma( p_context->pix_fmt );
473         }
474
475
476         if ( p_sys->f_i_quant_factor != 0.0 )
477             p_context->i_quant_factor = p_sys->f_i_quant_factor;
478
479         p_context->noise_reduction = p_sys->i_noise_reduction;
480
481         if ( p_sys->b_mpeg4_matrix )
482         {
483             p_context->intra_matrix = mpeg4_default_intra_matrix;
484             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
485         }
486
487         if ( p_sys->b_pre_me )
488         {
489             p_context->pre_me = 1;
490             p_context->me_pre_cmp = FF_CMP_CHROMA;
491         }
492
493         if ( p_sys->b_interlace )
494         {
495             if ( p_context->height <= 280 )
496             {
497                 if ( p_context->height != 16 || p_context->width != 16 )
498                     msg_Warn( p_enc,
499                         "disabling interlaced video because height=%d <= 280",
500                         p_context->height );
501             }
502             else
503             {
504                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
505                 if ( p_sys->b_interlace_me )
506                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
507             }
508         }
509
510         if ( p_sys->b_trellis )
511             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
512
513         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
514             p_context->flags |= CODEC_FLAG_QSCALE;
515
516         if ( p_enc->i_threads >= 1 )
517             p_context->thread_count = p_enc->i_threads;
518
519         if( p_sys->i_vtolerance > 0 )
520             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
521
522         /* usually if someone sets bitrate, he likes more to get that bitrate
523          * over quality should help 'normal' user to get asked bitrate
524          */
525         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
526         {
527             p_sys->i_qmax = 51;
528             p_sys->i_qmin = 3;
529         }
530
531         if( p_sys->i_qmin > 0 )
532         {
533             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
534             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
535         }
536         if( p_sys->i_qmax > 0 )
537         {
538             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
539             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
540         }
541         p_context->max_qdiff = 3;
542
543         p_context->mb_decision = p_sys->i_hq;
544
545         if( p_sys->i_quality )
546         {
547             p_context->flags |= CODEC_FLAG_QSCALE;
548             p_context->global_quality = p_sys->i_quality;
549         }
550         else
551         {
552             p_context->rc_qsquish = 1.0;
553             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
554             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
555             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
556             /* This is from ffmpeg's ffmpeg.c : */
557             p_context->rc_initial_buffer_occupancy
558                 = p_sys->i_rc_buffer_size * 3/4;
559             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
560         }
561     }
562     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
563     {
564         /* work around bug in libmp3lame encoding */
565         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
566             p_enc->fmt_in.audio.i_channels = 2;
567
568         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
569         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
570         p_context->channels    = p_enc->fmt_out.audio.i_channels;
571
572         if ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') )
573         {
574             /* XXX: FAAC does resample only when setting the INPUT samplerate
575              * to the desired value (-R option of the faac frontend)
576             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
577 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
578         /* Ignore FF_PROFILE_UNKNOWN */
579         if( p_sys->i_aac_profile >= FF_PROFILE_AAC_MAIN )
580             p_context->profile = p_sys->i_aac_profile;
581 #endif
582         }
583     }
584
585     /* Misc parameters */
586     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
587
588     if( i_codec_id == CODEC_ID_RAWVIDEO )
589     {
590         /* XXX: hack: Force same codec (will be handled by transcode) */
591         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
592         p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
593     }
594
595     /* Make sure we get extradata filled by the encoder */
596     p_context->extradata_size = 0;
597     p_context->extradata = NULL;
598     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
599
600     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
601
602     if( avcodec_open( p_context, p_codec ) )
603     {
604         vlc_mutex_unlock( lock );
605         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
606              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
607                || i_codec_id == CODEC_ID_MP3) )
608         {
609             if( p_context->channels > 2 )
610             {
611                 p_context->channels = 2;
612                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
613                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
614             }
615
616             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
617             {
618                 int i_frequency, i;
619
620                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
621                 {
622                     if ( p_enc->fmt_out.audio.i_rate
623                             == mpa_freq_tab[i_frequency] )
624                         break;
625                 }
626                 if ( i_frequency == 6 )
627                 {
628                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
629                              p_enc->fmt_out.audio.i_rate );
630                     free( p_sys );
631                     return VLC_EGENERIC;
632                 }
633
634                 for ( i = 1; i < 14; i++ )
635                 {
636                     if ( p_enc->fmt_out.i_bitrate / 1000
637                           <= mpa_bitrate_tab[i_frequency / 3][i] )
638                         break;
639                 }
640                 if ( p_enc->fmt_out.i_bitrate / 1000
641                       != mpa_bitrate_tab[i_frequency / 3][i] )
642                 {
643                     msg_Warn( p_enc,
644                               "MPEG audio doesn't support bitrate=%d, using %d",
645                               p_enc->fmt_out.i_bitrate,
646                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
647                     p_enc->fmt_out.i_bitrate =
648                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
649                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
650                 }
651             }
652
653             p_context->codec = NULL;
654             vlc_mutex_lock( lock );
655             if( avcodec_open( p_context, p_codec ) )
656             {
657                 vlc_mutex_unlock( lock );
658                 msg_Err( p_enc, "cannot open encoder" );
659                 intf_UserFatal( p_enc, false,
660                                 _("Streaming / Transcoding failed"),
661                                 _("VLC could not open the encoder.") );
662                 free( p_sys );
663                 return VLC_EGENERIC;
664             }
665         }
666         else
667         {
668             msg_Err( p_enc, "cannot open encoder" );
669             intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
670                             _("VLC could not open the encoder.") );
671             free( p_sys );
672             return VLC_EGENERIC;
673         }
674     }
675     vlc_mutex_unlock( lock);
676
677     p_enc->fmt_out.i_extra = p_context->extradata_size;
678     if( p_enc->fmt_out.i_extra )
679     {
680         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
681         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
682                 p_enc->fmt_out.i_extra );
683     }
684     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
685
686     if( p_enc->fmt_in.i_cat == AUDIO_ES )
687     {
688         p_sys->i_buffer_out = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
689         p_sys->p_buffer_out = malloc( p_sys->i_buffer_out );
690         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
691         p_sys->p_buffer = malloc( p_sys->i_frame_size );
692         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
693     }
694
695     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
696
697     return VLC_SUCCESS;
698 }
699
700 /****************************************************************************
701  * Ffmpeg threading system
702  ****************************************************************************/
703 static void* FfmpegThread( vlc_object_t *p_this )
704 {
705     struct thread_context_t *p_context = (struct thread_context_t *)p_this;
706     while ( vlc_object_alive (p_context) && !p_context->b_error )
707     {
708         vlc_mutex_lock( &p_context->lock );
709         while ( !p_context->b_work && vlc_object_alive (p_context) && !p_context->b_error )
710         {
711             vlc_cond_wait( &p_context->cond, &p_context->lock );
712         }
713         p_context->b_work = 0;
714         vlc_mutex_unlock( &p_context->lock );
715         if ( !vlc_object_alive (p_context) || p_context->b_error )
716             break;
717
718         if ( p_context->pf_func )
719         {
720             p_context->i_ret = p_context->pf_func( p_context->p_context,
721                                                    p_context->arg );
722         }
723
724         vlc_mutex_lock( &p_context->lock );
725         p_context->b_done = 1;
726         vlc_cond_signal( &p_context->cond );
727         vlc_mutex_unlock( &p_context->lock );
728     }
729
730     return NULL;
731 }
732
733 static int FfmpegExecute( AVCodecContext *s,
734                           int (*pf_func)(AVCodecContext *c2, void *arg2),
735                           void **arg, int *ret, int count )
736 {
737     struct thread_context_t ** pp_contexts =
738                          (struct thread_context_t **)s->thread_opaque;
739     int i;
740
741     /* Note, we can be certain that this is not called with the same
742      * AVCodecContext by different threads at the same time */
743     for ( i = 0; i < count; i++ )
744     {
745         vlc_mutex_lock( &pp_contexts[i]->lock );
746         pp_contexts[i]->arg = arg[i];
747         pp_contexts[i]->pf_func = pf_func;
748         pp_contexts[i]->i_ret = 12345;
749         pp_contexts[i]->b_work = 1;
750         vlc_cond_signal( &pp_contexts[i]->cond );
751         vlc_mutex_unlock( &pp_contexts[i]->lock );
752     }
753     for ( i = 0; i < count; i++ )
754     {
755         vlc_mutex_lock( &pp_contexts[i]->lock );
756         while ( !pp_contexts[i]->b_done )
757         {
758             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
759         }
760         pp_contexts[i]->b_done = 0;
761         pp_contexts[i]->pf_func = NULL;
762         vlc_mutex_unlock( &pp_contexts[i]->lock );
763
764         if ( ret )
765         {
766             ret[i] = pp_contexts[i]->i_ret;
767         }
768     }
769
770     return 0;
771 }
772
773 /****************************************************************************
774  * EncodeVideo: the whole thing
775  ****************************************************************************/
776 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
777 {
778     encoder_sys_t *p_sys = p_enc->p_sys;
779     AVFrame frame;
780     int i_out, i_plane;
781
782     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
783     {
784         struct thread_context_t ** pp_contexts;
785         int i;
786
787         p_sys->b_inited = 1;
788         pp_contexts = malloc( sizeof(struct thread_context_t *)
789                                  * p_enc->i_threads );
790         p_sys->p_context->thread_opaque = (void *)pp_contexts;
791
792         for ( i = 0; i < p_enc->i_threads; i++ )
793         {
794             pp_contexts[i] = vlc_object_create( p_enc,
795                                      sizeof(struct thread_context_t) );
796             pp_contexts[i]->p_context = p_sys->p_context;
797             vlc_mutex_init( &pp_contexts[i]->lock );
798             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
799             pp_contexts[i]->b_work = 0;
800             pp_contexts[i]->b_done = 0;
801             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
802                                     VLC_THREAD_PRIORITY_VIDEO, false ) )
803             {
804                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
805                 return NULL;
806             }
807         }
808
809         p_sys->p_context->execute = FfmpegExecute;
810     }
811
812     memset( &frame, 0, sizeof( AVFrame ) );
813     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
814     {
815         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
816         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
817     }
818
819     /* Let ffmpeg select the frame type */
820     frame.pict_type = 0;
821
822     frame.repeat_pict = p_pict->i_nb_fields - 2;
823     frame.interlaced_frame = !p_pict->b_progressive;
824     frame.top_field_first = !!p_pict->b_top_field_first;
825
826     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
827     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
828     {
829         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
830
831         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
832         {
833             mtime_t current_date = mdate();
834
835             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
836             {
837                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
838                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
839                 msg_Dbg( p_enc, "hurry up mode 3" );
840             }
841             else
842             {
843                 p_sys->p_context->mb_decision = p_sys->i_hq;
844
845                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
846                 {
847                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
848                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
849                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
850                     msg_Dbg( p_enc, "hurry up mode 2" );
851                 }
852                 else
853                 {
854                     if ( p_sys->b_trellis )
855                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
856
857                     p_sys->p_context->noise_reduction =
858                         p_sys->i_noise_reduction;
859                 }
860             }
861
862             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
863             {
864                 frame.pict_type = FF_P_TYPE;
865                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
866             }
867         }
868     }
869     else
870     {
871         frame.pts = (int64_t)AV_NOPTS_VALUE;
872     }
873
874     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
875     {
876         if ( p_sys->i_last_pts == frame.pts )
877         {
878             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
879                       "same PTS (%"PRId64 ")", frame.pts );
880             return NULL;
881         }
882         else if ( p_sys->i_last_pts > frame.pts )
883         {
884             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
885                       "past (current: %"PRId64 ", last: %"PRId64")",
886                       frame.pts, p_sys->i_last_pts );
887             return NULL;
888         }
889         else
890         {
891             p_sys->i_last_pts = frame.pts;
892         }
893     }
894
895     frame.quality = p_sys->i_quality;
896
897     /* Ugly work-around for stupid libavcodec behaviour */
898     p_sys->i_framenum++;
899     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
900     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
901         p_enc->fmt_in.video.i_frame_rate_base;
902     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
903     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
904     /* End work-around */
905
906     i_out = avcodec_encode_video( p_sys->p_context, p_sys->p_buffer_out,
907                                   p_sys->i_buffer_out, &frame );
908
909     if( i_out > 0 )
910     {
911         block_t *p_block = block_New( p_enc, i_out );
912         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
913
914         /* FIXME, 3-2 pulldown is not handled correctly */
915         p_block->i_length = INT64_C(1000000) *
916             p_enc->fmt_in.video.i_frame_rate_base /
917                 p_enc->fmt_in.video.i_frame_rate;
918
919         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
920         {
921             /* No delay -> output pts == input pts */
922             p_block->i_pts = p_block->i_dts = p_pict->date;
923         }
924         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
925             p_sys->p_context->coded_frame->pts != 0 &&
926             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
927         {
928             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
929             p_block->i_pts = p_sys->p_context->coded_frame->pts;
930
931             /* Ugly work-around for stupid libavcodec behaviour */
932             {
933                 int64_t i_framenum = p_block->i_pts *
934                     p_enc->fmt_in.video.i_frame_rate /
935                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
936
937                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
938             }
939             /* End work-around */
940
941             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
942                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
943             {
944                 p_block->i_dts = p_block->i_pts;
945             }
946             else
947             {
948                 if( p_sys->i_last_ref_pts )
949                 {
950                     p_block->i_dts = p_sys->i_last_ref_pts;
951                 }
952                 else
953                 {
954                     /* Let's put something sensible */
955                     p_block->i_dts = p_block->i_pts;
956                 }
957
958                 p_sys->i_last_ref_pts = p_block->i_pts;
959             }
960         }
961         else
962         {
963             /* Buggy libavcodec which doesn't update coded_frame->pts
964              * correctly */
965             p_block->i_dts = p_block->i_pts = p_pict->date;
966         }
967
968         switch ( p_sys->p_context->coded_frame->pict_type )
969         {
970         case FF_I_TYPE:
971             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
972             break;
973         case FF_P_TYPE:
974             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
975             break;
976         case FF_B_TYPE:
977             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
978             break;
979         }
980
981         return p_block;
982     }
983
984     return NULL;
985 }
986
987 /****************************************************************************
988  * EncodeAudio: the whole thing
989  ****************************************************************************/
990 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
991 {
992     encoder_sys_t *p_sys = p_enc->p_sys;
993     block_t *p_block, *p_chain = NULL;
994
995     uint8_t *p_buffer = p_aout_buf->p_buffer;
996     int i_samples = p_aout_buf->i_nb_samples;
997     int i_samples_delay = p_sys->i_samples_delay;
998
999     p_sys->i_pts = p_aout_buf->start_date -
1000                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1001                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1002
1003     p_sys->i_samples_delay += i_samples;
1004
1005     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
1006     {
1007         int16_t *p_samples;
1008         int i_out;
1009
1010         if( i_samples_delay )
1011         {
1012             /* Take care of the left-over from last time */
1013             int i_delay_size = i_samples_delay * 2 *
1014                                  p_sys->p_context->channels;
1015             int i_size = p_sys->i_frame_size - i_delay_size;
1016
1017             p_samples = (int16_t *)p_sys->p_buffer;
1018             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
1019             p_buffer -= i_delay_size;
1020             i_samples += i_samples_delay;
1021             i_samples_delay = 0;
1022         }
1023         else
1024         {
1025             p_samples = (int16_t *)p_buffer;
1026         }
1027
1028         i_out = avcodec_encode_audio( p_sys->p_context, p_sys->p_buffer_out,
1029                                       p_sys->i_buffer_out, p_samples );
1030
1031 #if 0
1032         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1033 #endif
1034         if( i_out < 0 ) break;
1035
1036         p_buffer += p_sys->i_frame_size;
1037         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
1038         i_samples -= p_sys->p_context->frame_size;
1039
1040         if( i_out == 0 ) continue;
1041
1042         p_block = block_New( p_enc, i_out );
1043         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
1044
1045         p_block->i_length = (mtime_t)1000000 *
1046             (mtime_t)p_sys->p_context->frame_size /
1047             (mtime_t)p_sys->p_context->sample_rate;
1048
1049         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1050
1051         /* Update pts */
1052         p_sys->i_pts += p_block->i_length;
1053         block_ChainAppend( &p_chain, p_block );
1054     }
1055
1056     /* Backup the remaining raw samples */
1057     if( i_samples )
1058     {
1059         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1060                 p_sys->p_context->channels, p_buffer,
1061                 i_samples * 2 * p_sys->p_context->channels );
1062     }
1063
1064     return p_chain;
1065 }
1066
1067 /*****************************************************************************
1068  * CloseEncoder: ffmpeg encoder destruction
1069  *****************************************************************************/
1070 void CloseEncoder( vlc_object_t *p_this )
1071 {
1072     encoder_t *p_enc = (encoder_t *)p_this;
1073     encoder_sys_t *p_sys = p_enc->p_sys;
1074
1075     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1076     {
1077         int i;
1078         struct thread_context_t ** pp_contexts =
1079                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1080         for ( i = 0; i < p_enc->i_threads; i++ )
1081         {
1082             vlc_object_kill( pp_contexts[i] );
1083             vlc_cond_signal( &pp_contexts[i]->cond );
1084             vlc_thread_join( pp_contexts[i] );
1085             vlc_mutex_destroy( &pp_contexts[i]->lock );
1086             vlc_cond_destroy( &pp_contexts[i]->cond );
1087             vlc_object_release( pp_contexts[i] );
1088         }
1089
1090         free( pp_contexts );
1091     }
1092
1093     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
1094     avcodec_close( p_sys->p_context );
1095     vlc_mutex_unlock( lock );
1096     av_free( p_sys->p_context );
1097
1098     free( p_sys->p_buffer );
1099     free( p_sys->p_buffer_out );
1100
1101     free( p_sys );
1102 }