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