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