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