avcodec: define coded_width/height on encoding
[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->coded_width = p_enc->fmt_in.video.i_width;
504         p_context->coded_height = p_enc->fmt_in.video.i_height;
505         p_context->width = p_enc->fmt_in.video.i_visible_width;
506         p_context->height = p_enc->fmt_in.video.i_visible_height;
507
508         probe_video_frame_rate( p_enc, p_context, p_codec );
509         set_video_color_settings( &p_enc->fmt_in.video, p_context );
510
511         /* Defaults from ffmpeg.c */
512         p_context->qblur = 0.5;
513         p_context->qcompress = 0.5;
514         p_context->b_quant_offset = 1.25;
515         p_context->b_quant_factor = 1.25;
516         p_context->i_quant_offset = 0.0;
517         p_context->i_quant_factor = -0.8;
518
519         p_context->lumi_masking = p_sys->f_lumi_masking;
520         p_context->dark_masking = p_sys->f_dark_masking;
521         p_context->p_masking = p_sys->f_p_masking;
522         add_av_option_float( p_enc, &options, "border_mask", p_sys->f_border_masking );
523
524         if( p_sys->i_key_int > 0 )
525             p_context->gop_size = p_sys->i_key_int;
526         p_context->max_b_frames =
527             VLC_CLIP( p_sys->i_b_frames, 0, FF_MAX_B_FRAMES );
528         if( !p_context->max_b_frames  &&
529             (  p_enc->fmt_out.i_codec == VLC_CODEC_MPGV ||
530                p_enc->fmt_out.i_codec == VLC_CODEC_MP2V ) )
531             p_context->flags |= AV_CODEC_FLAG_LOW_DELAY;
532
533         av_reduce( &p_context->sample_aspect_ratio.num,
534                    &p_context->sample_aspect_ratio.den,
535                    p_enc->fmt_in.video.i_sar_num,
536                    p_enc->fmt_in.video.i_sar_den, 1 << 30 );
537
538
539         p_enc->fmt_in.i_codec = VLC_CODEC_I420;
540
541         /* Very few application support YUV in TIFF, not even VLC */
542         if( p_enc->fmt_out.i_codec == VLC_CODEC_TIFF )
543             p_enc->fmt_in.i_codec = VLC_CODEC_RGB24;
544
545         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
546         GetFfmpegChroma( &p_context->pix_fmt, &p_enc->fmt_in.video );
547
548         if( p_codec->pix_fmts )
549         {
550             static const enum AVPixelFormat vlc_pix_fmts[] = {
551                 AV_PIX_FMT_YUV420P,
552                 AV_PIX_FMT_NV12,
553                 AV_PIX_FMT_RGB24,
554             };
555             bool found = false;
556             const enum PixelFormat *p = p_codec->pix_fmts;
557             for( ; !found && *p != -1; p++ )
558             {
559                 for( size_t i = 0; i < ARRAY_SIZE(vlc_pix_fmts); ++i )
560                 {
561                     if( *p == vlc_pix_fmts[i] )
562                     {
563                         found = true;
564                         p_context->pix_fmt = *p;
565                         break;
566                     }
567                 }
568             }
569             if (!found) p_context->pix_fmt = p_codec->pix_fmts[0];
570             GetVlcChroma( &p_enc->fmt_in.video, p_context->pix_fmt );
571             p_enc->fmt_in.i_codec = p_enc->fmt_in.video.i_chroma;
572         }
573
574
575         if ( p_sys->f_i_quant_factor != 0.f )
576             p_context->i_quant_factor = p_sys->f_i_quant_factor;
577
578         int nr = var_GetInteger( p_enc, ENC_CFG_PREFIX "noise-reduction" );
579         add_av_option_int( p_enc, &options, "noise_reduction", nr );
580
581         if ( p_sys->b_mpeg4_matrix )
582         {
583             p_context->intra_matrix = mpeg4_default_intra_matrix;
584             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
585         }
586
587         if ( p_sys->b_pre_me )
588         {
589             add_av_option_int( p_enc, &options, "mepre", 1 );
590             p_context->me_pre_cmp = FF_CMP_CHROMA;
591         }
592
593         if ( p_sys->b_interlace )
594         {
595             if ( p_context->height <= 280 )
596             {
597                 if ( p_context->height != 16 || p_context->width != 16 )
598                     msg_Warn( p_enc,
599                         "disabling interlaced video because height=%d <= 280",
600                         p_context->height );
601             }
602             else
603             {
604                 p_context->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
605                 if ( p_sys->b_interlace_me )
606                     p_context->flags |= AV_CODEC_FLAG_INTERLACED_ME;
607             }
608         }
609
610         p_context->trellis = p_sys->b_trellis;
611
612         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
613             p_context->flags |= AV_CODEC_FLAG_QSCALE;
614         /* These codecs cause libavcodec to exit if thread_count is > 1.
615            See libavcodec/mpegvideo_enc.c:MPV_encode_init and
616            libavcodec/svq3.c , WMV2 calls MPV_encode_init also.
617          */
618         if ( i_codec_id == AV_CODEC_ID_FLV1 ||
619              i_codec_id == AV_CODEC_ID_H261 ||
620              i_codec_id == AV_CODEC_ID_LJPEG ||
621              i_codec_id == AV_CODEC_ID_MJPEG ||
622              i_codec_id == AV_CODEC_ID_H263 ||
623              i_codec_id == AV_CODEC_ID_H263P ||
624              i_codec_id == AV_CODEC_ID_MSMPEG4V1 ||
625              i_codec_id == AV_CODEC_ID_MSMPEG4V2 ||
626              i_codec_id == AV_CODEC_ID_MSMPEG4V3 ||
627              i_codec_id == AV_CODEC_ID_WMV1 ||
628              i_codec_id == AV_CODEC_ID_WMV2 ||
629              i_codec_id == AV_CODEC_ID_RV10 ||
630              i_codec_id == AV_CODEC_ID_RV20 ||
631              i_codec_id == AV_CODEC_ID_SVQ3 )
632             p_enc->i_threads = 1;
633
634         if( p_sys->i_vtolerance > 0 )
635             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
636
637         /* usually if someone sets bitrate, he likes more to get that bitrate
638          * over quality should help 'normal' user to get asked bitrate
639          */
640         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
641         {
642             p_sys->i_qmax = 51;
643             p_sys->i_qmin = 3;
644         }
645
646         if( p_sys->i_qmin > 0 )
647         {
648             p_context->qmin = p_sys->i_qmin;
649             p_context->mb_lmin = p_sys->i_qmin * FF_QP2LAMBDA;
650             add_av_option_int( p_enc, &options, "lmin", p_context->mb_lmin);
651         }
652         if( p_sys->i_qmax > 0 )
653         {
654             p_context->qmax = p_sys->i_qmax;
655             p_context->mb_lmax = p_sys->i_qmax * FF_QP2LAMBDA;
656             add_av_option_int( p_enc, &options, "lmax", p_context->mb_lmax);
657         }
658         p_context->max_qdiff = 3;
659
660         p_context->mb_decision = p_sys->i_hq;
661
662         if( p_sys->i_quality && !p_enc->fmt_out.i_bitrate )
663         {
664             p_context->flags |= AV_CODEC_FLAG_QSCALE;
665             p_context->global_quality = p_sys->i_quality;
666         }
667         else
668         {
669             av_dict_set(&options, "qsquish", "1.0", 0);
670             /* Default to 1/2 second buffer for given bitrate unless defined otherwise*/
671             if( !p_sys->i_rc_buffer_size )
672             {
673                 p_sys->i_rc_buffer_size = p_enc->fmt_out.i_bitrate * 8 / 2;
674             }
675             msg_Dbg( p_enc, "rc buffer size %d bits", p_sys->i_rc_buffer_size );
676             /* Set maxrate/minrate to bitrate to try to get CBR */
677             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
678             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
679             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
680             /* This is from ffmpeg's ffmpeg.c : */
681             p_context->rc_initial_buffer_occupancy
682                 = p_sys->i_rc_buffer_size * 3/4;
683             add_av_option_float( p_enc, &options, "rc_buffer_aggressivity", p_sys->f_rc_buffer_aggressivity );
684         }
685     }
686     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
687     {
688         p_context->codec_type  = AVMEDIA_TYPE_AUDIO;
689         p_context->sample_fmt  = p_codec->sample_fmts ?
690                                     p_codec->sample_fmts[0] :
691                                     AV_SAMPLE_FMT_S16;
692
693         /* Try to match avcodec input format to vlc format so we could avoid one
694            format conversion */
695         if( GetVlcAudioFormat( p_context->sample_fmt ) != p_enc->fmt_in.i_codec
696             && p_codec->sample_fmts )
697         {
698             msg_Dbg( p_enc, "Trying to find more suitable sample format instead of %s", av_get_sample_fmt_name( p_context->sample_fmt ) );
699             for( unsigned int i=0; p_codec->sample_fmts[i] != -1; i++ )
700             {
701                 if( GetVlcAudioFormat( p_codec->sample_fmts[i] ) == p_enc->fmt_in.i_codec )
702                 {
703                     p_context->sample_fmt = p_codec->sample_fmts[i];
704                     msg_Dbg( p_enc, "Using %s as new sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
705                     break;
706                 }
707             }
708         }
709         p_sys->b_planar = av_sample_fmt_is_planar( p_context->sample_fmt );
710         // Try if we can use interleaved format for codec input as VLC doesn't really do planar audio yet
711         // FIXME: Remove when planar/interleaved audio in vlc is equally supported
712         if( p_sys->b_planar && p_codec->sample_fmts )
713         {
714             msg_Dbg( p_enc, "Trying to find packet sample format instead of planar %s", av_get_sample_fmt_name( p_context->sample_fmt ) );
715             for( unsigned int i=0; p_codec->sample_fmts[i] != -1; i++ )
716             {
717                 if( !av_sample_fmt_is_planar( p_codec->sample_fmts[i] ) )
718                 {
719                     p_context->sample_fmt = p_codec->sample_fmts[i];
720                     msg_Dbg( p_enc, "Changing to packet format %s as new sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
721                     break;
722                 }
723             }
724         }
725         msg_Dbg( p_enc, "Ended up using %s as sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
726         p_enc->fmt_in.i_codec  = GetVlcAudioFormat( p_context->sample_fmt );
727         p_sys->b_planar = av_sample_fmt_is_planar( p_context->sample_fmt );
728
729         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
730         date_Init( &p_sys->buffer_date, p_enc->fmt_out.audio.i_rate, 1 );
731         p_context->time_base.num = 1;
732         p_context->time_base.den = p_context->sample_rate;
733         p_context->channels      = p_enc->fmt_out.audio.i_channels;
734         p_context->channel_layout = channel_mask[p_context->channels][1];
735
736         /* Setup Channel ordering for multichannel audio
737          * as VLC channel order isn't same as libavcodec expects
738          */
739
740         p_sys->i_channels_to_reorder = 0;
741
742         /* Specified order
743          * Copied from audio.c
744          */
745         const unsigned i_order_max = 8 * sizeof(p_context->channel_layout);
746         uint32_t pi_order_dst[AOUT_CHAN_MAX] = { 0 };
747         uint32_t order_mask = 0;
748         int i_channels_src = 0;
749
750         if( p_context->channel_layout )
751         {
752             msg_Dbg( p_enc, "Creating channel order for reordering");
753             for( unsigned i = 0; i < sizeof(pi_channels_map)/sizeof(*pi_channels_map); i++ )
754             {
755                 if( p_context->channel_layout & pi_channels_map[i][0] )
756                 {
757                     msg_Dbg( p_enc, "%d %"PRIx64" mapped to %"PRIx64"", i_channels_src, pi_channels_map[i][0], pi_channels_map[i][1]);
758                     pi_order_dst[i_channels_src++] = pi_channels_map[i][1];
759                     order_mask |= pi_channels_map[i][1];
760                 }
761             }
762         }
763         else
764         {
765             msg_Dbg( p_enc, "Creating default channel order for reordering");
766             /* Create default order  */
767             for( unsigned int i = 0; i < __MIN( i_order_max, (unsigned)p_sys->p_context->channels ); i++ )
768             {
769                 if( i < sizeof(pi_channels_map)/sizeof(*pi_channels_map) )
770                 {
771                     msg_Dbg( p_enc, "%d channel is %"PRIx64"", i_channels_src, pi_channels_map[i][1]);
772                     pi_order_dst[i_channels_src++] = pi_channels_map[i][1];
773                     order_mask |= pi_channels_map[i][1];
774                 }
775             }
776         }
777         if( i_channels_src != p_context->channels )
778             msg_Err( p_enc, "Channel layout not understood" );
779
780         p_sys->i_channels_to_reorder =
781             aout_CheckChannelReorder( NULL, pi_order_dst, order_mask,
782                                       p_sys->pi_reorder_layout );
783
784         if ( p_enc->fmt_out.i_codec == VLC_CODEC_MP4A )
785         {
786             /* XXX: FAAC does resample only when setting the INPUT samplerate
787              * to the desired value (-R option of the faac frontend)
788             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
789             /* vlc should default to low-complexity profile, faac encoder
790              * has bug and aac audio has issues otherwise atm */
791             p_context->profile = p_sys->i_aac_profile;
792         }
793     }
794
795     /* Misc parameters */
796     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
797
798     /* Set reasonable defaults to VP8, based on
799        libvpx-720p preset from libvpx ffmpeg-patch */
800     if( i_codec_id == AV_CODEC_ID_VP8 )
801     {
802         /* Lets give bitrate tolerance */
803         p_context->bit_rate_tolerance = __MAX(2 * (int)p_enc->fmt_out.i_bitrate, p_sys->i_vtolerance );
804         /* default to 120 frames between keyframe */
805         if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" ) )
806             p_context->gop_size = 120;
807         /* Don't set rc-values atm, they were from time before
808            libvpx was officially in FFmpeg */
809         //p_context->rc_max_rate = 24 * 1000 * 1000; //24M
810         //p_context->rc_min_rate = 40 * 1000; // 40k
811         /* seems that FFmpeg presets have 720p as divider for buffers */
812         if( p_enc->fmt_out.video.i_visible_height >= 720 )
813         {
814             /* Check that we don't overrun users qmin/qmax values */
815             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
816             {
817                 p_context->qmin = 10;
818                 p_context->mb_lmin = 10 * FF_QP2LAMBDA;
819                 add_av_option_int( p_enc, &options, "lmin", p_context->mb_lmin );
820             }
821
822             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" ) )
823             {
824                 p_context->qmax = 42;
825                 p_context->mb_lmax = 42 * FF_QP2LAMBDA;
826                 add_av_option_int( p_enc, &options, "lmax", p_context->mb_lmax );
827             }
828
829         } else if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
830         {
831                 p_context->qmin = 1;
832                 p_context->mb_lmin = FF_QP2LAMBDA;
833                 add_av_option_int( p_enc, &options, "lmin", p_context->mb_lmin );
834         }
835
836
837 #if 0 /* enable when/if vp8 encoder is accepted in libavcodec */
838         p_context->lag = 16;
839         p_context->level = 216;
840         p_context->profile = 0;
841         p_context->rc_buffer_aggressivity = 0.95;
842         p_context->token_partitions = 4;
843         p_context->mb_static_threshold = 0;
844 #endif
845     }
846
847     if( i_codec_id == AV_CODEC_ID_RAWVIDEO )
848     {
849         /* XXX: hack: Force same codec (will be handled by transcode) */
850         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
851         GetFfmpegChroma( &p_context->pix_fmt, &p_enc->fmt_in.video );
852     }
853
854     /* Make sure we get extradata filled by the encoder */
855     p_context->extradata_size = 0;
856     p_context->extradata = NULL;
857     p_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
858
859     if( p_enc->i_threads >= 1)
860         p_context->thread_count = p_enc->i_threads;
861     else
862         p_context->thread_count = vlc_GetCPUCount();
863
864     int ret;
865     char *psz_opts = var_InheritString(p_enc, ENC_CFG_PREFIX "options");
866     if (psz_opts) {
867         vlc_av_get_options(psz_opts, &options);
868         free(psz_opts);
869     }
870
871     vlc_avcodec_lock();
872     ret = avcodec_open2( p_context, p_codec, options ? &options : NULL );
873     vlc_avcodec_unlock();
874
875     AVDictionaryEntry *t = NULL;
876     while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
877         msg_Err(p_enc, "Unknown option \"%s\"", t->key);
878     }
879
880     if( ret )
881     {
882         if( p_enc->fmt_in.i_cat != AUDIO_ES ||
883                 (p_context->channels <= 2 && i_codec_id != AV_CODEC_ID_MP2
884                  && i_codec_id != AV_CODEC_ID_MP3) )
885 errmsg:
886         {
887             static const char types[][12] = {
888                 [UNKNOWN_ES] = N_("unknown"), [VIDEO_ES] = N_("video"),
889                 [AUDIO_ES] = N_("audio"), [SPU_ES] = N_("subpicture"),
890             };
891             const char *type = types[0];
892             union
893             {
894                 vlc_fourcc_t value;
895                 char txt[4];
896             } fcc = { .value = p_enc->fmt_out.i_codec };
897
898             if (likely((unsigned)p_enc->fmt_in.i_cat < sizeof (types) / sizeof (types[0])))
899                 type = types[p_enc->fmt_in.i_cat];
900             msg_Err( p_enc, "cannot open %4.4s %s encoder", fcc.txt, type );
901             vlc_dialog_display_error( p_enc, _("Streaming / Transcoding failed"),
902                 _("VLC could not open the %4.4s %s encoder."),
903                 fcc.txt, vlc_gettext(type) );
904             av_dict_free(&options);
905             goto error;
906         }
907
908         if( p_context->channels > 2 )
909         {
910             p_context->channels = 2;
911             p_context->channel_layout = channel_mask[p_context->channels][1];
912
913             /* Change fmt_in in order to ask for a channels conversion */
914             p_enc->fmt_in.audio.i_channels =
915             p_enc->fmt_out.audio.i_channels = 2;
916             p_enc->fmt_in.audio.i_physical_channels =
917             p_enc->fmt_out.audio.i_physical_channels = AOUT_CHANS_STEREO;
918             p_sys->i_channels_to_reorder = 0;
919             msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
920         }
921
922         if( i_codec_id == AV_CODEC_ID_MP2 || i_codec_id == AV_CODEC_ID_MP3 )
923         {
924             int i_frequency, i;
925             es_format_t *fmt = &p_enc->fmt_out;
926
927             for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
928                 if ( fmt->audio.i_rate == mpa_freq_tab[i_frequency] )
929                     break;
930
931             if ( i_frequency == 6 )
932             {
933                 msg_Warn( p_enc, "MPEG audio doesn't support frequency=%d",
934                         fmt->audio.i_rate );
935                 /* Fallback to 44100 hz */
936                 p_context->sample_rate = p_enc->fmt_in.audio.i_rate =
937                 p_enc->fmt_out.audio.i_rate = 44100;
938             }
939
940             for ( i = 1; i < 14; i++ )
941                 if (fmt->i_bitrate/1000 <= mpa_bitrate_tab[i_frequency / 3][i])
942                     break;
943
944             if (fmt->i_bitrate / 1000 != mpa_bitrate_tab[i_frequency / 3][i])
945             {
946                 msg_Warn( p_enc,
947                         "MPEG audio doesn't support bitrate=%d, using %d",
948                         fmt->i_bitrate,
949                         mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
950                 fmt->i_bitrate = mpa_bitrate_tab[i_frequency / 3][i] * 1000;
951                 p_context->bit_rate = fmt->i_bitrate;
952             }
953         }
954
955         p_context->codec = NULL;
956         vlc_avcodec_lock();
957         ret = avcodec_open2( p_context, p_codec, options ? &options : NULL );
958         vlc_avcodec_unlock();
959         if( ret )
960             goto errmsg;
961     }
962
963     av_dict_free(&options);
964
965     if( i_codec_id == AV_CODEC_ID_FLAC )
966     {
967         p_enc->fmt_out.i_extra = 4 + 1 + 3 + p_context->extradata_size;
968         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
969         if( p_enc->fmt_out.p_extra )
970         {
971             uint8_t *p = p_enc->fmt_out.p_extra;
972             p[0] = 0x66;    /* f */
973             p[1] = 0x4C;    /* L */
974             p[2] = 0x61;    /* a */
975             p[3] = 0x43;    /* C */
976             p[4] = 0x80;    /* streaminfo block, last block before audio */
977             p[5] = ( p_context->extradata_size >> 16 ) & 0xff;
978             p[6] = ( p_context->extradata_size >>  8 ) & 0xff;
979             p[7] = ( p_context->extradata_size       ) & 0xff;
980             memcpy( &p[8], p_context->extradata, p_context->extradata_size );
981         }
982         else
983         {
984             p_enc->fmt_out.i_extra = 0;
985         }
986     }
987     else
988     {
989         p_enc->fmt_out.i_extra = p_context->extradata_size;
990         if( p_enc->fmt_out.i_extra )
991         {
992             p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
993             if ( p_enc->fmt_out.p_extra == NULL )
994             {
995                 goto error;
996             }
997             memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
998                     p_enc->fmt_out.i_extra );
999         }
1000     }
1001
1002     p_context->flags &= ~AV_CODEC_FLAG_GLOBAL_HEADER;
1003
1004     if( p_enc->fmt_in.i_cat == AUDIO_ES )
1005     {
1006         p_enc->fmt_in.i_codec = GetVlcAudioFormat( p_sys->p_context->sample_fmt );
1007         p_enc->fmt_in.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_in.i_codec );
1008
1009         p_sys->i_sample_bytes = (p_enc->fmt_in.audio.i_bitspersample / 8);
1010         p_sys->i_frame_size = p_context->frame_size > 1 ?
1011                                     p_context->frame_size :
1012                                     AV_INPUT_BUFFER_MIN_SIZE;
1013         p_sys->i_buffer_out = av_samples_get_buffer_size(NULL,
1014                 p_sys->p_context->channels, p_sys->i_frame_size,
1015                 p_sys->p_context->sample_fmt, DEFAULT_ALIGN);
1016         p_sys->p_buffer = av_malloc( p_sys->i_buffer_out );
1017         if ( unlikely( p_sys->p_buffer == NULL ) )
1018         {
1019             goto error;
1020         }
1021         p_enc->fmt_out.audio.i_frame_length = p_context->frame_size;
1022         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
1023         p_enc->fmt_out.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_out.i_codec );
1024         //b_variable tells if we can feed any size frames to encoder
1025         p_sys->b_variable = p_context->frame_size ? false : true;
1026
1027
1028         if( p_sys->b_planar )
1029         {
1030             p_sys->p_interleave_buf = av_malloc( p_sys->i_buffer_out );
1031             if( unlikely( p_sys->p_interleave_buf == NULL ) )
1032                 goto error;
1033         }
1034     }
1035
1036     p_sys->frame = av_frame_alloc();
1037     if( !p_sys->frame )
1038     {
1039         goto error;
1040     }
1041     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
1042
1043     p_enc->pf_encode_video = EncodeVideo;
1044     p_enc->pf_encode_audio = EncodeAudio;
1045
1046
1047     return VLC_SUCCESS;
1048 error:
1049     free( p_enc->fmt_out.p_extra );
1050     av_free( p_sys->p_buffer );
1051     av_free( p_sys->p_interleave_buf );
1052     avcodec_free_context( &p_context );
1053     free( p_sys );
1054     return VLC_ENOMEM;
1055 }
1056
1057 typedef struct
1058 {
1059     block_t self;
1060     AVPacket packet;
1061 } vlc_av_packet_t;
1062
1063 static void vlc_av_packet_Release(block_t *block)
1064 {
1065     vlc_av_packet_t *b = (void *) block;
1066
1067     av_packet_unref(&b->packet);
1068     free(b);
1069 }
1070
1071 static const struct vlc_block_callbacks vlc_av_packet_cbs =
1072 {
1073     vlc_av_packet_Release,
1074 };
1075
1076 static block_t *vlc_av_packet_Wrap(AVPacket *packet, vlc_tick_t i_length, AVCodecContext *context )
1077 {
1078     if ( packet->data == NULL &&
1079          packet->flags == 0 &&
1080          packet->pts == AV_NOPTS_VALUE &&
1081          packet->dts == AV_NOPTS_VALUE )
1082         return NULL; /* totally empty AVPacket */
1083
1084     vlc_av_packet_t *b = malloc( sizeof( *b ) );
1085     if( unlikely(b == NULL) )
1086         return NULL;
1087
1088     block_t *p_block = &b->self;
1089
1090     block_Init( p_block, &vlc_av_packet_cbs, packet->data, packet->size );
1091     p_block->i_nb_samples = 0;
1092     p_block->cbs = &vlc_av_packet_cbs;
1093     b->packet = *packet;
1094
1095     p_block->i_length = i_length;
1096     p_block->i_pts = FROM_AV_TS(packet->pts);
1097     p_block->i_dts = FROM_AV_TS(packet->dts);
1098     if( unlikely( packet->flags & AV_PKT_FLAG_CORRUPT ) )
1099         p_block->i_flags |= BLOCK_FLAG_CORRUPTED;
1100     if( packet->flags & AV_PKT_FLAG_KEY )
1101         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1102     p_block->i_pts = p_block->i_pts * CLOCK_FREQ * context->time_base.num / context->time_base.den;
1103     p_block->i_dts = p_block->i_dts * CLOCK_FREQ * context->time_base.num / context->time_base.den;
1104
1105     return p_block;
1106 }
1107
1108 static void check_hurry_up( encoder_sys_t *p_sys, AVFrame *frame, encoder_t *p_enc )
1109 {
1110     vlc_tick_t current_date = vlc_tick_now();
1111
1112     if ( current_date + HURRY_UP_GUARD3 > FROM_AV_TS(frame->pts) )
1113     {
1114         p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
1115         p_sys->p_context->trellis = 0;
1116         msg_Dbg( p_enc, "hurry up mode 3" );
1117     }
1118     else
1119     {
1120         p_sys->p_context->mb_decision = p_sys->i_hq;
1121
1122         if ( current_date + HURRY_UP_GUARD2 > FROM_AV_TS(frame->pts) )
1123         {
1124             p_sys->p_context->trellis = 0;
1125             msg_Dbg( p_enc, "hurry up mode 2" );
1126         }
1127         else
1128         {
1129             p_sys->p_context->trellis = p_sys->b_trellis;
1130         }
1131     }
1132
1133     if ( current_date + HURRY_UP_GUARD1 > FROM_AV_TS(frame->pts) )
1134     {
1135         frame->pict_type = AV_PICTURE_TYPE_P;
1136         /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
1137     }
1138 }
1139
1140 static block_t *encode_avframe( encoder_t *p_enc, encoder_sys_t *p_sys, AVFrame *frame )
1141 {
1142     AVPacket av_pkt;
1143     av_pkt.data = NULL;
1144     av_pkt.size = 0;
1145
1146     av_init_packet( &av_pkt );
1147
1148     int ret = avcodec_send_frame( p_sys->p_context, frame );
1149     if( frame && ret != 0 && ret != AVERROR(EAGAIN) )
1150     {
1151         msg_Warn( p_enc, "cannot send one frame to encoder %d", ret );
1152         return NULL;
1153     }
1154     ret = avcodec_receive_packet( p_sys->p_context, &av_pkt );
1155     if( ret != 0 && ret != AVERROR(EAGAIN) )
1156     {
1157         msg_Warn( p_enc, "cannot encode one frame" );
1158         return NULL;
1159     }
1160
1161     block_t *p_block = vlc_av_packet_Wrap( &av_pkt,
1162             av_pkt.duration / p_sys->p_context->time_base.den, p_sys->p_context );
1163     if( unlikely(p_block == NULL) )
1164     {
1165         av_packet_unref( &av_pkt );
1166         return NULL;
1167     }
1168     return p_block;
1169 }
1170
1171 /****************************************************************************
1172  * EncodeVideo: the whole thing
1173  ****************************************************************************/
1174 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
1175 {
1176     encoder_sys_t *p_sys = p_enc->p_sys;
1177     int i_plane;
1178
1179     AVFrame *frame = NULL;
1180     if( likely(p_pict) ) {
1181         frame = p_sys->frame;
1182         av_frame_unref( frame );
1183
1184         for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
1185         {
1186             p_sys->frame->data[i_plane] = p_pict->p[i_plane].p_pixels;
1187             p_sys->frame->linesize[i_plane] = p_pict->p[i_plane].i_pitch;
1188         }
1189
1190         /* Let libavcodec select the frame type */
1191         frame->pict_type = 0;
1192
1193         frame->repeat_pict = p_pict->i_nb_fields - 2;
1194         frame->interlaced_frame = !p_pict->b_progressive;
1195         frame->top_field_first = !!p_pict->b_top_field_first;
1196
1197         frame->format = p_sys->p_context->pix_fmt;
1198         frame->width = p_sys->p_context->width;
1199         frame->height = p_sys->p_context->height;
1200
1201         /* Set the pts of the frame being encoded
1202          * avcodec likes pts to be in time_base units
1203          * frame number */
1204         if( likely( p_pict->date != VLC_TICK_INVALID ) )
1205             frame->pts = p_pict->date * p_sys->p_context->time_base.den /
1206                           CLOCK_FREQ / p_sys->p_context->time_base.num;
1207         else
1208             frame->pts = AV_NOPTS_VALUE;
1209
1210         if ( p_sys->b_hurry_up && frame->pts != AV_NOPTS_VALUE )
1211             check_hurry_up( p_sys, frame, p_enc );
1212
1213         if ( ( frame->pts != AV_NOPTS_VALUE ) && ( frame->pts != VLC_TICK_INVALID ) )
1214         {
1215             if ( p_sys->i_last_pts == FROM_AV_TS(frame->pts) )
1216             {
1217                 msg_Warn( p_enc, "almost fed libavcodec with two frames with "
1218                           "the same PTS (%"PRId64 ")", frame->pts );
1219                 return NULL;
1220             }
1221             else if ( p_sys->i_last_pts > FROM_AV_TS(frame->pts) )
1222             {
1223                 msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
1224                          "past (current: %"PRId64 ", last: %"PRId64")",
1225                          frame->pts, p_sys->i_last_pts );
1226                 return NULL;
1227             }
1228             else
1229                 p_sys->i_last_pts = FROM_AV_TS(frame->pts);
1230         }
1231
1232         frame->quality = p_sys->i_quality;
1233     }
1234
1235     block_t *p_block = encode_avframe( p_enc, p_sys, frame );
1236
1237     if( p_block )
1238     {
1239        switch ( p_sys->p_context->coded_frame->pict_type )
1240        {
1241        case AV_PICTURE_TYPE_I:
1242        case AV_PICTURE_TYPE_SI:
1243            p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1244            break;
1245        case AV_PICTURE_TYPE_P:
1246        case AV_PICTURE_TYPE_SP:
1247            p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1248            break;
1249        case AV_PICTURE_TYPE_B:
1250        case AV_PICTURE_TYPE_BI:
1251            p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1252            break;
1253        default:
1254            p_block->i_flags |= BLOCK_FLAG_TYPE_PB;
1255        }
1256     }
1257
1258     return p_block;
1259 }
1260
1261 static block_t *handle_delay_buffer( encoder_t *p_enc, encoder_sys_t *p_sys, unsigned int buffer_delay,
1262                                      block_t *p_aout_buf, size_t leftover_samples )
1263 {
1264     block_t *p_block = NULL;
1265     //How much we need to copy from new packet
1266     const size_t leftover = leftover_samples * p_sys->p_context->channels * p_sys->i_sample_bytes;
1267
1268     av_frame_unref( p_sys->frame );
1269     p_sys->frame->format     = p_sys->p_context->sample_fmt;
1270     p_sys->frame->nb_samples = leftover_samples + p_sys->i_samples_delay;
1271
1272     if( likely( date_Get( &p_sys->buffer_date ) != VLC_TICK_INVALID) )
1273     {
1274         /* Convert to AV timing */
1275         p_sys->frame->pts = date_Get( &p_sys->buffer_date ) - VLC_TICK_0;
1276         p_sys->frame->pts = p_sys->frame->pts * p_sys->p_context->time_base.den /
1277                             CLOCK_FREQ / p_sys->p_context->time_base.num;
1278         date_Increment( &p_sys->buffer_date, p_sys->frame->nb_samples );
1279     }
1280     else p_sys->frame->pts = AV_NOPTS_VALUE;
1281
1282     if( likely( p_aout_buf ) )
1283     {
1284
1285         p_aout_buf->i_nb_samples -= leftover_samples;
1286         memcpy( p_sys->p_buffer+buffer_delay, p_aout_buf->p_buffer, leftover );
1287
1288         // We need to deinterleave from p_aout_buf to p_buffer the leftover bytes
1289         if( p_sys->b_planar )
1290             aout_Deinterleave( p_sys->p_interleave_buf, p_sys->p_buffer,
1291                 p_sys->i_frame_size, p_sys->p_context->channels, p_enc->fmt_in.i_codec );
1292         else
1293             memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer, leftover);
1294
1295         p_aout_buf->p_buffer     += leftover;
1296         p_aout_buf->i_buffer     -= leftover;
1297         p_aout_buf->i_pts         = date_Get( &p_sys->buffer_date );
1298     }
1299
1300     if(unlikely( ( (leftover + buffer_delay) < p_sys->i_buffer_out ) &&
1301                  !(p_sys->p_codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME )))
1302     {
1303         msg_Dbg( p_enc, "No small last frame support, padding");
1304         size_t padding_size = p_sys->i_buffer_out - (leftover+buffer_delay);
1305         memset( p_sys->p_buffer + (leftover+buffer_delay), 0, padding_size );
1306         buffer_delay += padding_size;
1307     }
1308     if( avcodec_fill_audio_frame( p_sys->frame, p_sys->p_context->channels,
1309             p_sys->p_context->sample_fmt, p_sys->b_planar ? p_sys->p_interleave_buf : p_sys->p_buffer,
1310             p_sys->i_buffer_out,
1311             DEFAULT_ALIGN) < 0 )
1312     {
1313         msg_Err( p_enc, "filling error on fillup" );
1314         p_sys->frame->nb_samples = 0;
1315     }
1316
1317
1318     p_sys->i_samples_delay = 0;
1319
1320     p_block = encode_avframe( p_enc, p_sys, p_sys->frame );
1321
1322     return p_block;
1323 }
1324
1325 /****************************************************************************
1326  * EncodeAudio: the whole thing
1327  ****************************************************************************/
1328 static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
1329 {
1330     encoder_sys_t *p_sys = p_enc->p_sys;
1331
1332     block_t *p_block, *p_chain = NULL;
1333     size_t buffer_delay = 0, i_samples_left = 0;
1334
1335
1336     //i_bytes_left is amount of bytes we get
1337     i_samples_left = p_aout_buf ? p_aout_buf->i_nb_samples : 0;
1338     buffer_delay = p_sys->i_samples_delay * p_sys->i_sample_bytes * p_sys->p_context->channels;
1339
1340     //p_sys->i_buffer_out = p_sys->i_frame_size * chan * p_sys->i_sample_bytes
1341     //Calculate how many bytes we would need from current buffer to fill frame
1342     size_t leftover_samples = __MAX(0,__MIN((ssize_t)i_samples_left, (ssize_t)(p_sys->i_frame_size - p_sys->i_samples_delay)));
1343
1344     if( p_aout_buf && ( p_aout_buf->i_pts != VLC_TICK_INVALID ) )
1345     {
1346         date_Set( &p_sys->buffer_date, p_aout_buf->i_pts );
1347         /* take back amount we have leftover from previous buffer*/
1348         if( p_sys->i_samples_delay > 0 )
1349             date_Decrement( &p_sys->buffer_date, p_sys->i_samples_delay );
1350     }
1351     /* Handle reordering here so we have p_sys->p_buffer always in correct
1352      * order already */
1353     if( p_aout_buf && p_sys->i_channels_to_reorder > 0 )
1354     {
1355         aout_ChannelReorder( p_aout_buf->p_buffer, p_aout_buf->i_buffer,
1356              p_sys->i_channels_to_reorder, p_sys->pi_reorder_layout,
1357              p_enc->fmt_in.i_codec );
1358     }
1359
1360     // Check if we have enough samples in delay_buffer and current p_aout_buf to fill frame
1361     // Or if we are cleaning up
1362     if( ( buffer_delay > 0 ) &&
1363             ( ( p_aout_buf && ( leftover_samples <= p_aout_buf->i_nb_samples ) &&
1364                ( (leftover_samples + p_sys->i_samples_delay ) >= p_sys->i_frame_size )
1365               ) ||
1366              ( !p_aout_buf )
1367             )
1368          )
1369     {
1370         p_chain = handle_delay_buffer( p_enc, p_sys, buffer_delay, p_aout_buf, leftover_samples );
1371         buffer_delay = 0;
1372         if( unlikely( !p_chain ) )
1373             return NULL;
1374     }
1375
1376     if( unlikely( !p_aout_buf ) )
1377     {
1378         msg_Dbg(p_enc,"Flushing..");
1379         do {
1380             p_block = encode_avframe( p_enc, p_sys, NULL );
1381             if( likely( p_block ) )
1382             {
1383                 block_ChainAppend( &p_chain, p_block );
1384             }
1385         } while( p_block );
1386         return p_chain;
1387     }
1388
1389
1390     while( ( p_aout_buf->i_nb_samples >= p_sys->i_frame_size ) ||
1391            ( p_sys->b_variable && p_aout_buf->i_nb_samples ) )
1392     {
1393         av_frame_unref( p_sys->frame );
1394
1395         if( p_sys->b_variable )
1396             p_sys->frame->nb_samples = p_aout_buf->i_nb_samples;
1397         else
1398             p_sys->frame->nb_samples = p_sys->i_frame_size;
1399         p_sys->frame->format     = p_sys->p_context->sample_fmt;
1400         if( likely(date_Get( &p_sys->buffer_date ) != VLC_TICK_INVALID) )
1401         {
1402             /* Convert to AV timing */
1403             p_sys->frame->pts = date_Get( &p_sys->buffer_date ) - VLC_TICK_0;
1404             p_sys->frame->pts = p_sys->frame->pts * p_sys->p_context->time_base.den /
1405                                 CLOCK_FREQ / p_sys->p_context->time_base.num;
1406         }
1407         else p_sys->frame->pts = AV_NOPTS_VALUE;
1408
1409         const int in_bytes = p_sys->frame->nb_samples *
1410             p_sys->p_context->channels * p_sys->i_sample_bytes;
1411
1412         if( p_sys->b_planar )
1413         {
1414             aout_Deinterleave( p_sys->p_buffer, p_aout_buf->p_buffer,
1415                                p_sys->frame->nb_samples, p_sys->p_context->channels, p_enc->fmt_in.i_codec );
1416
1417         }
1418         else
1419         {
1420             memcpy(p_sys->p_buffer, p_aout_buf->p_buffer, in_bytes);
1421         }
1422
1423         if( avcodec_fill_audio_frame( p_sys->frame, p_sys->p_context->channels,
1424                                     p_sys->p_context->sample_fmt,
1425                                     p_sys->p_buffer,
1426                                     p_sys->i_buffer_out,
1427                                     DEFAULT_ALIGN) < 0 )
1428         {
1429                  msg_Err( p_enc, "filling error on encode" );
1430                  p_sys->frame->nb_samples = 0;
1431         }
1432
1433         p_aout_buf->p_buffer     += in_bytes;
1434         p_aout_buf->i_buffer     -= in_bytes;
1435         p_aout_buf->i_nb_samples -= p_sys->frame->nb_samples;
1436         if( likely(date_Get( &p_sys->buffer_date ) != VLC_TICK_INVALID) )
1437             date_Increment( &p_sys->buffer_date, p_sys->frame->nb_samples );
1438
1439         p_block = encode_avframe( p_enc, p_sys, p_sys->frame );
1440         if( likely( p_block ) )
1441             block_ChainAppend( &p_chain, p_block );
1442     }
1443
1444     // We have leftover samples that don't fill frame_size, and libavcodec doesn't seem to like
1445     // that frame has more data than p_sys->i_frame_size most of the cases currently.
1446     if( p_aout_buf->i_nb_samples > 0 )
1447     {
1448        memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer,
1449                p_aout_buf->i_nb_samples * p_sys->i_sample_bytes * p_sys->p_context->channels);
1450        p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1451     }
1452
1453     return p_chain;
1454 }
1455
1456 /*****************************************************************************
1457  * EndVideoEnc: libavcodec encoder destruction
1458  *****************************************************************************/
1459 void EndVideoEnc( vlc_object_t *p_this )
1460 {
1461     encoder_t *p_enc = (encoder_t *)p_this;
1462     encoder_sys_t *p_sys = p_enc->p_sys;
1463
1464     av_frame_free( &p_sys->frame );
1465
1466     vlc_avcodec_lock();
1467     avcodec_close( p_sys->p_context );
1468     vlc_avcodec_unlock();
1469     avcodec_free_context( &p_sys->p_context );
1470
1471
1472     av_free( p_sys->p_interleave_buf );
1473     av_free( p_sys->p_buffer );
1474
1475     free( p_sys );
1476 }