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 void* FfmpegThread( vlc_object_t *p_this );
  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     int        i_rc_buffer_size;
 135     float      f_rc_buffer_aggressivity;
 136     bool       b_pre_me;
 137     bool       b_hurry_up;
 138     bool       b_interlace, b_interlace_me;
 139     float      f_i_quant_factor;
 140     int        i_noise_reduction;
 141     bool       b_mpeg4_matrix;
 142     bool       b_trellis;
 143     int        i_quality; /* for VBR */
 144     float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
 145     int        i_luma_elim, i_chroma_elim;
 146 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 147     int        i_aac_profile; /* AAC profile to use.*/
 148 #endif
 149     /* Used to work around stupid timestamping behaviour in libavcodec */
 150     uint64_t i_framenum;
 151     mtime_t  pi_delay_pts[MAX_FRAME_DELAY];
 152 };
 153
 154 static const char *const ppsz_enc_options[] = {
 155     "keyint", "bframes", "vt", "qmin", "qmax", "hq",
 156     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
 157     "interlace", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
 158     "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
 159     "p-masking", "border-masking", "luma-elim-threshold",
 160     "chroma-elim-threshold",
 161 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 162      "aac-profile",
 163 #endif
 164      NULL
 165 };
 166
 167 static const uint16_t mpa_bitrate_tab[2][15] =
 168 {
 169     {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
 170     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
 171 };
 172
 173 static const uint16_t mpa_freq_tab[6] =
 174 { 44100, 48000, 32000, 22050, 24000, 16000 };
 175
 176 static const uint16_t mpeg4_default_intra_matrix[64] = {
 177   8, 17, 18, 19, 21, 23, 25, 27,
 178  17, 18, 19, 21, 23, 25, 27, 28,
 179  20, 21, 22, 23, 24, 26, 28, 30,
 180  21, 22, 23, 24, 26, 28, 30, 32,
 181  22, 23, 24, 26, 28, 30, 32, 35,
 182  23, 24, 26, 28, 30, 32, 35, 38,
 183  25, 26, 28, 30, 32, 35, 38, 41,
 184  27, 28, 30, 32, 35, 38, 41, 45,
 185 };
 186
 187 static const uint16_t mpeg4_default_non_intra_matrix[64] = {
 188  16, 17, 18, 19, 20, 21, 22, 23,
 189  17, 18, 19, 20, 21, 22, 23, 24,
 190  18, 19, 20, 21, 22, 23, 24, 25,
 191  19, 20, 21, 22, 23, 24, 26, 27,
 192  20, 21, 22, 23, 25, 26, 27, 28,
 193  21, 22, 23, 24, 26, 27, 28, 30,
 194  22, 23, 24, 26, 27, 28, 30, 31,
 195  23, 24, 25, 27, 28, 30, 31, 33,
 196 };
 197
 198 /*****************************************************************************
 199  * OpenEncoder: probe the encoder
 200  *****************************************************************************/
 201
 202 int OpenEncoder( vlc_object_t *p_this )
 203 {
 204     encoder_t *p_enc = (encoder_t *)p_this;
 205     encoder_sys_t *p_sys = p_enc->p_sys;
 206     AVCodecContext *p_context;
 207     AVCodec *p_codec;
 208     int i_codec_id, i_cat;
 209     const char *psz_namecodec;
 210     vlc_value_t val;
 211
 212     if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
 213                              &psz_namecodec ) )
 214     {
 215         if( TestFfmpegChroma( -1, p_enc->fmt_out.i_codec ) != VLC_SUCCESS )
 216         {
 217             /* handed chroma output */
 218             return VLC_EGENERIC;
 219         }
 220         i_cat      = VIDEO_ES;
 221         i_codec_id = CODEC_ID_RAWVIDEO;
 222         psz_namecodec = "Raw video";
 223     }
 224
 225     if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
 226     {
 227         msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
 228         intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 229                         _("\"%s\" is no video encoder."), psz_namecodec );
 230         return VLC_EGENERIC;
 231     }
 232
 233     if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
 234     {
 235         msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
 236         intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 237                         _("\"%s\" is no audio encoder."), psz_namecodec );
 238         return VLC_EGENERIC;
 239     }
 240
 241     /* Initialization must be done before avcodec_find_encoder() */
 242     InitLibavcodec( p_this );
 243
 244     p_codec = avcodec_find_encoder( i_codec_id );
 245     if( !p_codec )
 246     {
 247         msg_Err( p_enc, "cannot find encoder %s", psz_namecodec );
 248         intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 249                         _("VLC could not find encoder \"%s\"."), psz_namecodec );
 250         return VLC_EGENERIC;
 251     }
 252
 253     /* Allocate the memory needed to store the encoder's structure */
 254     if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )
 255         return VLC_ENOMEM;
 256     memset( p_sys, 0, sizeof(encoder_sys_t) );
 257     p_enc->p_sys = p_sys;
 258     p_sys->p_codec = p_codec;
 259
 260     p_enc->pf_encode_video = EncodeVideo;
 261     p_enc->pf_encode_audio = EncodeAudio;
 262
 263     p_sys->p_buffer = NULL;
 264     p_sys->p_buffer_out = NULL;
 265     p_sys->i_buffer_out = 0;
 266
 267     p_sys->p_context = p_context = avcodec_alloc_context();
 268     p_context->debug = config_GetInt( p_enc, "ffmpeg-debug" );
 269     p_context->opaque = (void *)p_this;
 270
 271     /* Set CPU capabilities */
 272     unsigned i_cpu = vlc_CPU();
 273     p_context->dsp_mask = 0;
 274     if( !(i_cpu & CPU_CAPABILITY_MMX) )
 275     {
 276         p_context->dsp_mask |= FF_MM_MMX;
 277     }
 278     if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
 279     {
 280         p_context->dsp_mask |= FF_MM_MMXEXT;
 281     }
 282     if( !(i_cpu & CPU_CAPABILITY_3DNOW) )
 283     {
 284         p_context->dsp_mask |= FF_MM_3DNOW;
 285     }
 286     if( !(i_cpu & CPU_CAPABILITY_SSE) )
 287     {
 288         p_context->dsp_mask |= FF_MM_SSE;
 289         p_context->dsp_mask |= FF_MM_SSE2;
 290     }
 291
 292     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
 293
 294     var_Get( p_enc, ENC_CFG_PREFIX "keyint", &val );
 295     p_sys->i_key_int = val.i_int;
 296
 297     var_Get( p_enc, ENC_CFG_PREFIX "bframes", &val );
 298     p_sys->i_b_frames = val.i_int;
 299
 300     var_Get( p_enc, ENC_CFG_PREFIX "vt", &val );
 301     p_sys->i_vtolerance = val.i_int * 1000;
 302
 303     var_Get( p_enc, ENC_CFG_PREFIX "interlace", &val );
 304     p_sys->b_interlace = val.b_bool;
 305
 306     var_Get( p_enc, ENC_CFG_PREFIX "interlace-me", &val );
 307     p_sys->b_interlace_me = val.b_bool;
 308
 309     var_Get( p_enc, ENC_CFG_PREFIX "pre-me", &val );
 310     p_sys->b_pre_me = val.b_bool;
 311
 312     var_Get( p_enc, ENC_CFG_PREFIX "hurry-up", &val );
 313     p_sys->b_hurry_up = val.b_bool;
 314     if( p_sys->b_hurry_up )
 315     {
 316         /* hurry up mode needs noise reduction, even small */
 317         p_sys->i_noise_reduction = 1;
 318     }
 319
 320     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-size", &val );
 321     p_sys->i_rc_buffer_size = val.i_int;
 322     var_Get( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity", &val );
 323     p_sys->f_rc_buffer_aggressivity = val.f_float;
 324
 325     var_Get( p_enc, ENC_CFG_PREFIX "i-quant-factor", &val );
 326     p_sys->f_i_quant_factor = val.f_float;
 327
 328     var_Get( p_enc, ENC_CFG_PREFIX "noise-reduction", &val );
 329     p_sys->i_noise_reduction = val.i_int;
 330
 331     var_Get( p_enc, ENC_CFG_PREFIX "mpeg4-matrix", &val );
 332     p_sys->b_mpeg4_matrix = val.b_bool;
 333
 334     var_Get( p_enc, ENC_CFG_PREFIX "qscale", &val );
 335     if( val.f_float < 0.01 || val.f_float > 255.0 ) val.f_float = 0;
 336     p_sys->i_quality = (int)(FF_QP2LAMBDA * val.f_float + 0.5);
 337
 338     var_Get( p_enc, ENC_CFG_PREFIX "hq", &val );
 339     p_sys->i_hq = FF_MB_DECISION_RD;
 340     if( val.psz_string && *val.psz_string )
 341     {
 342         if( !strcmp( val.psz_string, "rd" ) )
 343             p_sys->i_hq = FF_MB_DECISION_RD;
 344         else if( !strcmp( val.psz_string, "bits" ) )
 345             p_sys->i_hq = FF_MB_DECISION_BITS;
 346         else if( !strcmp( val.psz_string, "simple" ) )
 347             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
 348         else
 349             p_sys->i_hq = FF_MB_DECISION_RD;
 350     }
 351     else
 352         p_sys->i_hq = FF_MB_DECISION_RD;
 353     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_AAC_LOW;
 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, setting it to low" );
 397             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
 398         }
 399     }
 400     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->i_buffer_out = p_context->height * p_context->width * 3;
 458         if( p_sys->i_buffer_out < FF_MIN_BUFFER_SIZE )
 459             p_sys->i_buffer_out = FF_MIN_BUFFER_SIZE;
 460         p_sys->p_buffer_out = malloc( p_sys->i_buffer_out );
 461
 462         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
 463         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
 464         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 465
 466         if( p_codec->pix_fmts )
 467         {
 468             const enum PixelFormat *p = p_codec->pix_fmts;
 469             for( ; *p != -1; p++ )
 470             {
 471                 if( *p == p_context->pix_fmt ) break;
 472             }
 473             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
 474             GetVlcChroma( &p_enc->fmt_in.video, p_context->pix_fmt );
 475             p_enc->fmt_in.i_codec = p_enc->fmt_in.video.i_chroma;
 476         }
 477
 478
 479         if ( p_sys->f_i_quant_factor != 0.0 )
 480             p_context->i_quant_factor = p_sys->f_i_quant_factor;
 481
 482         p_context->noise_reduction = p_sys->i_noise_reduction;
 483
 484         if ( p_sys->b_mpeg4_matrix )
 485         {
 486             p_context->intra_matrix = mpeg4_default_intra_matrix;
 487             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
 488         }
 489
 490         if ( p_sys->b_pre_me )
 491         {
 492             p_context->pre_me = 1;
 493             p_context->me_pre_cmp = FF_CMP_CHROMA;
 494         }
 495
 496         if ( p_sys->b_interlace )
 497         {
 498             if ( p_context->height <= 280 )
 499             {
 500                 if ( p_context->height != 16 || p_context->width != 16 )
 501                     msg_Warn( p_enc,
 502                         "disabling interlaced video because height=%d <= 280",
 503                         p_context->height );
 504             }
 505             else
 506             {
 507                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
 508                 if ( p_sys->b_interlace_me )
 509                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
 510             }
 511         }
 512
 513         if ( p_sys->b_trellis )
 514             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 515
 516         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
 517             p_context->flags |= CODEC_FLAG_QSCALE;
 518
 519         if ( p_enc->i_threads >= 1 )
 520             p_context->thread_count = p_enc->i_threads;
 521
 522         if( p_sys->i_vtolerance > 0 )
 523             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
 524
 525         /* usually if someone sets bitrate, he likes more to get that bitrate
 526          * over quality should help 'normal' user to get asked bitrate
 527          */
 528         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
 529         {
 530             p_sys->i_qmax = 51;
 531             p_sys->i_qmin = 3;
 532         }
 533
 534         if( p_sys->i_qmin > 0 )
 535         {
 536             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
 537             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
 538         }
 539         if( p_sys->i_qmax > 0 )
 540         {
 541             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
 542             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
 543         }
 544         p_context->max_qdiff = 3;
 545
 546         p_context->mb_decision = p_sys->i_hq;
 547
 548         if( p_sys->i_quality )
 549         {
 550             p_context->flags |= CODEC_FLAG_QSCALE;
 551             p_context->global_quality = p_sys->i_quality;
 552         }
 553         else
 554         {
 555             p_context->rc_qsquish = 1.0;
 556             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
 557             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
 558             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
 559             /* This is from ffmpeg's ffmpeg.c : */
 560             p_context->rc_initial_buffer_occupancy
 561                 = p_sys->i_rc_buffer_size * 3/4;
 562             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
 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.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 595         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 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 void* FfmpegThread( vlc_object_t *p_this )
 707 {
 708     struct thread_context_t *p_context = (struct thread_context_t *)p_this;
 709     int canc = vlc_savecancel ();
 710     while ( vlc_object_alive (p_context) && !p_context->b_error )
 711     {
 712         vlc_mutex_lock( &p_context->lock );
 713         while ( !p_context->b_work && vlc_object_alive (p_context) && !p_context->b_error )
 714         {
 715             vlc_cond_wait( &p_context->cond, &p_context->lock );
 716         }
 717         p_context->b_work = 0;
 718         vlc_mutex_unlock( &p_context->lock );
 719         if ( !vlc_object_alive (p_context) || p_context->b_error )
 720             break;
 721
 722         if ( p_context->pf_func )
 723         {
 724             p_context->i_ret = p_context->pf_func( p_context->p_context,
 725                                                    p_context->arg );
 726         }
 727
 728         vlc_mutex_lock( &p_context->lock );
 729         p_context->b_done = 1;
 730         vlc_cond_signal( &p_context->cond );
 731         vlc_mutex_unlock( &p_context->lock );
 732     }
 733
 734     vlc_restorecancel (canc);
 735     return NULL;
 736 }
 737
 738 static int FfmpegExecute( AVCodecContext *s,
 739                           int (*pf_func)(AVCodecContext *c2, void *arg2),
 740                           void **arg, int *ret, int count )
 741 {
 742     struct thread_context_t ** pp_contexts =
 743                          (struct thread_context_t **)s->thread_opaque;
 744     int i;
 745
 746     /* Note, we can be certain that this is not called with the same
 747      * AVCodecContext by different threads at the same time */
 748     for ( i = 0; i < count; i++ )
 749     {
 750         vlc_mutex_lock( &pp_contexts[i]->lock );
 751         pp_contexts[i]->arg = arg[i];
 752         pp_contexts[i]->pf_func = pf_func;
 753         pp_contexts[i]->i_ret = 12345;
 754         pp_contexts[i]->b_work = 1;
 755         vlc_cond_signal( &pp_contexts[i]->cond );
 756         vlc_mutex_unlock( &pp_contexts[i]->lock );
 757     }
 758     for ( i = 0; i < count; i++ )
 759     {
 760         vlc_mutex_lock( &pp_contexts[i]->lock );
 761         while ( !pp_contexts[i]->b_done )
 762         {
 763             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
 764         }
 765         pp_contexts[i]->b_done = 0;
 766         pp_contexts[i]->pf_func = NULL;
 767         vlc_mutex_unlock( &pp_contexts[i]->lock );
 768
 769         if ( ret )
 770         {
 771             ret[i] = pp_contexts[i]->i_ret;
 772         }
 773     }
 774
 775     return 0;
 776 }
 777
 778 /****************************************************************************
 779  * EncodeVideo: the whole thing
 780  ****************************************************************************/
 781 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 782 {
 783     encoder_sys_t *p_sys = p_enc->p_sys;
 784     AVFrame frame;
 785     int i_out, i_plane;
 786
 787     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
 788     {
 789         struct thread_context_t ** pp_contexts;
 790         int i;
 791
 792         p_sys->b_inited = 1;
 793         pp_contexts = malloc( sizeof(struct thread_context_t *)
 794                                  * p_enc->i_threads );
 795         p_sys->p_context->thread_opaque = (void *)pp_contexts;
 796
 797         for ( i = 0; i < p_enc->i_threads; i++ )
 798         {
 799             pp_contexts[i] = vlc_object_create( p_enc,
 800                                      sizeof(struct thread_context_t) );
 801             pp_contexts[i]->p_context = p_sys->p_context;
 802             vlc_mutex_init( &pp_contexts[i]->lock );
 803             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
 804             pp_contexts[i]->b_work = 0;
 805             pp_contexts[i]->b_done = 0;
 806             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
 807                                     VLC_THREAD_PRIORITY_VIDEO, false ) )
 808             {
 809                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
 810                 return NULL;
 811             }
 812         }
 813
 814         p_sys->p_context->execute = FfmpegExecute;
 815     }
 816
 817     memset( &frame, 0, sizeof( AVFrame ) );
 818     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 819     {
 820         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
 821         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 822     }
 823
 824     /* Let ffmpeg select the frame type */
 825     frame.pict_type = 0;
 826
 827     frame.repeat_pict = p_pict->i_nb_fields - 2;
 828     frame.interlaced_frame = !p_pict->b_progressive;
 829     frame.top_field_first = !!p_pict->b_top_field_first;
 830
 831     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
 832     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
 833     {
 834         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 835
 836         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
 837         {
 838             mtime_t current_date = mdate();
 839
 840             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
 841             {
 842                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 843                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 844                 msg_Dbg( p_enc, "hurry up mode 3" );
 845             }
 846             else
 847             {
 848                 p_sys->p_context->mb_decision = p_sys->i_hq;
 849
 850                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
 851                 {
 852                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 853                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 854                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
 855                     msg_Dbg( p_enc, "hurry up mode 2" );
 856                 }
 857                 else
 858                 {
 859                     if ( p_sys->b_trellis )
 860                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 861
 862                     p_sys->p_context->noise_reduction =
 863                         p_sys->i_noise_reduction;
 864                 }
 865             }
 866
 867             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
 868             {
 869                 frame.pict_type = FF_P_TYPE;
 870                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 871             }
 872         }
 873     }
 874     else
 875     {
 876         frame.pts = (int64_t)AV_NOPTS_VALUE;
 877     }
 878
 879     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
 880     {
 881         if ( p_sys->i_last_pts == frame.pts )
 882         {
 883             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 884                       "same PTS (%"PRId64 ")", frame.pts );
 885             return NULL;
 886         }
 887         else if ( p_sys->i_last_pts > frame.pts )
 888         {
 889             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 890                       "past (current: %"PRId64 ", last: %"PRId64")",
 891                       frame.pts, p_sys->i_last_pts );
 892             return NULL;
 893         }
 894         else
 895         {
 896             p_sys->i_last_pts = frame.pts;
 897         }
 898     }
 899
 900     frame.quality = p_sys->i_quality;
 901
 902     /* Ugly work-around for stupid libavcodec behaviour */
 903     p_sys->i_framenum++;
 904     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
 905     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
 906         p_enc->fmt_in.video.i_frame_rate_base;
 907     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
 908     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
 909     /* End work-around */
 910
 911     i_out = avcodec_encode_video( p_sys->p_context, p_sys->p_buffer_out,
 912                                   p_sys->i_buffer_out, &frame );
 913
 914     if( i_out > 0 )
 915     {
 916         block_t *p_block = block_New( p_enc, i_out );
 917         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 918
 919         /* FIXME, 3-2 pulldown is not handled correctly */
 920         p_block->i_length = INT64_C(1000000) *
 921             p_enc->fmt_in.video.i_frame_rate_base /
 922                 p_enc->fmt_in.video.i_frame_rate;
 923
 924         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 925         {
 926             /* No delay -> output pts == input pts */
 927             p_block->i_pts = p_block->i_dts = p_pict->date;
 928         }
 929         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 930             p_sys->p_context->coded_frame->pts != 0 &&
 931             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 932         {
 933             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 934             p_block->i_pts = p_sys->p_context->coded_frame->pts;
 935
 936             /* Ugly work-around for stupid libavcodec behaviour */
 937             {
 938                 int64_t i_framenum = p_block->i_pts *
 939                     p_enc->fmt_in.video.i_frame_rate /
 940                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
 941
 942                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
 943             }
 944             /* End work-around */
 945
 946             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
 947                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
 948             {
 949                 p_block->i_dts = p_block->i_pts;
 950             }
 951             else
 952             {
 953                 if( p_sys->i_last_ref_pts )
 954                 {
 955                     p_block->i_dts = p_sys->i_last_ref_pts;
 956                 }
 957                 else
 958                 {
 959                     /* Let's put something sensible */
 960                     p_block->i_dts = p_block->i_pts;
 961                 }
 962
 963                 p_sys->i_last_ref_pts = p_block->i_pts;
 964             }
 965         }
 966         else
 967         {
 968             /* Buggy libavcodec which doesn't update coded_frame->pts
 969              * correctly */
 970             p_block->i_dts = p_block->i_pts = p_pict->date;
 971         }
 972
 973         switch ( p_sys->p_context->coded_frame->pict_type )
 974         {
 975         case FF_I_TYPE:
 976             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
 977             break;
 978         case FF_P_TYPE:
 979             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
 980             break;
 981         case FF_B_TYPE:
 982             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
 983             break;
 984         }
 985
 986         return p_block;
 987     }
 988
 989     return NULL;
 990 }
 991
 992 /****************************************************************************
 993  * EncodeAudio: the whole thing
 994  ****************************************************************************/
 995 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
 996 {
 997     encoder_sys_t *p_sys = p_enc->p_sys;
 998     block_t *p_block, *p_chain = NULL;
 999
1000     uint8_t *p_buffer = p_aout_buf->p_buffer;
1001     int i_samples = p_aout_buf->i_nb_samples;
1002     int i_samples_delay = p_sys->i_samples_delay;
1003
1004     p_sys->i_pts = p_aout_buf->start_date -
1005                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1006                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1007
1008     p_sys->i_samples_delay += i_samples;
1009
1010     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
1011     {
1012         int16_t *p_samples;
1013         int i_out;
1014
1015         if( i_samples_delay )
1016         {
1017             /* Take care of the left-over from last time */
1018             int i_delay_size = i_samples_delay * 2 *
1019                                  p_sys->p_context->channels;
1020             int i_size = p_sys->i_frame_size - i_delay_size;
1021
1022             p_samples = (int16_t *)p_sys->p_buffer;
1023             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
1024             p_buffer -= i_delay_size;
1025             i_samples += i_samples_delay;
1026             i_samples_delay = 0;
1027         }
1028         else
1029         {
1030             p_samples = (int16_t *)p_buffer;
1031         }
1032
1033         i_out = avcodec_encode_audio( p_sys->p_context, p_sys->p_buffer_out,
1034                                       p_sys->i_buffer_out, p_samples );
1035
1036 #if 0
1037         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1038 #endif
1039         if( i_out < 0 ) break;
1040
1041         p_buffer += p_sys->i_frame_size;
1042         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
1043         i_samples -= p_sys->p_context->frame_size;
1044
1045         if( i_out == 0 ) continue;
1046
1047         p_block = block_New( p_enc, i_out );
1048         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
1049
1050         p_block->i_length = (mtime_t)1000000 *
1051             (mtime_t)p_sys->p_context->frame_size /
1052             (mtime_t)p_sys->p_context->sample_rate;
1053
1054         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1055
1056         /* Update pts */
1057         p_sys->i_pts += p_block->i_length;
1058         block_ChainAppend( &p_chain, p_block );
1059     }
1060
1061     /* Backup the remaining raw samples */
1062     if( i_samples )
1063     {
1064         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1065                 p_sys->p_context->channels, p_buffer,
1066                 i_samples * 2 * p_sys->p_context->channels );
1067     }
1068
1069     return p_chain;
1070 }
1071
1072 /*****************************************************************************
1073  * CloseEncoder: ffmpeg encoder destruction
1074  *****************************************************************************/
1075 void CloseEncoder( vlc_object_t *p_this )
1076 {
1077     encoder_t *p_enc = (encoder_t *)p_this;
1078     encoder_sys_t *p_sys = p_enc->p_sys;
1079
1080     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1081     {
1082         int i;
1083         struct thread_context_t ** pp_contexts =
1084                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1085         for ( i = 0; i < p_enc->i_threads; i++ )
1086         {
1087             vlc_object_kill( pp_contexts[i] );
1088             vlc_cond_signal( &pp_contexts[i]->cond );
1089             vlc_thread_join( pp_contexts[i] );
1090             vlc_mutex_destroy( &pp_contexts[i]->lock );
1091             vlc_cond_destroy( &pp_contexts[i]->cond );
1092             vlc_object_release( pp_contexts[i] );
1093         }
1094
1095         free( pp_contexts );
1096     }
1097
1098     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
1099     avcodec_close( p_sys->p_context );
1100     vlc_mutex_unlock( lock );
1101     av_free( p_sys->p_context );
1102
1103     free( p_sys->p_buffer );
1104     free( p_sys->p_buffer_out );
1105
1106     free( p_sys );
1107 }