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

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