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