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  E_(OpenEncoder) ( vlc_object_t * );
  64 void E_(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     vlc_bool_t      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     vlc_bool_t 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     vlc_bool_t b_strict_rc;
 132     int        i_rc_buffer_size;
 133     float      f_rc_buffer_aggressivity;
 134     vlc_bool_t b_pre_me;
 135     vlc_bool_t b_hurry_up;
 136     vlc_bool_t b_interlace, b_interlace_me;
 137     float      f_i_quant_factor;
 138     int        i_noise_reduction;
 139     vlc_bool_t b_mpeg4_matrix;
 140     vlc_bool_t 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 E_(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( !E_(GetFfmpegCodec)( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
 211                              &psz_namecodec ) )
 212     {
 213         if( E_(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, VLC_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, VLC_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     E_(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, VLC_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;
 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     if( val.psz_string ) free( val.psz_string );
 354
 355     var_Get( p_enc, ENC_CFG_PREFIX "qmin", &val );
 356     p_sys->i_qmin = val.i_int;
 357     var_Get( p_enc, ENC_CFG_PREFIX "qmax", &val );
 358     p_sys->i_qmax = val.i_int;
 359     var_Get( p_enc, ENC_CFG_PREFIX "trellis", &val );
 360     p_sys->b_trellis = val.b_bool;
 361
 362     var_Get( p_enc, ENC_CFG_PREFIX "strict", &val );
 363     if( val.i_int < - 1 || val.i_int > 1 ) val.i_int = 0;
 364     p_context->strict_std_compliance = val.i_int;
 365
 366     var_Get( p_enc, ENC_CFG_PREFIX "lumi-masking", &val );
 367     p_sys->f_lumi_masking = val.f_float;
 368     var_Get( p_enc, ENC_CFG_PREFIX "dark-masking", &val );
 369     p_sys->f_dark_masking = val.f_float;
 370     var_Get( p_enc, ENC_CFG_PREFIX "p-masking", &val );
 371     p_sys->f_p_masking = val.f_float;
 372     var_Get( p_enc, ENC_CFG_PREFIX "border-masking", &val );
 373     p_sys->f_border_masking = val.f_float;
 374     var_Get( p_enc, ENC_CFG_PREFIX "luma-elim-threshold", &val );
 375     p_sys->i_luma_elim = val.i_int;
 376     var_Get( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold", &val );
 377     p_sys->i_chroma_elim = val.i_int;
 378
 379 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 380     var_Get( p_enc, ENC_CFG_PREFIX "aac-profile", &val );
 381     p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
 382     if( val.psz_string && *val.psz_string )
 383     {
 384         if( !strncmp( val.psz_string, "main", 4 ) )
 385             p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
 386         else if( !strncmp( val.psz_string, "low", 3 ) )
 387             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
 388 #if 0    /* Not supported by FAAC encoder */
 389         else if( !strncmp( val.psz_string, "ssr", 3 ) )
 390             p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
 391 #endif
 392         else  if( !strncmp( val.psz_string, "ltp", 3 ) )
 393             p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
 394         else
 395         {
 396             msg_Warn( p_enc, "unknown AAC profile requested" );
 397             p_sys->i_aac_profile = FF_PROFILE_UNKNOWN;
 398         }
 399     }
 400     if( val.psz_string ) free( val.psz_string );
 401 #endif
 402
 403     if( p_enc->fmt_in.i_cat == VIDEO_ES )
 404     {
 405         int i_aspect_num, i_aspect_den;
 406
 407         if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
 408         {
 409             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
 410                       p_enc->fmt_in.video.i_height );
 411             free( p_sys );
 412             return VLC_EGENERIC;
 413         }
 414
 415         p_context->width = p_enc->fmt_in.video.i_width;
 416         p_context->height = p_enc->fmt_in.video.i_height;
 417         if( p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v')
 418              && (p_context->width > 720 || p_context->height > 576) )
 419             p_context->level = 4; /* High level */
 420
 421         p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
 422         p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
 423
 424         /* Defaults from ffmpeg.c */
 425         p_context->qblur = 0.5;
 426         p_context->qcompress = 0.5;
 427         p_context->b_quant_offset = 1.25;
 428         p_context->b_quant_factor = 1.25;
 429         p_context->i_quant_offset = 0.0;
 430         p_context->i_quant_factor = -0.8;
 431
 432         p_context->lumi_masking = p_sys->f_lumi_masking;
 433         p_context->dark_masking = p_sys->f_dark_masking;
 434         p_context->p_masking = p_sys->f_p_masking;
 435         p_context->border_masking = p_sys->f_border_masking;
 436         p_context->luma_elim_threshold = p_sys->i_luma_elim;
 437         p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
 438
 439         if( p_sys->i_key_int > 0 )
 440             p_context->gop_size = p_sys->i_key_int;
 441         p_context->max_b_frames =
 442             __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
 443         p_context->b_frame_strategy = 0;
 444         if( !p_context->max_b_frames  &&
 445             (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
 446                p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
 447             p_context->flags |= CODEC_FLAG_LOW_DELAY;
 448
 449         av_reduce( &i_aspect_num, &i_aspect_den,
 450                    p_enc->fmt_in.video.i_aspect,
 451                    VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
 452         av_reduce( &p_context->sample_aspect_ratio.num,
 453                    &p_context->sample_aspect_ratio.den,
 454                    i_aspect_num * (int64_t)p_context->height,
 455                    i_aspect_den * (int64_t)p_context->width, 1 << 30 );
 456
 457         p_sys->p_buffer_out = malloc( p_context->height * p_context->width * 3 );
 458
 459         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
 460         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
 461         if( p_codec->pix_fmts )
 462         {
 463             const enum PixelFormat *p = p_codec->pix_fmts;
 464             for( ; *p != -1; p++ )
 465             {
 466                 if( *p == p_context->pix_fmt ) break;
 467             }
 468             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
 469             p_enc->fmt_in.i_codec = E_(GetVlcChroma)( p_context->pix_fmt );
 470         }
 471
 472         if ( p_sys->b_strict_rc )
 473         {
 474             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
 475             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
 476             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
 477             /* This is from ffmpeg's ffmpeg.c : */
 478             p_context->rc_initial_buffer_occupancy
 479                 = p_sys->i_rc_buffer_size * 3/4;
 480             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
 481         }
 482
 483         if ( p_sys->f_i_quant_factor != 0.0 )
 484             p_context->i_quant_factor = p_sys->f_i_quant_factor;
 485
 486         p_context->noise_reduction = p_sys->i_noise_reduction;
 487
 488         if ( p_sys->b_mpeg4_matrix )
 489         {
 490             p_context->intra_matrix = mpeg4_default_intra_matrix;
 491             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
 492         }
 493
 494         if ( p_sys->b_pre_me )
 495         {
 496             p_context->pre_me = 1;
 497             p_context->me_pre_cmp = FF_CMP_CHROMA;
 498         }
 499
 500         if ( p_sys->b_interlace )
 501         {
 502             if ( p_context->height <= 280 )
 503             {
 504                 if ( p_context->height != 16 || p_context->width != 16 )
 505                     msg_Warn( p_enc,
 506                         "disabling interlaced video because height=%d <= 280",
 507                         p_context->height );
 508             }
 509             else
 510             {
 511                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
 512                 if ( p_sys->b_interlace_me )
 513                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
 514             }
 515         }
 516
 517         if ( p_sys->b_trellis )
 518             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 519
 520         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
 521             p_context->flags |= CODEC_FLAG_QSCALE;
 522
 523         if ( p_enc->i_threads >= 1 )
 524             p_context->thread_count = p_enc->i_threads;
 525
 526         if( p_sys->i_vtolerance > 0 )
 527             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
 528
 529         /* usually if someone sets bitrate, he likes more to get that bitrate over quality
 530          * should help 'normal' user to get asked bitrate
 531          */
 532         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
 533         {
 534             p_sys->i_qmax = 51;
 535             p_sys->i_qmin = 3;
 536         }
 537
 538         if( p_sys->i_qmin > 0 )
 539         {
 540             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
 541             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
 542         }
 543         if( p_sys->i_qmax > 0 )
 544         {
 545             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
 546             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
 547         }
 548         p_context->max_qdiff = 3;
 549
 550         p_context->mb_decision = p_sys->i_hq;
 551
 552         if( p_sys->i_quality )
 553         {
 554             p_context->flags |= CODEC_FLAG_QSCALE;
 555             p_context->global_quality = p_sys->i_quality;
 556         }
 557     }
 558     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
 559     {
 560         /* work around bug in libmp3lame encoding */
 561         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
 562             p_enc->fmt_in.audio.i_channels = 2;
 563
 564         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
 565         p_context->sample_rate = p_enc->fmt_in.audio.i_rate;
 566         p_context->channels    = p_enc->fmt_in.audio.i_channels;
 567
 568 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 569         /* Ignore FF_PROFILE_UNKNOWN */
 570         if( ( p_sys->i_aac_profile >= FF_PROFILE_AAC_MAIN ) &&
 571             ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') ) )
 572             p_context->profile = p_sys->i_aac_profile;
 573 #endif
 574     }
 575
 576     /* Misc parameters */
 577     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 578
 579     if( i_codec_id == CODEC_ID_RAWVIDEO )
 580     {
 581         /* XXX: hack: Force same codec (will be handled by transcode) */
 582         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 583         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
 584     }
 585
 586     /* Make sure we get extradata filled by the encoder */
 587     p_context->extradata_size = 0;
 588     p_context->extradata = NULL;
 589     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 590
 591     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
 592
 593     if( avcodec_open( p_context, p_codec ) )
 594     {
 595         vlc_mutex_unlock( lock );
 596         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
 597              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
 598                || i_codec_id == CODEC_ID_MP3) )
 599         {
 600             if( p_context->channels > 2 )
 601             {
 602                 p_context->channels = 2;
 603                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
 604                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 605             }
 606
 607             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
 608             {
 609                 int i_frequency, i;
 610
 611                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 612                 {
 613                     if ( p_enc->fmt_out.audio.i_rate
 614                             == mpa_freq_tab[i_frequency] )
 615                         break;
 616                 }
 617                 if ( i_frequency == 6 )
 618                 {
 619                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 620                              p_enc->fmt_out.audio.i_rate );
 621                     free( p_sys );
 622                     return VLC_EGENERIC;
 623                 }
 624
 625                 for ( i = 1; i < 14; i++ )
 626                 {
 627                     if ( p_enc->fmt_out.i_bitrate / 1000
 628                           <= mpa_bitrate_tab[i_frequency / 3][i] )
 629                         break;
 630                 }
 631                 if ( p_enc->fmt_out.i_bitrate / 1000
 632                       != mpa_bitrate_tab[i_frequency / 3][i] )
 633                 {
 634                     msg_Warn( p_enc,
 635                               "MPEG audio doesn't support bitrate=%d, using %d",
 636                               p_enc->fmt_out.i_bitrate,
 637                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 638                     p_enc->fmt_out.i_bitrate =
 639                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 640                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 641                 }
 642             }
 643
 644             p_context->codec = NULL;
 645             vlc_mutex_lock( lock );
 646             if( avcodec_open( p_context, p_codec ) )
 647             {
 648                 vlc_mutex_unlock( lock );
 649                 msg_Err( p_enc, "cannot open encoder" );
 650                 intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
 651                                 _("VLC could not open the encoder.") );
 652                 free( p_sys );
 653                 return VLC_EGENERIC;
 654             }
 655         }
 656         else
 657         {
 658             msg_Err( p_enc, "cannot open encoder" );
 659             intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
 660                             _("VLC could not open the encoder.") );
 661             free( p_sys );
 662             return VLC_EGENERIC;
 663         }
 664     }
 665     vlc_mutex_unlock( lock);
 666
 667     p_enc->fmt_out.i_extra = p_context->extradata_size;
 668     if( p_enc->fmt_out.i_extra )
 669     {
 670         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 671         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 672                 p_enc->fmt_out.i_extra );
 673     }
 674     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 675
 676     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 677     {
 678         p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
 679         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
 680         p_sys->p_buffer = malloc( p_sys->i_frame_size );
 681         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 682     }
 683
 684     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 685
 686     return VLC_SUCCESS;
 687 }
 688
 689 /****************************************************************************
 690  * Ffmpeg threading system
 691  ****************************************************************************/
 692 static int FfmpegThread( struct thread_context_t *p_context )
 693 {
 694     while ( !p_context->b_die && !p_context->b_error )
 695     {
 696         vlc_mutex_lock( &p_context->lock );
 697         while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
 698         {
 699             vlc_cond_wait( &p_context->cond, &p_context->lock );
 700         }
 701         p_context->b_work = 0;
 702         vlc_mutex_unlock( &p_context->lock );
 703         if ( p_context->b_die || p_context->b_error )
 704             break;
 705
 706         if ( p_context->pf_func )
 707         {
 708             p_context->i_ret = p_context->pf_func( p_context->p_context,
 709                                                    p_context->arg );
 710         }
 711
 712         vlc_mutex_lock( &p_context->lock );
 713         p_context->b_done = 1;
 714         vlc_cond_signal( &p_context->cond );
 715         vlc_mutex_unlock( &p_context->lock );
 716     }
 717
 718     return 0;
 719 }
 720
 721 static int FfmpegExecute( AVCodecContext *s,
 722                           int (*pf_func)(AVCodecContext *c2, void *arg2),
 723                           void **arg, int *ret, int count )
 724 {
 725     struct thread_context_t ** pp_contexts =
 726                          (struct thread_context_t **)s->thread_opaque;
 727     int i;
 728
 729     /* Note, we can be certain that this is not called with the same
 730      * AVCodecContext by different threads at the same time */
 731     for ( i = 0; i < count; i++ )
 732     {
 733         vlc_mutex_lock( &pp_contexts[i]->lock );
 734         pp_contexts[i]->arg = arg[i];
 735         pp_contexts[i]->pf_func = pf_func;
 736         pp_contexts[i]->i_ret = 12345;
 737         pp_contexts[i]->b_work = 1;
 738         vlc_cond_signal( &pp_contexts[i]->cond );
 739         vlc_mutex_unlock( &pp_contexts[i]->lock );
 740     }
 741     for ( i = 0; i < count; i++ )
 742     {
 743         vlc_mutex_lock( &pp_contexts[i]->lock );
 744         while ( !pp_contexts[i]->b_done )
 745         {
 746             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
 747         }
 748         pp_contexts[i]->b_done = 0;
 749         pp_contexts[i]->pf_func = NULL;
 750         vlc_mutex_unlock( &pp_contexts[i]->lock );
 751
 752         if ( ret )
 753         {
 754             ret[i] = pp_contexts[i]->i_ret;
 755         }
 756     }
 757
 758     return 0;
 759 }
 760
 761 /****************************************************************************
 762  * EncodeVideo: the whole thing
 763  ****************************************************************************/
 764 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 765 {
 766     encoder_sys_t *p_sys = p_enc->p_sys;
 767     AVFrame frame;
 768     int i_out, i_plane;
 769
 770     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
 771     {
 772         struct thread_context_t ** pp_contexts;
 773         int i;
 774
 775         p_sys->b_inited = 1;
 776         pp_contexts = malloc( sizeof(struct thread_context_t *)
 777                                  * p_enc->i_threads );
 778         p_sys->p_context->thread_opaque = (void *)pp_contexts;
 779
 780         for ( i = 0; i < p_enc->i_threads; i++ )
 781         {
 782             pp_contexts[i] = vlc_object_create( p_enc,
 783                                      sizeof(struct thread_context_t) );
 784             pp_contexts[i]->p_context = p_sys->p_context;
 785             vlc_mutex_init( p_enc, &pp_contexts[i]->lock );
 786             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
 787             pp_contexts[i]->b_work = 0;
 788             pp_contexts[i]->b_done = 0;
 789             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
 790                                     VLC_THREAD_PRIORITY_VIDEO, VLC_FALSE ) )
 791             {
 792                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
 793                 return NULL;
 794             }
 795         }
 796
 797         p_sys->p_context->execute = FfmpegExecute;
 798     }
 799
 800     memset( &frame, 0, sizeof( AVFrame ) );
 801     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 802     {
 803         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
 804         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 805     }
 806
 807     /* Let ffmpeg select the frame type */
 808     frame.pict_type = 0;
 809
 810     frame.repeat_pict = p_pict->i_nb_fields - 2;
 811     frame.interlaced_frame = !p_pict->b_progressive;
 812     frame.top_field_first = !!p_pict->b_top_field_first;
 813
 814     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
 815     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
 816     {
 817         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 818
 819         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
 820         {
 821             mtime_t current_date = mdate();
 822
 823             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
 824             {
 825                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 826                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 827                 msg_Dbg( p_enc, "hurry up mode 3" );
 828             }
 829             else
 830             {
 831                 p_sys->p_context->mb_decision = p_sys->i_hq;
 832
 833                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
 834                 {
 835                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 836                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 837                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
 838                     msg_Dbg( p_enc, "hurry up mode 2" );
 839                 }
 840                 else
 841                 {
 842                     if ( p_sys->b_trellis )
 843                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 844
 845                     p_sys->p_context->noise_reduction =
 846                         p_sys->i_noise_reduction;
 847                 }
 848             }
 849
 850             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
 851             {
 852                 frame.pict_type = FF_P_TYPE;
 853                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 854             }
 855         }
 856     }
 857     else
 858     {
 859         frame.pts = (int64_t)AV_NOPTS_VALUE;
 860     }
 861
 862     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
 863     {
 864         if ( p_sys->i_last_pts == frame.pts )
 865         {
 866             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 867                       "same PTS (" I64Fd ")", frame.pts );
 868             return NULL;
 869         }
 870         else if ( p_sys->i_last_pts > frame.pts )
 871         {
 872             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 873                       "past (current: " I64Fd ", last: "I64Fd")",
 874                       frame.pts, p_sys->i_last_pts );
 875             return NULL;
 876         }
 877         else
 878         {
 879             p_sys->i_last_pts = frame.pts;
 880         }
 881     }
 882
 883     frame.quality = p_sys->i_quality;
 884
 885     /* Ugly work-around for stupid libavcodec behaviour */
 886     p_sys->i_framenum++;
 887     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
 888     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
 889         p_enc->fmt_in.video.i_frame_rate_base;
 890     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
 891     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
 892     /* End work-around */
 893
 894     i_out = avcodec_encode_video( p_sys->p_context, (uint8_t*)p_sys->p_buffer_out,
 895                                   p_sys->p_context->height * p_sys->p_context->width * 3, &frame );
 896
 897     if( i_out > 0 )
 898     {
 899         block_t *p_block = block_New( p_enc, i_out );
 900         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 901
 902         /* FIXME, 3-2 pulldown is not handled correctly */
 903         p_block->i_length = I64C(1000000) *
 904             p_enc->fmt_in.video.i_frame_rate_base /
 905                 p_enc->fmt_in.video.i_frame_rate;
 906
 907         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 908         {
 909             /* No delay -> output pts == input pts */
 910             p_block->i_pts = p_block->i_dts = p_pict->date;
 911         }
 912         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 913             p_sys->p_context->coded_frame->pts != 0 &&
 914             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 915         {
 916             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 917             p_block->i_pts = p_sys->p_context->coded_frame->pts;
 918
 919             /* Ugly work-around for stupid libavcodec behaviour */
 920             {
 921                 int64_t i_framenum = p_block->i_pts *
 922                     p_enc->fmt_in.video.i_frame_rate /
 923                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
 924
 925                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
 926             }
 927             /* End work-around */
 928
 929             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
 930                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
 931             {
 932                 p_block->i_dts = p_block->i_pts;
 933             }
 934             else
 935             {
 936                 if( p_sys->i_last_ref_pts )
 937                 {
 938                     p_block->i_dts = p_sys->i_last_ref_pts;
 939                 }
 940                 else
 941                 {
 942                     /* Let's put something sensible */
 943                     p_block->i_dts = p_block->i_pts;
 944                 }
 945
 946                 p_sys->i_last_ref_pts = p_block->i_pts;
 947             }
 948         }
 949         else
 950         {
 951             /* Buggy libavcodec which doesn't update coded_frame->pts
 952              * correctly */
 953             p_block->i_dts = p_block->i_pts = p_pict->date;
 954         }
 955
 956         switch ( p_sys->p_context->coded_frame->pict_type )
 957         {
 958         case FF_I_TYPE:
 959             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
 960             break;
 961         case FF_P_TYPE:
 962             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
 963             break;
 964         case FF_B_TYPE:
 965             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
 966             break;
 967         }
 968
 969         return p_block;
 970     }
 971
 972     return NULL;
 973 }
 974
 975 /****************************************************************************
 976  * EncodeAudio: the whole thing
 977  ****************************************************************************/
 978 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
 979 {
 980     encoder_sys_t *p_sys = p_enc->p_sys;
 981     block_t *p_block, *p_chain = NULL;
 982
 983     uint8_t *p_buffer = p_aout_buf->p_buffer;
 984     int i_samples = p_aout_buf->i_nb_samples;
 985     int i_samples_delay = p_sys->i_samples_delay;
 986
 987     p_sys->i_pts = p_aout_buf->start_date -
 988                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
 989                 (mtime_t)p_enc->fmt_in.audio.i_rate;
 990
 991     p_sys->i_samples_delay += i_samples;
 992
 993     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
 994     {
 995         int16_t *p_samples;
 996         int i_out;
 997
 998         if( i_samples_delay )
 999         {
1000             /* Take care of the left-over from last time */
1001             int i_delay_size = i_samples_delay * 2 *
1002                                  p_sys->p_context->channels;
1003             int i_size = p_sys->i_frame_size - i_delay_size;
1004
1005             p_samples = (int16_t *)p_sys->p_buffer;
1006             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
1007             p_buffer -= i_delay_size;
1008             i_samples += i_samples_delay;
1009             i_samples_delay = 0;
1010         }
1011         else
1012         {
1013             p_samples = (int16_t *)p_buffer;
1014         }
1015
1016         i_out = avcodec_encode_audio( p_sys->p_context, (uint8_t *)p_sys->p_buffer_out,
1017                                       2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
1018                                       p_samples );
1019
1020 #if 0
1021         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1022 #endif
1023         if( i_out < 0 ) break;
1024
1025         p_buffer += p_sys->i_frame_size;
1026         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
1027         i_samples -= p_sys->p_context->frame_size;
1028
1029         if( i_out == 0 ) continue;
1030
1031         p_block = block_New( p_enc, i_out );
1032         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
1033
1034         p_block->i_length = (mtime_t)1000000 *
1035             (mtime_t)p_sys->p_context->frame_size /
1036             (mtime_t)p_sys->p_context->sample_rate;
1037
1038         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1039
1040         /* Update pts */
1041         p_sys->i_pts += p_block->i_length;
1042         block_ChainAppend( &p_chain, p_block );
1043     }
1044
1045     /* Backup the remaining raw samples */
1046     if( i_samples )
1047     {
1048         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1049                 p_sys->p_context->channels, p_buffer,
1050                 i_samples * 2 * p_sys->p_context->channels );
1051     }
1052
1053     return p_chain;
1054 }
1055
1056 /*****************************************************************************
1057  * CloseEncoder: ffmpeg encoder destruction
1058  *****************************************************************************/
1059 void E_(CloseEncoder)( vlc_object_t *p_this )
1060 {
1061     encoder_t *p_enc = (encoder_t *)p_this;
1062     encoder_sys_t *p_sys = p_enc->p_sys;
1063
1064     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1065     {
1066         int i;
1067         struct thread_context_t ** pp_contexts =
1068                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1069         for ( i = 0; i < p_enc->i_threads; i++ )
1070         {
1071             vlc_object_kill( pp_contexts[i] );
1072             vlc_cond_signal( &pp_contexts[i]->cond );
1073             vlc_thread_join( pp_contexts[i] );
1074             vlc_mutex_destroy( &pp_contexts[i]->lock );
1075             vlc_cond_destroy( &pp_contexts[i]->cond );
1076             vlc_object_release( pp_contexts[i] );
1077         }
1078
1079         free( pp_contexts );
1080     }
1081
1082     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
1083     avcodec_close( p_sys->p_context );
1084     vlc_mutex_unlock( lock );
1085     av_free( p_sys->p_context );
1086
1087     if( p_sys->p_buffer ) free( p_sys->p_buffer );
1088     if( p_sys->p_buffer_out ) free( p_sys->p_buffer_out );
1089
1090     free( p_sys );
1091 }