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