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