git.sesse.net Git - vlc/blob - modules/codec/avcodec/encoder.c

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