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 );
  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.   ***\n", 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         if( p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v')
 431              && (p_context->width > 720 || p_context->height > 576) )
 432             p_context->level = 4; /* High level */
 433
 434         p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
 435         p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
 436
 437         /* Defaults from ffmpeg.c */
 438         p_context->qblur = 0.5;
 439         p_context->qcompress = 0.5;
 440         p_context->b_quant_offset = 1.25;
 441         p_context->b_quant_factor = 1.25;
 442         p_context->i_quant_offset = 0.0;
 443         p_context->i_quant_factor = -0.8;
 444
 445         p_context->lumi_masking = p_sys->f_lumi_masking;
 446         p_context->dark_masking = p_sys->f_dark_masking;
 447         p_context->p_masking = p_sys->f_p_masking;
 448         p_context->border_masking = p_sys->f_border_masking;
 449         p_context->luma_elim_threshold = p_sys->i_luma_elim;
 450         p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
 451
 452         if( p_sys->i_key_int > 0 )
 453             p_context->gop_size = p_sys->i_key_int;
 454         p_context->max_b_frames =
 455             __MAX( __MIN( p_sys->i_b_frames, FF_MAX_B_FRAMES ), 0 );
 456         p_context->b_frame_strategy = 0;
 457         if( !p_context->max_b_frames  &&
 458             (  p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '2', 'v') ||
 459                p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
 460             p_context->flags |= CODEC_FLAG_LOW_DELAY;
 461
 462         av_reduce( &i_aspect_num, &i_aspect_den,
 463                    p_enc->fmt_in.video.i_aspect,
 464                    VOUT_ASPECT_FACTOR, 1 << 30 /* something big */ );
 465         av_reduce( &p_context->sample_aspect_ratio.num,
 466                    &p_context->sample_aspect_ratio.den,
 467                    i_aspect_num * (int64_t)p_context->height,
 468                    i_aspect_den * (int64_t)p_context->width, 1 << 30 );
 469
 470         p_sys->i_buffer_out = p_context->height * p_context->width * 3;
 471         if( p_sys->i_buffer_out < FF_MIN_BUFFER_SIZE )
 472             p_sys->i_buffer_out = FF_MIN_BUFFER_SIZE;
 473         p_sys->p_buffer_out = malloc( p_sys->i_buffer_out );
 474
 475         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
 476         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
 477         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 478
 479         if( p_codec->pix_fmts )
 480         {
 481             const enum PixelFormat *p = p_codec->pix_fmts;
 482             for( ; *p != -1; p++ )
 483             {
 484                 if( *p == p_context->pix_fmt ) break;
 485             }
 486             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
 487             GetVlcChroma( &p_enc->fmt_in.video, p_context->pix_fmt );
 488             p_enc->fmt_in.i_codec = p_enc->fmt_in.video.i_chroma;
 489         }
 490
 491
 492         if ( p_sys->f_i_quant_factor != 0.0 )
 493             p_context->i_quant_factor = p_sys->f_i_quant_factor;
 494
 495         p_context->noise_reduction = p_sys->i_noise_reduction;
 496
 497         if ( p_sys->b_mpeg4_matrix )
 498         {
 499             p_context->intra_matrix = mpeg4_default_intra_matrix;
 500             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
 501         }
 502
 503         if ( p_sys->b_pre_me )
 504         {
 505             p_context->pre_me = 1;
 506             p_context->me_pre_cmp = FF_CMP_CHROMA;
 507         }
 508
 509         if ( p_sys->b_interlace )
 510         {
 511             if ( p_context->height <= 280 )
 512             {
 513                 if ( p_context->height != 16 || p_context->width != 16 )
 514                     msg_Warn( p_enc,
 515                         "disabling interlaced video because height=%d <= 280",
 516                         p_context->height );
 517             }
 518             else
 519             {
 520                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
 521                 if ( p_sys->b_interlace_me )
 522                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
 523             }
 524         }
 525
 526 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
 527         if ( p_sys->b_trellis )
 528             p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 529 #else
 530         p_context->trellis = p_sys->b_trellis;
 531 #endif
 532
 533         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
 534             p_context->flags |= CODEC_FLAG_QSCALE;
 535
 536         if ( p_enc->i_threads >= 1 )
 537             p_context->thread_count = p_enc->i_threads;
 538
 539         if( p_sys->i_vtolerance > 0 )
 540             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
 541
 542         /* usually if someone sets bitrate, he likes more to get that bitrate
 543          * over quality should help 'normal' user to get asked bitrate
 544          */
 545         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
 546         {
 547             p_sys->i_qmax = 51;
 548             p_sys->i_qmin = 3;
 549         }
 550
 551         if( p_sys->i_qmin > 0 )
 552         {
 553             p_context->mb_qmin = p_context->qmin = p_sys->i_qmin;
 554             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
 555         }
 556         if( p_sys->i_qmax > 0 )
 557         {
 558             p_context->mb_qmax = p_context->qmax = p_sys->i_qmax;
 559             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
 560         }
 561         p_context->max_qdiff = 3;
 562
 563         p_context->mb_decision = p_sys->i_hq;
 564
 565         if( p_sys->i_quality )
 566         {
 567             p_context->flags |= CODEC_FLAG_QSCALE;
 568             p_context->global_quality = p_sys->i_quality;
 569         }
 570         else
 571         {
 572             p_context->rc_qsquish = 1.0;
 573             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
 574             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
 575             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
 576             /* This is from ffmpeg's ffmpeg.c : */
 577             p_context->rc_initial_buffer_occupancy
 578                 = p_sys->i_rc_buffer_size * 3/4;
 579             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
 580         }
 581     }
 582     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
 583     {
 584         /* work around bug in libmp3lame encoding */
 585         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
 586             p_enc->fmt_in.audio.i_channels = 2;
 587
 588         p_enc->fmt_in.i_codec  = AOUT_FMT_S16_NE;
 589         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
 590         p_context->channels    = p_enc->fmt_out.audio.i_channels;
 591
 592         if ( p_enc->fmt_out.i_codec == VLC_FOURCC('m','p','4','a') )
 593         {
 594             /* XXX: FAAC does resample only when setting the INPUT samplerate
 595              * to the desired value (-R option of the faac frontend)
 596             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
 597 #if LIBAVCODEC_VERSION_INT >= ((51<<16)+(40<<8)+4)
 598             /* vlc should default to low-complexity profile, faac encoder
 599              * has bug and aac audio has issues otherwise atm */
 600             p_context->profile = p_sys->i_aac_profile;
 601 #endif
 602         }
 603     }
 604
 605     /* Misc parameters */
 606     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 607
 608     if( i_codec_id == CODEC_ID_RAWVIDEO )
 609     {
 610         /* XXX: hack: Force same codec (will be handled by transcode) */
 611         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 612         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 613     }
 614
 615     /* Make sure we get extradata filled by the encoder */
 616     p_context->extradata_size = 0;
 617     p_context->extradata = NULL;
 618     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 619
 620     vlc_mutex_lock( &avcodec_lock );
 621
 622     if( avcodec_open( p_context, p_codec ) )
 623     {
 624         vlc_mutex_unlock( &avcodec_lock );
 625         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
 626              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
 627                || i_codec_id == CODEC_ID_MP3) )
 628         {
 629             if( p_context->channels > 2 )
 630             {
 631                 p_context->channels = 2;
 632                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
 633                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 634             }
 635
 636             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
 637             {
 638                 int i_frequency, i;
 639
 640                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 641                 {
 642                     if ( p_enc->fmt_out.audio.i_rate
 643                             == mpa_freq_tab[i_frequency] )
 644                         break;
 645                 }
 646                 if ( i_frequency == 6 )
 647                 {
 648                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 649                              p_enc->fmt_out.audio.i_rate );
 650                     free( p_sys );
 651                     return VLC_EGENERIC;
 652                 }
 653
 654                 for ( i = 1; i < 14; i++ )
 655                 {
 656                     if ( p_enc->fmt_out.i_bitrate / 1000
 657                           <= mpa_bitrate_tab[i_frequency / 3][i] )
 658                         break;
 659                 }
 660                 if ( p_enc->fmt_out.i_bitrate / 1000
 661                       != mpa_bitrate_tab[i_frequency / 3][i] )
 662                 {
 663                     msg_Warn( p_enc,
 664                               "MPEG audio doesn't support bitrate=%d, using %d",
 665                               p_enc->fmt_out.i_bitrate,
 666                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 667                     p_enc->fmt_out.i_bitrate =
 668                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 669                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 670                 }
 671             }
 672
 673             p_context->codec = NULL;
 674             vlc_mutex_lock( &avcodec_lock );
 675             if( avcodec_open( p_context, p_codec ) )
 676             {
 677                 vlc_mutex_unlock( &avcodec_lock );
 678                 msg_Err( p_enc, "cannot open encoder" );
 679                 intf_UserFatal( p_enc, false,
 680                                 _("Streaming / Transcoding failed"),
 681                                 _("VLC could not open the encoder.") );
 682                 free( p_sys );
 683                 return VLC_EGENERIC;
 684             }
 685         }
 686         else
 687         {
 688             msg_Err( p_enc, "cannot open encoder" );
 689             intf_UserFatal( p_enc, false, _("Streaming / Transcoding failed"),
 690                             _("VLC could not open the encoder.") );
 691             free( p_sys );
 692             return VLC_EGENERIC;
 693         }
 694     }
 695     vlc_mutex_unlock( &avcodec_lock );
 696
 697     p_enc->fmt_out.i_extra = p_context->extradata_size;
 698     if( p_enc->fmt_out.i_extra )
 699     {
 700         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 701         memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 702                 p_enc->fmt_out.i_extra );
 703     }
 704     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 705
 706     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 707     {
 708         p_sys->i_buffer_out = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
 709         p_sys->p_buffer_out = malloc( p_sys->i_buffer_out );
 710         p_sys->i_frame_size = p_context->frame_size * 2 * p_context->channels;
 711         p_sys->p_buffer = malloc( p_sys->i_frame_size );
 712         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 713     }
 714
 715     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 716
 717     return VLC_SUCCESS;
 718 }
 719
 720 /****************************************************************************
 721  * Ffmpeg threading system
 722  ****************************************************************************/
 723 static void* FfmpegThread( vlc_object_t *p_this )
 724 {
 725     struct thread_context_t *p_context = (struct thread_context_t *)p_this;
 726     int canc = vlc_savecancel ();
 727     while ( vlc_object_alive (p_context) && !p_context->b_error )
 728     {
 729         vlc_mutex_lock( &p_context->lock );
 730         while ( !p_context->b_work && vlc_object_alive (p_context) && !p_context->b_error )
 731         {
 732             vlc_cond_wait( &p_context->cond, &p_context->lock );
 733         }
 734         p_context->b_work = 0;
 735         vlc_mutex_unlock( &p_context->lock );
 736         if ( !vlc_object_alive (p_context) || p_context->b_error )
 737             break;
 738
 739         if ( p_context->pf_func )
 740         {
 741             p_context->i_ret = p_context->pf_func( p_context->p_context,
 742                                                    p_context->arg );
 743         }
 744
 745         vlc_mutex_lock( &p_context->lock );
 746         p_context->b_done = 1;
 747         vlc_cond_signal( &p_context->cond );
 748         vlc_mutex_unlock( &p_context->lock );
 749     }
 750
 751     vlc_restorecancel (canc);
 752     return NULL;
 753 }
 754
 755 static int FfmpegExecute( AVCodecContext *s,
 756                           int (*pf_func)(AVCodecContext *c2, void *arg2),
 757                           void **arg, int *ret, int count )
 758 {
 759     struct thread_context_t ** pp_contexts =
 760                          (struct thread_context_t **)s->thread_opaque;
 761     int i;
 762
 763     /* Note, we can be certain that this is not called with the same
 764      * AVCodecContext by different threads at the same time */
 765     for ( i = 0; i < count; i++ )
 766     {
 767         vlc_mutex_lock( &pp_contexts[i]->lock );
 768         pp_contexts[i]->arg = arg[i];
 769         pp_contexts[i]->pf_func = pf_func;
 770         pp_contexts[i]->i_ret = 12345;
 771         pp_contexts[i]->b_work = 1;
 772         vlc_cond_signal( &pp_contexts[i]->cond );
 773         vlc_mutex_unlock( &pp_contexts[i]->lock );
 774     }
 775     for ( i = 0; i < count; i++ )
 776     {
 777         vlc_mutex_lock( &pp_contexts[i]->lock );
 778         while ( !pp_contexts[i]->b_done )
 779         {
 780             vlc_cond_wait( &pp_contexts[i]->cond, &pp_contexts[i]->lock );
 781         }
 782         pp_contexts[i]->b_done = 0;
 783         pp_contexts[i]->pf_func = NULL;
 784         vlc_mutex_unlock( &pp_contexts[i]->lock );
 785
 786         if ( ret )
 787         {
 788             ret[i] = pp_contexts[i]->i_ret;
 789         }
 790     }
 791
 792     return 0;
 793 }
 794
 795 /****************************************************************************
 796  * EncodeVideo: the whole thing
 797  ****************************************************************************/
 798 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 799 {
 800     encoder_sys_t *p_sys = p_enc->p_sys;
 801     AVFrame frame;
 802     int i_out, i_plane;
 803
 804     if ( !p_sys->b_inited && p_enc->i_threads >= 1 )
 805     {
 806         struct thread_context_t ** pp_contexts;
 807         int i;
 808
 809         p_sys->b_inited = 1;
 810         pp_contexts = malloc( sizeof(struct thread_context_t *)
 811                                  * p_enc->i_threads );
 812         p_sys->p_context->thread_opaque = (void *)pp_contexts;
 813
 814         for ( i = 0; i < p_enc->i_threads; i++ )
 815         {
 816             pp_contexts[i] = vlc_object_create( p_enc,
 817                                      sizeof(struct thread_context_t) );
 818             pp_contexts[i]->p_context = p_sys->p_context;
 819             vlc_mutex_init( &pp_contexts[i]->lock );
 820             vlc_cond_init( &pp_contexts[i]->cond );
 821             pp_contexts[i]->b_work = 0;
 822             pp_contexts[i]->b_done = 0;
 823             if ( vlc_thread_create( pp_contexts[i], "encoder", FfmpegThread,
 824                                     VLC_THREAD_PRIORITY_VIDEO ) )
 825             {
 826                 msg_Err( p_enc, "cannot spawn encoder thread, expect to die soon" );
 827                 return NULL;
 828             }
 829         }
 830
 831         p_sys->p_context->execute = FfmpegExecute;
 832     }
 833
 834     memset( &frame, 0, sizeof( AVFrame ) );
 835     for( i_plane = 0; i_plane < p_pict->i_planes; i_plane++ )
 836     {
 837         frame.data[i_plane] = p_pict->p[i_plane].p_pixels;
 838         frame.linesize[i_plane] = p_pict->p[i_plane].i_pitch;
 839     }
 840
 841     /* Let ffmpeg select the frame type */
 842     frame.pict_type = 0;
 843
 844     frame.repeat_pict = p_pict->i_nb_fields - 2;
 845     frame.interlaced_frame = !p_pict->b_progressive;
 846     frame.top_field_first = !!p_pict->b_top_field_first;
 847
 848     /* Set the pts of the frame being encoded (segfaults with mpeg4!)*/
 849     if( p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '4', 'v' ) )
 850     {
 851         frame.pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 852
 853         if ( p_sys->b_hurry_up && frame.pts != (int64_t)AV_NOPTS_VALUE )
 854         {
 855             mtime_t current_date = mdate();
 856
 857             if ( current_date + HURRY_UP_GUARD3 > frame.pts )
 858             {
 859                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 860 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
 861                 p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 862 #else
 863                 p_sys->p_context->trellis = 0;
 864 #endif
 865                 msg_Dbg( p_enc, "hurry up mode 3" );
 866             }
 867             else
 868             {
 869                 p_sys->p_context->mb_decision = p_sys->i_hq;
 870
 871                 if ( current_date + HURRY_UP_GUARD2 > frame.pts )
 872                 {
 873 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
 874                     p_sys->p_context->flags &= ~CODEC_FLAG_TRELLIS_QUANT;
 875 #else
 876                     p_sys->p_context->trellis = 0;
 877 #endif
 878                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 879                          + (HURRY_UP_GUARD2 + current_date - frame.pts) / 500;
 880                     msg_Dbg( p_enc, "hurry up mode 2" );
 881                 }
 882                 else
 883                 {
 884 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
 885                     if ( p_sys->b_trellis )
 886                         p_sys->p_context->flags |= CODEC_FLAG_TRELLIS_QUANT;
 887 #else
 888                     p_sys->p_context->trellis = p_sys->b_trellis;
 889 #endif
 890
 891                     p_sys->p_context->noise_reduction =
 892                         p_sys->i_noise_reduction;
 893                 }
 894             }
 895
 896             if ( current_date + HURRY_UP_GUARD1 > frame.pts )
 897             {
 898                 frame.pict_type = FF_P_TYPE;
 899                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 900             }
 901         }
 902     }
 903     else
 904     {
 905         frame.pts = (int64_t)AV_NOPTS_VALUE;
 906     }
 907
 908     if ( frame.pts != (int64_t)AV_NOPTS_VALUE && frame.pts != 0 )
 909     {
 910         if ( p_sys->i_last_pts == frame.pts )
 911         {
 912             msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 913                       "same PTS (%"PRId64 ")", frame.pts );
 914             return NULL;
 915         }
 916         else if ( p_sys->i_last_pts > frame.pts )
 917         {
 918             msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 919                       "past (current: %"PRId64 ", last: %"PRId64")",
 920                       frame.pts, p_sys->i_last_pts );
 921             return NULL;
 922         }
 923         else
 924         {
 925             p_sys->i_last_pts = frame.pts;
 926         }
 927     }
 928
 929     frame.quality = p_sys->i_quality;
 930
 931     /* Ugly work-around for stupid libavcodec behaviour */
 932     p_sys->i_framenum++;
 933     p_sys->pi_delay_pts[p_sys->i_framenum % MAX_FRAME_DELAY] = frame.pts;
 934     frame.pts = p_sys->i_framenum * AV_TIME_BASE *
 935         p_enc->fmt_in.video.i_frame_rate_base;
 936     frame.pts += p_enc->fmt_in.video.i_frame_rate - 1;
 937     frame.pts /= p_enc->fmt_in.video.i_frame_rate;
 938     /* End work-around */
 939
 940     i_out = avcodec_encode_video( p_sys->p_context, p_sys->p_buffer_out,
 941                                   p_sys->i_buffer_out, &frame );
 942
 943     if( i_out > 0 )
 944     {
 945         block_t *p_block = block_New( p_enc, i_out );
 946         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
 947
 948         /* FIXME, 3-2 pulldown is not handled correctly */
 949         p_block->i_length = INT64_C(1000000) *
 950             p_enc->fmt_in.video.i_frame_rate_base /
 951                 p_enc->fmt_in.video.i_frame_rate;
 952
 953         if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 954         {
 955             /* No delay -> output pts == input pts */
 956             p_block->i_pts = p_block->i_dts = p_pict->date;
 957         }
 958         else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 959             p_sys->p_context->coded_frame->pts != 0 &&
 960             p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 961         {
 962             p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 963             p_block->i_pts = p_sys->p_context->coded_frame->pts;
 964
 965             /* Ugly work-around for stupid libavcodec behaviour */
 966             {
 967                 int64_t i_framenum = p_block->i_pts *
 968                     p_enc->fmt_in.video.i_frame_rate /
 969                     p_enc->fmt_in.video.i_frame_rate_base / AV_TIME_BASE;
 970
 971                 p_block->i_pts = p_sys->pi_delay_pts[i_framenum % MAX_FRAME_DELAY];
 972             }
 973             /* End work-around */
 974
 975             if( p_sys->p_context->coded_frame->pict_type != FF_I_TYPE &&
 976                 p_sys->p_context->coded_frame->pict_type != FF_P_TYPE )
 977             {
 978                 p_block->i_dts = p_block->i_pts;
 979             }
 980             else
 981             {
 982                 if( p_sys->i_last_ref_pts )
 983                 {
 984                     p_block->i_dts = p_sys->i_last_ref_pts;
 985                 }
 986                 else
 987                 {
 988                     /* Let's put something sensible */
 989                     p_block->i_dts = p_block->i_pts;
 990                 }
 991
 992                 p_sys->i_last_ref_pts = p_block->i_pts;
 993             }
 994         }
 995         else
 996         {
 997             /* Buggy libavcodec which doesn't update coded_frame->pts
 998              * correctly */
 999             p_block->i_dts = p_block->i_pts = p_pict->date;
1000         }
1001
1002         switch ( p_sys->p_context->coded_frame->pict_type )
1003         {
1004         case FF_I_TYPE:
1005             p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1006             break;
1007         case FF_P_TYPE:
1008             p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1009             break;
1010         case FF_B_TYPE:
1011             p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1012             break;
1013         }
1014
1015         return p_block;
1016     }
1017
1018     return NULL;
1019 }
1020
1021 /****************************************************************************
1022  * EncodeAudio: the whole thing
1023  ****************************************************************************/
1024 static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
1025 {
1026     encoder_sys_t *p_sys = p_enc->p_sys;
1027     block_t *p_block, *p_chain = NULL;
1028
1029     uint8_t *p_buffer = p_aout_buf->p_buffer;
1030     int i_samples = p_aout_buf->i_nb_samples;
1031     int i_samples_delay = p_sys->i_samples_delay;
1032
1033     p_sys->i_pts = p_aout_buf->start_date -
1034                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1035                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1036
1037     p_sys->i_samples_delay += i_samples;
1038
1039     while( p_sys->i_samples_delay >= p_sys->p_context->frame_size )
1040     {
1041         int16_t *p_samples;
1042         int i_out;
1043
1044         if( i_samples_delay )
1045         {
1046             /* Take care of the left-over from last time */
1047             int i_delay_size = i_samples_delay * 2 *
1048                                  p_sys->p_context->channels;
1049             int i_size = p_sys->i_frame_size - i_delay_size;
1050
1051             p_samples = (int16_t *)p_sys->p_buffer;
1052             memcpy( p_sys->p_buffer + i_delay_size, p_buffer, i_size );
1053             p_buffer -= i_delay_size;
1054             i_samples += i_samples_delay;
1055             i_samples_delay = 0;
1056         }
1057         else
1058         {
1059             p_samples = (int16_t *)p_buffer;
1060         }
1061
1062         i_out = avcodec_encode_audio( p_sys->p_context, p_sys->p_buffer_out,
1063                                       p_sys->i_buffer_out, p_samples );
1064
1065 #if 0
1066         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1067 #endif
1068         if( i_out < 0 ) break;
1069
1070         p_buffer += p_sys->i_frame_size;
1071         p_sys->i_samples_delay -= p_sys->p_context->frame_size;
1072         i_samples -= p_sys->p_context->frame_size;
1073
1074         if( i_out == 0 ) continue;
1075
1076         p_block = block_New( p_enc, i_out );
1077         memcpy( p_block->p_buffer, p_sys->p_buffer_out, i_out );
1078
1079         p_block->i_length = (mtime_t)1000000 *
1080             (mtime_t)p_sys->p_context->frame_size /
1081             (mtime_t)p_sys->p_context->sample_rate;
1082
1083         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1084
1085         /* Update pts */
1086         p_sys->i_pts += p_block->i_length;
1087         block_ChainAppend( &p_chain, p_block );
1088     }
1089
1090     /* Backup the remaining raw samples */
1091     if( i_samples )
1092     {
1093         memcpy( p_sys->p_buffer + i_samples_delay * 2 *
1094                 p_sys->p_context->channels, p_buffer,
1095                 i_samples * 2 * p_sys->p_context->channels );
1096     }
1097
1098     return p_chain;
1099 }
1100
1101 /*****************************************************************************
1102  * CloseEncoder: ffmpeg encoder destruction
1103  *****************************************************************************/
1104 void CloseEncoder( vlc_object_t *p_this )
1105 {
1106     encoder_t *p_enc = (encoder_t *)p_this;
1107     encoder_sys_t *p_sys = p_enc->p_sys;
1108
1109     if ( p_sys->b_inited && p_enc->i_threads >= 1 )
1110     {
1111         int i;
1112         struct thread_context_t ** pp_contexts =
1113                 (struct thread_context_t **)p_sys->p_context->thread_opaque;
1114         for ( i = 0; i < p_enc->i_threads; i++ )
1115         {
1116             vlc_object_kill( pp_contexts[i] );
1117             vlc_cond_signal( &pp_contexts[i]->cond );
1118             vlc_thread_join( pp_contexts[i] );
1119             vlc_mutex_destroy( &pp_contexts[i]->lock );
1120             vlc_cond_destroy( &pp_contexts[i]->cond );
1121             vlc_object_release( pp_contexts[i] );
1122         }
1123
1124         free( pp_contexts );
1125     }
1126
1127     vlc_mutex_lock( &avcodec_lock );
1128     avcodec_close( p_sys->p_context );
1129     vlc_mutex_unlock( &avcodec_lock );
1130     av_free( p_sys->p_context );
1131
1132     free( p_sys->p_buffer );
1133     free( p_sys->p_buffer_out );
1134
1135     free( p_sys );
1136 }