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         if( p_sys->i_qmin > 0 )
 500             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
 501             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
 502         if( p_sys->i_qmax > 0 )
 503             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
 504             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
 505         p_context->max_qdiff = 3;
 506
 507         p_context->mb_decision = p_sys->i_hq;
 508
 509         if( p_sys->i_quality )
 510         {
 511             p_context->flags |= CODEC_FLAG_QSCALE;
 512             p_context->global_quality = p_sys->i_quality;
 513         }
 514     }
 515     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
 516     {
 517         /* work around bug in libmp3lame encoding */
 518         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
 519             p_enc->fmt_in.audio.i_channels = 2;
 520
 521         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
 522         p_context->sample_rate = p_enc->fmt_in.audio.i_rate;
 523         p_context->channels    = p_enc->fmt_in.audio.i_channels;
 524     }
 525
 526     /* Misc parameters */
 527     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 528
 529     if( i_codec_id == CODEC_ID_RAWVIDEO )
 530     {
 531         /* XXX: hack: Force same codec (will be handled by transcode) */
 532         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 533         p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
 534     }
 535
 536     /* Make sure we get extradata filled by the encoder */
 537     p_context->extradata_size = 0;
 538     p_context->extradata = NULL;
 539     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 540
 541     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
 542
 543     if( avcodec_open( p_context, p_codec ) )
 544     {
 545         vlc_mutex_unlock( lock );
 546         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
 547              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
 548                || i_codec_id == CODEC_ID_MP3) )
 549         {
 550             if( p_context->channels > 2 )
 551             {
 552                 p_context->channels = 2;
 553                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
 554                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 555             }
 556
 557             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
 558             {
 559                 int i_frequency, i;
 560
 561                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 562                 {
 563                     if ( p_enc->fmt_out.audio.i_rate
 564                             == mpa_freq_tab[i_frequency] )
 565                         break;
 566                 }
 567                 if ( i_frequency == 6 )
 568                 {
 569                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 570                              p_enc->fmt_out.audio.i_rate );
 571                     free( p_sys );
 572                     return VLC_EGENERIC;
 573                 }
 574
 575                 for ( i = 1; i < 14; i++ )
 576                 {
 577                     if ( p_enc->fmt_out.i_bitrate / 1000
 578                           <= mpa_bitrate_tab[i_frequency / 3][i] )
 579                         break;
 580                 }
 581                 if ( p_enc->fmt_out.i_bitrate / 1000
 582                       != mpa_bitrate_tab[i_frequency / 3][i] )
 583                 {
 584                     msg_Warn( p_enc,
 585                               "MPEG audio doesn't support bitrate=%d, using %d",
 586                               p_enc->fmt_out.i_bitrate,
 587                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 588                     p_enc->fmt_out.i_bitrate =
 589                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 590                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 591                 }
 592             }
 593
 594             p_context->codec = NULL;
 595             vlc_mutex_lock( lock );
 596             if( avcodec_open( p_context, p_codec ) )
 597             {
 598                 vlc_mutex_unlock( lock );
 599                 msg_Err( p_enc, "cannot open encoder" );
 600                 intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
 601                                 _("VLC could not open the encoder.") );
 602                 free( p_sys );
 603                 return VLC_EGENERIC;
 604             }
 605         }
 606         else
 607         {
 608             msg_Err( p_enc, "cannot open encoder" );
 609             intf_UserFatal( p_enc, VLC_FALSE, _("Streaming / Transcoding failed"),
 610                             _("VLC could not open the encoder.") );
 611             free( p_sys );
 612             return VLC_EGENERIC;
 613         }
 614     }
 615     vlc_mutex_unlock( lock);
 616
 617     p_enc->fmt_out.i_extra = p_context->extradata_size;
 618     if( p_enc->fmt_out.i_extra )
 619     {
 620         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 621         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 622                 p_enc->fmt_out.i_extra );
 623     }
 624     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 625
 626     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 627     {
 628         p_sys->p_buffer_out = malloc( 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE );
 629         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
 630         p_sys->p_buffer = malloc( p_sys->i_frame_size );
 631         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 632     }
 633
 634     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 635
 636     return VLC_SUCCESS;
 637 }
 638
 639 /****************************************************************************
 640  * Ffmpeg threading system
 641  ****************************************************************************/
 642 static int FfmpegThread( struct thread_context_t *p_context )
 643 {
 644     while ( !p_context->b_die && !p_context->b_error )
 645     {
 646         vlc_mutex_lock( &p_context->lock );
 647         while ( !p_context->b_work && !p_context->b_die && !p_context->b_error )
 648         {
 649             vlc_cond_wait( &p_context->cond, &p_context->lock );
 650         }
 651         p_context->b_work = 0;
 652         vlc_mutex_unlock( &p_context->lock );
 653         if ( p_context->b_die || p_context->b_error )
 654             break;
 655
 656         if ( p_context->pf_func )
 657         {
 658             p_context->i_ret = p_context->pf_func( p_context->p_context,
 659                                                    p_context->arg );
 660         }
 661
 662         vlc_mutex_lock( &p_context->lock );
 663         p_context->b_done = 1;
 664         vlc_cond_signal( &p_context->cond );
 665         vlc_mutex_unlock( &p_context->lock );
 666     }
 667
 668     return 0;
 669 }
 670
 671 static int FfmpegExecute( AVCodecContext *s,
 672                           int (*pf_func)(AVCodecContext *c2, void *arg2),
 673                           void **arg, int *ret, int count )
 674 {
 675     struct thread_context_t ** pp_contexts =
 676                          (struct thread_context_t **)s->thread_opaque;
 677     int i;
 678
 679     /* Note, we can be certain that this is not called with the same
 680      * AVCodecContext by different threads at the same time */
 681     for ( i = 0; i < count; i++ )
 682     {
 683         vlc_mutex_lock( &pp_contexts[i]->lock );
 684         pp_contexts[i]->arg = arg[i];
 685         pp_contexts[i]->pf_func = pf_func;
 686         pp_contexts[i]->i_ret = 12345;
 687         pp_contexts[i]->b_work = 1;
 688         vlc_cond_signal( &pp_contexts[i]->cond );
 689         vlc_mutex_unlock( &pp_contexts[i]->lock );
 690     }
 691     for ( i = 0; i < count; i++ )
 692     {
 693         vlc_mutex_lock( &pp_contexts[i]->lock );
 694         while ( !pp_contexts[i]->b_done )
 695         {
 696             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
 697         }
 698         pp_contexts[i]->b_done = 0;
 699         pp_contexts[i]->pf_func = NULL;
 700         vlc_mutex_unlock( &pp_contexts[i]->lock );
 701
 702         if ( ret )
 703         {
 704             ret[i] = pp_contexts[i]->i_ret;
 705         }
 706     }
 707
 708     return 0;
 709 }
 710
 711 /****************************************************************************
 712  * EncodeVideo: the whole thing
 713  ****************************************************************************/
 714 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 715 {
 716     encoder_sys_t *p_sys = p_enc->p_sys;
 717     AVFrame frame;
 718     int i_out, i_plane;
 719
 720     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
 721     {
 722         struct thread_context_t ** pp_contexts;
 723         int i;
 724
 725         p_sys->b_inited = 1;
 726         pp_contexts = malloc( sizeof(struct thread_context_t *)
 727                                  * p_enc->i_threads );
 728         p_sys->p_context->thread_opaque = (void *)pp_contexts;
 729
 730         for ( i = 0; i < p_enc->i_threads; i++ )
 731         {
 732             pp_contexts[i] = vlc_object_create( p_enc,
 733                                      sizeof(struct thread_context_t) );
 734             pp_contexts[i]->p_context = p_sys->p_context;
 735             vlc_mutex_init( p_enc, &pp_contexts[i]->lock );
 736             vlc_cond_init( p_enc, &pp_contexts[i]->cond );
 737             pp_contexts[i]->b_work = 0;
 738             pp_contexts[i]->b_done = 0;
 739             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
 740                                     VLC_THREAD_PRIORITY_VIDEO, VLC_FALSE ) )
 741             {
 742                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
 743                 return NULL;
 744             }
 745         }
 746
 747         p_sys->p_context->execute = FfmpegExecute;
 748     }
 749
 750     memset( &frame, 0, sizeof( AVFrame ) );
 751     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 752     {
 753         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
 754         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 755     }
 756
 757     /* Let ffmpeg select the frame type */
 758     frame.pict_type = 0;
 759
 760     frame.repeat_pict = p_pict->i_nb_fields - 2;
 761     frame.interlaced_frame = !p_pict->b_progressive;
 762     frame.top_field_first = !!p_pict->b_top_field_first;
 763
 764     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
 765     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
 766     {
 767         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 768
 769         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
 770         {
 771             mtime_t current_date = mdate();
 772
 773             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
 774             {
 775                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 776                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 777                 msg_Dbg( p_enc, "hurry up mode 3" );
 778             }
 779             else
 780             {
 781                 p_sys->p_context->mb_decision = p_sys->i_hq;
 782
 783                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
 784                 {
 785                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 786                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 787                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
 788                     msg_Dbg( p_enc, "hurry up mode 2" );
 789                 }
 790                 else
 791                 {
 792                     if ( p_sys->b_trellis )
 793                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 794
 795                     p_sys->p_context->noise_reduction =
 796                         p_sys->i_noise_reduction;
 797                 }
 798             }
 799
 800             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
 801             {
 802                 frame.pict_type = FF_P_TYPE;
 803                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 804             }
 805         }
 806     }
 807     else
 808     {
 809         frame.pts = (int64_t)AV_NOPTS_VALUE;
 810     }
 811
 812     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
 813     {
 814         if ( p_sys->i_last_pts == frame.pts )
 815         {
 816             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 817                       "same PTS (" I64Fd ")", frame.pts );
 818             return NULL;
 819         }
 820         else if ( p_sys->i_last_pts > frame.pts )
 821         {
 822             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 823                       "past (current: " I64Fd ", last: "I64Fd")",
 824                       frame.pts, p_sys->i_last_pts );
 825             return NULL;
 826         }
 827         else
 828         {
 829             p_sys->i_last_pts = frame.pts;
 830         }
 831     }
 832
 833     frame.quality = p_sys->i_quality;
 834
 835     /* Ugly work-around for stupid libavcodec behaviour */
 836     p_sys->i_framenum++;
 837     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
 838     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
 839         p_enc->fmt_in.video.i_frame_rate_base;
 840     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
 841     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
 842     /* End work-around */
 843
 844     i_out = avcodec_encode_video( p_sys->p_context, (uint8_t*)p_sys->p_buffer_out,
 845                                   p_sys->p_context->height * p_sys->p_context->width * 3, &frame );
 846
 847     if( i_out > 0 )
 848     {
 849         block_t *p_block = block_New( p_enc, i_out );
 850         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 851
 852         /* FIXME, 3-2 pulldown is not handled correctly */
 853         p_block->i_length = I64C(1000000) *
 854             p_enc->fmt_in.video.i_frame_rate_base /
 855                 p_enc->fmt_in.video.i_frame_rate;
 856
 857         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 858         {
 859             /* No delay -> output pts == input pts */
 860             p_block->i_pts = p_block->i_dts = p_pict->date;
 861         }
 862         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 863             p_sys->p_context->coded_frame->pts != 0 &&
 864             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 865         {
 866             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 867             p_block->i_pts = p_sys->p_context->coded_frame->pts;
 868
 869             /* Ugly work-around for stupid libavcodec behaviour */
 870             {
 871                 int64_t i_framenum = p_block->i_pts *
 872                     p_enc->fmt_in.video.i_frame_rate /
 873                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
 874
 875                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
 876             }
 877             /* End work-around */
 878
 879             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
 880                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
 881             {
 882                 p_block->i_dts = p_block->i_pts;
 883             }
 884             else
 885             {
 886                 if( p_sys->i_last_ref_pts )
 887                 {
 888                     p_block->i_dts = p_sys->i_last_ref_pts;
 889                 }
 890                 else
 891                 {
 892                     /* Let's put something sensible */
 893                     p_block->i_dts = p_block->i_pts;
 894                 }
 895
 896                 p_sys->i_last_ref_pts = p_block->i_pts;
 897             }
 898         }
 899         else
 900         {
 901             /* Buggy libavcodec which doesn't update coded_frame->pts
 902              * correctly */
 903             p_block->i_dts = p_block->i_pts = p_pict->date;
 904         }
 905
 906         switch ( p_sys->p_context->coded_frame->pict_type )
 907         {
 908         case FF_I_TYPE:
 909             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
 910             break;
 911         case FF_P_TYPE:
 912             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
 913             break;
 914         case FF_B_TYPE:
 915             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
 916             break;
 917         }
 918
 919         return p_block;
 920     }
 921
 922     return NULL;
 923 }
 924
 925 /****************************************************************************
 926  * EncodeAudio: the whole thing
 927  ****************************************************************************/
 928 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
 929 {
 930     encoder_sys_t *p_sys = p_enc->p_sys;
 931     block_t *p_block, *p_chain = NULL;
 932
 933     uint8_t *p_buffer = p_aout_buf->p_buffer;
 934     int i_samples = p_aout_buf->i_nb_samples;
 935     int i_samples_delay = p_sys->i_samples_delay;
 936
 937     p_sys->i_pts = p_aout_buf->start_date -
 938                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
 939                 (mtime_t)p_enc->fmt_in.audio.i_rate;
 940
 941     p_sys->i_samples_delay += i_samples;
 942
 943     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
 944     {
 945         int16_t *p_samples;
 946         int i_out;
 947
 948         if( i_samples_delay )
 949         {
 950             /* Take care of the left-over from last time */
 951             int i_delay_size = i_samples_delay * 2 *
 952                                  p_sys->p_context->channels;
 953             int i_size = p_sys->i_frame_size - i_delay_size;
 954
 955             p_samples = (int16_t *)p_sys->p_buffer;
 956             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
 957             p_buffer -= i_delay_size;
 958             i_samples += i_samples_delay;
 959             i_samples_delay = 0;
 960         }
 961         else
 962         {
 963             p_samples = (int16_t *)p_buffer;
 964         }
 965
 966         i_out = avcodec_encode_audio( p_sys->p_context, (uint8_t *)p_sys->p_buffer_out,
 967                                       2 * AVCODEC_MAX_AUDIO_FRAME_SIZE,
 968                                       p_samples );
 969
 970 #if 0
 971         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
 972 #endif
 973         if( i_out < 0 ) break;
 974
 975         p_buffer += p_sys->i_frame_size;
 976         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
 977         i_samples -= p_sys->p_context->frame_size;
 978
 979         if( i_out == 0 ) continue;
 980
 981         p_block = block_New( p_enc, i_out );
 982         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 983
 984         p_block->i_length = (mtime_t)1000000 *
 985             (mtime_t)p_sys->p_context->frame_size /
 986             (mtime_t)p_sys->p_context->sample_rate;
 987
 988         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
 989
 990         /* Update pts */
 991         p_sys->i_pts += p_block->i_length;
 992         block_ChainAppend( &p_chain, p_block );
 993     }
 994
 995     /* Backup the remaining raw samples */
 996     if( i_samples )
 997     {
 998         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
 999                 p_sys->p_context->channels, p_buffer,
1000                 i_samples * 2 * p_sys->p_context->channels );
1001     }
1002
1003     return p_chain;
1004 }
1005
1006 /*****************************************************************************
1007  * CloseEncoder: ffmpeg encoder destruction
1008  *****************************************************************************/
1009 void E_(CloseEncoder)( vlc_object_t *p_this )
1010 {
1011     encoder_t *p_enc = (encoder_t *)p_this;
1012     encoder_sys_t *p_sys = p_enc->p_sys;
1013
1014     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1015     {
1016         int i;
1017         struct thread_context_t ** pp_contexts =
1018                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1019         for ( i = 0; i < p_enc->i_threads; i++ )
1020         {
1021             vlc_object_kill( pp_contexts[i] );
1022             vlc_cond_signal( &pp_contexts[i]->cond );
1023             vlc_thread_join( pp_contexts[i] );
1024             vlc_mutex_destroy( &pp_contexts[i]->lock );
1025             vlc_cond_destroy( &pp_contexts[i]->cond );
1026             vlc_object_destroy( pp_contexts[i] );
1027         }
1028
1029         free( pp_contexts );
1030     }
1031
1032     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
1033     avcodec_close( p_sys->p_context );
1034     vlc_mutex_unlock( lock );
1035     av_free( p_sys->p_context );
1036
1037     if( p_sys->p_buffer ) free( p_sys->p_buffer );
1038     if( p_sys->p_buffer_out ) free( p_sys->p_buffer_out );
1039
1040     free( p_sys );
1041 }