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