Fix FfmpegExecute callback prototype
[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, int );
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.   ***", 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 = calloc( 1, sizeof(encoder_sys_t) ) ) == NULL )
267         return VLC_ENOMEM;
268     p_enc->p_sys = p_sys;
269     p_sys->p_codec = p_codec;
270
271     p_enc->pf_encode_video = EncodeVideo;
272     p_enc->pf_encode_audio = EncodeAudio;
273
274     p_sys->p_buffer = NULL;
275     p_sys->p_buffer_out = NULL;
276     p_sys->i_buffer_out = 0;
277
278     p_sys->p_context = p_context = avcodec_alloc_context();
279     p_context->debug = config_GetInt( p_enc, "ffmpeg-debug" );
280     p_context->opaque = (void *)p_this;
281
282     /* Set CPU capabilities */
283     unsigned i_cpu = vlc_CPU();
284     p_context->dsp_mask = 0;
285     if( !(i_cpu & CPU_CAPABILITY_MMX) )
286     {
287         p_context->dsp_mask |= FF_MM_MMX;
288     }
289     if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
290     {
291         p_context->dsp_mask |= FF_MM_MMXEXT;
292     }
293     if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
294     {
295         p_context->dsp_mask |= FF_MM_3DNOW;
296     }
297     if( !(i_cpu & CPU_CAPABILITY_SSE) )
298     {
299         p_context->dsp_mask |= FF_MM_SSE;
300         p_context->dsp_mask |= FF_MM_SSE2;
301     }
302
303     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
304
305     var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
306     p_sys->i_key_int = val.i_int;
307
308     var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
309     p_sys->i_b_frames = val.i_int;
310
311     var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
312     p_sys->i_vtolerance = val.i_int * 1000;
313
314     var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
315     p_sys->b_interlace = val.b_bool;
316
317     var_Get( p_enc, ENC_CFG_PREFIX "interlace-me", &val );
318     p_sys->b_interlace_me = val.b_bool;
319
320     var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
321     p_sys->b_pre_me = val.b_bool;
322
323     var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
324     p_sys->b_hurry_up = val.b_bool;
325     if( p_sys->b_hurry_up )
326     {
327         /* hurry up mode needs noise reduction, even small */
328         p_sys->i_noise_reduction = 1;
329     }
330
331     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
332     p_sys->i_rc_buffer_size = val.i_int;
333     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
334     p_sys->f_rc_buffer_aggressivity = val.f_float;
335
336     var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
337     p_sys->f_i_quant_factor = val.f_float;
338
339     var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
340     p_sys->i_noise_reduction = val.i_int;
341
342     var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
343     p_sys->b_mpeg4_matrix = val.b_bool;
344
345     var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
346     if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
347     p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
348
349     var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
350     p_sys->i_hq = FF_MB_DECISION_RD;
351     if( val.psz_string && *val.psz_string )
352     {
353         if( !strcmp( val.psz_string, "rd" ) )
354             p_sys->i_hq = FF_MB_DECISION_RD;
355         else if( !strcmp( val.psz_string, "bits" ) )
356             p_sys->i_hq = FF_MB_DECISION_BITS;
357         else if( !strcmp( val.psz_string, "simple" ) )
358             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
359         else
360             p_sys->i_hq = FF_MB_DECISION_RD;
361     }
362     else
363         p_sys->i_hq = FF_MB_DECISION_RD;
364     free( val.psz_string );
365
366     var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
367     p_sys->i_qmin = val.i_int;
368     var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
369     p_sys->i_qmax = val.i_int;
370     var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
371     p_sys->b_trellis = val.b_bool;
372
373     var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
374     if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
375     p_context->strict_std_compliance = val.i_int;
376
377     var_Get( p_enc, ENC_CFG_PREFIX "lumi-masking", &val );
378     p_sys->f_lumi_masking = val.f_float;
379     var_Get( p_enc, ENC_CFG_PREFIX "dark-masking", &val );
380     p_sys->f_dark_masking = val.f_float;
381     var_Get( p_enc, ENC_CFG_PREFIX "p-masking", &val );
382     p_sys->f_p_masking = val.f_float;
383     var_Get( p_enc, ENC_CFG_PREFIX "border-masking", &val );
384     p_sys->f_border_masking = val.f_float;
385     var_Get( p_enc, ENC_CFG_PREFIX "luma-elim-threshold", &val );
386     p_sys->i_luma_elim = val.i_int;
387     var_Get( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold", &val );
388     p_sys->i_chroma_elim = val.i_int;
389
390 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
391     var_Get( p_enc, ENC_CFG_PREFIX "aac-profile", &val );
392     /* ffmpeg uses faac encoder atm, and it has issues with
393      * other than low-complexity profile, so default to that */
394     p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
395     if( val.psz_string && *val.psz_string )
396     {
397         if( !strncmp( val.psz_string, "main", 4 ) )
398             p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
399         else if( !strncmp( val.psz_string, "low", 3 ) )
400             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
401 #if 0    /* Not supported by FAAC encoder */
402         else if( !strncmp( val.psz_string, "ssr", 3 ) )
403             p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
404 #endif
405         else  if( !strncmp( val.psz_string, "ltp", 3 ) )
406             p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
407         else
408         {
409             msg_Warn( p_enc, "unknown AAC profile requested, setting it to low" );
410             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
411         }
412     }
413     free( val.psz_string );
414 #endif
415
416     if( p_enc->fmt_in.i_cat == VIDEO_ES )
417     {
418         int i_aspect_num, i_aspect_den;
419
420         if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
421         {
422             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
423                       p_enc->fmt_in.video.i_height );
424             free( p_sys );
425             return VLC_EGENERIC;
426         }
427
428         p_context->width = p_enc->fmt_in.video.i_width;
429         p_context->height = p_enc->fmt_in.video.i_height;
430
431         p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
432         p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
433
434         /* Defaults from ffmpeg.c */
435         p_context->qblur = 0.5;
436         p_context->qcompress = 0.5;
437         p_context->b_quant_offset = 1.25;
438         p_context->b_quant_factor = 1.25;
439         p_context->i_quant_offset = 0.0;
440         p_context->i_quant_factor = -0.8;
441
442         p_context->lumi_masking = p_sys->f_lumi_masking;
443         p_context->dark_masking = p_sys->f_dark_masking;
444         p_context->p_masking = p_sys->f_p_masking;
445         p_context->border_masking = p_sys->f_border_masking;
446         p_context->luma_elim_threshold = p_sys->i_luma_elim;
447         p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
448
449         if( p_sys->i_key_int > 0 )
450             p_context->gop_size = p_sys->i_key_int;
451         p_context->max_b_frames =
452             __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
453         p_context->b_frame_strategy = 0;
454         if( !p_context->max_b_frames  &&
455             (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
456                p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
457             p_context->flags |= CODEC_FLAG_LOW_DELAY;
458
459         av_reduce( &i_aspect_num, &i_aspect_den,
460                    p_enc->fmt_in.video.i_aspect,
461                    VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
462         av_reduce( &p_context->sample_aspect_ratio.num,
463                    &p_context->sample_aspect_ratio.den,
464                    i_aspect_num * (int64_t)p_context->height,
465                    i_aspect_den * (int64_t)p_context->width, 1 << 30 );
466
467         p_sys->i_buffer_out = p_context->height * p_context->width * 3;
468         if( p_sys->i_buffer_out < FF_MIN_BUFFER_SIZE )
469             p_sys->i_buffer_out = FF_MIN_BUFFER_SIZE;
470         p_sys->p_buffer_out = malloc( p_sys->i_buffer_out );
471
472         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
473         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
474         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
475
476         if( p_codec->pix_fmts )
477         {
478             const enum PixelFormat *p = p_codec->pix_fmts;
479             for( ; *p != -1; p++ )
480             {
481                 if( *p == p_context->pix_fmt ) break;
482             }
483             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
484             GetVlcChroma( &p_enc->fmt_in.video, p_context->pix_fmt );
485             p_enc->fmt_in.i_codec = p_enc->fmt_in.video.i_chroma;
486         }
487
488
489         if ( p_sys->f_i_quant_factor != 0.0 )
490             p_context->i_quant_factor = p_sys->f_i_quant_factor;
491
492         p_context->noise_reduction = p_sys->i_noise_reduction;
493
494         if ( p_sys->b_mpeg4_matrix )
495         {
496             p_context->intra_matrix = mpeg4_default_intra_matrix;
497             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
498         }
499
500         if ( p_sys->b_pre_me )
501         {
502             p_context->pre_me = 1;
503             p_context->me_pre_cmp = FF_CMP_CHROMA;
504         }
505
506         if ( p_sys->b_interlace )
507         {
508             if ( p_context->height <= 280 )
509             {
510                 if ( p_context->height != 16 || p_context->width != 16 )
511                     msg_Warn( p_enc,
512                         "disabling interlaced video because height=%d <= 280",
513                         p_context->height );
514             }
515             else
516             {
517                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
518                 if ( p_sys->b_interlace_me )
519                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
520             }
521         }
522
523 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
524         if ( p_sys->b_trellis )
525             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
526 #else
527         p_context->trellis = p_sys->b_trellis;
528 #endif
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         else
568         {
569             p_context->rc_qsquish = 1.0;
570             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
571             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
572             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
573             /* This is from ffmpeg's ffmpeg.c : */
574             p_context->rc_initial_buffer_occupancy
575                 = p_sys->i_rc_buffer_size * 3/4;
576             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
577         }
578     }
579     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
580     {
581         /* work around bug in libmp3lame encoding */
582         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
583             p_enc->fmt_in.audio.i_channels = 2;
584
585         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
586         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
587         p_context->channels    = p_enc->fmt_out.audio.i_channels;
588
589         if ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') )
590         {
591             /* XXX: FAAC does resample only when setting the INPUT samplerate
592              * to the desired value (-R option of the faac frontend)
593             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
594 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
595             /* vlc should default to low-complexity profile, faac encoder
596              * has bug and aac audio has issues otherwise atm */
597             p_context->profile = p_sys->i_aac_profile;
598 #endif
599         }
600     }
601
602     /* Misc parameters */
603     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
604
605     if( i_codec_id == CODEC_ID_RAWVIDEO )
606     {
607         /* XXX: hack: Force same codec (will be handled by transcode) */
608         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
609         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
610     }
611
612     /* Make sure we get extradata filled by the encoder */
613     p_context->extradata_size = 0;
614     p_context->extradata = NULL;
615     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
616
617     vlc_mutex_lock( &avcodec_lock );
618
619     if( avcodec_open( p_context, p_codec ) )
620     {
621         vlc_mutex_unlock( &avcodec_lock );
622         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
623              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
624                || i_codec_id == CODEC_ID_MP3) )
625         {
626             if( p_context->channels > 2 )
627             {
628                 p_context->channels = 2;
629                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
630                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
631             }
632
633             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
634             {
635                 int i_frequency, i;
636
637                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
638                 {
639                     if ( p_enc->fmt_out.audio.i_rate
640                             == mpa_freq_tab[i_frequency] )
641                         break;
642                 }
643                 if ( i_frequency == 6 )
644                 {
645                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
646                              p_enc->fmt_out.audio.i_rate );
647                     free( p_sys );
648                     return VLC_EGENERIC;
649                 }
650
651                 for ( i = 1; i < 14; i++ )
652                 {
653                     if ( p_enc->fmt_out.i_bitrate / 1000
654                           <= mpa_bitrate_tab[i_frequency / 3][i] )
655                         break;
656                 }
657                 if ( p_enc->fmt_out.i_bitrate / 1000
658                       != mpa_bitrate_tab[i_frequency / 3][i] )
659                 {
660                     msg_Warn( p_enc,
661                               "MPEG audio doesn't support bitrate=%d, using %d",
662                               p_enc->fmt_out.i_bitrate,
663                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
664                     p_enc->fmt_out.i_bitrate =
665                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
666                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
667                 }
668             }
669
670             p_context->codec = NULL;
671             vlc_mutex_lock( &avcodec_lock );
672             if( avcodec_open( p_context, p_codec ) )
673             {
674                 vlc_mutex_unlock( &avcodec_lock );
675                 msg_Err( p_enc, "cannot open encoder" );
676                 intf_UserFatal( p_enc, false,
677                                 _("Streaming / Transcoding failed"),
678                                 _("VLC could not open the encoder.") );
679                 free( p_sys );
680                 return VLC_EGENERIC;
681             }
682         }
683         else
684         {
685             msg_Err( p_enc, "cannot open encoder" );
686             intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
687                             _("VLC could not open the encoder.") );
688             free( p_sys );
689             return VLC_EGENERIC;
690         }
691     }
692     vlc_mutex_unlock( &avcodec_lock );
693
694     p_enc->fmt_out.i_extra = p_context->extradata_size;
695     if( p_enc->fmt_out.i_extra )
696     {
697         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
698         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
699                 p_enc->fmt_out.i_extra );
700     }
701     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
702
703     if( p_enc->fmt_in.i_cat == AUDIO_ES )
704     {
705         p_sys->i_buffer_out = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
706         p_sys->p_buffer_out = malloc( p_sys->i_buffer_out );
707         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
708         p_sys->p_buffer = malloc( p_sys->i_frame_size );
709         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
710     }
711
712     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
713
714     return VLC_SUCCESS;
715 }
716
717 /****************************************************************************
718  * Ffmpeg threading system
719  ****************************************************************************/
720 static void* FfmpegThread( vlc_object_t *p_this )
721 {
722     struct thread_context_t *p_context = (struct thread_context_t *)p_this;
723     int canc = vlc_savecancel ();
724     while ( vlc_object_alive (p_context) && !p_context->b_error )
725     {
726         vlc_mutex_lock( &p_context->lock );
727         while ( !p_context->b_work && vlc_object_alive (p_context) && !p_context->b_error )
728         {
729             vlc_cond_wait( &p_context->cond, &p_context->lock );
730         }
731         p_context->b_work = 0;
732         vlc_mutex_unlock( &p_context->lock );
733         if ( !vlc_object_alive (p_context) || p_context->b_error )
734             break;
735
736         if ( p_context->pf_func )
737         {
738             p_context->i_ret = p_context->pf_func( p_context->p_context,
739                                                    p_context->arg );
740         }
741
742         vlc_mutex_lock( &p_context->lock );
743         p_context->b_done = 1;
744         vlc_cond_signal( &p_context->cond );
745         vlc_mutex_unlock( &p_context->lock );
746     }
747
748     vlc_restorecancel (canc);
749     return NULL;
750 }
751
752 static int FfmpegExecute( AVCodecContext *s,
753                           int (*pf_func)(AVCodecContext *c2, void *arg2),
754                           void *arg, int *ret, int count, int size )
755 {
756     struct thread_context_t ** pp_contexts =
757                          (struct thread_context_t **)s->thread_opaque;
758     void **argv = arg;
759
760     /* Note, we can be certain that this is not called with the same
761      * AVCodecContext by different threads at the same time */
762     for ( int i = 0; i < count; i++ )
763     {
764         vlc_mutex_lock( &pp_contexts[i]->lock );
765         pp_contexts[i]->arg = argv[i];
766         pp_contexts[i]->pf_func = pf_func;
767         pp_contexts[i]->i_ret = 12345;
768         pp_contexts[i]->b_work = 1;
769         vlc_cond_signal( &pp_contexts[i]->cond );
770         vlc_mutex_unlock( &pp_contexts[i]->lock );
771     }
772     for ( int i = 0; i < count; i++ )
773     {
774         vlc_mutex_lock( &pp_contexts[i]->lock );
775         while ( !pp_contexts[i]->b_done )
776         {
777             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
778         }
779         pp_contexts[i]->b_done = 0;
780         pp_contexts[i]->pf_func = NULL;
781         vlc_mutex_unlock( &pp_contexts[i]->lock );
782
783         if ( ret )
784         {
785             ret[i] = pp_contexts[i]->i_ret;
786         }
787     }
788
789     (void)size;
790     return 0;
791 }
792
793 /****************************************************************************
794  * EncodeVideo: the whole thing
795  ****************************************************************************/
796 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
797 {
798     encoder_sys_t *p_sys = p_enc->p_sys;
799     AVFrame frame;
800     int i_out, i_plane;
801
802     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
803     {
804         struct thread_context_t ** pp_contexts;
805         int i;
806
807         p_sys->b_inited = 1;
808         pp_contexts = malloc( sizeof(struct thread_context_t *)
809                                  * p_enc->i_threads );
810         p_sys->p_context->thread_opaque = (void *)pp_contexts;
811
812         for ( i = 0; i < p_enc->i_threads; i++ )
813         {
814             pp_contexts[i] = vlc_object_create( p_enc,
815                                      sizeof(struct thread_context_t) );
816             pp_contexts[i]->p_context = p_sys->p_context;
817             vlc_mutex_init( &pp_contexts[i]->lock );
818             vlc_cond_init( &pp_contexts[i]->cond );
819             pp_contexts[i]->b_work = 0;
820             pp_contexts[i]->b_done = 0;
821             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
822                                     VLC_THREAD_PRIORITY_VIDEO ) )
823             {
824                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
825                 return NULL;
826             }
827         }
828
829         p_sys->p_context->execute = FfmpegExecute;
830     }
831
832     memset( &frame, 0, sizeof( AVFrame ) );
833     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
834     {
835         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
836         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
837     }
838
839     /* Let ffmpeg select the frame type */
840     frame.pict_type = 0;
841
842     frame.repeat_pict = p_pict->i_nb_fields - 2;
843     frame.interlaced_frame = !p_pict->b_progressive;
844     frame.top_field_first = !!p_pict->b_top_field_first;
845
846     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
847     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
848     {
849         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
850
851         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
852         {
853             mtime_t current_date = mdate();
854
855             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
856             {
857                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
858 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
859                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
860 #else
861                 p_sys->p_context->trellis = 0;
862 #endif
863                 msg_Dbg( p_enc, "hurry up mode 3" );
864             }
865             else
866             {
867                 p_sys->p_context->mb_decision = p_sys->i_hq;
868
869                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
870                 {
871 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
872                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
873 #else
874                     p_sys->p_context->trellis = 0;
875 #endif
876                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
877                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
878                     msg_Dbg( p_enc, "hurry up mode 2" );
879                 }
880                 else
881                 {
882 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
883                     if ( p_sys->b_trellis )
884                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
885 #else
886                     p_sys->p_context->trellis = p_sys->b_trellis;
887 #endif
888
889                     p_sys->p_context->noise_reduction =
890                         p_sys->i_noise_reduction;
891                 }
892             }
893
894             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
895             {
896                 frame.pict_type = FF_P_TYPE;
897                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
898             }
899         }
900     }
901     else
902     {
903         frame.pts = (int64_t)AV_NOPTS_VALUE;
904     }
905
906     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
907     {
908         if ( p_sys->i_last_pts == frame.pts )
909         {
910             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
911                       "same PTS (%"PRId64 ")", frame.pts );
912             return NULL;
913         }
914         else if ( p_sys->i_last_pts > frame.pts )
915         {
916             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
917                       "past (current: %"PRId64 ", last: %"PRId64")",
918                       frame.pts, p_sys->i_last_pts );
919             return NULL;
920         }
921         else
922         {
923             p_sys->i_last_pts = frame.pts;
924         }
925     }
926
927     frame.quality = p_sys->i_quality;
928
929     /* Ugly work-around for stupid libavcodec behaviour */
930     p_sys->i_framenum++;
931     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
932     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
933         p_enc->fmt_in.video.i_frame_rate_base;
934     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
935     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
936     /* End work-around */
937
938     i_out = avcodec_encode_video( p_sys->p_context, p_sys->p_buffer_out,
939                                   p_sys->i_buffer_out, &frame );
940
941     if( i_out > 0 )
942     {
943         block_t *p_block = block_New( p_enc, i_out );
944         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
945
946         /* FIXME, 3-2 pulldown is not handled correctly */
947         p_block->i_length = INT64_C(1000000) *
948             p_enc->fmt_in.video.i_frame_rate_base /
949                 p_enc->fmt_in.video.i_frame_rate;
950
951         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
952         {
953             /* No delay -> output pts == input pts */
954             p_block->i_pts = p_block->i_dts = p_pict->date;
955         }
956         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
957             p_sys->p_context->coded_frame->pts != 0 &&
958             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
959         {
960             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
961             p_block->i_pts = p_sys->p_context->coded_frame->pts;
962
963             /* Ugly work-around for stupid libavcodec behaviour */
964             {
965                 int64_t i_framenum = p_block->i_pts *
966                     p_enc->fmt_in.video.i_frame_rate /
967                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
968
969                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
970             }
971             /* End work-around */
972
973             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
974                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
975             {
976                 p_block->i_dts = p_block->i_pts;
977             }
978             else
979             {
980                 if( p_sys->i_last_ref_pts )
981                 {
982                     p_block->i_dts = p_sys->i_last_ref_pts;
983                 }
984                 else
985                 {
986                     /* Let's put something sensible */
987                     p_block->i_dts = p_block->i_pts;
988                 }
989
990                 p_sys->i_last_ref_pts = p_block->i_pts;
991             }
992         }
993         else
994         {
995             /* Buggy libavcodec which doesn't update coded_frame->pts
996              * correctly */
997             p_block->i_dts = p_block->i_pts = p_pict->date;
998         }
999
1000         switch ( p_sys->p_context->coded_frame->pict_type )
1001         {
1002         case FF_I_TYPE:
1003             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1004             break;
1005         case FF_P_TYPE:
1006             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1007             break;
1008         case FF_B_TYPE:
1009             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1010             break;
1011         }
1012
1013         return p_block;
1014     }
1015
1016     return NULL;
1017 }
1018
1019 /****************************************************************************
1020  * EncodeAudio: the whole thing
1021  ****************************************************************************/
1022 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1023 {
1024     encoder_sys_t *p_sys = p_enc->p_sys;
1025     block_t *p_block, *p_chain = NULL;
1026
1027     uint8_t *p_buffer = p_aout_buf->p_buffer;
1028     int i_samples = p_aout_buf->i_nb_samples;
1029     int i_samples_delay = p_sys->i_samples_delay;
1030
1031     p_sys->i_pts = p_aout_buf->start_date -
1032                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1033                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1034
1035     p_sys->i_samples_delay += i_samples;
1036
1037     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
1038     {
1039         int16_t *p_samples;
1040         int i_out;
1041
1042         if( i_samples_delay )
1043         {
1044             /* Take care of the left-over from last time */
1045             int i_delay_size = i_samples_delay * 2 *
1046                                  p_sys->p_context->channels;
1047             int i_size = p_sys->i_frame_size - i_delay_size;
1048
1049             p_samples = (int16_t *)p_sys->p_buffer;
1050             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
1051             p_buffer -= i_delay_size;
1052             i_samples += i_samples_delay;
1053             i_samples_delay = 0;
1054         }
1055         else
1056         {
1057             p_samples = (int16_t *)p_buffer;
1058         }
1059
1060         i_out = avcodec_encode_audio( p_sys->p_context, p_sys->p_buffer_out,
1061                                       p_sys->i_buffer_out, p_samples );
1062
1063 #if 0
1064         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1065 #endif
1066         if( i_out < 0 ) break;
1067
1068         p_buffer += p_sys->i_frame_size;
1069         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
1070         i_samples -= p_sys->p_context->frame_size;
1071
1072         if( i_out == 0 ) continue;
1073
1074         p_block = block_New( p_enc, i_out );
1075         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
1076
1077         p_block->i_length = (mtime_t)1000000 *
1078             (mtime_t)p_sys->p_context->frame_size /
1079             (mtime_t)p_sys->p_context->sample_rate;
1080
1081         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1082
1083         /* Update pts */
1084         p_sys->i_pts += p_block->i_length;
1085         block_ChainAppend( &p_chain, p_block );
1086     }
1087
1088     /* Backup the remaining raw samples */
1089     if( i_samples )
1090     {
1091         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1092                 p_sys->p_context->channels, p_buffer,
1093                 i_samples * 2 * p_sys->p_context->channels );
1094     }
1095
1096     return p_chain;
1097 }
1098
1099 /*****************************************************************************
1100  * CloseEncoder: ffmpeg encoder destruction
1101  *****************************************************************************/
1102 void CloseEncoder( vlc_object_t *p_this )
1103 {
1104     encoder_t *p_enc = (encoder_t *)p_this;
1105     encoder_sys_t *p_sys = p_enc->p_sys;
1106
1107     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1108     {
1109         int i;
1110         struct thread_context_t ** pp_contexts =
1111                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1112         for ( i = 0; i < p_enc->i_threads; i++ )
1113         {
1114             vlc_object_kill( pp_contexts[i] );
1115             vlc_cond_signal( &pp_contexts[i]->cond );
1116             vlc_thread_join( pp_contexts[i] );
1117             vlc_mutex_destroy( &pp_contexts[i]->lock );
1118             vlc_cond_destroy( &pp_contexts[i]->cond );
1119             vlc_object_release( pp_contexts[i] );
1120         }
1121
1122         free( pp_contexts );
1123     }
1124
1125     vlc_mutex_lock( &avcodec_lock );
1126     avcodec_close( p_sys->p_context );
1127     vlc_mutex_unlock( &avcodec_lock );
1128     av_free( p_sys->p_context );
1129
1130     free( p_sys->p_buffer );
1131     free( p_sys->p_buffer_out );
1132
1133     free( p_sys );
1134 }