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