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