git.sesse.net Git - vlc/blob - modules/codec/avcodec/encoder.c

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