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