dialog: use new API
[vlc.git] / modules / codec / avcodec / encoder.c
1 /*****************************************************************************
2  * encoder.c: video and audio encoder using the libavcodec library
3  *****************************************************************************
4  * Copyright (C) 1999-2004 VLC authors and 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  * 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 it
14  * under the terms of the GNU Lesser General Public License as published by
15  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * 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 <math.h>
36
37 #include <vlc_common.h>
38 #include <vlc_aout.h>
39 #include <vlc_sout.h>
40 #include <vlc_codec.h>
41 #include <vlc_dialog.h>
42 #include <vlc_avcodec.h>
43 #include <vlc_cpu.h>
44
45 #include <libavcodec/avcodec.h>
46 #include <libavutil/channel_layout.h>
47
48 #include "avcodec.h"
49 #include "avcommon.h"
50
51 #if LIBAVUTIL_VERSION_CHECK( 52,2,6,0,0 )
52 # include <libavutil/channel_layout.h>
53 #endif
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 #define RAW_AUDIO_FRAME_SIZE (2048)
62
63 /*****************************************************************************
64  * Local prototypes
65  *****************************************************************************/
66 int  OpenEncoder ( vlc_object_t * );
67 void CloseEncoder( vlc_object_t * );
68
69 static block_t *EncodeVideo( encoder_t *, picture_t * );
70 static block_t *EncodeAudio( encoder_t *, block_t * );
71
72 struct thread_context_t;
73
74 /*****************************************************************************
75  * thread_context_t : for multithreaded encoding
76  *****************************************************************************/
77 struct thread_context_t
78 {
79     VLC_COMMON_MEMBERS
80
81     AVCodecContext  *p_context;
82     int             (* pf_func)(AVCodecContext *c, void *arg);
83     void            *arg;
84     int             i_ret;
85
86     vlc_mutex_t     lock;
87     vlc_cond_t      cond;
88     bool            b_work, b_done;
89 };
90
91 /*****************************************************************************
92  * encoder_sys_t : libavcodec encoder descriptor
93  *****************************************************************************/
94 struct encoder_sys_t
95 {
96     /*
97      * libavcodec properties
98      */
99     AVCodec         *p_codec;
100     AVCodecContext  *p_context;
101
102     /*
103      * Common buffer mainly for audio as frame size in there needs usually be constant
104      */
105     uint8_t *p_buffer;
106     size_t i_buffer_out;
107     uint8_t *p_interleave_buf;
108
109     /*
110      * Video properties
111      */
112     mtime_t i_last_ref_pts;
113     mtime_t i_buggy_pts_detect;
114     mtime_t i_last_pts;
115     bool    b_inited;
116
117     /*
118      * Audio properties
119      */
120     size_t i_sample_bytes;
121     size_t i_frame_size;
122     size_t i_samples_delay; //How much samples in delay buffer
123     bool b_planar;
124     bool b_variable;    //Encoder can be fed with any size frames not just frame_size
125     mtime_t i_pts;
126     date_t  buffer_date;
127
128     /* Multichannel (>2) channel reordering */
129     uint8_t    i_channels_to_reorder;
130     uint8_t    pi_reorder_layout[AOUT_CHAN_MAX];
131
132     /* Encoding settings */
133     int        i_key_int;
134     int        i_b_frames;
135     int        i_vtolerance;
136     int        i_qmin;
137     int        i_qmax;
138     int        i_hq;
139     int        i_rc_buffer_size;
140     float      f_rc_buffer_aggressivity;
141     bool       b_pre_me;
142     bool       b_hurry_up;
143     bool       b_interlace, b_interlace_me;
144     float      f_i_quant_factor;
145     int        i_noise_reduction;
146     bool       b_mpeg4_matrix;
147     bool       b_trellis;
148     int        i_quality; /* for VBR */
149     float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
150     int        i_aac_profile; /* AAC profile to use.*/
151
152     AVFrame    *frame;
153 };
154
155
156 /* Taken from audio.c*/
157 static const uint64_t pi_channels_map[][2] =
158 {
159     { AV_CH_FRONT_LEFT,        AOUT_CHAN_LEFT },
160     { AV_CH_FRONT_RIGHT,       AOUT_CHAN_RIGHT },
161     { AV_CH_FRONT_CENTER,      AOUT_CHAN_CENTER },
162     { AV_CH_LOW_FREQUENCY,     AOUT_CHAN_LFE },
163     { AV_CH_BACK_LEFT,         AOUT_CHAN_REARLEFT },
164     { AV_CH_BACK_RIGHT,        AOUT_CHAN_REARRIGHT },
165     { AV_CH_FRONT_LEFT_OF_CENTER, 0 },
166     { AV_CH_FRONT_RIGHT_OF_CENTER, 0 },
167     { AV_CH_BACK_CENTER,       AOUT_CHAN_REARCENTER },
168     { AV_CH_SIDE_LEFT,         AOUT_CHAN_MIDDLELEFT },
169     { AV_CH_SIDE_RIGHT,        AOUT_CHAN_MIDDLERIGHT },
170     { AV_CH_TOP_CENTER,        0 },
171     { AV_CH_TOP_FRONT_LEFT,    0 },
172     { AV_CH_TOP_FRONT_CENTER,  0 },
173     { AV_CH_TOP_FRONT_RIGHT,   0 },
174     { AV_CH_TOP_BACK_LEFT,     0 },
175     { AV_CH_TOP_BACK_CENTER,   0 },
176     { AV_CH_TOP_BACK_RIGHT,    0 },
177     { AV_CH_STEREO_LEFT,       0 },
178     { AV_CH_STEREO_RIGHT,      0 },
179 };
180
181 static const uint32_t channel_mask[][2] = {
182     {0,0},
183     {AOUT_CHAN_CENTER, AV_CH_LAYOUT_MONO},
184     {AOUT_CHANS_STEREO, AV_CH_LAYOUT_STEREO},
185     {AOUT_CHANS_2_1, AV_CH_LAYOUT_2POINT1},
186     {AOUT_CHANS_4_0, AV_CH_LAYOUT_4POINT0},
187     {AOUT_CHANS_4_1, AV_CH_LAYOUT_4POINT1},
188     {AOUT_CHANS_5_1, AV_CH_LAYOUT_5POINT1_BACK},
189     {AOUT_CHANS_7_0, AV_CH_LAYOUT_7POINT0},
190     {AOUT_CHANS_7_1, AV_CH_LAYOUT_7POINT1},
191     {AOUT_CHANS_8_1, AV_CH_LAYOUT_OCTAGONAL},
192 };
193
194 static const char *const ppsz_enc_options[] = {
195     "keyint", "bframes", "vt", "qmin", "qmax", "codec", "hq",
196     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
197     "interlace", "interlace-me", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
198     "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
199     "p-masking", "border-masking",
200     "aac-profile", "options",
201     NULL
202 };
203
204 static const uint16_t mpa_bitrate_tab[2][15] =
205 {
206     {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
207     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
208 };
209
210 static const uint16_t mpa_freq_tab[6] =
211 { 44100, 48000, 32000, 22050, 24000, 16000 };
212
213 static const uint16_t mpeg4_default_intra_matrix[64] = {
214   8, 17, 18, 19, 21, 23, 25, 27,
215  17, 18, 19, 21, 23, 25, 27, 28,
216  20, 21, 22, 23, 24, 26, 28, 30,
217  21, 22, 23, 24, 26, 28, 30, 32,
218  22, 23, 24, 26, 28, 30, 32, 35,
219  23, 24, 26, 28, 30, 32, 35, 38,
220  25, 26, 28, 30, 32, 35, 38, 41,
221  27, 28, 30, 32, 35, 38, 41, 45,
222 };
223
224 static const uint16_t mpeg4_default_non_intra_matrix[64] = {
225  16, 17, 18, 19, 20, 21, 22, 23,
226  17, 18, 19, 20, 21, 22, 23, 24,
227  18, 19, 20, 21, 22, 23, 24, 25,
228  19, 20, 21, 22, 23, 24, 26, 27,
229  20, 21, 22, 23, 25, 26, 27, 28,
230  21, 22, 23, 24, 26, 27, 28, 30,
231  22, 23, 24, 26, 27, 28, 30, 31,
232  23, 24, 25, 27, 28, 30, 31, 33,
233 };
234
235 static const int DEFAULT_ALIGN = 0;
236
237
238 /*****************************************************************************
239  * OpenEncoder: probe the encoder
240  *****************************************************************************/
241 static void probe_video_frame_rate( encoder_t *p_enc, AVCodecContext *p_context, AVCodec *p_codec )
242 {
243     /* if we don't have i_frame_rate_base, we are probing and just checking if we can find codec
244      * so set fps to requested fps if asked by user or input fps is availabled */
245     p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base ? p_enc->fmt_in.video.i_frame_rate_base : 1;
246
247     // MP4V doesn't like CLOCK_FREQ denominator in time_base, so use 1/25 as default for that
248     p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate_base ? p_enc->fmt_in.video.i_frame_rate :
249                                   ( p_enc->fmt_out.i_codec == VLC_CODEC_MP4V ? 25 : CLOCK_FREQ );
250
251     msg_Dbg( p_enc, "Time base for probing setted to %d/%d", p_context->time_base.num, p_context->time_base.den );
252     if( p_codec->supported_framerates )
253     {
254         /* We are finding fps values so 1/time_base */
255         AVRational target = {
256             .num = p_context->time_base.den,
257             .den = p_context->time_base.num
258         };
259         int idx = av_find_nearest_q_idx(target, p_codec->supported_framerates);
260
261         p_context->time_base.num = p_codec->supported_framerates[idx].den ?
262                                     p_codec->supported_framerates[idx].den : 1;
263         p_context->time_base.den = p_codec->supported_framerates[idx].den ?
264                                     p_codec->supported_framerates[idx].num : CLOCK_FREQ;
265
266         /* If we have something reasonable on supported framerates, use that*/
267         if( p_context->time_base.den && p_context->time_base.den < CLOCK_FREQ )
268         {
269             p_enc->fmt_out.video.i_frame_rate_base =
270                 p_enc->fmt_in.video.i_frame_rate_base =
271                 p_context->time_base.num;
272             p_enc->fmt_out.video.i_frame_rate =
273                 p_enc->fmt_in.video.i_frame_rate =
274                 p_context->time_base.den;
275         }
276     }
277     msg_Dbg( p_enc, "Time base set to %d/%d", p_context->time_base.num, p_context->time_base.den );
278 }
279
280 int OpenEncoder( vlc_object_t *p_this )
281 {
282     encoder_t *p_enc = (encoder_t *)p_this;
283     encoder_sys_t *p_sys;
284     AVCodecContext *p_context;
285     AVCodec *p_codec = NULL;
286     unsigned i_codec_id;
287     int i_cat;
288     const char *psz_namecodec;
289     float f_val;
290     char *psz_val;
291
292     /* Initialization must be done before avcodec_find_encoder() */
293     vlc_init_avcodec(p_this);
294
295     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
296
297     if( p_enc->fmt_out.i_codec == VLC_CODEC_MP1V )
298     {
299         i_cat = VIDEO_ES;
300         i_codec_id = AV_CODEC_ID_MPEG1VIDEO;
301         psz_namecodec = "MPEG-1 video";
302     }
303     else if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
304                              &psz_namecodec ) )
305     {
306         if( FindFfmpegChroma( p_enc->fmt_out.i_codec ) == AV_PIX_FMT_NONE )
307             return VLC_EGENERIC; /* handed chroma output */
308
309         i_cat      = VIDEO_ES;
310         i_codec_id = AV_CODEC_ID_RAWVIDEO;
311         psz_namecodec = "Raw video";
312     }
313
314     if( i_cat == UNKNOWN_ES )
315         return VLC_EGENERIC;
316
317     if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
318     {
319         msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
320         vlc_dialog_display_error( p_enc, _("Streaming / Transcoding failed"),
321             _("\"%s\" is no video encoder."), psz_namecodec );
322         return VLC_EGENERIC;
323     }
324
325     if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
326     {
327         msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
328         vlc_dialog_display_error( p_enc, _("Streaming / Transcoding failed"),
329             _("\"%s\" is no audio encoder."), psz_namecodec );
330         return VLC_EGENERIC;
331     }
332
333     if( p_enc->fmt_out.i_cat == SPU_ES )
334     {
335         /* We don't support subtitle encoding */
336         return VLC_EGENERIC;
337     }
338
339     char *psz_encoder = var_GetString( p_this, ENC_CFG_PREFIX "codec" );
340     if( psz_encoder && *psz_encoder )
341     {
342         p_codec = avcodec_find_encoder_by_name( psz_encoder );
343         if( !p_codec )
344             msg_Err( p_this, "Encoder `%s' not found", psz_encoder );
345         else if( p_codec->id != i_codec_id )
346         {
347             msg_Err( p_this, "Encoder `%s' can't handle %4.4s",
348                     psz_encoder, (char*)&p_enc->fmt_out.i_codec );
349             p_codec = NULL;
350         }
351     }
352     free( psz_encoder );
353     if( !p_codec )
354         p_codec = avcodec_find_encoder( i_codec_id );
355     if( !p_codec )
356     {
357         msg_Err( p_enc, "cannot find encoder %s\n"
358 "*** Your Libav/FFmpeg installation is crippled.   ***\n"
359 "*** Please check with your Libav/FFmpeg packager. ***\n"
360 "*** This is NOT a VLC media player issue.   ***", psz_namecodec );
361
362         vlc_dialog_display_error( p_enc, _("Streaming / Transcoding failed"), _(
363 /* I have had enough of all these MPEG-3 transcoding bug reports.
364  * Downstream packager, you had better not patch this out, or I will be really
365  * annoyed. Think about it - you don't want to fork the VLC translation files,
366  * do you? -- Courmisch, 2008-10-22 */
367 "It seems your Libav/FFmpeg (libavcodec) installation lacks the following encoder:\n"
368 "%s.\n"
369 "If you don't know how to fix this, ask for support from your distribution.\n"
370 "\n"
371 "This is not an error inside VLC media player.\n"
372 "Do not contact the VideoLAN project about this issue.\n"),
373             psz_namecodec );
374         return VLC_EGENERIC;
375     }
376
377     /* Allocate the memory needed to store the encoder's structure */
378     if( ( p_sys = calloc( 1, sizeof(encoder_sys_t) ) ) == NULL )
379         return VLC_ENOMEM;
380     p_enc->p_sys = p_sys;
381     p_sys->i_samples_delay = 0;
382     p_sys->p_codec = p_codec;
383     p_sys->b_planar = false;
384
385     p_sys->p_buffer = NULL;
386     p_sys->p_interleave_buf = NULL;
387     p_sys->i_buffer_out = 0;
388
389     p_context = avcodec_alloc_context3(p_codec);
390     if( unlikely(p_context == NULL) )
391     {
392         free( p_sys );
393         return VLC_ENOMEM;
394     }
395     p_sys->p_context = p_context;
396     p_sys->p_context->codec_id = p_sys->p_codec->id;
397     p_context->thread_type = 0;
398     p_context->debug = var_InheritInteger( p_enc, "avcodec-debug" );
399     p_context->opaque = (void *)p_this;
400
401     p_sys->i_key_int = var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" );
402     p_sys->i_b_frames = var_GetInteger( p_enc, ENC_CFG_PREFIX "bframes" );
403     p_sys->i_vtolerance = var_GetInteger( p_enc, ENC_CFG_PREFIX "vt" ) * 1000;
404     p_sys->b_interlace = var_GetBool( p_enc, ENC_CFG_PREFIX "interlace" );
405     p_sys->b_interlace_me = var_GetBool( p_enc, ENC_CFG_PREFIX "interlace-me" );
406     p_sys->b_pre_me = var_GetBool( p_enc, ENC_CFG_PREFIX "pre-me" );
407     p_sys->b_hurry_up = var_GetBool( p_enc, ENC_CFG_PREFIX "hurry-up" );
408
409     if( p_sys->b_hurry_up )
410     {
411         /* hurry up mode needs noise reduction, even small */
412         p_sys->i_noise_reduction = 1;
413     }
414
415     p_sys->i_rc_buffer_size = var_GetInteger( p_enc, ENC_CFG_PREFIX "rc-buffer-size" );
416     p_sys->f_rc_buffer_aggressivity = var_GetFloat( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity" );
417     p_sys->f_i_quant_factor = var_GetFloat( p_enc, ENC_CFG_PREFIX "i-quant-factor" );
418     p_sys->i_noise_reduction = var_GetInteger( p_enc, ENC_CFG_PREFIX "noise-reduction" );
419     p_sys->b_mpeg4_matrix = var_GetBool( p_enc, ENC_CFG_PREFIX "mpeg4-matrix" );
420
421     f_val = var_GetFloat( p_enc, ENC_CFG_PREFIX "qscale" );
422
423     p_sys->i_quality = 0;
424     if( f_val < .01f || f_val > 255.f )
425         f_val = 0.f;
426     else
427         p_sys->i_quality = lroundf(FF_QP2LAMBDA * f_val);
428
429     psz_val = var_GetString( p_enc, ENC_CFG_PREFIX "hq" );
430     p_sys->i_hq = FF_MB_DECISION_RD;
431     if( psz_val && *psz_val )
432     {
433         if( !strcmp( psz_val, "rd" ) )
434             p_sys->i_hq = FF_MB_DECISION_RD;
435         else if( !strcmp( psz_val, "bits" ) )
436             p_sys->i_hq = FF_MB_DECISION_BITS;
437         else if( !strcmp( psz_val, "simple" ) )
438             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
439         else
440             p_sys->i_hq = FF_MB_DECISION_RD;
441     }
442     else
443         p_sys->i_hq = FF_MB_DECISION_RD;
444     free( psz_val );
445
446     p_sys->i_qmin = var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" );
447     p_sys->i_qmax = var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" );
448     p_sys->b_trellis = var_GetBool( p_enc, ENC_CFG_PREFIX "trellis" );
449
450     p_context->strict_std_compliance = var_GetInteger( p_enc, ENC_CFG_PREFIX "strict" );
451
452     p_sys->f_lumi_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "lumi-masking" );
453     p_sys->f_dark_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "dark-masking" );
454     p_sys->f_p_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "p-masking" );
455     p_sys->f_border_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "border-masking" );
456
457     psz_val = var_GetString( p_enc, ENC_CFG_PREFIX "aac-profile" );
458     /* libavcodec uses faac encoder atm, and it has issues with
459      * other than low-complexity profile, so default to that */
460     p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
461     if( psz_val && *psz_val )
462     {
463         if( !strncmp( psz_val, "main", 4 ) )
464             p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
465         else if( !strncmp( psz_val, "low", 3 ) )
466             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
467         else if( !strncmp( psz_val, "ssr", 3 ) )
468             p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
469         else if( !strncmp( psz_val, "ltp", 3 ) )
470             p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
471 /* These require libavcodec with libfdk-aac */
472         else if( !strncmp( psz_val, "hev2", 4 ) )
473             p_sys->i_aac_profile = FF_PROFILE_AAC_HE_V2;
474         else if( !strncmp( psz_val, "hev1", 4 ) )
475             p_sys->i_aac_profile = FF_PROFILE_AAC_HE;
476         else if( !strncmp( psz_val, "ld", 2 ) )
477             p_sys->i_aac_profile = FF_PROFILE_AAC_LD;
478         else if( !strncmp( psz_val, "eld", 3 ) )
479             p_sys->i_aac_profile = FF_PROFILE_AAC_ELD;
480         else
481         {
482             msg_Warn( p_enc, "unknown AAC profile requested, setting it to low" );
483             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
484         }
485     }
486     free( psz_val );
487
488     if( p_enc->fmt_in.i_cat == VIDEO_ES )
489     {
490         if( !p_enc->fmt_in.video.i_visible_width || !p_enc->fmt_in.video.i_visible_height )
491         {
492             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_visible_width,
493                       p_enc->fmt_in.video.i_visible_height );
494             avcodec_free_context( &p_context );
495             free( p_sys );
496             return VLC_EGENERIC;
497         }
498
499         p_context->codec_type = AVMEDIA_TYPE_VIDEO;
500
501         p_context->width = p_enc->fmt_in.video.i_visible_width;
502         p_context->height = p_enc->fmt_in.video.i_visible_height;
503
504         probe_video_frame_rate( p_enc, p_context, p_codec );
505
506         /* Defaults from ffmpeg.c */
507         p_context->qblur = 0.5;
508         p_context->qcompress = 0.5;
509         p_context->b_quant_offset = 1.25;
510         p_context->b_quant_factor = 1.25;
511         p_context->i_quant_offset = 0.0;
512         p_context->i_quant_factor = -0.8;
513
514         p_context->lumi_masking = p_sys->f_lumi_masking;
515         p_context->dark_masking = p_sys->f_dark_masking;
516         p_context->p_masking = p_sys->f_p_masking;
517         p_context->border_masking = p_sys->f_border_masking;
518
519         if( p_sys->i_key_int > 0 )
520             p_context->gop_size = p_sys->i_key_int;
521         p_context->max_b_frames =
522             VLC_CLIP( p_sys->i_b_frames, 0, FF_MAX_B_FRAMES );
523         p_context->b_frame_strategy = 0;
524         if( !p_context->max_b_frames  &&
525             (  p_enc->fmt_out.i_codec == VLC_CODEC_MPGV ||
526                p_enc->fmt_out.i_codec == VLC_CODEC_MP2V ) )
527             p_context->flags |= CODEC_FLAG_LOW_DELAY;
528
529         av_reduce( &p_context->sample_aspect_ratio.num,
530                    &p_context->sample_aspect_ratio.den,
531                    p_enc->fmt_in.video.i_sar_num,
532                    p_enc->fmt_in.video.i_sar_den, 1 << 30 );
533
534
535         p_enc->fmt_in.i_codec = VLC_CODEC_I420;
536
537         /* Very few application support YUV in TIFF, not even VLC */
538         if( p_enc->fmt_out.i_codec == VLC_CODEC_TIFF )
539             p_enc->fmt_in.i_codec = VLC_CODEC_RGB24;
540
541         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
542         GetFfmpegChroma( &p_context->pix_fmt, &p_enc->fmt_in.video );
543
544         if( p_codec->pix_fmts )
545         {
546             const enum PixelFormat *p = p_codec->pix_fmts;
547             for( ; *p != -1; p++ )
548             {
549                 if( *p == p_context->pix_fmt ) break;
550             }
551             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
552             GetVlcChroma( &p_enc->fmt_in.video, p_context->pix_fmt );
553             p_enc->fmt_in.i_codec = p_enc->fmt_in.video.i_chroma;
554         }
555
556
557         if ( p_sys->f_i_quant_factor != 0.f )
558             p_context->i_quant_factor = p_sys->f_i_quant_factor;
559
560         p_context->noise_reduction = p_sys->i_noise_reduction;
561
562         if ( p_sys->b_mpeg4_matrix )
563         {
564             p_context->intra_matrix = mpeg4_default_intra_matrix;
565             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
566         }
567
568         if ( p_sys->b_pre_me )
569         {
570             p_context->pre_me = 1;
571             p_context->me_pre_cmp = FF_CMP_CHROMA;
572         }
573
574         if ( p_sys->b_interlace )
575         {
576             if ( p_context->height <= 280 )
577             {
578                 if ( p_context->height != 16 || p_context->width != 16 )
579                     msg_Warn( p_enc,
580                         "disabling interlaced video because height=%d <= 280",
581                         p_context->height );
582             }
583             else
584             {
585                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
586                 if ( p_sys->b_interlace_me )
587                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
588             }
589         }
590
591         p_context->trellis = p_sys->b_trellis;
592
593         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
594             p_context->flags |= CODEC_FLAG_QSCALE;
595         /* These codecs cause libavcodec to exit if thread_count is > 1.
596            See libavcodec/mpegvideo_enc.c:MPV_encode_init and
597            libavcodec/svq3.c , WMV2 calls MPV_encode_init also.
598          */
599         if ( i_codec_id == AV_CODEC_ID_FLV1 ||
600              i_codec_id == AV_CODEC_ID_H261 ||
601              i_codec_id == AV_CODEC_ID_LJPEG ||
602              i_codec_id == AV_CODEC_ID_MJPEG ||
603              i_codec_id == AV_CODEC_ID_H263 ||
604              i_codec_id == AV_CODEC_ID_H263P ||
605              i_codec_id == AV_CODEC_ID_MSMPEG4V1 ||
606              i_codec_id == AV_CODEC_ID_MSMPEG4V2 ||
607              i_codec_id == AV_CODEC_ID_MSMPEG4V3 ||
608              i_codec_id == AV_CODEC_ID_WMV1 ||
609              i_codec_id == AV_CODEC_ID_WMV2 ||
610              i_codec_id == AV_CODEC_ID_RV10 ||
611              i_codec_id == AV_CODEC_ID_RV20 ||
612              i_codec_id == AV_CODEC_ID_SVQ3 )
613             p_enc->i_threads = 1;
614
615         if( p_sys->i_vtolerance > 0 )
616             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
617
618         /* usually if someone sets bitrate, he likes more to get that bitrate
619          * over quality should help 'normal' user to get asked bitrate
620          */
621         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
622         {
623             p_sys->i_qmax = 51;
624             p_sys->i_qmin = 3;
625         }
626
627         if( p_sys->i_qmin > 0 )
628         {
629             p_context->qmin = p_sys->i_qmin;
630             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
631         }
632         if( p_sys->i_qmax > 0 )
633         {
634             p_context->qmax = p_sys->i_qmax;
635             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
636         }
637         p_context->max_qdiff = 3;
638
639         p_context->mb_decision = p_sys->i_hq;
640
641         if( p_sys->i_quality && !p_enc->fmt_out.i_bitrate )
642         {
643             p_context->flags |= CODEC_FLAG_QSCALE;
644             p_context->global_quality = p_sys->i_quality;
645         }
646         else
647         {
648             p_context->rc_qsquish = 1.0;
649             /* Default to 1/2 second buffer for given bitrate unless defined otherwise*/
650             if( !p_sys->i_rc_buffer_size )
651             {
652                 p_sys->i_rc_buffer_size = p_enc->fmt_out.i_bitrate * 8 / 2;
653             }
654             msg_Dbg( p_enc, "rc buffer size %d bits", p_sys->i_rc_buffer_size );
655             /* Set maxrate/minrate to bitrate to try to get CBR */
656             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
657             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
658             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
659             /* This is from ffmpeg's ffmpeg.c : */
660             p_context->rc_initial_buffer_occupancy
661                 = p_sys->i_rc_buffer_size * 3/4;
662             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
663         }
664     }
665     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
666     {
667         /* work around bug in libmp3lame encoding */
668         if( i_codec_id == AV_CODEC_ID_MP3 && p_enc->fmt_out.audio.i_channels  > 2 )
669             p_enc->fmt_out.audio.i_channels = 2;
670         p_context->codec_type  = AVMEDIA_TYPE_AUDIO;
671         p_context->sample_fmt  = p_codec->sample_fmts ?
672                                     p_codec->sample_fmts[0] :
673                                     AV_SAMPLE_FMT_S16;
674
675         /* Try to match avcodec input format to vlc format so we could avoid one
676            format conversion */
677         if( GetVlcAudioFormat( p_context->sample_fmt ) != p_enc->fmt_in.i_codec
678             && p_codec->sample_fmts )
679         {
680             msg_Dbg( p_enc, "Trying to find more suitable sample format instead of %s", av_get_sample_fmt_name( p_context->sample_fmt ) );
681             for( unsigned int i=0; p_codec->sample_fmts[i] != -1; i++ )
682             {
683                 if( GetVlcAudioFormat( p_codec->sample_fmts[i] ) == p_enc->fmt_in.i_codec )
684                 {
685                     p_context->sample_fmt = p_codec->sample_fmts[i];
686                     msg_Dbg( p_enc, "Using %s as new sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
687                     break;
688                 }
689             }
690         }
691         p_sys->b_planar = av_sample_fmt_is_planar( p_context->sample_fmt );
692         // Try if we can use interleaved format for codec input as VLC doesn't really do planar audio yet
693         // FIXME: Remove when planar/interleaved audio in vlc is equally supported
694         if( p_sys->b_planar && p_codec->sample_fmts )
695         {
696             msg_Dbg( p_enc, "Trying to find packet sample format instead of planar %s", av_get_sample_fmt_name( p_context->sample_fmt ) );
697             for( unsigned int i=0; p_codec->sample_fmts[i] != -1; i++ )
698             {
699                 if( !av_sample_fmt_is_planar( p_codec->sample_fmts[i] ) )
700                 {
701                     p_context->sample_fmt = p_codec->sample_fmts[i];
702                     msg_Dbg( p_enc, "Changing to packet format %s as new sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
703                     break;
704                 }
705             }
706         }
707         msg_Dbg( p_enc, "Ended up using %s as sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
708         p_enc->fmt_in.i_codec  = GetVlcAudioFormat( p_context->sample_fmt );
709         p_sys->b_planar = av_sample_fmt_is_planar( p_context->sample_fmt );
710
711         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
712         date_Init( &p_sys->buffer_date, p_enc->fmt_out.audio.i_rate, 1 );
713         date_Set( &p_sys->buffer_date, AV_NOPTS_VALUE );
714         p_context->time_base.num = 1;
715         p_context->time_base.den = p_context->sample_rate;
716         p_context->channels      = p_enc->fmt_out.audio.i_channels;
717 #if LIBAVUTIL_VERSION_CHECK( 52, 2, 6, 0, 0)
718         p_context->channel_layout = channel_mask[p_context->channels][1];
719
720         /* Setup Channel ordering for multichannel audio
721          * as VLC channel order isn't same as libavcodec expects
722          */
723
724         p_sys->i_channels_to_reorder = 0;
725
726         /* Specified order
727          * Copied from audio.c
728          */
729         const unsigned i_order_max = 8 * sizeof(p_context->channel_layout);
730         uint32_t pi_order_dst[AOUT_CHAN_MAX] = { };
731         int i_channels_src = 0;
732
733         if( p_context->channel_layout )
734         {
735             msg_Dbg( p_enc, "Creating channel order for reordering");
736             for( unsigned i = 0; i < sizeof(pi_channels_map)/sizeof(*pi_channels_map); i++ )
737             {
738                 if( p_context->channel_layout & pi_channels_map[i][0] )
739                 {
740                     msg_Dbg( p_enc, "%d %"PRIx64" mapped to %"PRIx64"", i_channels_src, pi_channels_map[i][0], pi_channels_map[i][1]);
741                     pi_order_dst[i_channels_src++] = pi_channels_map[i][1];
742                 }
743             }
744         }
745         else
746         {
747             msg_Dbg( p_enc, "Creating default channel order for reordering");
748             /* Create default order  */
749             for( unsigned int i = 0; i < __MIN( i_order_max, (unsigned)p_sys->p_context->channels ); i++ )
750             {
751                 if( i < sizeof(pi_channels_map)/sizeof(*pi_channels_map) )
752                 {
753                     msg_Dbg( p_enc, "%d channel is %"PRIx64"", i_channels_src, pi_channels_map[i][1]);
754                     pi_order_dst[i_channels_src++] = pi_channels_map[i][1];
755                 }
756             }
757         }
758         if( i_channels_src != p_context->channels )
759             msg_Err( p_enc, "Channel layout not understood" );
760
761         p_sys->i_channels_to_reorder = aout_CheckChannelReorder( NULL, pi_order_dst,
762             channel_mask[p_context->channels][0], p_sys->pi_reorder_layout );
763 #endif
764
765         if ( p_enc->fmt_out.i_codec == VLC_CODEC_MP4A )
766         {
767             /* XXX: FAAC does resample only when setting the INPUT samplerate
768              * to the desired value (-R option of the faac frontend)
769             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
770             /* vlc should default to low-complexity profile, faac encoder
771              * has bug and aac audio has issues otherwise atm */
772             p_context->profile = p_sys->i_aac_profile;
773         }
774     }
775
776     /* Misc parameters */
777     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
778
779     /* Set reasonable defaults to VP8, based on
780        libvpx-720p preset from libvpx ffmpeg-patch */
781     if( i_codec_id == AV_CODEC_ID_VP8 )
782     {
783         /* Lets give bitrate tolerance */
784         p_context->bit_rate_tolerance = __MAX(2 * (int)p_enc->fmt_out.i_bitrate, p_sys->i_vtolerance );
785         /* default to 120 frames between keyframe */
786         if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" ) )
787             p_context->gop_size = 120;
788         /* Don't set rc-values atm, they were from time before
789            libvpx was officially in FFmpeg */
790         //p_context->rc_max_rate = 24 * 1000 * 1000; //24M
791         //p_context->rc_min_rate = 40 * 1000; // 40k
792         /* seems that FFmpeg presets have 720p as divider for buffers */
793         if( p_enc->fmt_out.video.i_visible_height >= 720 )
794         {
795             /* Check that we don't overrun users qmin/qmax values */
796             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
797             {
798                 p_context->qmin = 10;
799                 p_context->mb_lmin = p_context->lmin = 10 * FF_QP2LAMBDA;
800             }
801
802             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" ) )
803             {
804                 p_context->qmax = 42;
805                 p_context->mb_lmax = p_context->lmax = 42 * FF_QP2LAMBDA;
806             }
807
808         } else if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
809         {
810                 p_context->qmin = 1;
811                 p_context->mb_lmin = p_context->lmin = FF_QP2LAMBDA;
812         }
813
814
815 #if 0 /* enable when/if vp8 encoder is accepted in libavcodec */
816         p_context->lag = 16;
817         p_context->level = 216;
818         p_context->profile = 0;
819         p_context->rc_buffer_aggressivity = 0.95;
820         p_context->token_partitions = 4;
821         p_context->mb_static_threshold = 0;
822 #endif
823     }
824
825     if( i_codec_id == AV_CODEC_ID_RAWVIDEO )
826     {
827         /* XXX: hack: Force same codec (will be handled by transcode) */
828         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
829         GetFfmpegChroma( &p_context->pix_fmt, &p_enc->fmt_in.video );
830     }
831
832     /* Make sure we get extradata filled by the encoder */
833     p_context->extradata_size = 0;
834     p_context->extradata = NULL;
835     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
836
837     if( p_enc->i_threads >= 1)
838         p_context->thread_count = p_enc->i_threads;
839     else
840         p_context->thread_count = vlc_GetCPUCount();
841
842     int ret;
843     char *psz_opts = var_InheritString(p_enc, ENC_CFG_PREFIX "options");
844     AVDictionary *options = NULL;
845     if (psz_opts && *psz_opts)
846         options = vlc_av_get_options(psz_opts);
847     free(psz_opts);
848
849     vlc_avcodec_lock();
850     ret = avcodec_open2( p_context, p_codec, options ? &options : NULL );
851     vlc_avcodec_unlock();
852
853     AVDictionaryEntry *t = NULL;
854     while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
855         msg_Err(p_enc, "Unknown option \"%s\"", t->key);
856     }
857
858     if( ret )
859     {
860         if( p_enc->fmt_in.i_cat != AUDIO_ES ||
861                 (p_context->channels <= 2 && i_codec_id != AV_CODEC_ID_MP2
862                  && i_codec_id != AV_CODEC_ID_MP3) )
863 errmsg:
864         {
865             static const char types[][12] = {
866                 [UNKNOWN_ES] = N_("unknown"), [VIDEO_ES] = N_("video"),
867                 [AUDIO_ES] = N_("audio"), [SPU_ES] = N_("subpicture"),
868             };
869             const char *type = types[0];
870             union
871             {
872                 vlc_fourcc_t value;
873                 char txt[4];
874             } fcc = { .value = p_enc->fmt_out.i_codec };
875
876             if (likely((unsigned)p_enc->fmt_in.i_cat < sizeof (types) / sizeof (types[0])))
877                 type = types[p_enc->fmt_in.i_cat];
878             msg_Err( p_enc, "cannot open %4.4s %s encoder", fcc.txt, type );
879             vlc_dialog_display_error( p_enc, _("Streaming / Transcoding failed"),
880                 _("VLC could not open the %4.4s %s encoder."),
881                 fcc.txt, vlc_gettext(type) );
882             av_dict_free(&options);
883             goto error;
884         }
885
886         if( p_context->channels > 2 )
887         {
888             p_context->channels = 2;
889             p_enc->fmt_in.audio.i_channels = 2; // FIXME
890             msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
891         }
892
893         if( i_codec_id == AV_CODEC_ID_MP2 || i_codec_id == AV_CODEC_ID_MP3 )
894         {
895             int i_frequency, i;
896             es_format_t *fmt = &p_enc->fmt_out;
897
898             for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
899                 if ( fmt->audio.i_rate == mpa_freq_tab[i_frequency] )
900                     break;
901
902             if ( i_frequency == 6 )
903             {
904                 msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
905                         fmt->audio.i_rate );
906                 av_dict_free(&options);
907                 goto error;
908             }
909
910             for ( i = 1; i < 14; i++ )
911                 if (fmt->i_bitrate/1000 <= mpa_bitrate_tab[i_frequency / 3][i])
912                     break;
913
914             if (fmt->i_bitrate / 1000 != mpa_bitrate_tab[i_frequency / 3][i])
915             {
916                 msg_Warn( p_enc,
917                         "MPEG audio doesn't support bitrate=%d, using %d",
918                         fmt->i_bitrate,
919                         mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
920                 fmt->i_bitrate = mpa_bitrate_tab[i_frequency / 3][i] * 1000;
921                 p_context->bit_rate = fmt->i_bitrate;
922             }
923         }
924
925         p_context->codec = NULL;
926         vlc_avcodec_lock();
927         ret = avcodec_open2( p_context, p_codec, options ? &options : NULL );
928         vlc_avcodec_unlock();
929         if( ret )
930             goto errmsg;
931     }
932
933     av_dict_free(&options);
934
935     if( i_codec_id == AV_CODEC_ID_FLAC )
936     {
937         p_enc->fmt_out.i_extra = 4 + 1 + 3 + p_context->extradata_size;
938         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
939         if( p_enc->fmt_out.p_extra )
940         {
941             uint8_t *p = p_enc->fmt_out.p_extra;
942             p[0] = 0x66;    /* f */
943             p[1] = 0x4C;    /* L */
944             p[2] = 0x61;    /* a */
945             p[3] = 0x43;    /* C */
946             p[4] = 0x80;    /* streaminfo block, last block before audio */
947             p[5] = ( p_context->extradata_size >> 16 ) & 0xff;
948             p[6] = ( p_context->extradata_size >>  8 ) & 0xff;
949             p[7] = ( p_context->extradata_size       ) & 0xff;
950             memcpy( &p[8], p_context->extradata, p_context->extradata_size );
951         }
952         else
953         {
954             p_enc->fmt_out.i_extra = 0;
955         }
956     }
957     else
958     {
959         p_enc->fmt_out.i_extra = p_context->extradata_size;
960         if( p_enc->fmt_out.i_extra )
961         {
962             p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
963             if ( p_enc->fmt_out.p_extra == NULL )
964             {
965                 goto error;
966             }
967             memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
968                     p_enc->fmt_out.i_extra );
969         }
970     }
971
972     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
973
974     if( p_enc->fmt_in.i_cat == AUDIO_ES )
975     {
976         p_enc->fmt_in.i_codec = GetVlcAudioFormat( p_sys->p_context->sample_fmt );
977         p_enc->fmt_in.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_in.i_codec );
978
979         p_sys->i_sample_bytes = (p_enc->fmt_in.audio.i_bitspersample / 8);
980         p_sys->i_frame_size = p_context->frame_size > 1 ?
981                                     p_context->frame_size :
982                                     FF_MIN_BUFFER_SIZE;
983         p_sys->i_buffer_out = av_samples_get_buffer_size(NULL,
984                 p_sys->p_context->channels, p_sys->i_frame_size,
985                 p_sys->p_context->sample_fmt, DEFAULT_ALIGN);
986         p_sys->p_buffer = av_malloc( p_sys->i_buffer_out );
987         if ( unlikely( p_sys->p_buffer == NULL ) )
988         {
989             goto error;
990         }
991         p_enc->fmt_out.audio.i_frame_length = p_context->frame_size;
992         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
993         p_enc->fmt_out.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_out.i_codec );
994         //b_variable tells if we can feed any size frames to encoder
995         p_sys->b_variable = p_context->frame_size ? false : true;
996
997
998         if( p_sys->b_planar )
999         {
1000             p_sys->p_interleave_buf = av_malloc( p_sys->i_buffer_out );
1001             if( unlikely( p_sys->p_interleave_buf == NULL ) )
1002                 goto error;
1003         }
1004     }
1005
1006     p_sys->frame = av_frame_alloc();
1007     if( !p_sys->frame )
1008     {
1009         goto error;
1010     }
1011     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
1012
1013     p_enc->pf_encode_video = EncodeVideo;
1014     p_enc->pf_encode_audio = EncodeAudio;
1015
1016
1017     return VLC_SUCCESS;
1018 error:
1019     free( p_enc->fmt_out.p_extra );
1020     av_free( p_sys->p_buffer );
1021     av_free( p_sys->p_interleave_buf );
1022     avcodec_free_context( &p_context );
1023     free( p_sys );
1024     return VLC_ENOMEM;
1025 }
1026
1027 typedef struct
1028 {
1029     block_t self;
1030     AVPacket packet;
1031 } vlc_av_packet_t;
1032
1033 static void vlc_av_packet_Release(block_t *block)
1034 {
1035     vlc_av_packet_t *b = (void *) block;
1036
1037     av_free_packet(&b->packet);
1038     free(b);
1039 }
1040
1041 static block_t *vlc_av_packet_Wrap(AVPacket *packet, mtime_t i_length, AVCodecContext *context )
1042 {
1043     vlc_av_packet_t *b = malloc( sizeof( *b ) );
1044     if( unlikely(b == NULL) )
1045         return NULL;
1046
1047     block_t *p_block = &b->self;
1048
1049     block_Init( p_block, packet->data, packet->size );
1050     p_block->i_nb_samples = 0;
1051     p_block->pf_release = vlc_av_packet_Release;
1052     b->packet = *packet;
1053
1054     p_block->i_length = i_length;
1055     p_block->i_pts = packet->pts;
1056     p_block->i_dts = packet->dts;
1057     if( unlikely( packet->flags & AV_PKT_FLAG_CORRUPT ) )
1058         p_block->i_flags |= BLOCK_FLAG_CORRUPTED;
1059     p_block->i_pts = p_block->i_pts * CLOCK_FREQ * context->time_base.num / context->time_base.den;
1060     p_block->i_dts = p_block->i_dts * CLOCK_FREQ * context->time_base.num / context->time_base.den;
1061
1062     return p_block;
1063 }
1064
1065 /****************************************************************************
1066  * EncodeVideo: the whole thing
1067  ****************************************************************************/
1068 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
1069 {
1070     encoder_sys_t *p_sys = p_enc->p_sys;
1071     int i_plane;
1072
1073     AVFrame *frame = NULL;
1074     if( likely(p_pict) ) {
1075         frame = p_sys->frame;
1076         av_frame_unref( frame );
1077
1078         for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
1079         {
1080             p_sys->frame->data[i_plane] = p_pict->p[i_plane].p_pixels;
1081             p_sys->frame->linesize[i_plane] = p_pict->p[i_plane].i_pitch;
1082         }
1083
1084         /* Let libavcodec select the frame type */
1085         frame->pict_type = 0;
1086
1087         frame->repeat_pict = p_pict->i_nb_fields - 2;
1088         frame->interlaced_frame = !p_pict->b_progressive;
1089         frame->top_field_first = !!p_pict->b_top_field_first;
1090
1091         /* Set the pts of the frame being encoded
1092          * avcodec likes pts to be in time_base units
1093          * frame number */
1094         if( likely( p_pict->date > VLC_TS_INVALID ) )
1095             frame->pts = p_pict->date * p_sys->p_context->time_base.den /
1096                           CLOCK_FREQ / p_sys->p_context->time_base.num;
1097         else
1098             frame->pts = AV_NOPTS_VALUE;
1099
1100         if ( p_sys->b_hurry_up && frame->pts != AV_NOPTS_VALUE )
1101         {
1102             mtime_t current_date = mdate();
1103
1104             if ( current_date + HURRY_UP_GUARD3 > frame->pts )
1105             {
1106                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
1107                 p_sys->p_context->trellis = 0;
1108                 msg_Dbg( p_enc, "hurry up mode 3" );
1109             }
1110             else
1111             {
1112                 p_sys->p_context->mb_decision = p_sys->i_hq;
1113
1114                 if ( current_date + HURRY_UP_GUARD2 > frame->pts )
1115                 {
1116                     p_sys->p_context->trellis = 0;
1117                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
1118                         + (HURRY_UP_GUARD2 + current_date - frame->pts) / 500;
1119                     msg_Dbg( p_enc, "hurry up mode 2" );
1120                 }
1121                 else
1122                 {
1123                     p_sys->p_context->trellis = p_sys->b_trellis;
1124
1125                     p_sys->p_context->noise_reduction =
1126                        p_sys->i_noise_reduction;
1127                 }
1128             }
1129
1130             if ( current_date + HURRY_UP_GUARD1 > frame->pts )
1131             {
1132                 frame->pict_type = AV_PICTURE_TYPE_P;
1133                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
1134             }
1135         }
1136
1137         if ( ( frame->pts != AV_NOPTS_VALUE ) && ( frame->pts != VLC_TS_INVALID ) )
1138         {
1139             if ( p_sys->i_last_pts == frame->pts )
1140             {
1141                 msg_Warn( p_enc, "almost fed libavcodec with two frames with "
1142                           "the same PTS (%"PRId64 ")", frame->pts );
1143                 return NULL;
1144             }
1145             else if ( p_sys->i_last_pts > frame->pts )
1146             {
1147                 msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
1148                          "past (current: %"PRId64 ", last: %"PRId64")",
1149                          frame->pts, p_sys->i_last_pts );
1150                 return NULL;
1151             }
1152             else
1153                 p_sys->i_last_pts = frame->pts;
1154         }
1155
1156         frame->quality = p_sys->i_quality;
1157     }
1158
1159     AVPacket av_pkt;
1160     av_pkt.data = NULL;
1161     av_pkt.size = 0;
1162     int is_data;
1163
1164     av_init_packet( &av_pkt );
1165
1166     if( avcodec_encode_video2( p_sys->p_context, &av_pkt, frame, &is_data ) < 0
1167      || is_data == 0 )
1168     {
1169         return NULL;
1170     }
1171
1172     block_t *p_block = vlc_av_packet_Wrap( &av_pkt,
1173             av_pkt.duration / p_sys->p_context->time_base.den, p_sys->p_context );
1174     if( unlikely(p_block == NULL) )
1175     {
1176         av_free_packet( &av_pkt );
1177         return NULL;
1178     }
1179
1180     switch ( p_sys->p_context->coded_frame->pict_type )
1181     {
1182     case AV_PICTURE_TYPE_I:
1183     case AV_PICTURE_TYPE_SI:
1184         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1185         break;
1186     case AV_PICTURE_TYPE_P:
1187     case AV_PICTURE_TYPE_SP:
1188         p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1189         break;
1190     case AV_PICTURE_TYPE_B:
1191     case AV_PICTURE_TYPE_BI:
1192         p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1193         break;
1194     default:
1195         p_block->i_flags |= BLOCK_FLAG_TYPE_PB;
1196     }
1197
1198     return p_block;
1199 }
1200
1201 static block_t *encode_audio_buffer( encoder_t *p_enc, encoder_sys_t *p_sys,  AVFrame *frame )
1202 {
1203     int got_packet, i_out;
1204     got_packet=i_out=0;
1205     AVPacket packet = {0};
1206     block_t *p_block = block_Alloc( p_sys->i_buffer_out );
1207     av_init_packet( &packet );
1208     packet.data = p_block->p_buffer;
1209     packet.size = p_block->i_buffer;
1210
1211     i_out = avcodec_encode_audio2( p_sys->p_context, &packet, frame, &got_packet );
1212     if( unlikely( !got_packet || ( i_out < 0 ) ) )
1213     {
1214         if( i_out < 0 )
1215         {
1216             msg_Err( p_enc,"Encoding problem..");
1217         }
1218         block_Release( p_block );
1219         return NULL;
1220     }
1221     p_block->i_buffer = packet.size;
1222
1223     p_block->i_length = (mtime_t)CLOCK_FREQ *
1224      (mtime_t)p_sys->i_frame_size /
1225      (mtime_t)p_sys->p_context->sample_rate;
1226
1227     if( likely( packet.pts != AV_NOPTS_VALUE ) )
1228         p_block->i_dts = p_block->i_pts = packet.pts;
1229     else
1230         p_block->i_dts = p_block->i_pts = VLC_TS_INVALID;
1231     return p_block;
1232 }
1233
1234 static block_t *handle_delay_buffer( encoder_t *p_enc, encoder_sys_t *p_sys, int buffer_delay, block_t *p_aout_buf, int leftover_samples )
1235 {
1236     block_t *p_block = NULL;
1237     //How much we need to copy from new packet
1238     const int leftover = leftover_samples * p_sys->p_context->channels * p_sys->i_sample_bytes;
1239
1240     av_frame_unref( p_sys->frame );
1241     p_sys->frame->format     = p_sys->p_context->sample_fmt;
1242     p_sys->frame->nb_samples = leftover_samples + p_sys->i_samples_delay;
1243
1244
1245     p_sys->frame->pts        = date_Get( &p_sys->buffer_date );
1246
1247     if( likely( p_sys->frame->pts != AV_NOPTS_VALUE) )
1248         date_Increment( &p_sys->buffer_date, p_sys->frame->nb_samples );
1249
1250     if( likely( p_aout_buf ) )
1251     {
1252
1253         p_aout_buf->i_nb_samples -= leftover_samples;
1254         memcpy( p_sys->p_buffer+buffer_delay, p_aout_buf->p_buffer, leftover );
1255
1256         // We need to deinterleave from p_aout_buf to p_buffer the leftover bytes
1257         if( p_sys->b_planar )
1258             aout_Deinterleave( p_sys->p_interleave_buf, p_sys->p_buffer,
1259                 p_sys->i_frame_size, p_sys->p_context->channels, p_enc->fmt_in.i_codec );
1260         else
1261             memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer, leftover);
1262
1263         p_aout_buf->p_buffer     += leftover;
1264         p_aout_buf->i_buffer     -= leftover;
1265         if( likely( p_sys->frame->pts != AV_NOPTS_VALUE) )
1266             p_aout_buf->i_pts         = date_Get( &p_sys->buffer_date );
1267     }
1268
1269     if(unlikely( ( (leftover + buffer_delay) < p_sys->i_buffer_out ) &&
1270                  !(p_sys->p_codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME )))
1271     {
1272         msg_Dbg( p_enc, "No small last frame support, padding");
1273         size_t padding_size = p_sys->i_buffer_out - (leftover+buffer_delay);
1274         memset( p_sys->p_buffer + (leftover+buffer_delay), 0, padding_size );
1275         buffer_delay += padding_size;
1276     }
1277     if( avcodec_fill_audio_frame( p_sys->frame, p_sys->p_context->channels,
1278             p_sys->p_context->sample_fmt, p_sys->b_planar ? p_sys->p_interleave_buf : p_sys->p_buffer,
1279             p_sys->i_buffer_out,
1280             DEFAULT_ALIGN) < 0 )
1281     {
1282         msg_Err( p_enc, "filling error on fillup" );
1283         p_sys->frame->nb_samples = 0;
1284     }
1285
1286
1287     p_sys->i_samples_delay = 0;
1288
1289     p_block = encode_audio_buffer( p_enc, p_sys, p_sys->frame );
1290
1291     return p_block;
1292 }
1293
1294 /****************************************************************************
1295  * EncodeAudio: the whole thing
1296  ****************************************************************************/
1297 static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
1298 {
1299     encoder_sys_t *p_sys = p_enc->p_sys;
1300
1301     block_t *p_block, *p_chain = NULL;
1302     size_t buffer_delay = 0, i_samples_left = 0;
1303
1304
1305     //i_bytes_left is amount of bytes we get
1306     i_samples_left = p_aout_buf ? p_aout_buf->i_nb_samples : 0;
1307     buffer_delay = p_sys->i_samples_delay * p_sys->i_sample_bytes * p_sys->p_context->channels;
1308
1309     //p_sys->i_buffer_out = p_sys->i_frame_size * chan * p_sys->i_sample_bytes
1310     //Calculate how many bytes we would need from current buffer to fill frame
1311     size_t leftover_samples = __MAX(0,__MIN((ssize_t)i_samples_left, (ssize_t)(p_sys->i_frame_size - p_sys->i_samples_delay)));
1312
1313     if( p_aout_buf && ( p_aout_buf->i_pts > VLC_TS_INVALID ) )
1314     {
1315         date_Set( &p_sys->buffer_date, p_aout_buf->i_pts );
1316         /* take back amount we have leftover from previous buffer*/
1317         if( p_sys->i_samples_delay > 0 )
1318             date_Decrement( &p_sys->buffer_date, p_sys->i_samples_delay );
1319     }
1320     /* Handle reordering here so we have p_sys->p_buffer always in correct
1321      * order already */
1322     if( p_aout_buf && p_sys->i_channels_to_reorder > 0 )
1323     {
1324         aout_ChannelReorder( p_aout_buf->p_buffer, p_aout_buf->i_buffer,
1325              p_sys->i_channels_to_reorder, p_sys->pi_reorder_layout,
1326              p_enc->fmt_in.i_codec );
1327     }
1328
1329     // Check if we have enough samples in delay_buffer and current p_aout_buf to fill frame
1330     // Or if we are cleaning up
1331     if( ( buffer_delay > 0 ) &&
1332             ( ( p_aout_buf && ( leftover_samples <= p_aout_buf->i_nb_samples ) &&
1333                ( (leftover_samples + p_sys->i_samples_delay ) >= p_sys->i_frame_size )
1334               ) ||
1335              ( !p_aout_buf )
1336             )
1337          )
1338     {
1339         p_chain = handle_delay_buffer( p_enc, p_sys, buffer_delay, p_aout_buf, leftover_samples );
1340         buffer_delay = 0;
1341         if( unlikely( !p_chain ) )
1342             return NULL;
1343     }
1344
1345     if( unlikely( !p_aout_buf ) )
1346     {
1347         msg_Dbg(p_enc,"Flushing..");
1348         do {
1349             p_block = encode_audio_buffer( p_enc, p_sys, NULL );
1350             if( likely( p_block ) )
1351             {
1352                 block_ChainAppend( &p_chain, p_block );
1353             }
1354         } while( p_block );
1355         return p_chain;
1356     }
1357
1358
1359     while( ( p_aout_buf->i_nb_samples >= p_sys->i_frame_size ) ||
1360            ( p_sys->b_variable && p_aout_buf->i_nb_samples ) )
1361     {
1362         av_frame_unref( p_sys->frame );
1363
1364         if( p_sys->b_variable )
1365             p_sys->frame->nb_samples = p_aout_buf->i_nb_samples;
1366         else
1367             p_sys->frame->nb_samples = p_sys->i_frame_size;
1368         p_sys->frame->format     = p_sys->p_context->sample_fmt;
1369         p_sys->frame->pts        = date_Get( &p_sys->buffer_date );
1370
1371         const int in_bytes = p_sys->frame->nb_samples *
1372             p_sys->p_context->channels * p_sys->i_sample_bytes;
1373
1374         if( p_sys->b_planar )
1375         {
1376             aout_Deinterleave( p_sys->p_buffer, p_aout_buf->p_buffer,
1377                                p_sys->frame->nb_samples, p_sys->p_context->channels, p_enc->fmt_in.i_codec );
1378
1379         }
1380         else
1381         {
1382             memcpy(p_sys->p_buffer, p_aout_buf->p_buffer, in_bytes);
1383         }
1384
1385         if( avcodec_fill_audio_frame( p_sys->frame, p_sys->p_context->channels,
1386                                     p_sys->p_context->sample_fmt,
1387                                     p_sys->p_buffer,
1388                                     p_sys->i_buffer_out,
1389                                     DEFAULT_ALIGN) < 0 )
1390         {
1391                  msg_Err( p_enc, "filling error on encode" );
1392                  p_sys->frame->nb_samples = 0;
1393         }
1394
1395         p_aout_buf->p_buffer     += in_bytes;
1396         p_aout_buf->i_buffer     -= in_bytes;
1397         p_aout_buf->i_nb_samples -= p_sys->frame->nb_samples;
1398         if( likely( p_sys->frame->pts != AV_NOPTS_VALUE) )
1399             date_Increment( &p_sys->buffer_date, p_sys->frame->nb_samples );
1400
1401         p_block = encode_audio_buffer( p_enc, p_sys, p_sys->frame );
1402         if( likely( p_block ) )
1403             block_ChainAppend( &p_chain, p_block );
1404     }
1405
1406     // We have leftover samples that don't fill frame_size, and libavcodec doesn't seem to like
1407     // that frame has more data than p_sys->i_frame_size most of the cases currently.
1408     if( p_aout_buf->i_nb_samples > 0 )
1409     {
1410        memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer,
1411                p_aout_buf->i_nb_samples * p_sys->i_sample_bytes * p_sys->p_context->channels);
1412        p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1413     }
1414
1415     return p_chain;
1416 }
1417
1418 /*****************************************************************************
1419  * CloseEncoder: libavcodec encoder destruction
1420  *****************************************************************************/
1421 void CloseEncoder( vlc_object_t *p_this )
1422 {
1423     encoder_t *p_enc = (encoder_t *)p_this;
1424     encoder_sys_t *p_sys = p_enc->p_sys;
1425
1426     av_frame_free( &p_sys->frame );
1427
1428     vlc_avcodec_lock();
1429     avcodec_close( p_sys->p_context );
1430     vlc_avcodec_unlock();
1431     avcodec_free_context( &p_sys->p_context );
1432
1433
1434     av_free( p_sys->p_interleave_buf );
1435     av_free( p_sys->p_buffer );
1436
1437     free( p_sys );
1438 }