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