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_FOURCC('m', 'p', '2', 'v') ||
 457                p_enc->fmt_out.i_codec == VLC_FOURCC('m', 'p', '1', 'v') ) )
 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_FOURCC('I','4','2','0');
 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  = AOUT_FMT_S16_NE;
 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_FOURCC('m','p','4','a') )
 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_FOURCC( 'm', 'p', '4', 'v' ) )
 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 }