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