git.sesse.net Git - vlc/blob - modules/codec/ffmpeg/encoder.c

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