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