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