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

   1 /*****************************************************************************
   2  * encoder.c: video and audio encoder using the ffmpeg library
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 the VideoLAN team
   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
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 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 General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, 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/vlc.h>
  36 #include <vlc_vout.h>
  37 #include <vlc_aout.h>
  38 #include <vlc_sout.h>
  39 #include <vlc_codec.h>
  40 #include <vlc_interface.h>
  41
  42 /* ffmpeg header */
  43 #define HAVE_MMX 1
  44 #ifdef HAVE_LIBAVCODEC_AVCODEC_H
  45 #   include <libavcodec/avcodec.h>
  46 #elif defined(HAVE_FFMPEG_AVCODEC_H)
  47 #   include <ffmpeg/avcodec.h>
  48 #else
  49 #   include <avcodec.h>
  50 #endif
  51
  52 #include "ffmpeg.h"
  53
  54 #define HURRY_UP_GUARD1 (450000)
  55 #define HURRY_UP_GUARD2 (300000)
  56 #define HURRY_UP_GUARD3 (100000)
  57
  58 #define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
  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 *, aout_buffer_t * );
  68
  69 struct thread_context_t;
  70 static int FfmpegThread( struct thread_context_t *p_context );
  71 static int FfmpegExecute( AVCodecContext *s,
  72                           int (*pf_func)(AVCodecContext *c2, void *arg2),
  73                           void **arg, int *ret, int count );
  74
  75 /*****************************************************************************
  76  * thread_context_t : for multithreaded encoding
  77  *****************************************************************************/
  78 struct thread_context_t
  79 {
  80     VLC_COMMON_MEMBERS
  81
  82     AVCodecContext  *p_context;
  83     int             (* pf_func)(AVCodecContext *c, void *arg);
  84     void            *arg;
  85     int             i_ret;
  86
  87     vlc_mutex_t     lock;
  88     vlc_cond_t      cond;
  89     bool            b_work, b_done;
  90 };
  91
  92 /*****************************************************************************
  93  * encoder_sys_t : ffmpeg encoder descriptor
  94  *****************************************************************************/
  95 struct encoder_sys_t
  96 {
  97     /*
  98      * Ffmpeg properties
  99      */
 100     AVCodec         *p_codec;
 101     AVCodecContext  *p_context;
 102
 103     /*
 104      * Common properties
 105      */
 106     char *p_buffer;
 107     char *p_buffer_out;
 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     int i_frame_size;
 121     int i_samples_delay;
 122     mtime_t i_pts;
 123
 124     /* Encoding settings */
 125     int        i_key_int;
 126     int        i_b_frames;
 127     int        i_vtolerance;
 128     int        i_qmin;
 129     int        i_qmax;
 130     int        i_hq;
 131     bool       b_strict_rc;
 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     int        i_luma_elim, i_chroma_elim;
 144 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 145     int        i_aac_profile; /* AAC profile to use.*/
 146 #endif
 147     /* Used to work around stupid timestamping behaviour in libavcodec */
 148     uint64_t i_framenum;
 149     mtime_t  pi_delay_pts[MAX_FRAME_DELAY];
 150 };
 151
 152 static const char *ppsz_enc_options[] = {
 153     "keyint", "bframes", "vt", "qmin", "qmax", "hq", "strict-rc",
 154     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
 155     "interlace", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
 156     "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
 157     "p-masking", "border-masking", "luma-elim-threshold",
 158     "chroma-elim-threshold",
 159 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 160      "aac-profile",
 161 #endif
 162      NULL
 163 };
 164
 165 static const uint16_t mpa_bitrate_tab[2][15] =
 166 {
 167     {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
 168     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
 169 };
 170
 171 static const uint16_t mpa_freq_tab[6] =
 172 { 44100, 48000, 32000, 22050, 24000, 16000 };
 173
 174 static const uint16_t mpeg4_default_intra_matrix[64] = {
 175   8, 17, 18, 19, 21, 23, 25, 27,
 176  17, 18, 19, 21, 23, 25, 27, 28,
 177  20, 21, 22, 23, 24, 26, 28, 30,
 178  21, 22, 23, 24, 26, 28, 30, 32,
 179  22, 23, 24, 26, 28, 30, 32, 35,
 180  23, 24, 26, 28, 30, 32, 35, 38,
 181  25, 26, 28, 30, 32, 35, 38, 41,
 182  27, 28, 30, 32, 35, 38, 41, 45,
 183 };
 184
 185 static const uint16_t mpeg4_default_non_intra_matrix[64] = {
 186  16, 17, 18, 19, 20, 21, 22, 23,
 187  17, 18, 19, 20, 21, 22, 23, 24,
 188  18, 19, 20, 21, 22, 23, 24, 25,
 189  19, 20, 21, 22, 23, 24, 26, 27,
 190  20, 21, 22, 23, 25, 26, 27, 28,
 191  21, 22, 23, 24, 26, 27, 28, 30,
 192  22, 23, 24, 26, 27, 28, 30, 31,
 193  23, 24, 25, 27, 28, 30, 31, 33,
 194 };
 195
 196 /*****************************************************************************
 197  * OpenEncoder: probe the encoder
 198  *****************************************************************************/
 199
 200 int OpenEncoder( vlc_object_t *p_this )
 201 {
 202     encoder_t *p_enc = (encoder_t *)p_this;
 203     encoder_sys_t *p_sys = p_enc->p_sys;
 204     AVCodecContext *p_context;
 205     AVCodec *p_codec;
 206     int i_codec_id, i_cat;
 207     const char *psz_namecodec;
 208     vlc_value_t val;
 209
 210     if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
 211                              &psz_namecodec ) )
 212     {
 213         if( GetFfmpegChroma( p_enc->fmt_out.i_codec ) < 0 )
 214         {
 215             /* handed chroma output */
 216             return VLC_EGENERIC;
 217         }
 218         i_cat      = VIDEO_ES;
 219         i_codec_id = CODEC_ID_RAWVIDEO;
 220         psz_namecodec = "Raw video";
 221     }
 222
 223     if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
 224     {
 225         msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
 226         intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 227                         _("\"%s\" is no video encoder."), psz_namecodec );
 228         return VLC_EGENERIC;
 229     }
 230
 231     if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
 232     {
 233         msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
 234         intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 235                         _("\"%s\" is no audio encoder."), psz_namecodec );
 236         return VLC_EGENERIC;
 237     }
 238
 239     /* Initialization must be done before avcodec_find_encoder() */
 240     InitLibavcodec( p_this );
 241
 242     p_codec = avcodec_find_encoder( i_codec_id );
 243     if( !p_codec )
 244     {
 245         msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
 246         intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 247                         _("VLC could not find encoder \"%s\"."), psz_namecodec );
 248         return VLC_EGENERIC;
 249     }
 250
 251     /* Allocate the memory needed to store the encoder's structure */
 252     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
 253     {
 254         msg_Err( p_enc, "out of memory" );
 255         return VLC_EGENERIC;
 256     }
 257     memset( p_sys, 0, sizeof(encoder_sys_t) );
 258     p_enc->p_sys = p_sys;
 259     p_sys->p_codec = p_codec;
 260
 261     p_enc->pf_encode_video = EncodeVideo;
 262     p_enc->pf_encode_audio = EncodeAudio;
 263
 264     p_sys->p_buffer_out = NULL;
 265     p_sys->p_buffer = NULL;
 266
 267     p_sys->p_context = p_context = avcodec_alloc_context();
 268     p_context->debug = config_GetInt( p_enc, "ffmpeg-debug" );
 269     p_context->opaque = (void *)p_this;
 270
 271     /* Set CPU capabilities */
 272     unsigned i_cpu = vlc_CPU();
 273     p_context->dsp_mask = 0;
 274     if( !(i_cpu & CPU_CAPABILITY_MMX) )
 275     {
 276         p_context->dsp_mask |= FF_MM_MMX;
 277     }
 278     if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
 279     {
 280         p_context->dsp_mask |= FF_MM_MMXEXT;
 281     }
 282     if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
 283     {
 284         p_context->dsp_mask |= FF_MM_3DNOW;
 285     }
 286     if( !(i_cpu & CPU_CAPABILITY_SSE) )
 287     {
 288         p_context->dsp_mask |= FF_MM_SSE;
 289         p_context->dsp_mask |= FF_MM_SSE2;
 290     }
 291
 292     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
 293
 294     var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
 295     p_sys->i_key_int = val.i_int;
 296
 297     var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
 298     p_sys->i_b_frames = val.i_int;
 299
 300     var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
 301     p_sys->i_vtolerance = val.i_int * 1000;
 302
 303     var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
 304     p_sys->b_interlace = val.b_bool;
 305
 306     var_Get( p_enc, ENC_CFG_PREFIX "interlace-me", &val );
 307     p_sys->b_interlace_me = val.b_bool;
 308
 309     var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
 310     p_sys->b_pre_me = val.b_bool;
 311
 312     var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
 313     p_sys->b_hurry_up = val.b_bool;
 314     if( p_sys->b_hurry_up )
 315     {
 316         /* hurry up mode needs noise reduction, even small */
 317         p_sys->i_noise_reduction = 1;
 318     }
 319
 320     var_Get( p_enc, ENC_CFG_PREFIX "strict-rc", &val );
 321     p_sys->b_strict_rc = val.b_bool;
 322     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
 323     p_sys->i_rc_buffer_size = val.i_int;
 324     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
 325     p_sys->f_rc_buffer_aggressivity = val.f_float;
 326
 327     var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
 328     p_sys->f_i_quant_factor = val.f_float;
 329
 330     var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
 331     p_sys->i_noise_reduction = val.i_int;
 332
 333     var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
 334     p_sys->b_mpeg4_matrix = val.b_bool;
 335
 336     var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
 337     if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
 338     p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
 339
 340     var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
 341     p_sys->i_hq = FF_MB_DECISION_RD;
 342     if( val.psz_string && *val.psz_string )
 343     {
 344         if( !strcmp( val.psz_string, "rd" ) )
 345             p_sys->i_hq = FF_MB_DECISION_RD;
 346         else if( !strcmp( val.psz_string, "bits" ) )
 347             p_sys->i_hq = FF_MB_DECISION_BITS;
 348         else if( !strcmp( val.psz_string, "simple" ) )
 349             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
 350         else
 351             p_sys->i_hq = FF_MB_DECISION_RD;
 352     }
 353     else
 354         p_sys->i_hq = FF_MB_DECISION_RD;
 355     free( val.psz_string );
 356
 357     var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
 358     p_sys->i_qmin = val.i_int;
 359     var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
 360     p_sys->i_qmax = val.i_int;
 361     var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
 362     p_sys->b_trellis = val.b_bool;
 363
 364     var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
 365     if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
 366     p_context->strict_std_compliance = val.i_int;
 367
 368     var_Get( p_enc, ENC_CFG_PREFIX "lumi-masking", &val );
 369     p_sys->f_lumi_masking = val.f_float;
 370     var_Get( p_enc, ENC_CFG_PREFIX "dark-masking", &val );
 371     p_sys->f_dark_masking = val.f_float;
 372     var_Get( p_enc, ENC_CFG_PREFIX "p-masking", &val );
 373     p_sys->f_p_masking = val.f_float;
 374     var_Get( p_enc, ENC_CFG_PREFIX "border-masking", &val );
 375     p_sys->f_border_masking = val.f_float;
 376     var_Get( p_enc, ENC_CFG_PREFIX "luma-elim-threshold", &val );
 377     p_sys->i_luma_elim = val.i_int;
 378     var_Get( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold", &val );
 379     p_sys->i_chroma_elim = val.i_int;
 380
 381 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 382     var_Get( p_enc, ENC_CFG_PREFIX "aac-profile", &val );
 383     p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
 384     if( val.psz_string && *val.psz_string )
 385     {
 386         if( !strncmp( val.psz_string, "main", 4 ) )
 387             p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
 388         else if( !strncmp( val.psz_string, "low", 3 ) )
 389             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
 390 #if 0    /* Not supported by FAAC encoder */
 391         else if( !strncmp( val.psz_string, "ssr", 3 ) )
 392             p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
 393 #endif
 394         else  if( !strncmp( val.psz_string, "ltp", 3 ) )
 395             p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
 396         else
 397         {
 398             msg_Warn( p_enc, "unknown AAC profile requested" );
 399             p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
 400         }
 401     }
 402     free( val.psz_string );
 403 #endif
 404
 405     if( p_enc->fmt_in.i_cat == VIDEO_ES )
 406     {
 407         int i_aspect_num, i_aspect_den;
 408
 409         if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
 410         {
 411             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
 412                       p_enc->fmt_in.video.i_height );
 413             free( p_sys );
 414             return VLC_EGENERIC;
 415         }
 416
 417         p_context->width = p_enc->fmt_in.video.i_width;
 418         p_context->height = p_enc->fmt_in.video.i_height;
 419         if( p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v')
 420              && (p_context->width > 720 || p_context->height > 576) )
 421             p_context->level = 4; /* High level */
 422
 423         p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
 424         p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
 425
 426         /* Defaults from ffmpeg.c */
 427         p_context->qblur = 0.5;
 428         p_context->qcompress = 0.5;
 429         p_context->b_quant_offset = 1.25;
 430         p_context->b_quant_factor = 1.25;
 431         p_context->i_quant_offset = 0.0;
 432         p_context->i_quant_factor = -0.8;
 433
 434         p_context->lumi_masking = p_sys->f_lumi_masking;
 435         p_context->dark_masking = p_sys->f_dark_masking;
 436         p_context->p_masking = p_sys->f_p_masking;
 437         p_context->border_masking = p_sys->f_border_masking;
 438         p_context->luma_elim_threshold = p_sys->i_luma_elim;
 439         p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
 440
 441         if( p_sys->i_key_int > 0 )
 442             p_context->gop_size = p_sys->i_key_int;
 443         p_context->max_b_frames =
 444             __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
 445         p_context->b_frame_strategy = 0;
 446         if( !p_context->max_b_frames  &&
 447             (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
 448                p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
 449             p_context->flags |= CODEC_FLAG_LOW_DELAY;
 450
 451         av_reduce( &i_aspect_num, &i_aspect_den,
 452                    p_enc->fmt_in.video.i_aspect,
 453                    VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
 454         av_reduce( &p_context->sample_aspect_ratio.num,
 455                    &p_context->sample_aspect_ratio.den,
 456                    i_aspect_num * (int64_t)p_context->height,
 457                    i_aspect_den * (int64_t)p_context->width, 1 << 30 );
 458
 459         p_sys->p_buffer_out = malloc( p_context->height * p_context->width * 3 );
 460
 461         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
 462         p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
 463         if( p_codec->pix_fmts )
 464         {
 465             const enum PixelFormat *p = p_codec->pix_fmts;
 466             for( ; *p != -1; p++ )
 467             {
 468                 if( *p == p_context->pix_fmt ) break;
 469             }
 470             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
 471             p_enc->fmt_in.i_codec = GetVlcChroma( p_context->pix_fmt );
 472         }
 473
 474         if ( p_sys->b_strict_rc )
 475         {
 476             p_context->rc_qsquish = 1.0;
 477             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
 478             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
 479             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
 480             /* This is from ffmpeg's ffmpeg.c : */
 481             p_context->rc_initial_buffer_occupancy
 482                 = p_sys->i_rc_buffer_size * 3/4;
 483             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
 484         }
 485
 486         if ( p_sys->f_i_quant_factor != 0.0 )
 487             p_context->i_quant_factor = p_sys->f_i_quant_factor;
 488
 489         p_context->noise_reduction = p_sys->i_noise_reduction;
 490
 491         if ( p_sys->b_mpeg4_matrix )
 492         {
 493             p_context->intra_matrix = mpeg4_default_intra_matrix;
 494             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
 495         }
 496
 497         if ( p_sys->b_pre_me )
 498         {
 499             p_context->pre_me = 1;
 500             p_context->me_pre_cmp = FF_CMP_CHROMA;
 501         }
 502
 503         if ( p_sys->b_interlace )
 504         {
 505             if ( p_context->height <= 280 )
 506             {
 507                 if ( p_context->height != 16 || p_context->width != 16 )
 508                     msg_Warn( p_enc,
 509                         "disabling interlaced video because height=%d <= 280",
 510                         p_context->height );
 511             }
 512             else
 513             {
 514                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
 515                 if ( p_sys->b_interlace_me )
 516                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
 517             }
 518         }
 519
 520         if ( p_sys->b_trellis )
 521             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 522
 523         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
 524             p_context->flags |= CODEC_FLAG_QSCALE;
 525
 526         if ( p_enc->i_threads >= 1 )
 527             p_context->thread_count = p_enc->i_threads;
 528
 529         if( p_sys->i_vtolerance > 0 )
 530             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
 531
 532         /* usually if someone sets bitrate, he likes more to get that bitrate
 533          * over quality should help 'normal' user to get asked bitrate
 534          */
 535         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
 536         {
 537             p_sys->i_qmax = 51;
 538             p_sys->i_qmin = 3;
 539         }
 540
 541         if( p_sys->i_qmin > 0 )
 542         {
 543             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
 544             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
 545         }
 546         if( p_sys->i_qmax > 0 )
 547         {
 548             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
 549             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
 550         }
 551         p_context->max_qdiff = 3;
 552
 553         p_context->mb_decision = p_sys->i_hq;
 554
 555         if( p_sys->i_quality )
 556         {
 557             p_context->flags |= CODEC_FLAG_QSCALE;
 558             p_context->global_quality = p_sys->i_quality;
 559         }
 560     }
 561     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
 562     {
 563         /* work around bug in libmp3lame encoding */
 564         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
 565             p_enc->fmt_in.audio.i_channels = 2;
 566
 567         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
 568         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
 569         p_context->channels    = p_enc->fmt_out.audio.i_channels;
 570
 571         if ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') )
 572         {
 573             /* XXX: FAAC does resample only when setting the INPUT samplerate
 574              * to the desired value (-R option of the faac frontend) */
 575             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;
 576 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 577         /* Ignore FF_PROFILE_UNKNOWN */
 578         if( p_sys->i_aac_profile >= FF_PROFILE_AAC_MAIN )
 579             p_context->profile = p_sys->i_aac_profile;
 580 #endif
 581         }
 582     }
 583
 584     /* Misc parameters */
 585     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 586
 587     if( i_codec_id == CODEC_ID_RAWVIDEO )
 588     {
 589         /* XXX: hack: Force same codec (will be handled by transcode) */
 590         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 591         p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
 592     }
 593
 594     /* Make sure we get extradata filled by the encoder */
 595     p_context->extradata_size = 0;
 596     p_context->extradata = NULL;
 597     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 598
 599     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
 600
 601     if( avcodec_open( p_context, p_codec ) )
 602     {
 603         vlc_mutex_unlock( lock );
 604         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
 605              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
 606                || i_codec_id == CODEC_ID_MP3) )
 607         {
 608             if( p_context->channels > 2 )
 609             {
 610                 p_context->channels = 2;
 611                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
 612                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 613             }
 614
 615             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
 616             {
 617                 int i_frequency, i;
 618
 619                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 620                 {
 621                     if ( p_enc->fmt_out.audio.i_rate
 622                             == mpa_freq_tab[i_frequency] )
 623                         break;
 624                 }
 625                 if ( i_frequency == 6 )
 626                 {
 627                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 628                              p_enc->fmt_out.audio.i_rate );
 629                     free( p_sys );
 630                     return VLC_EGENERIC;
 631                 }
 632
 633                 for ( i = 1; i < 14; i++ )
 634                 {
 635                     if ( p_enc->fmt_out.i_bitrate / 1000
 636                           <= mpa_bitrate_tab[i_frequency / 3][i] )
 637                         break;
 638                 }
 639                 if ( p_enc->fmt_out.i_bitrate / 1000
 640                       != mpa_bitrate_tab[i_frequency / 3][i] )
 641                 {
 642                     msg_Warn( p_enc,
 643                               "MPEG audio doesn't support bitrate=%d, using %d",
 644                               p_enc->fmt_out.i_bitrate,
 645                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 646                     p_enc->fmt_out.i_bitrate =
 647                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 648                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 649                 }
 650             }
 651
 652             p_context->codec = NULL;
 653             vlc_mutex_lock( lock );
 654             if( avcodec_open( p_context, p_codec ) )
 655             {
 656                 vlc_mutex_unlock( lock );
 657                 msg_Err( p_enc, "cannot open encoder" );
 658                 intf_UserFatal( p_enc, false,
 659                                 _("Streaming / Transcoding failed"),
 660                                 _("VLC could not open the encoder.") );
 661                 free( p_sys );
 662                 return VLC_EGENERIC;
 663             }
 664         }
 665         else
 666         {
 667             msg_Err( p_enc, "cannot open encoder" );
 668             intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 669                             _("VLC could not open the encoder.") );
 670             free( p_sys );
 671             return VLC_EGENERIC;
 672         }
 673     }
 674     vlc_mutex_unlock( lock);
 675
 676     p_enc->fmt_out.i_extra = p_context->extradata_size;
 677     if( p_enc->fmt_out.i_extra )
 678     {
 679         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 680         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 681                 p_enc->fmt_out.i_extra );
 682     }
 683     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 684
 685     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 686     {
 687         p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
 688         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
 689         p_sys->p_buffer = malloc( p_sys->i_frame_size );
 690         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 691     }
 692
 693     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 694
 695     return VLC_SUCCESS;
 696 }
 697
 698 /****************************************************************************
 699  * Ffmpeg threading system
 700  ****************************************************************************/
 701 static int FfmpegThread( struct thread_context_t *p_context )
 702 {
 703     while ( !p_context->b_die && !p_context->b_error )
 704     {
 705         vlc_mutex_lock( &p_context->lock );
 706         while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
 707         {
 708             vlc_cond_wait( &p_context->cond, &p_context->lock );
 709         }
 710         p_context->b_work = 0;
 711         vlc_mutex_unlock( &p_context->lock );
 712         if ( p_context->b_die || p_context->b_error )
 713             break;
 714
 715         if ( p_context->pf_func )
 716         {
 717             p_context->i_ret = p_context->pf_func( p_context->p_context,
 718                                                    p_context->arg );
 719         }
 720
 721         vlc_mutex_lock( &p_context->lock );
 722         p_context->b_done = 1;
 723         vlc_cond_signal( &p_context->cond );
 724         vlc_mutex_unlock( &p_context->lock );
 725     }
 726
 727     return 0;
 728 }
 729
 730 static int FfmpegExecute( AVCodecContext *s,
 731                           int (*pf_func)(AVCodecContext *c2, void *arg2),
 732                           void **arg, int *ret, int count )
 733 {
 734     struct thread_context_t ** pp_contexts =
 735                          (struct thread_context_t **)s->thread_opaque;
 736     int i;
 737
 738     /* Note, we can be certain that this is not called with the same
 739      * AVCodecContext by different threads at the same time */
 740     for ( i = 0; i < count; i++ )
 741     {
 742         vlc_mutex_lock( &pp_contexts[i]->lock );
 743         pp_contexts[i]->arg = arg[i];
 744         pp_contexts[i]->pf_func = pf_func;
 745         pp_contexts[i]->i_ret = 12345;
 746         pp_contexts[i]->b_work = 1;
 747         vlc_cond_signal( &pp_contexts[i]->cond );
 748         vlc_mutex_unlock( &pp_contexts[i]->lock );
 749     }
 750     for ( i = 0; i < count; i++ )
 751     {
 752         vlc_mutex_lock( &pp_contexts[i]->lock );
 753         while ( !pp_contexts[i]->b_done )
 754         {
 755             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
 756         }
 757         pp_contexts[i]->b_done = 0;
 758         pp_contexts[i]->pf_func = NULL;
 759         vlc_mutex_unlock( &pp_contexts[i]->lock );
 760
 761         if ( ret )
 762         {
 763             ret[i] = pp_contexts[i]->i_ret;
 764         }
 765     }
 766
 767     return 0;
 768 }
 769
 770 /****************************************************************************
 771  * EncodeVideo: the whole thing
 772  ****************************************************************************/
 773 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 774 {
 775     encoder_sys_t *p_sys = p_enc->p_sys;
 776     AVFrame frame;
 777     int i_out, i_plane;
 778
 779     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
 780     {
 781         struct thread_context_t ** pp_contexts;
 782         int i;
 783
 784         p_sys->b_inited = 1;
 785         pp_contexts = malloc( sizeof(struct thread_context_t *)
 786                                  * p_enc->i_threads );
 787         p_sys->p_context->thread_opaque = (void *)pp_contexts;
 788
 789         for ( i = 0; i < p_enc->i_threads; i++ )
 790         {
 791             pp_contexts[i] = vlc_object_create( p_enc,
 792                                      sizeof(struct thread_context_t) );
 793             pp_contexts[i]->p_context = p_sys->p_context;
 794             vlc_mutex_init( &pp_contexts[i]->lock );
 795             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
 796             pp_contexts[i]->b_work = 0;
 797             pp_contexts[i]->b_done = 0;
 798             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
 799                                     VLC_THREAD_PRIORITY_VIDEO, false ) )
 800             {
 801                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
 802                 return NULL;
 803             }
 804         }
 805
 806         p_sys->p_context->execute = FfmpegExecute;
 807     }
 808
 809     memset( &frame, 0, sizeof( AVFrame ) );
 810     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 811     {
 812         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
 813         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 814     }
 815
 816     /* Let ffmpeg select the frame type */
 817     frame.pict_type = 0;
 818
 819     frame.repeat_pict = p_pict->i_nb_fields - 2;
 820     frame.interlaced_frame = !p_pict->b_progressive;
 821     frame.top_field_first = !!p_pict->b_top_field_first;
 822
 823     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
 824     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
 825     {
 826         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 827
 828         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
 829         {
 830             mtime_t current_date = mdate();
 831
 832             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
 833             {
 834                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 835                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 836                 msg_Dbg( p_enc, "hurry up mode 3" );
 837             }
 838             else
 839             {
 840                 p_sys->p_context->mb_decision = p_sys->i_hq;
 841
 842                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
 843                 {
 844                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 845                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 846                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
 847                     msg_Dbg( p_enc, "hurry up mode 2" );
 848                 }
 849                 else
 850                 {
 851                     if ( p_sys->b_trellis )
 852                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 853
 854                     p_sys->p_context->noise_reduction =
 855                         p_sys->i_noise_reduction;
 856                 }
 857             }
 858
 859             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
 860             {
 861                 frame.pict_type = FF_P_TYPE;
 862                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 863             }
 864         }
 865     }
 866     else
 867     {
 868         frame.pts = (int64_t)AV_NOPTS_VALUE;
 869     }
 870
 871     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
 872     {
 873         if ( p_sys->i_last_pts == frame.pts )
 874         {
 875             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 876                       "same PTS (%"PRId64 ")", frame.pts );
 877             return NULL;
 878         }
 879         else if ( p_sys->i_last_pts > frame.pts )
 880         {
 881             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 882                       "past (current: %"PRId64 ", last: %"PRId64")",
 883                       frame.pts, p_sys->i_last_pts );
 884             return NULL;
 885         }
 886         else
 887         {
 888             p_sys->i_last_pts = frame.pts;
 889         }
 890     }
 891
 892     frame.quality = p_sys->i_quality;
 893
 894     /* Ugly work-around for stupid libavcodec behaviour */
 895     p_sys->i_framenum++;
 896     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
 897     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
 898         p_enc->fmt_in.video.i_frame_rate_base;
 899     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
 900     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
 901     /* End work-around */
 902
 903     i_out = avcodec_encode_video( p_sys->p_context, (uint8_t*)p_sys->p_buffer_out,
 904                                   p_sys->p_context->height * p_sys->p_context->width * 3, &frame );
 905
 906     if( i_out > 0 )
 907     {
 908         block_t *p_block = block_New( p_enc, i_out );
 909         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 910
 911         /* FIXME, 3-2 pulldown is not handled correctly */
 912         p_block->i_length = INT64_C(1000000) *
 913             p_enc->fmt_in.video.i_frame_rate_base /
 914                 p_enc->fmt_in.video.i_frame_rate;
 915
 916         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 917         {
 918             /* No delay -> output pts == input pts */
 919             p_block->i_pts = p_block->i_dts = p_pict->date;
 920         }
 921         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 922             p_sys->p_context->coded_frame->pts != 0 &&
 923             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 924         {
 925             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 926             p_block->i_pts = p_sys->p_context->coded_frame->pts;
 927
 928             /* Ugly work-around for stupid libavcodec behaviour */
 929             {
 930                 int64_t i_framenum = p_block->i_pts *
 931                     p_enc->fmt_in.video.i_frame_rate /
 932                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
 933
 934                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
 935             }
 936             /* End work-around */
 937
 938             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
 939                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
 940             {
 941                 p_block->i_dts = p_block->i_pts;
 942             }
 943             else
 944             {
 945                 if( p_sys->i_last_ref_pts )
 946                 {
 947                     p_block->i_dts = p_sys->i_last_ref_pts;
 948                 }
 949                 else
 950                 {
 951                     /* Let's put something sensible */
 952                     p_block->i_dts = p_block->i_pts;
 953                 }
 954
 955                 p_sys->i_last_ref_pts = p_block->i_pts;
 956             }
 957         }
 958         else
 959         {
 960             /* Buggy libavcodec which doesn't update coded_frame->pts
 961              * correctly */
 962             p_block->i_dts = p_block->i_pts = p_pict->date;
 963         }
 964
 965         switch ( p_sys->p_context->coded_frame->pict_type )
 966         {
 967         case FF_I_TYPE:
 968             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
 969             break;
 970         case FF_P_TYPE:
 971             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
 972             break;
 973         case FF_B_TYPE:
 974             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
 975             break;
 976         }
 977
 978         return p_block;
 979     }
 980
 981     return NULL;
 982 }
 983
 984 /****************************************************************************
 985  * EncodeAudio: the whole thing
 986  ****************************************************************************/
 987 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
 988 {
 989     encoder_sys_t *p_sys = p_enc->p_sys;
 990     block_t *p_block, *p_chain = NULL;
 991
 992     uint8_t *p_buffer = p_aout_buf->p_buffer;
 993     int i_samples = p_aout_buf->i_nb_samples;
 994     int i_samples_delay = p_sys->i_samples_delay;
 995
 996     p_sys->i_pts = p_aout_buf->start_date -
 997                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
 998                 (mtime_t)p_enc->fmt_in.audio.i_rate;
 999
1000     p_sys->i_samples_delay += i_samples;
1001
1002     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
1003     {
1004         int16_t *p_samples;
1005         int i_out;
1006
1007         if( i_samples_delay )
1008         {
1009             /* Take care of the left-over from last time */
1010             int i_delay_size = i_samples_delay * 2 *
1011                                  p_sys->p_context->channels;
1012             int i_size = p_sys->i_frame_size - i_delay_size;
1013
1014             p_samples = (int16_t *)p_sys->p_buffer;
1015             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
1016             p_buffer -= i_delay_size;
1017             i_samples += i_samples_delay;
1018             i_samples_delay = 0;
1019         }
1020         else
1021         {
1022             p_samples = (int16_t *)p_buffer;
1023         }
1024
1025         i_out = avcodec_encode_audio( p_sys->p_context,
1026                                       (uint8_t *)p_sys->p_buffer_out,
1027                                       2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
1028                                       p_samples );
1029
1030 #if 0
1031         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1032 #endif
1033         if( i_out < 0 ) break;
1034
1035         p_buffer += p_sys->i_frame_size;
1036         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
1037         i_samples -= p_sys->p_context->frame_size;
1038
1039         if( i_out == 0 ) continue;
1040
1041         p_block = block_New( p_enc, i_out );
1042         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
1043
1044         p_block->i_length = (mtime_t)1000000 *
1045             (mtime_t)p_sys->p_context->frame_size /
1046             (mtime_t)p_sys->p_context->sample_rate;
1047
1048         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1049
1050         /* Update pts */
1051         p_sys->i_pts += p_block->i_length;
1052         block_ChainAppend( &p_chain, p_block );
1053     }
1054
1055     /* Backup the remaining raw samples */
1056     if( i_samples )
1057     {
1058         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1059                 p_sys->p_context->channels, p_buffer,
1060                 i_samples * 2 * p_sys->p_context->channels );
1061     }
1062
1063     return p_chain;
1064 }
1065
1066 /*****************************************************************************
1067  * CloseEncoder: ffmpeg encoder destruction
1068  *****************************************************************************/
1069 void CloseEncoder( vlc_object_t *p_this )
1070 {
1071     encoder_t *p_enc = (encoder_t *)p_this;
1072     encoder_sys_t *p_sys = p_enc->p_sys;
1073
1074     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1075     {
1076         int i;
1077         struct thread_context_t ** pp_contexts =
1078                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1079         for ( i = 0; i < p_enc->i_threads; i++ )
1080         {
1081             vlc_object_kill( pp_contexts[i] );
1082             vlc_cond_signal( &pp_contexts[i]->cond );
1083             vlc_thread_join( pp_contexts[i] );
1084             vlc_mutex_destroy( &pp_contexts[i]->lock );
1085             vlc_cond_destroy( &pp_contexts[i]->cond );
1086             vlc_object_release( pp_contexts[i] );
1087         }
1088
1089         free( pp_contexts );
1090     }
1091
1092     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
1093     avcodec_close( p_sys->p_context );
1094     vlc_mutex_unlock( lock );
1095     av_free( p_sys->p_context );
1096
1097     free( p_sys->p_buffer );
1098     free( p_sys->p_buffer_out );
1099
1100     free( p_sys );
1101 }