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