* include/video_output.h, ALL: changed api for vout_Request()/vout_Create() to be...
[vlc.git] / modules / codec / ffmpeg / encoder.c
1 /*****************************************************************************
2  * encoder.c: video and audio encoder using the ffmpeg library
3  *****************************************************************************
4  * Copyright (C) 1999-2004 VideoLAN
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  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <vlc/vlc.h>
30 #include <vlc/vout.h>
31 #include <vlc/aout.h>
32 #include <vlc/sout.h>
33 #include <vlc/decoder.h>
34
35 /* ffmpeg header */
36 #define HAVE_MMX
37 #ifdef HAVE_FFMPEG_AVCODEC_H
38 #   include <ffmpeg/avcodec.h>
39 #else
40 #   include <avcodec.h>
41 #endif
42
43 #if LIBAVCODEC_BUILD < 4704
44 #   define AV_NOPTS_VALUE 0
45 #endif
46 #if LIBAVCODEC_BUILD < 4684
47 #    define FF_QP2LAMBDA 118
48 #endif
49
50 #include "ffmpeg.h"
51
52 #define AVCODEC_MAX_VIDEO_FRAME_SIZE (3*1024*1024)
53 #define HURRY_UP_GUARD1 (450000)
54 #define HURRY_UP_GUARD2 (300000)
55 #define HURRY_UP_GUARD3 (100000)
56
57 #define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
58
59 /*****************************************************************************
60  * Local prototypes
61  *****************************************************************************/
62 int  E_(OpenEncoder) ( vlc_object_t * );
63 void E_(CloseEncoder)( vlc_object_t * );
64
65 static block_t *EncodeVideo( encoder_t *, picture_t * );
66 static block_t *EncodeAudio( encoder_t *, aout_buffer_t * );
67
68 struct thread_context_t;
69 static int FfmpegThread( struct thread_context_t *p_context );
70 static int FfmpegExecute( AVCodecContext *s,
71                           int (*pf_func)(AVCodecContext *c2, void *arg2),
72                           void **arg, int *ret, int count );
73
74 /*****************************************************************************
75  * thread_context_t : for multithreaded encoding
76  *****************************************************************************/
77 #if LIBAVCODEC_BUILD >= 4702
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     vlc_bool_t      b_work, b_done;
90 };
91 #endif
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     char *p_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     vlc_bool_t 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     vlc_bool_t b_strict_rc;
133     int        i_rc_buffer_size;
134     float      f_rc_buffer_aggressivity;
135     vlc_bool_t b_pre_me;
136     vlc_bool_t b_hurry_up;
137     vlc_bool_t b_interlace;
138     float      f_i_quant_factor;
139     int        i_noise_reduction;
140     vlc_bool_t b_mpeg4_matrix;
141     vlc_bool_t b_trellis;
142     int        i_quality; /* for VBR */
143
144     /* Used to work around stupid timestamping behaviour in libavcodec */
145     uint64_t i_framenum;
146     mtime_t  pi_delay_pts[MAX_FRAME_DELAY];
147 };
148
149 static const char *ppsz_enc_options[] = {
150     "keyint", "bframes", "vt", "qmin", "qmax", "hq", "strict-rc",
151     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
152     "interlace", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
153     "trellis", "qscale", "strict", NULL
154 };
155
156 /*****************************************************************************
157  * OpenEncoder: probe the encoder
158  *****************************************************************************/
159 extern int16_t IMPORT_SYMBOL ff_mpeg4_default_intra_matrix[];
160 extern int16_t IMPORT_SYMBOL ff_mpeg4_default_non_intra_matrix[];
161
162 int E_(OpenEncoder)( vlc_object_t *p_this )
163 {
164     encoder_t *p_enc = (encoder_t *)p_this;
165     encoder_sys_t *p_sys = p_enc->p_sys;
166     AVCodecContext *p_context;
167     AVCodec *p_codec;
168     int i_codec_id, i_cat;
169     char *psz_namecodec;
170     vlc_value_t val;
171
172     if( !E_(GetFfmpegCodec)( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
173                              &psz_namecodec ) )
174     {
175         if( E_(GetFfmpegChroma)( p_enc->fmt_out.i_codec ) < 0 )
176         {
177             /* handed chroma output */
178             return VLC_EGENERIC;
179         }
180         i_cat      = VIDEO_ES;
181         i_codec_id = CODEC_ID_RAWVIDEO;
182         psz_namecodec = "Raw video";
183     }
184
185
186     if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
187     {
188         msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
189         return VLC_EGENERIC;
190     }
191
192     if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
193     {
194         msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
195         return VLC_EGENERIC;
196     }
197
198     /* Initialization must be done before avcodec_find_decoder() */
199     E_(InitLibavcodec)(p_this);
200
201     p_codec = avcodec_find_encoder( i_codec_id );
202     if( !p_codec )
203     {
204         msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
205         return VLC_EGENERIC;
206     }
207
208     /* Allocate the memory needed to store the decoder's structure */
209     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
210     {
211         msg_Err( p_enc, "out of memory" );
212         return VLC_EGENERIC;
213     }
214     memset( p_sys, 0, sizeof(encoder_sys_t) );
215     p_enc->p_sys = p_sys;
216     p_sys->p_codec = p_codec;
217
218     p_enc->pf_encode_video = EncodeVideo;
219     p_enc->pf_encode_audio = EncodeAudio;
220
221     p_sys->p_buffer_out = NULL;
222     p_sys->p_buffer = NULL;
223
224     p_sys->p_context = p_context = avcodec_alloc_context();
225
226     /* Set CPU capabilities */
227     p_context->dsp_mask = 0;
228     if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_MMX) )
229     {
230         p_context->dsp_mask |= FF_MM_MMX;
231     }
232     if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_MMXEXT) )
233     {
234         p_context->dsp_mask |= FF_MM_MMXEXT;
235     }
236     if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_3DNOW) )
237     {
238         p_context->dsp_mask |= FF_MM_3DNOW;
239     }
240     if( !(p_enc->p_libvlc->i_cpu & CPU_CAPABILITY_SSE) )
241     {
242         p_context->dsp_mask |= FF_MM_SSE;
243         p_context->dsp_mask |= FF_MM_SSE2;
244     }
245
246     sout_CfgParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
247
248     var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
249     p_sys->i_key_int = val.i_int;
250
251     var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
252     p_sys->i_b_frames = val.i_int;
253
254     var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
255     p_sys->i_vtolerance = val.i_int;
256
257     var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
258     p_sys->b_interlace = val.b_bool;
259
260     var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
261     p_sys->b_pre_me = val.b_bool;
262
263     var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
264     p_sys->b_hurry_up = val.b_bool;
265     if( p_sys->b_hurry_up )
266     {
267         /* hurry up mode needs noise reduction, even small */
268         p_sys->i_noise_reduction = 1;
269     }
270
271     var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val );
272     p_sys->b_strict_rc = val.b_bool;
273     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
274     p_sys->i_rc_buffer_size = val.i_int;
275     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
276     p_sys->f_rc_buffer_aggressivity = val.f_float;
277
278     var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
279     p_sys->f_i_quant_factor = val.f_float;
280
281     var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
282     p_sys->i_noise_reduction = val.i_int;
283
284     var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
285     p_sys->b_mpeg4_matrix = val.b_bool;
286
287     var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
288     if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
289     p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
290
291     var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
292     if( val.psz_string && *val.psz_string )
293     {
294         if( !strcmp( val.psz_string, "rd" ) )
295             p_sys->i_hq = FF_MB_DECISION_RD;
296         else if( !strcmp( val.psz_string, "bits" ) )
297             p_sys->i_hq = FF_MB_DECISION_BITS;
298         else if( !strcmp( val.psz_string, "simple" ) )
299             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
300         else
301             p_sys->i_hq = FF_MB_DECISION_RD;
302     }
303     if( val.psz_string ) free( val.psz_string );
304
305     var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
306     p_sys->i_qmin = val.i_int;
307     var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
308     p_sys->i_qmax = val.i_int;
309     var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
310     p_sys->b_trellis = val.b_bool;
311
312     var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
313     if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
314     p_context->strict_std_compliance = val.i_int;
315
316     if( p_enc->fmt_in.i_cat == VIDEO_ES )
317     {
318         int i_aspect_num, i_aspect_den;
319
320         if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
321         {
322             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
323                       p_enc->fmt_in.video.i_height );
324             free( p_sys );
325             return VLC_EGENERIC;
326         }
327
328         p_context->width = p_enc->fmt_in.video.i_width;
329         p_context->height = p_enc->fmt_in.video.i_height;
330
331         p_context->frame_rate = p_enc->fmt_in.video.i_frame_rate;
332         p_context->frame_rate_base= p_enc->fmt_in.video.i_frame_rate_base;
333
334         /* Defaults from ffmpeg.c */
335         p_context->qblur = 0.5;
336         p_context->qcompress = 0.5;
337         p_context->b_quant_offset = 1.25;
338         p_context->b_quant_factor = 1.25;
339         p_context->i_quant_offset = 0.0;
340         p_context->i_quant_factor = -0.8;
341
342         if( p_sys->i_key_int > 0 )
343             p_context->gop_size = p_sys->i_key_int;
344         p_context->max_b_frames =
345             __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
346         p_context->b_frame_strategy = 0;
347
348 #if LIBAVCODEC_BUILD >= 4687
349         av_reduce( &i_aspect_num, &i_aspect_den,
350                    p_enc->fmt_in.video.i_aspect,
351                    VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
352         av_reduce( &p_context->sample_aspect_ratio.num,
353                    &p_context->sample_aspect_ratio.den,
354                    i_aspect_num * (int64_t)p_context->height,
355                    i_aspect_den * (int64_t)p_context->width, 1 << 30 );
356 #else
357         p_context->aspect_ratio = ((float)p_enc->fmt_in.video.i_aspect) /
358             VOUT_ASPECT_FACTOR;
359 #endif
360
361         p_sys->p_buffer_out = malloc( AVCODEC_MAX_VIDEO_FRAME_SIZE );
362
363         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
364         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
365 #if LIBAVCODEC_BUILD >= 4714
366         if( p_codec->pix_fmts )
367         {
368             const enum PixelFormat *p = p_codec->pix_fmts;
369             for( ; *p != -1; p++ )
370             {
371                 if( *p == p_context->pix_fmt ) break;
372             }
373             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
374             p_enc->fmt_in.i_codec = E_(GetVlcChroma)( p_context->pix_fmt );
375         }
376 #else
377         p_enc->fmt_in.i_codec = E_(GetVlcChroma)( p_context->pix_fmt );
378 #endif
379
380         if ( p_sys->b_strict_rc )
381         {
382             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
383             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
384             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
385         }
386
387         if ( p_sys->f_i_quant_factor != 0.0 )
388             p_context->i_quant_factor = p_sys->f_i_quant_factor;
389
390 #if LIBAVCODEC_BUILD >= 4690
391         p_context->noise_reduction = p_sys->i_noise_reduction;
392 #endif
393
394         if ( p_sys->b_mpeg4_matrix )
395         {
396             p_context->intra_matrix = ff_mpeg4_default_intra_matrix;
397             p_context->inter_matrix = ff_mpeg4_default_non_intra_matrix;
398         }
399
400         if ( p_sys->b_pre_me )
401         {
402             p_context->pre_me = 1;
403             p_context->me_pre_cmp = FF_CMP_CHROMA;
404         }
405
406         if ( p_sys->b_interlace )
407         {
408             p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
409 #if LIBAVCODEC_BUILD >= 4698
410             p_context->flags |= CODEC_FLAG_INTERLACED_ME;
411 #endif
412         }
413
414         if ( p_sys->b_trellis )
415             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
416
417 #if LIBAVCODEC_BUILD >= 4702
418         if ( p_enc->i_threads >= 1 )
419             p_context->thread_count = p_enc->i_threads;
420 #endif
421
422         if( p_sys->i_vtolerance > 0 )
423             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
424
425         if( p_sys->i_qmin > 0 )
426             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
427         if( p_sys->i_qmax > 0 )
428             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
429         p_context->max_qdiff = 3;
430
431         p_context->mb_decision = p_sys->i_hq;
432
433         if( p_sys->i_quality )
434         {
435             p_context->flags |= CODEC_FLAG_QSCALE;
436 #if LIBAVCODEC_BUILD >= 4668
437             p_context->global_quality = p_sys->i_quality;
438 #endif
439         }
440     }
441     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
442     {
443         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
444         p_context->sample_rate = p_enc->fmt_in.audio.i_rate;
445         p_context->channels    = p_enc->fmt_in.audio.i_channels;
446     }
447
448     /* Misc parameters */
449     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
450
451     if( i_codec_id == CODEC_ID_RAWVIDEO )
452     {
453         /* XXX: hack: Force same codec (will be handled by transcode) */
454         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
455         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
456     }
457
458     /* Make sure we get extradata filled by the encoder */
459     p_context->extradata_size = 0;
460     p_context->extradata = NULL;
461     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
462
463     if( avcodec_open( p_context, p_codec ) )
464     {
465         if( p_enc->fmt_in.i_cat == AUDIO_ES && p_context->channels > 2 )
466         {
467             p_context->channels = 2;
468             p_enc->fmt_in.audio.i_channels = 2; // FIXME
469             if( avcodec_open( p_context, p_codec ) )
470             {
471                 msg_Err( p_enc, "cannot open encoder" );
472                 free( p_sys );
473                 return VLC_EGENERIC;
474             }
475             msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
476         }
477         else
478         {
479             msg_Err( p_enc, "cannot open encoder" );
480             free( p_sys );
481             return VLC_EGENERIC;
482         }
483     }
484
485     p_enc->fmt_out.i_extra = p_context->extradata_size;
486     p_enc->fmt_out.p_extra = p_context->extradata;
487     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
488
489     if( p_enc->fmt_in.i_cat == AUDIO_ES )
490     {
491         p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
492         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
493         p_sys->p_buffer = malloc( p_sys->i_frame_size );
494     }
495
496     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
497
498     return VLC_SUCCESS;
499 }
500
501 /****************************************************************************
502  * Ffmpeg threading system
503  ****************************************************************************/
504 #if LIBAVCODEC_BUILD >= 4702
505 static int FfmpegThread( struct thread_context_t *p_context )
506 {
507     while ( !p_context->b_die && !p_context->b_error )
508     {
509         vlc_mutex_lock( &p_context->lock );
510         while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
511         {
512             vlc_cond_wait( &p_context->cond, &p_context->lock );
513         }
514         p_context->b_work = 0;
515         vlc_mutex_unlock( &p_context->lock );
516         if ( p_context->b_die || p_context->b_error )
517             break;
518
519         if ( p_context->pf_func )
520         {
521             p_context->i_ret = p_context->pf_func( p_context->p_context,
522                                                    p_context->arg );
523         }
524
525         vlc_mutex_lock( &p_context->lock );
526         p_context->b_done = 1;
527         vlc_cond_signal( &p_context->cond );
528         vlc_mutex_unlock( &p_context->lock );
529     }
530
531     return 0;
532 }
533
534 static int FfmpegExecute( AVCodecContext *s,
535                           int (*pf_func)(AVCodecContext *c2, void *arg2),
536                           void **arg, int *ret, int count )
537 {
538     struct thread_context_t ** pp_contexts =
539                          (struct thread_context_t **)s->thread_opaque;
540     int i;
541
542     /* Note, we can be certain that this is not called with the same
543      * AVCodecContext by different threads at the same time */
544     for ( i = 0; i < count; i++ )
545     {
546         vlc_mutex_lock( &pp_contexts[i]->lock );
547         pp_contexts[i]->arg = arg[i];
548         pp_contexts[i]->pf_func = pf_func;
549         pp_contexts[i]->i_ret = 12345;
550         pp_contexts[i]->b_work = 1;
551         vlc_cond_signal( &pp_contexts[i]->cond );
552         vlc_mutex_unlock( &pp_contexts[i]->lock );
553     }
554     for ( i = 0; i < count; i++ )
555     {
556         vlc_mutex_lock( &pp_contexts[i]->lock );
557         while ( !pp_contexts[i]->b_done )
558         {
559             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
560         }
561         pp_contexts[i]->b_done = 0;
562         pp_contexts[i]->pf_func = NULL;
563         vlc_mutex_unlock( &pp_contexts[i]->lock );
564
565         if ( ret )
566         {
567             ret[i] = pp_contexts[i]->i_ret;
568         }
569     }
570
571     return 0;
572 }
573 #endif
574
575 /****************************************************************************
576  * EncodeVideo: the whole thing
577  ****************************************************************************/
578 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
579 {
580     encoder_sys_t *p_sys = p_enc->p_sys;
581     AVFrame frame;
582     int i_out, i_plane;
583
584 #if LIBAVCODEC_BUILD >= 4702
585     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
586     {
587         struct thread_context_t ** pp_contexts;
588         int i;
589
590         p_sys->b_inited = 1;
591         pp_contexts = malloc( sizeof(struct thread_context_t *)
592                                  * p_enc->i_threads );
593         p_sys->p_context->thread_opaque = (void *)pp_contexts;
594
595         for ( i = 0; i < p_enc->i_threads; i++ )
596         {
597             pp_contexts[i] = vlc_object_create( p_enc,
598                                      sizeof(struct thread_context_t) );
599             pp_contexts[i]->p_context = p_sys->p_context;
600             vlc_mutex_init( p_enc, &pp_contexts[i]->lock );
601             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
602             pp_contexts[i]->b_work = 0;
603             pp_contexts[i]->b_done = 0;
604             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
605                                     VLC_THREAD_PRIORITY_VIDEO, VLC_FALSE ) )
606             {
607                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
608                 return NULL;
609             }
610         }
611
612         p_sys->p_context->execute = FfmpegExecute;
613     }
614 #endif
615
616     memset( &frame, 0, sizeof( AVFrame ) );
617     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
618     {
619         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
620         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
621     }
622
623     /* Let ffmpeg select the frame type */
624     frame.pict_type = 0;
625
626     frame.repeat_pict = 2 - p_pict->i_nb_fields;
627
628 #if LIBAVCODEC_BUILD >= 4685
629     frame.interlaced_frame = !p_pict->b_progressive;
630     frame.top_field_first = !!p_pict->b_top_field_first;
631 #endif
632
633 #if LIBAVCODEC_BUILD < 4702
634     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
635     if( p_enc->fmt_out.i_codec == VLC_FOURCC( 'm', 'p', 'g', 'v' ) ||
636         p_enc->fmt_out.i_codec == VLC_FOURCC( 'm', 'p', '1', 'v' ) ||
637         p_enc->fmt_out.i_codec == VLC_FOURCC( 'm', 'p', '2', 'v' ) )
638 #else
639     if( 1 )
640 #endif
641     {
642         frame.pts = p_pict->date ? p_pict->date : AV_NOPTS_VALUE;
643
644         if ( p_sys->b_hurry_up && frame.pts != AV_NOPTS_VALUE )
645         {
646             mtime_t current_date = mdate();
647
648             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
649             {
650                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
651                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
652                 msg_Dbg( p_enc, "hurry up mode 3" );
653             }
654             else
655             {
656                 p_sys->p_context->mb_decision = p_sys->i_hq;
657
658                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
659                 {
660                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
661 #if LIBAVCODEC_BUILD >= 4690
662                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
663                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
664 #endif
665                     msg_Dbg( p_enc, "hurry up mode 2" );
666                 }
667                 else
668                 {
669                     if ( p_sys->b_trellis )
670                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
671 #if LIBAVCODEC_BUILD >= 4690
672                     p_sys->p_context->noise_reduction =
673                         p_sys->i_noise_reduction;
674 #endif
675                 }
676             }
677
678             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
679             {
680                 frame.pict_type = FF_P_TYPE;
681                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
682             }
683         }
684     }
685     else
686     {
687         frame.pts = AV_NOPTS_VALUE;
688     }
689
690     if ( frame.pts != AV_NOPTS_VALUE && frame.pts != 0 )
691     {
692         if ( p_sys->i_last_pts == frame.pts )
693         {
694             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
695                       "same PTS (" I64Fd ")", frame.pts );
696             return NULL;
697         }
698         else if ( p_sys->i_last_pts > frame.pts )
699         {
700             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
701                       "past (current: " I64Fd ", last: "I64Fd")",
702                       frame.pts, p_sys->i_last_pts );
703             return NULL;
704         }
705         else
706         {
707             p_sys->i_last_pts = frame.pts;
708         }
709     }
710
711     frame.quality = p_sys->i_quality;
712
713     /* Ugly work-around for stupid libavcodec behaviour */
714 #if LIBAVCODEC_BUILD >= 4722
715     p_sys->i_framenum++;
716     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
717     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
718         p_enc->fmt_in.video.i_frame_rate_base;
719     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
720     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
721 #endif
722     /* End work-around */
723
724     i_out = avcodec_encode_video( p_sys->p_context, p_sys->p_buffer_out,
725                                   AVCODEC_MAX_VIDEO_FRAME_SIZE, &frame );
726
727     if( i_out > 0 )
728     {
729         block_t *p_block = block_New( p_enc, i_out );
730         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
731
732         /* FIXME, 3-2 pulldown is not handled correctly */
733         p_block->i_length = I64C(1000000) *
734             p_enc->fmt_in.video.i_frame_rate_base /
735                 p_enc->fmt_in.video.i_frame_rate;
736
737         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
738         {
739             /* No delay -> output pts == input pts */
740             p_block->i_pts = p_block->i_dts = p_pict->date;
741         }
742         else if( p_sys->p_context->coded_frame->pts != AV_NOPTS_VALUE &&
743             p_sys->p_context->coded_frame->pts != 0 &&
744             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
745         {
746             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
747             p_block->i_pts = p_sys->p_context->coded_frame->pts;
748
749             /* Ugly work-around for stupid libavcodec behaviour */
750 #if LIBAVCODEC_BUILD >= 4722
751             {
752             int64_t i_framenum = p_block->i_pts *
753                 p_enc->fmt_in.video.i_frame_rate /
754                 p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
755
756             p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
757             }
758 #endif
759             /* End work-around */
760
761             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
762                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
763             {
764                 p_block->i_dts = p_block->i_pts;
765             }
766             else
767             {
768                 if( p_sys->i_last_ref_pts )
769                 {
770                     p_block->i_dts = p_sys->i_last_ref_pts;
771                 }
772                 else
773                 {
774                     /* Let's put something sensible */
775                     p_block->i_dts = p_block->i_pts;
776                 }
777
778                 p_sys->i_last_ref_pts = p_block->i_pts;
779             }
780         }
781         else
782         {
783             /* Buggy libavcodec which doesn't update coded_frame->pts
784              * correctly */
785             p_block->i_dts = p_block->i_pts = p_pict->date;
786         }
787
788         switch ( p_sys->p_context->coded_frame->pict_type )
789         {
790         case FF_I_TYPE:
791             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
792             break;
793         case FF_P_TYPE:
794             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
795             break;
796         case FF_B_TYPE:
797             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
798             break;
799         }
800
801         return p_block;
802     }
803
804     return NULL;
805 }
806
807 /****************************************************************************
808  * EncodeAudio: the whole thing
809  ****************************************************************************/
810 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
811 {
812     encoder_sys_t *p_sys = p_enc->p_sys;
813     block_t *p_block, *p_chain = NULL;
814
815     char *p_buffer = p_aout_buf->p_buffer;
816     int i_samples = p_aout_buf->i_nb_samples;
817     int i_samples_delay = p_sys->i_samples_delay;
818
819     p_sys->i_pts = p_aout_buf->start_date -
820                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
821                 (mtime_t)p_enc->fmt_in.audio.i_rate;
822
823     p_sys->i_samples_delay += i_samples;
824
825     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
826     {
827         int16_t *p_samples;
828         int i_out;
829
830         if( i_samples_delay )
831         {
832             /* Take care of the left-over from last time */
833             int i_delay_size = i_samples_delay * 2 *
834                                  p_sys->p_context->channels;
835             int i_size = p_sys->i_frame_size - i_delay_size;
836
837             p_samples = (int16_t *)p_sys->p_buffer;
838             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
839             p_buffer -= i_delay_size;
840             i_samples += i_samples_delay;
841             i_samples_delay = 0;
842         }
843         else
844         {
845             p_samples = (int16_t *)p_buffer;
846         }
847
848         i_out = avcodec_encode_audio( p_sys->p_context, p_sys->p_buffer_out,
849                                       2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
850                                       p_samples );
851
852 #if 0
853         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
854 #endif
855         if( i_out < 0 ) break;
856
857         p_buffer += p_sys->i_frame_size;
858         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
859         i_samples -= p_sys->p_context->frame_size;
860
861         if( i_out == 0 ) continue;
862
863         p_block = block_New( p_enc, i_out );
864         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
865
866         p_block->i_length = (mtime_t)1000000 *
867             (mtime_t)p_sys->p_context->frame_size /
868             (mtime_t)p_sys->p_context->sample_rate;
869
870         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
871
872         /* Update pts */
873         p_sys->i_pts += p_block->i_length;
874         block_ChainAppend( &p_chain, p_block );
875     }
876
877     /* Backup the remaining raw samples */
878     if( i_samples )
879     {
880         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
881                 p_sys->p_context->channels, p_buffer,
882                 i_samples * 2 * p_sys->p_context->channels );
883     }
884
885     return p_chain;
886 }
887
888 /*****************************************************************************
889  * CloseEncoder: ffmpeg encoder destruction
890  *****************************************************************************/
891 void E_(CloseEncoder)( vlc_object_t *p_this )
892 {
893     encoder_t *p_enc = (encoder_t *)p_this;
894     encoder_sys_t *p_sys = p_enc->p_sys;
895
896 #if LIBAVCODEC_BUILD >= 4702
897     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
898     {
899         int i;
900         struct thread_context_t ** pp_contexts =
901                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
902         for ( i = 0; i < p_enc->i_threads; i++ )
903         {
904             pp_contexts[i]->b_die = 1;
905             vlc_cond_signal( &pp_contexts[i]->cond );
906             vlc_thread_join( pp_contexts[i] );
907             vlc_mutex_destroy( &pp_contexts[i]->lock );
908             vlc_cond_destroy( &pp_contexts[i]->cond );
909             vlc_object_destroy( pp_contexts[i] );
910         }
911
912         free( pp_contexts );
913     }
914 #endif
915
916     avcodec_close( p_sys->p_context );
917     av_free( p_sys->p_context );
918
919     if( p_sys->p_buffer ) free( p_sys->p_buffer );
920     if( p_sys->p_buffer_out ) free( p_sys->p_buffer_out );
921
922     free( p_sys );
923 }