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