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",
 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     vlc_avcodec_lock();
 742     ret = avcodec_open2( p_context, p_codec, NULL /* options */ );
 743     vlc_avcodec_unlock();
 744     if( ret )
 745     {
 746         if( p_enc->fmt_in.i_cat != AUDIO_ES ||
 747                 (p_context->channels <= 2 && i_codec_id != AV_CODEC_ID_MP2
 748                  && i_codec_id != AV_CODEC_ID_MP3) )
 749         {
 750             msg_Err( p_enc, "cannot open encoder" );
 751             dialog_Fatal( p_enc, _("Streaming / Transcoding failed"),
 752                     "%s", _("VLC could not open the encoder.") );
 753             free( p_sys );
 754             return VLC_EGENERIC;
 755         }
 756
 757         if( p_context->channels > 2 )
 758         {
 759             p_context->channels = 2;
 760             p_enc->fmt_in.audio.i_channels = 2; // FIXME
 761             msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 762         }
 763
 764         if( i_codec_id == AV_CODEC_ID_MP2 || i_codec_id == AV_CODEC_ID_MP3 )
 765         {
 766             int i_frequency, i;
 767             es_format_t *fmt = &p_enc->fmt_out;
 768
 769             for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 770                 if ( fmt->audio.i_rate == mpa_freq_tab[i_frequency] )
 771                     break;
 772
 773             if ( i_frequency == 6 )
 774             {
 775                 msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 776                         fmt->audio.i_rate );
 777                 free( p_sys );
 778                 return VLC_EGENERIC;
 779             }
 780
 781             for ( i = 1; i < 14; i++ )
 782                 if (fmt->i_bitrate/1000 <= mpa_bitrate_tab[i_frequency / 3][i])
 783                     break;
 784
 785             if (fmt->i_bitrate / 1000 != mpa_bitrate_tab[i_frequency / 3][i])
 786             {
 787                 msg_Warn( p_enc,
 788                         "MPEG audio doesn't support bitrate=%d, using %d",
 789                         fmt->i_bitrate,
 790                         mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 791                 fmt->i_bitrate = mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 792                 p_context->bit_rate = fmt->i_bitrate;
 793             }
 794         }
 795
 796         p_context->codec = NULL;
 797         vlc_avcodec_lock();
 798         ret = avcodec_open2( p_context, p_codec, NULL /* options */ );
 799         vlc_avcodec_unlock();
 800         if( ret )
 801         {
 802             msg_Err( p_enc, "cannot open encoder" );
 803             dialog_Fatal( p_enc,
 804                     _("Streaming / Transcoding failed"),
 805                     "%s", _("VLC could not open the encoder.") );
 806             free( p_sys );
 807             return VLC_EGENERIC;
 808         }
 809     }
 810
 811     if( i_codec_id == AV_CODEC_ID_FLAC )
 812     {
 813         p_enc->fmt_out.i_extra = 4 + 1 + 3 + p_context->extradata_size;
 814         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 815         if( p_enc->fmt_out.p_extra )
 816         {
 817             uint8_t *p = p_enc->fmt_out.p_extra;
 818             p[0] = 0x66;    /* f */
 819             p[1] = 0x4C;    /* L */
 820             p[2] = 0x61;    /* a */
 821             p[3] = 0x43;    /* C */
 822             p[4] = 0x80;    /* streaminfo block, last block before audio */
 823             p[5] = ( p_context->extradata_size >> 16 ) & 0xff;
 824             p[6] = ( p_context->extradata_size >>  8 ) & 0xff;
 825             p[7] = ( p_context->extradata_size       ) & 0xff;
 826             memcpy( &p[8], p_context->extradata, p_context->extradata_size );
 827         }
 828         else
 829         {
 830             p_enc->fmt_out.i_extra = 0;
 831         }
 832     }
 833     else
 834     {
 835         p_enc->fmt_out.i_extra = p_context->extradata_size;
 836         if( p_enc->fmt_out.i_extra )
 837         {
 838             p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 839             if ( p_enc->fmt_out.p_extra == NULL )
 840             {
 841                 goto error;
 842             }
 843             memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 844                     p_enc->fmt_out.i_extra );
 845         }
 846     }
 847
 848     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 849
 850     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 851     {
 852         p_enc->fmt_in.i_codec = GetVlcAudioFormat( p_sys->p_context->sample_fmt );
 853         p_enc->fmt_in.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_in.i_codec );
 854
 855         p_sys->i_sample_bytes = (p_enc->fmt_in.audio.i_bitspersample / 8);
 856         p_sys->i_frame_size = p_context->frame_size > 1 ?
 857                                     p_context->frame_size :
 858                                     FF_MIN_BUFFER_SIZE;
 859         p_sys->p_buffer = malloc( p_sys->i_frame_size * p_sys->i_sample_bytes * p_enc->fmt_in.audio.i_channels);
 860         if ( unlikely( p_sys->p_buffer == NULL ) )
 861         {
 862             goto error;
 863         }
 864         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 865         p_enc->fmt_out.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_out.i_codec );
 866         //b_variable tells if we can feed any size frames to encoder
 867         p_sys->b_variable = p_context->frame_size ? false : true;
 868
 869         p_sys->i_buffer_out = p_sys->i_frame_size * p_sys->i_sample_bytes * p_enc->fmt_in.audio.i_channels;
 870
 871         if( p_sys->b_planar )
 872         {
 873             p_sys->p_interleave_buf = malloc( p_sys->i_buffer_out );
 874             if( unlikely( p_sys->p_interleave_buf == NULL ) )
 875                 goto error;
 876         }
 877     }
 878
 879     p_sys->frame = avcodec_alloc_frame();
 880     if( !p_sys->frame )
 881     {
 882         goto error;
 883     }
 884     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 885
 886     p_enc->pf_encode_video = EncodeVideo;
 887     p_enc->pf_encode_audio = EncodeAudio;
 888
 889
 890     return VLC_SUCCESS;
 891 error:
 892     free( p_enc->fmt_out.p_extra );
 893     free( p_sys->p_buffer );
 894     free( p_sys->p_interleave_buf );
 895     free( p_sys );
 896     return VLC_ENOMEM;
 897 }
 898
 899 /****************************************************************************
 900  * EncodeVideo: the whole thing
 901  ****************************************************************************/
 902 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 903 {
 904     encoder_sys_t *p_sys = p_enc->p_sys;
 905     int i_out, i_plane, i_got_packet=1;
 906
 907     /* Initialize the video output buffer the first time.
 908      * This is done here instead of OpenEncoder() because we need the actual
 909      * bits_per_pixel value, without having to assume anything.
 910      */
 911     const int bytesPerPixel = p_enc->fmt_out.video.i_bits_per_pixel ?
 912                          p_enc->fmt_out.video.i_bits_per_pixel / 8 : 3;
 913     const int blocksize = __MAX( FF_MIN_BUFFER_SIZE,bytesPerPixel * p_sys->p_context->height * p_sys->p_context->width + 200 );
 914     block_t *p_block = block_Alloc( blocksize );
 915
 916 #if (LIBAVCODEC_VERSION_MAJOR >= 54)
 917     AVPacket av_pkt;
 918     /*We don't use av_pkt with major_version < 54, so no point init it*/
 919     av_init_packet( &av_pkt );
 920     av_pkt.data = p_block->p_buffer;
 921     av_pkt.size = p_block->i_buffer;
 922 #endif
 923     if( likely(p_pict) ) {
 924         avcodec_get_frame_defaults( p_sys->frame );
 925         for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 926         {
 927             p_sys->frame->data[i_plane] = p_pict->p[i_plane].p_pixels;
 928             p_sys->frame->linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 929         }
 930
 931         /* Let libavcodec select the frame type */
 932         p_sys->frame->pict_type = 0;
 933
 934         p_sys->frame->repeat_pict = p_pict->i_nb_fields - 2;
 935         p_sys->frame->interlaced_frame = !p_pict->b_progressive;
 936         p_sys->frame->top_field_first = !!p_pict->b_top_field_first;
 937
 938         /* Set the pts of the frame being encoded */
 939         p_sys->frame->pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 940
 941         if ( p_sys->b_hurry_up && p_sys->frame->pts != (int64_t)AV_NOPTS_VALUE )
 942         {
 943             mtime_t current_date = mdate();
 944
 945             if ( current_date + HURRY_UP_GUARD3 > p_sys->frame->pts )
 946             {
 947                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 948                 p_sys->p_context->trellis = 0;
 949                 msg_Dbg( p_enc, "hurry up mode 3" );
 950             }
 951             else
 952             {
 953                 p_sys->p_context->mb_decision = p_sys->i_hq;
 954
 955                 if ( current_date + HURRY_UP_GUARD2 > p_sys->frame->pts )
 956                 {
 957                     p_sys->p_context->trellis = 0;
 958                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 959                         + (HURRY_UP_GUARD2 + current_date - p_sys->frame->pts) / 500;
 960                     msg_Dbg( p_enc, "hurry up mode 2" );
 961                 }
 962                 else
 963                 {
 964                     p_sys->p_context->trellis = p_sys->b_trellis;
 965
 966                     p_sys->p_context->noise_reduction =
 967                        p_sys->i_noise_reduction;
 968                 }
 969             }
 970
 971             if ( current_date + HURRY_UP_GUARD1 > p_sys->frame->pts )
 972             {
 973                 p_sys->frame->pict_type = AV_PICTURE_TYPE_P;
 974                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 975             }
 976         }
 977
 978         if ( p_sys->frame->pts != (int64_t)AV_NOPTS_VALUE && p_sys->frame->pts != 0 )
 979         {
 980             if ( p_sys->i_last_pts == p_sys->frame->pts )
 981             {
 982                 msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 983                          "same PTS (%"PRId64 ")", p_sys->frame->pts );
 984                 return NULL;
 985             }
 986             else if ( p_sys->i_last_pts > p_sys->frame->pts )
 987             {
 988                 msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 989                          "past (current: %"PRId64 ", last: %"PRId64")",
 990                          p_sys->frame->pts, p_sys->i_last_pts );
 991                 return NULL;
 992             }
 993             else
 994             {
 995                 p_sys->i_last_pts = p_sys->frame->pts;
 996             }
 997         }
 998
 999         p_sys->frame->quality = p_sys->i_quality;
1000
1001 #if (LIBAVCODEC_VERSION_MAJOR < 54)
1002         i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer, p_block->i_buffer, p_sys->frame );
1003 #else
1004         i_out = avcodec_encode_video2( p_sys->p_context, &av_pkt, p_sys->frame, &i_got_packet );
1005 #endif
1006     }
1007     else
1008     {
1009 #if (LIBAVCODEC_VERSION_MAJOR < 54)
1010         i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer, p_block->i_buffer, NULL);
1011 #else
1012         i_out = avcodec_encode_video2( p_sys->p_context, &av_pkt, NULL, &i_got_packet );
1013 #endif
1014     }
1015
1016     if( unlikely( i_out < 0 || i_got_packet == 0 ) )
1017     {
1018         block_Release( p_block );
1019         return NULL;
1020     }
1021
1022
1023 #if (LIBAVCODEC_VERSION_MAJOR < 54)
1024     p_block->i_buffer = i_out;
1025
1026     /* FIXME, 3-2 pulldown is not handled correctly */
1027     p_block->i_length = INT64_C(1000000) *
1028         p_enc->fmt_in.video.i_frame_rate_base /
1029             p_enc->fmt_in.video.i_frame_rate;
1030
1031     if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
1032     {
1033         /* No delay -> output pts == input pts */
1034         if( p_pict )
1035             p_block->i_dts = p_pict->date;
1036         p_block->i_pts = p_block->i_dts;
1037     }
1038     else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
1039         p_sys->p_context->coded_frame->pts != 0 &&
1040         p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
1041     {
1042         p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
1043         p_block->i_pts = p_sys->p_context->coded_frame->pts;
1044
1045         if( p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_I &&
1046             p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_P )
1047         {
1048             p_block->i_dts = p_block->i_pts;
1049         }
1050         else
1051         {
1052             if( p_sys->i_last_ref_pts )
1053             {
1054                 p_block->i_dts = p_sys->i_last_ref_pts;
1055             }
1056             else
1057             {
1058                 /* Let's put something sensible */
1059                 p_block->i_dts = p_block->i_pts;
1060             }
1061
1062             p_sys->i_last_ref_pts = p_block->i_pts;
1063         }
1064     }
1065     else if( p_pict )
1066     {
1067         /* Buggy libavcodec which doesn't update coded_frame->pts
1068          * correctly */
1069         p_block->i_dts = p_block->i_pts = p_pict->date;
1070     }
1071 #else
1072     p_block->i_buffer = av_pkt.size;
1073
1074     p_block->i_length = av_pkt.duration / p_sys->p_context->time_base.den;
1075
1076     p_block->i_pts = av_pkt.pts;
1077     p_block->i_dts = av_pkt.dts;
1078     if( unlikely( av_pkt.flags & AV_PKT_FLAG_CORRUPT ) )
1079         p_block->i_flags |= BLOCK_FLAG_CORRUPTED;
1080 #endif
1081
1082     switch ( p_sys->p_context->coded_frame->pict_type )
1083     {
1084     case AV_PICTURE_TYPE_I:
1085     case AV_PICTURE_TYPE_SI:
1086         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1087         break;
1088     case AV_PICTURE_TYPE_P:
1089     case AV_PICTURE_TYPE_SP:
1090         p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1091         break;
1092     case AV_PICTURE_TYPE_B:
1093     case AV_PICTURE_TYPE_BI:
1094         p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1095         break;
1096     default:
1097         p_block->i_flags |= BLOCK_FLAG_TYPE_PB;
1098     }
1099
1100     return p_block;
1101 }
1102
1103 /****************************************************************************
1104  * EncodeAudio: the whole thing
1105  ****************************************************************************/
1106 static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
1107 {
1108     encoder_sys_t *p_sys = p_enc->p_sys;
1109
1110     block_t *p_block, *p_chain = NULL;
1111     int got_packet,i_out;
1112     size_t buffer_delay = 0, i_samples_left = 0;
1113
1114     //i_bytes_left is amount of bytes we get
1115     i_samples_left = p_aout_buf ? p_aout_buf->i_nb_samples : 0;
1116     buffer_delay = p_sys->i_samples_delay * p_sys->i_sample_bytes * p_enc->fmt_in.audio.i_channels;
1117
1118     //p_sys->i_buffer_out = p_sys->i_frame_size * chan * p_sys->i_sample_bytes
1119     //Calculate how many bytes we would need from current buffer to fill frame
1120     size_t leftover_samples = __MAX(0,__MIN((ssize_t)i_samples_left, (ssize_t)(p_sys->i_frame_size - p_sys->i_samples_delay)));
1121
1122     // Check if we have enough samples in delay_buffer and current p_aout_buf to fill frame
1123     // Or if we are cleaning up
1124     if( ( buffer_delay > 0 ) &&
1125             ( ( p_aout_buf && ( leftover_samples <= p_aout_buf->i_nb_samples ) &&
1126                ( (leftover_samples + p_sys->i_samples_delay ) >= p_sys->i_frame_size )
1127               ) ||
1128              ( !p_aout_buf )
1129             )
1130          )
1131     {
1132         //How much we need to copy from new packet
1133         const int leftover = leftover_samples * p_enc->fmt_in.audio.i_channels * p_sys->i_sample_bytes;
1134
1135 #if LIBAVUTIL_VERSION_CHECK( 51,27,2,46,100 )
1136         const int align = 0;
1137 #else
1138         const int align = 1;
1139 #endif
1140
1141         AVPacket packet = {0};
1142         avcodec_get_frame_defaults( p_sys->frame );
1143         p_sys->frame->format     = p_sys->p_context->sample_fmt;
1144         p_sys->frame->pts        = date_Get( &p_sys->buffer_date );
1145         p_sys->frame->nb_samples = leftover_samples + p_sys->i_samples_delay;
1146         date_Increment( &p_sys->buffer_date, p_sys->i_frame_size );
1147
1148         if( likely( p_aout_buf ) )
1149         {
1150             p_aout_buf->i_nb_samples -= leftover_samples;
1151             memcpy( p_sys->p_buffer+buffer_delay, p_aout_buf->p_buffer, leftover );
1152
1153             // We need to deinterleave from p_aout_buf to p_buffer the leftover bytes
1154             if( p_sys->b_planar )
1155                 aout_Deinterleave( p_sys->p_interleave_buf, p_sys->p_buffer,
1156                     p_sys->i_frame_size, p_enc->fmt_in.audio.i_channels, p_enc->fmt_in.i_codec );
1157             else
1158                 memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer, leftover);
1159
1160             p_aout_buf->p_buffer     += leftover;
1161             p_aout_buf->i_buffer     -= leftover;
1162             p_aout_buf->i_pts         = date_Get( &p_sys->buffer_date );
1163         }
1164         if(unlikely( ( (leftover + buffer_delay) < p_sys->i_buffer_out ) &&
1165                      !(p_sys->p_codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME ))
1166           )
1167         {
1168             msg_Dbg( p_enc, "No small last frame support, padding");
1169             size_t padding_size = p_sys->i_buffer_out - (leftover+buffer_delay);
1170             memset( p_sys->p_buffer + (leftover+buffer_delay), 0, padding_size );
1171             buffer_delay += padding_size;
1172         }
1173         if( avcodec_fill_audio_frame( p_sys->frame, p_enc->fmt_in.audio.i_channels,
1174                 p_sys->p_context->sample_fmt, p_sys->b_planar ? p_sys->p_interleave_buf : p_sys->p_buffer,
1175                 leftover + buffer_delay,
1176                 align) < 0 )
1177             msg_Err( p_enc, "filling error on fillup" );
1178
1179         buffer_delay = 0;
1180         p_sys->i_samples_delay = 0;
1181
1182         p_block = block_Alloc( p_sys->i_buffer_out );
1183         av_init_packet( &packet );
1184         packet.data = p_block->p_buffer;
1185         packet.size = p_block->i_buffer;
1186
1187         i_out = avcodec_encode_audio2( p_sys->p_context, &packet, p_sys->frame, &got_packet );
1188
1189         if( unlikely( !got_packet || ( i_out < 0 ) || !packet.size ) )
1190         {
1191             if( i_out < 0 )
1192             {
1193                 msg_Err( p_enc,"Encoding problem..");
1194                 return p_chain;
1195             }
1196             block_Release( p_block );
1197             return NULL;
1198         }
1199
1200         p_block->i_buffer = packet.size;
1201         p_block->i_length = (mtime_t)1000000 *
1202             (mtime_t)p_sys->frame->nb_samples /
1203             (mtime_t)p_sys->p_context->sample_rate;
1204
1205         p_block->i_dts = p_block->i_pts = packet.pts;
1206
1207         block_ChainAppend( &p_chain, p_block );
1208     }
1209
1210     if( unlikely( !p_aout_buf ) )
1211     {
1212         msg_Dbg(p_enc,"Flushing..");
1213         do {
1214             AVPacket packet = {0};
1215             p_block = block_Alloc( p_sys->i_buffer_out );
1216             av_init_packet( &packet );
1217             packet.data = p_block->p_buffer;
1218             packet.size = p_block->i_buffer;
1219
1220             i_out = avcodec_encode_audio2( p_sys->p_context, &packet, NULL, &got_packet );
1221             p_block->i_buffer = packet.size;
1222
1223             p_block->i_length = (mtime_t)1000000 *
1224              (mtime_t)p_sys->i_frame_size /
1225              (mtime_t)p_sys->p_context->sample_rate;
1226
1227             p_block->i_dts = p_block->i_pts = packet.pts;
1228
1229             if( i_out >= 0 && got_packet )
1230                 block_ChainAppend( &p_chain, p_block );
1231         } while( got_packet && (i_out>=0) );
1232         return p_chain;
1233     }
1234
1235
1236     while( ( p_aout_buf->i_nb_samples >= p_sys->i_frame_size ) ||
1237            ( p_sys->b_variable && p_aout_buf->i_nb_samples ) )
1238     {
1239         AVPacket packet = {0};
1240 #if LIBAVUTIL_VERSION_CHECK( 51,27,2,46,100 )
1241         const int align = 0;
1242 #else
1243         const int align = 1;
1244 #endif
1245
1246         if( unlikely( p_aout_buf->i_pts > VLC_TS_INVALID &&
1247                       p_aout_buf->i_pts != date_Get( &p_sys->buffer_date ) ) )
1248             date_Set( &p_sys->buffer_date, p_aout_buf->i_pts );
1249
1250         avcodec_get_frame_defaults( p_sys->frame );
1251         if( p_sys->b_variable )
1252             p_sys->frame->nb_samples = p_aout_buf->i_nb_samples;
1253         else
1254             p_sys->frame->nb_samples = p_sys->i_frame_size;
1255         p_sys->frame->format     = p_sys->p_context->sample_fmt;
1256         p_sys->frame->pts        = date_Get( &p_sys->buffer_date );
1257
1258         if( p_sys->b_planar )
1259         {
1260             aout_Deinterleave( p_sys->p_buffer, p_aout_buf->p_buffer,
1261                                p_sys->frame->nb_samples, p_enc->fmt_in.audio.i_channels, p_enc->fmt_in.i_codec );
1262
1263         }
1264
1265         if( avcodec_fill_audio_frame( p_sys->frame, p_enc->fmt_in.audio.i_channels,
1266                                     p_sys->p_context->sample_fmt,
1267                                     p_sys->b_planar ? p_sys->p_buffer : p_aout_buf->p_buffer,
1268                                     __MIN(p_sys->i_buffer_out, p_aout_buf->i_buffer),
1269                                     align) < 0 )
1270                  msg_Err( p_enc, "filling error on encode" );
1271
1272         p_aout_buf->p_buffer     += (p_sys->frame->nb_samples * p_enc->fmt_in.audio.i_channels * p_sys->i_sample_bytes);
1273         p_aout_buf->i_buffer     -= (p_sys->frame->nb_samples * p_enc->fmt_in.audio.i_channels * p_sys->i_sample_bytes);
1274         p_aout_buf->i_nb_samples -= p_sys->frame->nb_samples;
1275         date_Increment( &p_sys->buffer_date, p_sys->frame->nb_samples );
1276
1277
1278         p_block = block_Alloc( p_sys->i_buffer_out );
1279         av_init_packet( &packet );
1280         packet.data = p_block->p_buffer;
1281         packet.size = p_block->i_buffer;
1282
1283         i_out = avcodec_encode_audio2( p_sys->p_context, &packet, p_sys->frame, &got_packet );
1284         p_block->i_buffer = packet.size;
1285
1286         if( unlikely( !got_packet || ( i_out < 0 ) ) )
1287         {
1288             if( i_out < 0 )
1289             {
1290                 msg_Err( p_enc,"Encoding problem..");
1291                 return p_chain;
1292             }
1293             block_Release( p_block );
1294             continue;
1295         }
1296
1297         p_block->i_buffer = packet.size;
1298
1299         p_block->i_length = (mtime_t)1000000 *
1300             (mtime_t)p_sys->frame->nb_samples /
1301             (mtime_t)p_sys->p_context->sample_rate;
1302
1303         p_block->i_dts = p_block->i_pts = packet.pts;
1304
1305         block_ChainAppend( &p_chain, p_block );
1306     }
1307
1308     // We have leftover samples that don't fill frame_size, and libavcodec doesn't seem to like
1309     // that frame has more data than p_sys->i_frame_size most of the cases currently.
1310     if( p_aout_buf->i_nb_samples > 0 )
1311     {
1312        memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer,
1313                p_aout_buf->i_nb_samples * p_sys->i_sample_bytes * p_enc->fmt_in.audio.i_channels);
1314        p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1315     }
1316
1317     return p_chain;
1318 }
1319
1320 /*****************************************************************************
1321  * CloseEncoder: libavcodec encoder destruction
1322  *****************************************************************************/
1323 void CloseEncoder( vlc_object_t *p_this )
1324 {
1325     encoder_t *p_enc = (encoder_t *)p_this;
1326     encoder_sys_t *p_sys = p_enc->p_sys;
1327
1328     /*FIXME: we should use avcodec_free_frame, but we don't require so new avcodec that has it*/
1329     av_freep( &p_sys->frame );
1330
1331     vlc_avcodec_lock();
1332     avcodec_close( p_sys->p_context );
1333     vlc_avcodec_unlock();
1334     av_free( p_sys->p_context );
1335
1336
1337     free( p_sys->p_interleave_buf );
1338     free( p_sys->p_buffer );
1339
1340     free( p_sys );
1341 }