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