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 #include <libavcodec/avcodec.h>
  44
  45 #include "avcodec.h"
  46 #include "avcommon.h"
  47
  48 #if LIBAVUTIL_VERSION_CHECK( 52,2,6,0,0 )
  49 # include <libavutil/channel_layout.h>
  50 #endif
  51
  52 #define HURRY_UP_GUARD1 (450000)
  53 #define HURRY_UP_GUARD2 (300000)
  54 #define HURRY_UP_GUARD3 (100000)
  55
  56 #define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
  57
  58 #define RAW_AUDIO_FRAME_SIZE (2048)
  59
  60 /*****************************************************************************
  61  * Local prototypes
  62  *****************************************************************************/
  63 int  OpenEncoder ( vlc_object_t * );
  64 void CloseEncoder( vlc_object_t * );
  65
  66 static block_t *EncodeVideo( encoder_t *, picture_t * );
  67 static block_t *EncodeAudio( encoder_t *, block_t * );
  68
  69 struct thread_context_t;
  70
  71 /*****************************************************************************
  72  * thread_context_t : for multithreaded encoding
  73  *****************************************************************************/
  74 struct thread_context_t
  75 {
  76     VLC_COMMON_MEMBERS
  77
  78     AVCodecContext  *p_context;
  79     int             (* pf_func)(AVCodecContext *c, void *arg);
  80     void            *arg;
  81     int             i_ret;
  82
  83     vlc_mutex_t     lock;
  84     vlc_cond_t      cond;
  85     bool            b_work, b_done;
  86 };
  87
  88 /*****************************************************************************
  89  * encoder_sys_t : libavcodec encoder descriptor
  90  *****************************************************************************/
  91 struct encoder_sys_t
  92 {
  93     /*
  94      * libavcodec properties
  95      */
  96     AVCodec         *p_codec;
  97     AVCodecContext  *p_context;
  98
  99     /*
 100      * Common buffer mainly for audio as frame size in there needs usually be constant
 101      */
 102     uint8_t *p_buffer;
 103     size_t i_buffer_out;
 104     uint8_t *p_interleave_buf;
 105
 106     /*
 107      * Video properties
 108      */
 109     mtime_t i_last_ref_pts;
 110     mtime_t i_buggy_pts_detect;
 111     mtime_t i_last_pts;
 112     bool    b_inited;
 113
 114     /*
 115      * Audio properties
 116      */
 117     size_t i_sample_bytes;
 118     size_t i_frame_size;
 119     size_t i_samples_delay; //How much samples in delay buffer
 120     bool b_planar;
 121     bool b_variable;    //Encoder can be fed with any size frames not just frame_size
 122     mtime_t i_pts;
 123     date_t  buffer_date;
 124
 125     /* Encoding settings */
 126     int        i_key_int;
 127     int        i_b_frames;
 128     int        i_vtolerance;
 129     int        i_qmin;
 130     int        i_qmax;
 131     int        i_hq;
 132     int        i_rc_buffer_size;
 133     float      f_rc_buffer_aggressivity;
 134     bool       b_pre_me;
 135     bool       b_hurry_up;
 136     bool       b_interlace, b_interlace_me;
 137     float      f_i_quant_factor;
 138     int        i_noise_reduction;
 139     bool       b_mpeg4_matrix;
 140     bool       b_trellis;
 141     int        i_quality; /* for VBR */
 142     float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
 143 #if (LIBAVCODEC_VERSION_MAJOR < 55)
 144     int        i_luma_elim, i_chroma_elim;
 145 #endif
 146     int        i_aac_profile; /* AAC profile to use.*/
 147
 148     AVFrame    *frame;
 149 };
 150
 151 static const char *const ppsz_enc_options[] = {
 152     "keyint", "bframes", "vt", "qmin", "qmax", "codec", "hq",
 153     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
 154     "interlace", "interlace-me", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
 155     "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
 156     "p-masking", "border-masking",
 157 #if (LIBAVCODEC_VERSION_MAJOR < 55)
 158     "luma-elim-threshold", "chroma-elim-threshold",
 159 #endif
 160     "aac-profile", "options",
 161     NULL
 162 };
 163
 164 static const uint16_t mpa_bitrate_tab[2][15] =
 165 {
 166     {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
 167     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
 168 };
 169
 170 static const uint16_t mpa_freq_tab[6] =
 171 { 44100, 48000, 32000, 22050, 24000, 16000 };
 172
 173 static const uint16_t mpeg4_default_intra_matrix[64] = {
 174   8, 17, 18, 19, 21, 23, 25, 27,
 175  17, 18, 19, 21, 23, 25, 27, 28,
 176  20, 21, 22, 23, 24, 26, 28, 30,
 177  21, 22, 23, 24, 26, 28, 30, 32,
 178  22, 23, 24, 26, 28, 30, 32, 35,
 179  23, 24, 26, 28, 30, 32, 35, 38,
 180  25, 26, 28, 30, 32, 35, 38, 41,
 181  27, 28, 30, 32, 35, 38, 41, 45,
 182 };
 183
 184 static const uint16_t mpeg4_default_non_intra_matrix[64] = {
 185  16, 17, 18, 19, 20, 21, 22, 23,
 186  17, 18, 19, 20, 21, 22, 23, 24,
 187  18, 19, 20, 21, 22, 23, 24, 25,
 188  19, 20, 21, 22, 23, 24, 26, 27,
 189  20, 21, 22, 23, 25, 26, 27, 28,
 190  21, 22, 23, 24, 26, 27, 28, 30,
 191  22, 23, 24, 26, 27, 28, 30, 31,
 192  23, 24, 25, 27, 28, 30, 31, 33,
 193 };
 194
 195 /*****************************************************************************
 196  * OpenEncoder: probe the encoder
 197  *****************************************************************************/
 198
 199 int OpenEncoder( vlc_object_t *p_this )
 200 {
 201     encoder_t *p_enc = (encoder_t *)p_this;
 202     encoder_sys_t *p_sys;
 203     AVCodecContext *p_context;
 204     AVCodec *p_codec = NULL;
 205     unsigned i_codec_id;
 206     int 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_visible_width || !p_enc->fmt_in.video.i_visible_height )
 425         {
 426             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_visible_width,
 427                       p_enc->fmt_in.video.i_visible_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_visible_width;
 435         p_context->height = p_enc->fmt_in.video.i_visible_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_out.audio.i_channels  > 2 )
 609             p_enc->fmt_out.audio.i_channels = 2;
 610         p_context->codec_type  = AVMEDIA_TYPE_AUDIO;
 611         p_context->sample_fmt  = p_codec->sample_fmts ?
 612                                     p_codec->sample_fmts[0] :
 613                                     AV_SAMPLE_FMT_S16;
 614
 615         /* Try to match avcodec input format to vlc format so we could avoid one
 616            format conversion */
 617         if( GetVlcAudioFormat( p_context->sample_fmt ) != p_enc->fmt_in.i_codec )
 618         {
 619             msg_Dbg( p_enc, "Trying to find more suitable sample format instead of %s", av_get_sample_fmt_name( p_context->sample_fmt ) );
 620             for( unsigned int i=0; p_codec->sample_fmts[i] != -1; i++ )
 621             {
 622                 if( GetVlcAudioFormat( p_codec->sample_fmts[i] ) == p_enc->fmt_in.i_codec )
 623                 {
 624                     p_context->sample_fmt = p_codec->sample_fmts[i];
 625                     msg_Dbg( p_enc, "Using %s as new sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
 626                     break;
 627                 }
 628             }
 629         }
 630         p_sys->b_planar = av_sample_fmt_is_planar( p_context->sample_fmt );
 631         // Try if we can use interleaved format for codec input as VLC doesn't really do planar audio yet
 632         // FIXME: Remove when planar/interleaved audio in vlc is equally supported
 633         if( p_sys->b_planar )
 634         {
 635             msg_Dbg( p_enc, "Trying to find packet sample format instead of planar %s", av_get_sample_fmt_name( p_context->sample_fmt ) );
 636             for( unsigned int i=0; p_codec->sample_fmts[i] != -1; i++ )
 637             {
 638                 if( !av_sample_fmt_is_planar( p_codec->sample_fmts[i] ) )
 639                 {
 640                     p_context->sample_fmt = p_codec->sample_fmts[i];
 641                     msg_Dbg( p_enc, "Changing to packet format %s as new sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
 642                     break;
 643                 }
 644             }
 645         }
 646         msg_Dbg( p_enc, "Ended up using %s as sample format", av_get_sample_fmt_name( p_context->sample_fmt ) );
 647         p_enc->fmt_in.i_codec  = GetVlcAudioFormat( p_context->sample_fmt );
 648         p_sys->b_planar = av_sample_fmt_is_planar( p_context->sample_fmt );
 649
 650         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
 651         date_Init( &p_sys->buffer_date, p_enc->fmt_out.audio.i_rate, 1 );
 652         date_Set( &p_sys->buffer_date, 0 );
 653         p_context->time_base.num = 1;
 654         p_context->time_base.den = p_context->sample_rate;
 655         p_context->channels      = p_enc->fmt_out.audio.i_channels;
 656 #if LIBAVUTIL_VERSION_CHECK( 52, 2, 6, 0, 0)
 657         p_context->channel_layout = av_get_default_channel_layout( p_context->channels );
 658 #endif
 659
 660         if ( p_enc->fmt_out.i_codec == VLC_CODEC_MP4A )
 661         {
 662             /* XXX: FAAC does resample only when setting the INPUT samplerate
 663              * to the desired value (-R option of the faac frontend)
 664             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
 665             /* vlc should default to low-complexity profile, faac encoder
 666              * has bug and aac audio has issues otherwise atm */
 667             p_context->profile = p_sys->i_aac_profile;
 668         }
 669     }
 670
 671     /* Misc parameters */
 672     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 673
 674     /* Set reasonable defaults to VP8, based on
 675        libvpx-720p preset from libvpx ffmpeg-patch */
 676     if( i_codec_id == AV_CODEC_ID_VP8 )
 677     {
 678         /* Lets give bitrate tolerance */
 679         p_context->bit_rate_tolerance = __MAX(2 * (int)p_enc->fmt_out.i_bitrate, p_sys->i_vtolerance );
 680         /* default to 120 frames between keyframe */
 681         if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" ) )
 682             p_context->gop_size = 120;
 683         /* Don't set rc-values atm, they were from time before
 684            libvpx was officially in FFmpeg */
 685         //p_context->rc_max_rate = 24 * 1000 * 1000; //24M
 686         //p_context->rc_min_rate = 40 * 1000; // 40k
 687         /* seems that FFmpeg presets have 720p as divider for buffers */
 688         if( p_enc->fmt_out.video.i_visible_height >= 720 )
 689         {
 690             /* Check that we don't overrun users qmin/qmax values */
 691             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
 692             {
 693                 p_context->qmin = 10;
 694                 p_context->mb_lmin = p_context->lmin = 10 * FF_QP2LAMBDA;
 695             }
 696
 697             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" ) )
 698             {
 699                 p_context->qmax = 42;
 700                 p_context->mb_lmax = p_context->lmax = 42 * FF_QP2LAMBDA;
 701             }
 702
 703             } else {
 704             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
 705             {
 706                 p_context->qmin = 1;
 707                 p_context->mb_lmin = p_context->lmin = FF_QP2LAMBDA;
 708             }
 709         }
 710
 711
 712 #if 0 /* enable when/if vp8 encoder is accepted in libavcodec */
 713         p_context->lag = 16;
 714         p_context->level = 216;
 715         p_context->profile = 0;
 716         p_context->rc_buffer_aggressivity = 0.95;
 717         p_context->token_partitions = 4;
 718         p_context->mb_static_threshold = 0;
 719 #endif
 720     }
 721
 722     if( i_codec_id == AV_CODEC_ID_RAWVIDEO )
 723     {
 724         /* XXX: hack: Force same codec (will be handled by transcode) */
 725         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 726         GetFfmpegChroma( &p_context->pix_fmt, &p_enc->fmt_in.video );
 727     }
 728
 729     /* Make sure we get extradata filled by the encoder */
 730     p_context->extradata_size = 0;
 731     p_context->extradata = NULL;
 732     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 733
 734     if( p_enc->i_threads >= 1)
 735         p_context->thread_count = p_enc->i_threads;
 736     else
 737         p_context->thread_count = vlc_GetCPUCount();
 738
 739     int ret;
 740     char *psz_opts = var_InheritString(p_enc, ENC_CFG_PREFIX "options");
 741     AVDictionary *options = NULL;
 742     if (psz_opts && *psz_opts)
 743         options = vlc_av_get_options(psz_opts);
 744     free(psz_opts);
 745
 746     vlc_avcodec_lock();
 747     ret = avcodec_open2( p_context, p_codec, options ? &options : NULL );
 748     vlc_avcodec_unlock();
 749
 750     AVDictionaryEntry *t = NULL;
 751     while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {
 752         msg_Err(p_enc, "Unknown option \"%s\"", t->key);
 753     }
 754
 755     if( ret )
 756     {
 757         if( p_enc->fmt_in.i_cat != AUDIO_ES ||
 758                 (p_context->channels <= 2 && i_codec_id != AV_CODEC_ID_MP2
 759                  && i_codec_id != AV_CODEC_ID_MP3) )
 760 errmsg:
 761         {
 762             static const char types[][12] = {
 763                 [UNKNOWN_ES] = N_("unknown"), [VIDEO_ES] = N_("video"),
 764                 [AUDIO_ES] = N_("audio"), [SPU_ES] = N_("subpicture"),
 765             };
 766             const char *type = types[0];
 767             union
 768             {
 769                 vlc_fourcc_t value;
 770                 char txt[4];
 771             } fcc = { .value = p_enc->fmt_out.i_codec };
 772
 773             if (likely((unsigned)p_enc->fmt_in.i_cat < sizeof (types) / sizeof (types[0])))
 774                 type = types[p_enc->fmt_in.i_cat];
 775             msg_Err( p_enc, "cannot open %4.4s %s encoder", fcc.txt, type );
 776             dialog_Fatal( p_enc, _("Streaming / Transcoding failed"),
 777                           _("VLC could not open the %4.4s %s encoder."),
 778                           fcc.txt, vlc_gettext(type) );
 779             av_dict_free(&options);
 780             goto error;
 781         }
 782
 783         if( p_context->channels > 2 )
 784         {
 785             p_context->channels = 2;
 786             p_enc->fmt_in.audio.i_channels = 2; // FIXME
 787             msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 788         }
 789
 790         if( i_codec_id == AV_CODEC_ID_MP2 || i_codec_id == AV_CODEC_ID_MP3 )
 791         {
 792             int i_frequency, i;
 793             es_format_t *fmt = &p_enc->fmt_out;
 794
 795             for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 796                 if ( fmt->audio.i_rate == mpa_freq_tab[i_frequency] )
 797                     break;
 798
 799             if ( i_frequency == 6 )
 800             {
 801                 msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 802                         fmt->audio.i_rate );
 803                 av_dict_free(&options);
 804                 goto error;
 805             }
 806
 807             for ( i = 1; i < 14; i++ )
 808                 if (fmt->i_bitrate/1000 <= mpa_bitrate_tab[i_frequency / 3][i])
 809                     break;
 810
 811             if (fmt->i_bitrate / 1000 != mpa_bitrate_tab[i_frequency / 3][i])
 812             {
 813                 msg_Warn( p_enc,
 814                         "MPEG audio doesn't support bitrate=%d, using %d",
 815                         fmt->i_bitrate,
 816                         mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 817                 fmt->i_bitrate = mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 818                 p_context->bit_rate = fmt->i_bitrate;
 819             }
 820         }
 821
 822         p_context->codec = NULL;
 823         vlc_avcodec_lock();
 824         ret = avcodec_open2( p_context, p_codec, options ? &options : NULL );
 825         vlc_avcodec_unlock();
 826         if( ret )
 827             goto errmsg;
 828     }
 829
 830     av_dict_free(&options);
 831
 832     if( i_codec_id == AV_CODEC_ID_FLAC )
 833     {
 834         p_enc->fmt_out.i_extra = 4 + 1 + 3 + p_context->extradata_size;
 835         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 836         if( p_enc->fmt_out.p_extra )
 837         {
 838             uint8_t *p = p_enc->fmt_out.p_extra;
 839             p[0] = 0x66;    /* f */
 840             p[1] = 0x4C;    /* L */
 841             p[2] = 0x61;    /* a */
 842             p[3] = 0x43;    /* C */
 843             p[4] = 0x80;    /* streaminfo block, last block before audio */
 844             p[5] = ( p_context->extradata_size >> 16 ) & 0xff;
 845             p[6] = ( p_context->extradata_size >>  8 ) & 0xff;
 846             p[7] = ( p_context->extradata_size       ) & 0xff;
 847             memcpy( &p[8], p_context->extradata, p_context->extradata_size );
 848         }
 849         else
 850         {
 851             p_enc->fmt_out.i_extra = 0;
 852         }
 853     }
 854     else
 855     {
 856         p_enc->fmt_out.i_extra = p_context->extradata_size;
 857         if( p_enc->fmt_out.i_extra )
 858         {
 859             p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 860             if ( p_enc->fmt_out.p_extra == NULL )
 861             {
 862                 goto error;
 863             }
 864             memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 865                     p_enc->fmt_out.i_extra );
 866         }
 867     }
 868
 869     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 870
 871     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 872     {
 873         p_enc->fmt_in.i_codec = GetVlcAudioFormat( p_sys->p_context->sample_fmt );
 874         p_enc->fmt_in.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_in.i_codec );
 875
 876         p_sys->i_sample_bytes = (p_enc->fmt_in.audio.i_bitspersample / 8);
 877         p_sys->i_frame_size = p_context->frame_size > 1 ?
 878                                     p_context->frame_size :
 879                                     FF_MIN_BUFFER_SIZE;
 880         p_sys->i_buffer_out = p_sys->i_frame_size * p_sys->i_sample_bytes * p_sys->p_context->channels;
 881         p_sys->p_buffer = malloc( p_sys->i_buffer_out );
 882         if ( unlikely( p_sys->p_buffer == NULL ) )
 883         {
 884             goto error;
 885         }
 886         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 887         p_enc->fmt_out.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_out.i_codec );
 888         //b_variable tells if we can feed any size frames to encoder
 889         p_sys->b_variable = p_context->frame_size ? false : true;
 890
 891
 892         if( p_sys->b_planar )
 893         {
 894             p_sys->p_interleave_buf = malloc( p_sys->i_buffer_out );
 895             if( unlikely( p_sys->p_interleave_buf == NULL ) )
 896                 goto error;
 897         }
 898     }
 899
 900     p_sys->frame = avcodec_alloc_frame();
 901     if( !p_sys->frame )
 902     {
 903         goto error;
 904     }
 905     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 906
 907     p_enc->pf_encode_video = EncodeVideo;
 908     p_enc->pf_encode_audio = EncodeAudio;
 909
 910
 911     return VLC_SUCCESS;
 912 error:
 913     free( p_enc->fmt_out.p_extra );
 914     free( p_sys->p_buffer );
 915     free( p_sys->p_interleave_buf );
 916     free( p_sys );
 917     return VLC_ENOMEM;
 918 }
 919
 920 /****************************************************************************
 921  * EncodeVideo: the whole thing
 922  ****************************************************************************/
 923 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 924 {
 925     encoder_sys_t *p_sys = p_enc->p_sys;
 926     int i_plane;
 927     /* Initialize the video output buffer the first time.
 928      * This is done here instead of OpenEncoder() because we need the actual
 929      * bits_per_pixel value, without having to assume anything.
 930      */
 931     const int bytesPerPixel = p_enc->fmt_out.video.i_bits_per_pixel ?
 932                          p_enc->fmt_out.video.i_bits_per_pixel / 8 : 3;
 933     const int blocksize = __MAX( FF_MIN_BUFFER_SIZE,bytesPerPixel * p_sys->p_context->height * p_sys->p_context->width + 200 );
 934     block_t *p_block = block_Alloc( blocksize );
 935     if( unlikely(p_block == NULL) )
 936         return NULL;
 937
 938     AVFrame *frame = NULL;
 939     if( likely(p_pict) ) {
 940         frame = p_sys->frame;
 941         avcodec_get_frame_defaults( frame );
 942         for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 943         {
 944             p_sys->frame->data[i_plane] = p_pict->p[i_plane].p_pixels;
 945             p_sys->frame->linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 946         }
 947
 948         /* Let libavcodec select the frame type */
 949         frame->pict_type = 0;
 950
 951         frame->repeat_pict = p_pict->i_nb_fields - 2;
 952         frame->interlaced_frame = !p_pict->b_progressive;
 953         frame->top_field_first = !!p_pict->b_top_field_first;
 954
 955         /* Set the pts of the frame being encoded */
 956         frame->pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 957
 958         if ( p_sys->b_hurry_up && frame->pts != (int64_t)AV_NOPTS_VALUE )
 959         {
 960             mtime_t current_date = mdate();
 961
 962             if ( current_date + HURRY_UP_GUARD3 > frame->pts )
 963             {
 964                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 965                 p_sys->p_context->trellis = 0;
 966                 msg_Dbg( p_enc, "hurry up mode 3" );
 967             }
 968             else
 969             {
 970                 p_sys->p_context->mb_decision = p_sys->i_hq;
 971
 972                 if ( current_date + HURRY_UP_GUARD2 > frame->pts )
 973                 {
 974                     p_sys->p_context->trellis = 0;
 975                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 976                         + (HURRY_UP_GUARD2 + current_date - frame->pts) / 500;
 977                     msg_Dbg( p_enc, "hurry up mode 2" );
 978                 }
 979                 else
 980                 {
 981                     p_sys->p_context->trellis = p_sys->b_trellis;
 982
 983                     p_sys->p_context->noise_reduction =
 984                        p_sys->i_noise_reduction;
 985                 }
 986             }
 987
 988             if ( current_date + HURRY_UP_GUARD1 > frame->pts )
 989             {
 990                 frame->pict_type = AV_PICTURE_TYPE_P;
 991                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 992             }
 993         }
 994
 995         if ( frame->pts != (int64_t)AV_NOPTS_VALUE && frame->pts != 0 )
 996         {
 997             if ( p_sys->i_last_pts == frame->pts )
 998             {
 999                 msg_Warn( p_enc, "almost fed libavcodec with two frames with "
1000                           "the same PTS (%"PRId64 ")", frame->pts );
1001                 return NULL;
1002             }
1003             else if ( p_sys->i_last_pts > frame->pts )
1004             {
1005                 msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
1006                          "past (current: %"PRId64 ", last: %"PRId64")",
1007                          frame->pts, p_sys->i_last_pts );
1008                 return NULL;
1009             }
1010             else
1011                 p_sys->i_last_pts = frame->pts;
1012         }
1013
1014         frame->quality = p_sys->i_quality;
1015     }
1016
1017 #if (LIBAVCODEC_VERSION_MAJOR >= 54)
1018     AVPacket av_pkt;
1019     int is_data;
1020
1021     av_init_packet( &av_pkt );
1022     av_pkt.data = p_block->p_buffer;
1023     av_pkt.size = p_block->i_buffer;
1024
1025     if( avcodec_encode_video2( p_sys->p_context, &av_pkt, frame, &is_data ) < 0
1026      || is_data == 0 )
1027     {
1028         block_Release( p_block );
1029         return NULL;
1030     }
1031
1032     p_block->i_buffer = av_pkt.size;
1033     p_block->i_length = av_pkt.duration / p_sys->p_context->time_base.den;
1034     p_block->i_pts = av_pkt.pts;
1035     p_block->i_dts = av_pkt.dts;
1036     if( unlikely( av_pkt.flags & AV_PKT_FLAG_CORRUPT ) )
1037         p_block->i_flags |= BLOCK_FLAG_CORRUPTED;
1038
1039 #else
1040     int i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer,
1041                                       p_block->i_buffer, frame );
1042     if( i_out <= 0 )
1043     {
1044         block_Release( p_block );
1045         return NULL;
1046     }
1047
1048     p_block->i_buffer = i_out;
1049
1050     /* FIXME, 3-2 pulldown is not handled correctly */
1051     p_block->i_length = INT64_C(1000000) *
1052         p_enc->fmt_in.video.i_frame_rate_base /
1053             p_enc->fmt_in.video.i_frame_rate;
1054
1055     if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
1056     {
1057         /* No delay -> output pts == input pts */
1058         if( p_pict )
1059             p_block->i_dts = p_pict->date;
1060         p_block->i_pts = p_block->i_dts;
1061     }
1062     else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
1063         p_sys->p_context->coded_frame->pts != 0 &&
1064         p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
1065     {
1066         p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
1067         p_block->i_pts = p_sys->p_context->coded_frame->pts;
1068
1069         if( p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_I &&
1070             p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_P )
1071         {
1072             p_block->i_dts = p_block->i_pts;
1073         }
1074         else
1075         {
1076             if( p_sys->i_last_ref_pts )
1077             {
1078                 p_block->i_dts = p_sys->i_last_ref_pts;
1079             }
1080             else
1081             {
1082                 /* Let's put something sensible */
1083                 p_block->i_dts = p_block->i_pts;
1084             }
1085
1086             p_sys->i_last_ref_pts = p_block->i_pts;
1087         }
1088     }
1089     else if( p_pict )
1090     {
1091         /* Buggy libavcodec which doesn't update coded_frame->pts
1092          * correctly */
1093         p_block->i_dts = p_block->i_pts = p_pict->date;
1094     }
1095 #endif
1096
1097     switch ( p_sys->p_context->coded_frame->pict_type )
1098     {
1099     case AV_PICTURE_TYPE_I:
1100     case AV_PICTURE_TYPE_SI:
1101         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1102         break;
1103     case AV_PICTURE_TYPE_P:
1104     case AV_PICTURE_TYPE_SP:
1105         p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1106         break;
1107     case AV_PICTURE_TYPE_B:
1108     case AV_PICTURE_TYPE_BI:
1109         p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1110         break;
1111     default:
1112         p_block->i_flags |= BLOCK_FLAG_TYPE_PB;
1113     }
1114
1115     return p_block;
1116 }
1117
1118 /****************************************************************************
1119  * EncodeAudio: the whole thing
1120  ****************************************************************************/
1121 static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
1122 {
1123     encoder_sys_t *p_sys = p_enc->p_sys;
1124
1125     block_t *p_block, *p_chain = NULL;
1126     int got_packet,i_out;
1127     size_t buffer_delay = 0, i_samples_left = 0;
1128
1129
1130     //i_bytes_left is amount of bytes we get
1131     i_samples_left = p_aout_buf ? p_aout_buf->i_nb_samples : 0;
1132     buffer_delay = p_sys->i_samples_delay * p_sys->i_sample_bytes * p_sys->p_context->channels;
1133
1134     //p_sys->i_buffer_out = p_sys->i_frame_size * chan * p_sys->i_sample_bytes
1135     //Calculate how many bytes we would need from current buffer to fill frame
1136     size_t leftover_samples = __MAX(0,__MIN((ssize_t)i_samples_left, (ssize_t)(p_sys->i_frame_size - p_sys->i_samples_delay)));
1137
1138     // Check if we have enough samples in delay_buffer and current p_aout_buf to fill frame
1139     // Or if we are cleaning up
1140     if( ( buffer_delay > 0 ) &&
1141             ( ( p_aout_buf && ( leftover_samples <= p_aout_buf->i_nb_samples ) &&
1142                ( (leftover_samples + p_sys->i_samples_delay ) >= p_sys->i_frame_size )
1143               ) ||
1144              ( !p_aout_buf )
1145             )
1146          )
1147     {
1148         //How much we need to copy from new packet
1149         const int leftover = leftover_samples * p_sys->p_context->channels * p_sys->i_sample_bytes;
1150
1151 #if LIBAVUTIL_VERSION_CHECK( 51,27,2,46,100 )
1152         const int align = 0;
1153 #else
1154         const int align = 1;
1155 #endif
1156
1157         AVPacket packet = {0};
1158         avcodec_get_frame_defaults( p_sys->frame );
1159         p_sys->frame->format     = p_sys->p_context->sample_fmt;
1160         p_sys->frame->pts        = date_Get( &p_sys->buffer_date );
1161         p_sys->frame->nb_samples = leftover_samples + p_sys->i_samples_delay;
1162         date_Increment( &p_sys->buffer_date, p_sys->i_frame_size );
1163
1164         if( likely( p_aout_buf ) )
1165         {
1166             p_aout_buf->i_nb_samples -= leftover_samples;
1167             memcpy( p_sys->p_buffer+buffer_delay, p_aout_buf->p_buffer, leftover );
1168
1169             // We need to deinterleave from p_aout_buf to p_buffer the leftover bytes
1170             if( p_sys->b_planar )
1171                 aout_Deinterleave( p_sys->p_interleave_buf, p_sys->p_buffer,
1172                     p_sys->i_frame_size, p_sys->p_context->channels, p_enc->fmt_in.i_codec );
1173             else
1174                 memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer, leftover);
1175
1176             p_aout_buf->p_buffer     += leftover;
1177             p_aout_buf->i_buffer     -= leftover;
1178             p_aout_buf->i_pts         = date_Get( &p_sys->buffer_date );
1179         }
1180         if(unlikely( ( (leftover + buffer_delay) < p_sys->i_buffer_out ) &&
1181                      !(p_sys->p_codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME ))
1182           )
1183         {
1184             msg_Dbg( p_enc, "No small last frame support, padding");
1185             size_t padding_size = p_sys->i_buffer_out - (leftover+buffer_delay);
1186             memset( p_sys->p_buffer + (leftover+buffer_delay), 0, padding_size );
1187             buffer_delay += padding_size;
1188         }
1189         if( avcodec_fill_audio_frame( p_sys->frame, p_sys->p_context->channels,
1190                 p_sys->p_context->sample_fmt, p_sys->b_planar ? p_sys->p_interleave_buf : p_sys->p_buffer,
1191                 p_sys->i_buffer_out,
1192                 align) < 0 )
1193         {
1194             msg_Err( p_enc, "filling error on fillup" );
1195             p_sys->frame->nb_samples = 0;
1196         }
1197
1198         buffer_delay = 0;
1199         p_sys->i_samples_delay = 0;
1200
1201         p_block = block_Alloc( p_sys->i_buffer_out );
1202         av_init_packet( &packet );
1203         packet.data = p_block->p_buffer;
1204         packet.size = p_block->i_buffer;
1205
1206         i_out = avcodec_encode_audio2( p_sys->p_context, &packet, p_sys->frame, &got_packet );
1207
1208         if( unlikely( !got_packet || ( i_out < 0 ) || !packet.size ) )
1209         {
1210             if( i_out < 0 )
1211             {
1212                 msg_Err( p_enc,"Encoding problem..");
1213                 return p_chain;
1214             }
1215             block_Release( p_block );
1216             return NULL;
1217         }
1218
1219         p_block->i_buffer = packet.size;
1220         p_block->i_length = (mtime_t)1000000 *
1221             (mtime_t)p_sys->frame->nb_samples /
1222             (mtime_t)p_sys->p_context->sample_rate;
1223
1224         p_block->i_dts = p_block->i_pts = packet.pts;
1225
1226         block_ChainAppend( &p_chain, p_block );
1227     }
1228
1229     if( unlikely( !p_aout_buf ) )
1230     {
1231         msg_Dbg(p_enc,"Flushing..");
1232         do {
1233             AVPacket packet = {0};
1234             p_block = block_Alloc( p_sys->i_buffer_out );
1235             av_init_packet( &packet );
1236             packet.data = p_block->p_buffer;
1237             packet.size = p_block->i_buffer;
1238
1239             i_out = avcodec_encode_audio2( p_sys->p_context, &packet, NULL, &got_packet );
1240             p_block->i_buffer = packet.size;
1241
1242             p_block->i_length = (mtime_t)1000000 *
1243              (mtime_t)p_sys->i_frame_size /
1244              (mtime_t)p_sys->p_context->sample_rate;
1245
1246             p_block->i_dts = p_block->i_pts = packet.pts;
1247
1248             if( i_out >= 0 && got_packet )
1249                 block_ChainAppend( &p_chain, p_block );
1250         } while( got_packet && (i_out>=0) );
1251         return p_chain;
1252     }
1253
1254
1255     while( ( p_aout_buf->i_nb_samples >= p_sys->i_frame_size ) ||
1256            ( p_sys->b_variable && p_aout_buf->i_nb_samples ) )
1257     {
1258         AVPacket packet = {0};
1259 #if LIBAVUTIL_VERSION_CHECK( 51,27,2,46,100 )
1260         const int align = 0;
1261 #else
1262         const int align = 1;
1263 #endif
1264
1265         if( unlikely( p_aout_buf->i_pts > VLC_TS_INVALID &&
1266                       p_aout_buf->i_pts != date_Get( &p_sys->buffer_date ) ) )
1267             date_Set( &p_sys->buffer_date, p_aout_buf->i_pts );
1268
1269         avcodec_get_frame_defaults( p_sys->frame );
1270         if( p_sys->b_variable )
1271             p_sys->frame->nb_samples = p_aout_buf->i_nb_samples;
1272         else
1273             p_sys->frame->nb_samples = p_sys->i_frame_size;
1274         p_sys->frame->format     = p_sys->p_context->sample_fmt;
1275         p_sys->frame->pts        = date_Get( &p_sys->buffer_date );
1276
1277         if( p_sys->b_planar )
1278         {
1279             aout_Deinterleave( p_sys->p_buffer, p_aout_buf->p_buffer,
1280                                p_sys->frame->nb_samples, p_sys->p_context->channels, p_enc->fmt_in.i_codec );
1281
1282         }
1283
1284         if( avcodec_fill_audio_frame( p_sys->frame, p_sys->p_context->channels,
1285                                     p_sys->p_context->sample_fmt,
1286                                     p_sys->b_planar ? p_sys->p_buffer : p_aout_buf->p_buffer,
1287                                     __MIN(p_sys->i_buffer_out, p_aout_buf->i_buffer),
1288                                     align) < 0 )
1289         {
1290                  msg_Err( p_enc, "filling error on encode" );
1291                  p_sys->frame->nb_samples = 0;
1292         }
1293
1294         p_aout_buf->p_buffer     += (p_sys->frame->nb_samples * p_sys->p_context->channels * p_sys->i_sample_bytes);
1295         p_aout_buf->i_buffer     -= (p_sys->frame->nb_samples * p_sys->p_context->channels * p_sys->i_sample_bytes);
1296         p_aout_buf->i_nb_samples -= p_sys->frame->nb_samples;
1297         date_Increment( &p_sys->buffer_date, p_sys->frame->nb_samples );
1298
1299
1300         p_block = block_Alloc( p_sys->i_buffer_out );
1301         av_init_packet( &packet );
1302         packet.data = p_block->p_buffer;
1303         packet.size = p_block->i_buffer;
1304
1305         i_out = avcodec_encode_audio2( p_sys->p_context, &packet, p_sys->frame, &got_packet );
1306         p_block->i_buffer = packet.size;
1307
1308         if( unlikely( !got_packet || ( i_out < 0 ) ) )
1309         {
1310             if( i_out < 0 )
1311             {
1312                 msg_Err( p_enc,"Encoding problem..");
1313                 return p_chain;
1314             }
1315             block_Release( p_block );
1316             continue;
1317         }
1318
1319         p_block->i_buffer = packet.size;
1320
1321         p_block->i_length = (mtime_t)1000000 *
1322             (mtime_t)p_sys->frame->nb_samples /
1323             (mtime_t)p_sys->p_context->sample_rate;
1324
1325         p_block->i_dts = p_block->i_pts = packet.pts;
1326
1327         block_ChainAppend( &p_chain, p_block );
1328     }
1329
1330     // We have leftover samples that don't fill frame_size, and libavcodec doesn't seem to like
1331     // that frame has more data than p_sys->i_frame_size most of the cases currently.
1332     if( p_aout_buf->i_nb_samples > 0 )
1333     {
1334        memcpy( p_sys->p_buffer + buffer_delay, p_aout_buf->p_buffer,
1335                p_aout_buf->i_nb_samples * p_sys->i_sample_bytes * p_sys->p_context->channels);
1336        p_sys->i_samples_delay += p_aout_buf->i_nb_samples;
1337     }
1338
1339     return p_chain;
1340 }
1341
1342 /*****************************************************************************
1343  * CloseEncoder: libavcodec encoder destruction
1344  *****************************************************************************/
1345 void CloseEncoder( vlc_object_t *p_this )
1346 {
1347     encoder_t *p_enc = (encoder_t *)p_this;
1348     encoder_sys_t *p_sys = p_enc->p_sys;
1349
1350     /*FIXME: we should use avcodec_free_frame, but we don't require so new avcodec that has it*/
1351     av_freep( &p_sys->frame );
1352
1353     vlc_avcodec_lock();
1354     avcodec_close( p_sys->p_context );
1355     vlc_avcodec_unlock();
1356     av_free( p_sys->p_context );
1357
1358
1359     free( p_sys->p_interleave_buf );
1360     free( p_sys->p_buffer );
1361
1362     free( p_sys );
1363 }