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