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

   1 /*****************************************************************************
   2  * encoder.c: video and audio encoder using the libavcodec library
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Christophe Massiot <massiot@via.ecp.fr>
  10  * Part of the file Copyright (C) FFmpeg Project Developers
  11  * (mpeg4_default matrixes)
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 /*****************************************************************************
  29  * Preamble
  30  *****************************************************************************/
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34
  35 #include <vlc_common.h>
  36 #include <vlc_aout.h>
  37 #include <vlc_sout.h>
  38 #include <vlc_codec.h>
  39 #include <vlc_dialog.h>
  40 #include <vlc_avcodec.h>
  41 #include <vlc_cpu.h>
  42
  43 #define HAVE_MMX 1
  44 #include <libavcodec/avcodec.h>
  45
  46 #include "avcodec.h"
  47 #include "avcommon.h"
  48
  49 #define HURRY_UP_GUARD1 (450000)
  50 #define HURRY_UP_GUARD2 (300000)
  51 #define HURRY_UP_GUARD3 (100000)
  52
  53 #define MAX_FRAME_DELAY (FF_MAX_B_FRAMES + 2)
  54
  55 #define RAW_AUDIO_FRAME_SIZE (2048)
  56
  57 /*****************************************************************************
  58  * Local prototypes
  59  *****************************************************************************/
  60 int  OpenEncoder ( vlc_object_t * );
  61 void CloseEncoder( vlc_object_t * );
  62
  63 static block_t *EncodeVideo( encoder_t *, picture_t * );
  64 static block_t *EncodeAudio( encoder_t *, block_t * );
  65
  66 struct thread_context_t;
  67
  68 /*****************************************************************************
  69  * thread_context_t : for multithreaded encoding
  70  *****************************************************************************/
  71 struct thread_context_t
  72 {
  73     VLC_COMMON_MEMBERS
  74
  75     AVCodecContext  *p_context;
  76     int             (* pf_func)(AVCodecContext *c, void *arg);
  77     void            *arg;
  78     int             i_ret;
  79
  80     vlc_mutex_t     lock;
  81     vlc_cond_t      cond;
  82     bool            b_work, b_done;
  83 };
  84
  85 /*****************************************************************************
  86  * encoder_sys_t : libavcodec encoder descriptor
  87  *****************************************************************************/
  88 struct encoder_sys_t
  89 {
  90     /*
  91      * libavcodec properties
  92      */
  93     AVCodec         *p_codec;
  94     AVCodecContext  *p_context;
  95
  96     /*
  97      * Common properties
  98      */
  99     char *p_buffer;
 100     size_t i_buffer_out;
 101
 102     /*
 103      * Video properties
 104      */
 105     mtime_t i_last_ref_pts;
 106     mtime_t i_buggy_pts_detect;
 107     mtime_t i_last_pts;
 108     bool    b_inited;
 109
 110     /*
 111      * Audio properties
 112      */
 113     int i_sample_bytes;
 114     int i_frame_size;
 115     int i_samples_delay;
 116     mtime_t i_pts;
 117
 118     /* Encoding settings */
 119     int        i_key_int;
 120     int        i_b_frames;
 121     int        i_vtolerance;
 122     int        i_qmin;
 123     int        i_qmax;
 124     int        i_hq;
 125     int        i_rc_buffer_size;
 126     float      f_rc_buffer_aggressivity;
 127     bool       b_pre_me;
 128     bool       b_hurry_up;
 129     bool       b_interlace, b_interlace_me;
 130     float      f_i_quant_factor;
 131     int        i_noise_reduction;
 132     bool       b_mpeg4_matrix;
 133     bool       b_trellis;
 134     int        i_quality; /* for VBR */
 135     float      f_lumi_masking, f_dark_masking, f_p_masking, f_border_masking;
 136     int        i_luma_elim, i_chroma_elim;
 137     int        i_aac_profile; /* AAC profile to use.*/
 138 };
 139
 140 static const char *const ppsz_enc_options[] = {
 141     "keyint", "bframes", "vt", "qmin", "qmax", "codec", "hq",
 142     "rc-buffer-size", "rc-buffer-aggressivity", "pre-me", "hurry-up",
 143     "interlace", "interlace-me", "i-quant-factor", "noise-reduction", "mpeg4-matrix",
 144     "trellis", "qscale", "strict", "lumi-masking", "dark-masking",
 145     "p-masking", "border-masking", "luma-elim-threshold",
 146     "chroma-elim-threshold",
 147      "aac-profile",
 148      NULL
 149 };
 150
 151 static const uint16_t mpa_bitrate_tab[2][15] =
 152 {
 153     {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
 154     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
 155 };
 156
 157 static const uint16_t mpa_freq_tab[6] =
 158 { 44100, 48000, 32000, 22050, 24000, 16000 };
 159
 160 static const uint16_t mpeg4_default_intra_matrix[64] = {
 161   8, 17, 18, 19, 21, 23, 25, 27,
 162  17, 18, 19, 21, 23, 25, 27, 28,
 163  20, 21, 22, 23, 24, 26, 28, 30,
 164  21, 22, 23, 24, 26, 28, 30, 32,
 165  22, 23, 24, 26, 28, 30, 32, 35,
 166  23, 24, 26, 28, 30, 32, 35, 38,
 167  25, 26, 28, 30, 32, 35, 38, 41,
 168  27, 28, 30, 32, 35, 38, 41, 45,
 169 };
 170
 171 static const uint16_t mpeg4_default_non_intra_matrix[64] = {
 172  16, 17, 18, 19, 20, 21, 22, 23,
 173  17, 18, 19, 20, 21, 22, 23, 24,
 174  18, 19, 20, 21, 22, 23, 24, 25,
 175  19, 20, 21, 22, 23, 24, 26, 27,
 176  20, 21, 22, 23, 25, 26, 27, 28,
 177  21, 22, 23, 24, 26, 27, 28, 30,
 178  22, 23, 24, 26, 27, 28, 30, 31,
 179  23, 24, 25, 27, 28, 30, 31, 33,
 180 };
 181
 182 /*****************************************************************************
 183  * OpenEncoder: probe the encoder
 184  *****************************************************************************/
 185
 186 int OpenEncoder( vlc_object_t *p_this )
 187 {
 188     encoder_t *p_enc = (encoder_t *)p_this;
 189     encoder_sys_t *p_sys;
 190     AVCodecContext *p_context;
 191     AVCodec *p_codec = NULL;
 192     int i_codec_id, i_cat;
 193     const char *psz_namecodec;
 194     float f_val;
 195     char *psz_val;
 196
 197     /* Initialization must be done before avcodec_find_encoder() */
 198     vlc_init_avcodec();
 199
 200     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
 201
 202     if( p_enc->fmt_out.i_codec == VLC_CODEC_MP3 )
 203     {
 204         i_cat = AUDIO_ES;
 205         i_codec_id = CODEC_ID_MP3;
 206         psz_namecodec = "MPEG I/II Layer 3";
 207     }
 208     else if( p_enc->fmt_out.i_codec == VLC_CODEC_MP2 )
 209     {
 210         i_cat = AUDIO_ES;
 211         i_codec_id = CODEC_ID_MP2;
 212         psz_namecodec = "MPEG I/II Layer 2";
 213     }
 214     else if( p_enc->fmt_out.i_codec == VLC_CODEC_MP1V )
 215     {
 216         i_cat = VIDEO_ES;
 217         i_codec_id = CODEC_ID_MPEG1VIDEO;
 218         psz_namecodec = "MPEG-1 video";
 219     }
 220     else if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
 221                              &psz_namecodec ) )
 222     {
 223         if( TestFfmpegChroma( -1, p_enc->fmt_out.i_codec ) != VLC_SUCCESS )
 224         {
 225             /* handed chroma output */
 226             return VLC_EGENERIC;
 227         }
 228         i_cat      = VIDEO_ES;
 229         i_codec_id = CODEC_ID_RAWVIDEO;
 230         psz_namecodec = "Raw video";
 231     }
 232
 233     if( p_enc->fmt_out.i_cat == VIDEO_ES && i_cat != VIDEO_ES )
 234     {
 235         msg_Err( p_enc, "\"%s\" is not a video encoder", psz_namecodec );
 236         dialog_Fatal( p_enc, _("Streaming / Transcoding failed"),
 237                         _("\"%s\" is no video encoder."), psz_namecodec );
 238         return VLC_EGENERIC;
 239     }
 240
 241     if( p_enc->fmt_out.i_cat == AUDIO_ES && i_cat != AUDIO_ES )
 242     {
 243         msg_Err( p_enc, "\"%s\" is not an audio encoder", psz_namecodec );
 244         dialog_Fatal( p_enc, _("Streaming / Transcoding failed"),
 245                         _("\"%s\" is no audio encoder."), psz_namecodec );
 246         return VLC_EGENERIC;
 247     }
 248
 249     if( p_enc->fmt_out.i_cat == SPU_ES )
 250     {
 251         /* We don't support subtitle encoding */
 252         return VLC_EGENERIC;
 253     }
 254
 255     char *psz_encoder = var_GetString( p_this, ENC_CFG_PREFIX "codec" );
 256     if( psz_encoder && *psz_encoder )
 257     {
 258         p_codec = avcodec_find_encoder_by_name( psz_encoder );
 259         if( !p_codec )
 260             msg_Err( p_this, "Encoder `%s' not found", psz_encoder );
 261         else if( p_codec->id != i_codec_id )
 262         {
 263             msg_Err( p_this, "Encoder `%s' can't handle %4.4s",
 264                     psz_encoder, (char*)&p_enc->fmt_out.i_codec );
 265             p_codec = NULL;
 266         }
 267     }
 268     free( psz_encoder );
 269     if( !p_codec )
 270         p_codec = avcodec_find_encoder( i_codec_id );
 271     if( !p_codec )
 272     {
 273         msg_Err( p_enc, "cannot find encoder %s\n"
 274 "*** Your Libav/FFmpeg installation is crippled.   ***\n"
 275 "*** Please check with your Libav/FFmpeg packager. ***\n"
 276 "*** This is NOT a VLC media player issue.   ***", psz_namecodec );
 277
 278         dialog_Fatal( p_enc, _("Streaming / Transcoding failed"), _(
 279 /* I have had enough of all these MPEG-3 transcoding bug reports.
 280  * Downstream packager, you had better not patch this out, or I will be really
 281  * annoyed. Think about it - you don't want to fork the VLC translation files,
 282  * do you? -- Courmisch, 2008-10-22 */
 283 "It seems your Libav/FFmpeg (libavcodec) installation lacks the following encoder:\n"
 284 "%s.\n"
 285 "If you don't know how to fix this, ask for support from your distribution.\n"
 286 "\n"
 287 "This is not an error inside VLC media player.\n"
 288 "Do not contact the VideoLAN project about this issue.\n"),
 289             psz_namecodec );
 290         return VLC_EGENERIC;
 291     }
 292
 293     /* Allocate the memory needed to store the encoder's structure */
 294     if( ( p_sys = calloc( 1, sizeof(encoder_sys_t) ) ) == NULL )
 295         return VLC_ENOMEM;
 296     p_enc->p_sys = p_sys;
 297     p_sys->p_codec = p_codec;
 298
 299     p_enc->pf_encode_video = EncodeVideo;
 300     p_enc->pf_encode_audio = EncodeAudio;
 301
 302     p_sys->p_buffer = NULL;
 303     p_sys->i_buffer_out = 0;
 304
 305 #if LIBAVCODEC_VERSION_MAJOR < 54
 306     p_context = avcodec_alloc_context();
 307 #else
 308     p_context = avcodec_alloc_context3(p_codec);
 309 #endif
 310     p_sys->p_context = p_context;
 311     p_sys->p_context->codec_id = p_sys->p_codec->id;
 312     p_context->debug = var_InheritInteger( p_enc, "avcodec-debug" );
 313     p_context->opaque = (void *)p_this;
 314
 315     /* set CPU capabilities */
 316 #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT( 51, 25, 0 )
 317     av_set_cpu_flags_mask( INT_MAX & ~GetVlcDspMask() );
 318 #else
 319     p_context->dsp_mask = GetVlcDspMask();
 320 #endif
 321
 322     p_sys->i_key_int = var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" );
 323     p_sys->i_b_frames = var_GetInteger( p_enc, ENC_CFG_PREFIX "bframes" );
 324     p_sys->i_vtolerance = var_GetInteger( p_enc, ENC_CFG_PREFIX "vt" ) * 1000;
 325     p_sys->b_interlace = var_GetBool( p_enc, ENC_CFG_PREFIX "interlace" );
 326     p_sys->b_interlace_me = var_GetBool( p_enc, ENC_CFG_PREFIX "interlace-me" );
 327     p_sys->b_pre_me = var_GetBool( p_enc, ENC_CFG_PREFIX "pre-me" );
 328     p_sys->b_hurry_up = var_GetBool( p_enc, ENC_CFG_PREFIX "hurry-up" );
 329
 330     if( p_sys->b_hurry_up )
 331     {
 332         /* hurry up mode needs noise reduction, even small */
 333         p_sys->i_noise_reduction = 1;
 334     }
 335
 336     p_sys->i_rc_buffer_size = var_GetInteger( p_enc, ENC_CFG_PREFIX "rc-buffer-size" );
 337     p_sys->f_rc_buffer_aggressivity = var_GetFloat( p_enc, ENC_CFG_PREFIX "rc-buffer-aggressivity" );
 338     p_sys->f_i_quant_factor = var_GetFloat( p_enc, ENC_CFG_PREFIX "i-quant-factor" );
 339     p_sys->i_noise_reduction = var_GetInteger( p_enc, ENC_CFG_PREFIX "noise-reduction" );
 340     p_sys->b_mpeg4_matrix = var_GetBool( p_enc, ENC_CFG_PREFIX "mpeg4-matrix" );
 341
 342     f_val = var_GetFloat( p_enc, ENC_CFG_PREFIX "qscale" );
 343     if( f_val < 0.01 || f_val > 255.0 ) f_val = 0;
 344     p_sys->i_quality = (int)(FF_QP2LAMBDA * f_val + 0.5);
 345
 346     psz_val = var_GetString( p_enc, ENC_CFG_PREFIX "hq" );
 347     p_sys->i_hq = FF_MB_DECISION_RD;
 348     if( psz_val && *psz_val )
 349     {
 350         if( !strcmp( psz_val, "rd" ) )
 351             p_sys->i_hq = FF_MB_DECISION_RD;
 352         else if( !strcmp( psz_val, "bits" ) )
 353             p_sys->i_hq = FF_MB_DECISION_BITS;
 354         else if( !strcmp( psz_val, "simple" ) )
 355             p_sys->i_hq = FF_MB_DECISION_SIMPLE;
 356         else
 357             p_sys->i_hq = FF_MB_DECISION_RD;
 358     }
 359     else
 360         p_sys->i_hq = FF_MB_DECISION_RD;
 361     free( psz_val );
 362
 363     p_sys->i_qmin = var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" );
 364     p_sys->i_qmax = var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" );
 365     p_sys->b_trellis = var_GetBool( p_enc, ENC_CFG_PREFIX "trellis" );
 366
 367     p_context->strict_std_compliance = var_GetInteger( p_enc, ENC_CFG_PREFIX "strict" );
 368
 369     p_sys->f_lumi_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "lumi-masking" );
 370     p_sys->f_dark_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "dark-masking" );
 371     p_sys->f_p_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "p-masking" );
 372     p_sys->f_border_masking = var_GetFloat( p_enc, ENC_CFG_PREFIX "border-masking" );
 373     p_sys->i_luma_elim = var_GetInteger( p_enc, ENC_CFG_PREFIX "luma-elim-threshold" );
 374     p_sys->i_chroma_elim = var_GetInteger( p_enc, ENC_CFG_PREFIX "chroma-elim-threshold" );
 375
 376     psz_val = var_GetString( p_enc, ENC_CFG_PREFIX "aac-profile" );
 377     /* libavcodec uses faac encoder atm, and it has issues with
 378      * other than low-complexity profile, so default to that */
 379     p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
 380     if( psz_val && *psz_val )
 381     {
 382         if( !strncmp( psz_val, "main", 4 ) )
 383             p_sys->i_aac_profile = FF_PROFILE_AAC_MAIN;
 384         else if( !strncmp( psz_val, "low", 3 ) )
 385             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
 386 #if 0    /* Not supported by FAAC encoder */
 387         else if( !strncmp( psz_val, "ssr", 3 ) )
 388             p_sys->i_aac_profile = FF_PROFILE_AAC_SSR;
 389 #endif
 390         else if( !strncmp( psz_val, "ltp", 3 ) )
 391             p_sys->i_aac_profile = FF_PROFILE_AAC_LTP;
 392 #if LIBAVCODEC_VERSION_CHECK( 54, 19, 0, 35, 100 )
 393 /* These require libavcodec with libfdk-aac */
 394         else if( !strncmp( psz_val, "hev2", 4 ) )
 395             p_sys->i_aac_profile = FF_PROFILE_AAC_HE_V2;
 396         else if( !strncmp( psz_val, "hev1", 4 ) )
 397             p_sys->i_aac_profile = FF_PROFILE_AAC_HE;
 398 #endif
 399         else
 400         {
 401             msg_Warn( p_enc, "unknown AAC profile requested, setting it to low" );
 402             p_sys->i_aac_profile = FF_PROFILE_AAC_LOW;
 403         }
 404     }
 405     free( psz_val );
 406
 407     if( p_enc->fmt_in.i_cat == VIDEO_ES )
 408     {
 409         if( !p_enc->fmt_in.video.i_width || !p_enc->fmt_in.video.i_height )
 410         {
 411             msg_Warn( p_enc, "invalid size %ix%i", p_enc->fmt_in.video.i_width,
 412                       p_enc->fmt_in.video.i_height );
 413             free( p_sys );
 414             return VLC_EGENERIC;
 415         }
 416
 417         p_context->codec_type = AVMEDIA_TYPE_VIDEO;
 418
 419         p_context->width = p_enc->fmt_in.video.i_width;
 420         p_context->height = p_enc->fmt_in.video.i_height;
 421
 422         p_context->time_base.num = p_enc->fmt_in.video.i_frame_rate_base;
 423         p_context->time_base.den = p_enc->fmt_in.video.i_frame_rate;
 424         if( p_codec->supported_framerates )
 425         {
 426             AVRational target = {
 427                 .num = p_enc->fmt_in.video.i_frame_rate,
 428                 .den = p_enc->fmt_in.video.i_frame_rate_base,
 429             };
 430             int idx = av_find_nearest_q_idx(target, p_codec->supported_framerates);
 431
 432             p_context->time_base.num = p_codec->supported_framerates[idx].den;
 433             p_context->time_base.den = p_codec->supported_framerates[idx].num;
 434         }
 435
 436         /* Defaults from ffmpeg.c */
 437         p_context->qblur = 0.5;
 438         p_context->qcompress = 0.5;
 439         p_context->b_quant_offset = 1.25;
 440         p_context->b_quant_factor = 1.25;
 441         p_context->i_quant_offset = 0.0;
 442         p_context->i_quant_factor = -0.8;
 443
 444         p_context->lumi_masking = p_sys->f_lumi_masking;
 445         p_context->dark_masking = p_sys->f_dark_masking;
 446         p_context->p_masking = p_sys->f_p_masking;
 447         p_context->border_masking = p_sys->f_border_masking;
 448         p_context->luma_elim_threshold = p_sys->i_luma_elim;
 449         p_context->chroma_elim_threshold = p_sys->i_chroma_elim;
 450
 451         if( p_sys->i_key_int > 0 )
 452             p_context->gop_size = p_sys->i_key_int;
 453         p_context->max_b_frames =
 454             VLC_CLIP( p_sys->i_b_frames, 0, FF_MAX_B_FRAMES );
 455         p_context->b_frame_strategy = 0;
 456         if( !p_context->max_b_frames  &&
 457             (  p_enc->fmt_out.i_codec == VLC_CODEC_MPGV ||
 458                p_enc->fmt_out.i_codec == VLC_CODEC_MP2V ) )
 459             p_context->flags |= CODEC_FLAG_LOW_DELAY;
 460
 461         av_reduce( &p_context->sample_aspect_ratio.num,
 462                    &p_context->sample_aspect_ratio.den,
 463                    p_enc->fmt_in.video.i_sar_num,
 464                    p_enc->fmt_in.video.i_sar_den, 1 << 30 );
 465
 466
 467         p_enc->fmt_in.i_codec = VLC_CODEC_I420;
 468         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
 469         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 470
 471         if( p_codec->pix_fmts )
 472         {
 473             const enum PixelFormat *p = p_codec->pix_fmts;
 474             for( ; *p != -1; p++ )
 475             {
 476                 if( *p == p_context->pix_fmt ) break;
 477             }
 478             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
 479             GetVlcChroma( &p_enc->fmt_in.video, p_context->pix_fmt );
 480             p_enc->fmt_in.i_codec = p_enc->fmt_in.video.i_chroma;
 481         }
 482
 483
 484         if ( p_sys->f_i_quant_factor != 0.0 )
 485             p_context->i_quant_factor = p_sys->f_i_quant_factor;
 486
 487         p_context->noise_reduction = p_sys->i_noise_reduction;
 488
 489         if ( p_sys->b_mpeg4_matrix )
 490         {
 491             p_context->intra_matrix = mpeg4_default_intra_matrix;
 492             p_context->inter_matrix = mpeg4_default_non_intra_matrix;
 493         }
 494
 495         if ( p_sys->b_pre_me )
 496         {
 497             p_context->pre_me = 1;
 498             p_context->me_pre_cmp = FF_CMP_CHROMA;
 499         }
 500
 501         if ( p_sys->b_interlace )
 502         {
 503             if ( p_context->height <= 280 )
 504             {
 505                 if ( p_context->height != 16 || p_context->width != 16 )
 506                     msg_Warn( p_enc,
 507                         "disabling interlaced video because height=%d <= 280",
 508                         p_context->height );
 509             }
 510             else
 511             {
 512                 p_context->flags |= CODEC_FLAG_INTERLACED_DCT;
 513                 if ( p_sys->b_interlace_me )
 514                     p_context->flags |= CODEC_FLAG_INTERLACED_ME;
 515             }
 516         }
 517
 518         p_context->trellis = p_sys->b_trellis;
 519
 520         if ( p_sys->i_qmin > 0 && p_sys->i_qmin == p_sys->i_qmax )
 521             p_context->flags |= CODEC_FLAG_QSCALE;
 522         /* These codecs cause libavcodec to exit if thread_count is > 1.
 523            See libavcodec/mpegvideo_enc.c:MPV_encode_init and
 524            libavcodec/svq3.c , WMV2 calls MPV_encode_init also.
 525          */
 526         if ( i_codec_id == CODEC_ID_FLV1 ||
 527              i_codec_id == CODEC_ID_H261 ||
 528              i_codec_id == CODEC_ID_LJPEG ||
 529              i_codec_id == CODEC_ID_MJPEG ||
 530              i_codec_id == CODEC_ID_H263 ||
 531              i_codec_id == CODEC_ID_H263P ||
 532              i_codec_id == CODEC_ID_MSMPEG4V1 ||
 533              i_codec_id == CODEC_ID_MSMPEG4V2 ||
 534              i_codec_id == CODEC_ID_MSMPEG4V3 ||
 535              i_codec_id == CODEC_ID_WMV1 ||
 536              i_codec_id == CODEC_ID_WMV2 ||
 537              i_codec_id == CODEC_ID_RV10 ||
 538              i_codec_id == CODEC_ID_RV20 ||
 539              i_codec_id == CODEC_ID_SVQ3 )
 540             p_enc->i_threads = 1;
 541
 542         if( p_sys->i_vtolerance > 0 )
 543             p_context->bit_rate_tolerance = p_sys->i_vtolerance;
 544
 545         /* usually if someone sets bitrate, he likes more to get that bitrate
 546          * over quality should help 'normal' user to get asked bitrate
 547          */
 548         if( p_enc->fmt_out.i_bitrate > 0 && p_sys->i_qmax == 0 && p_sys->i_qmin == 0 )
 549         {
 550             p_sys->i_qmax = 51;
 551             p_sys->i_qmin = 3;
 552         }
 553
 554         if( p_sys->i_qmin > 0 )
 555         {
 556             p_context->qmin = p_sys->i_qmin;
 557             p_context->mb_lmin = p_context->lmin = p_sys->i_qmin * FF_QP2LAMBDA;
 558         }
 559         if( p_sys->i_qmax > 0 )
 560         {
 561             p_context->qmax = p_sys->i_qmax;
 562             p_context->mb_lmax = p_context->lmax = p_sys->i_qmax * FF_QP2LAMBDA;
 563         }
 564         p_context->max_qdiff = 3;
 565
 566         p_context->mb_decision = p_sys->i_hq;
 567
 568         if( p_sys->i_quality )
 569         {
 570             p_context->flags |= CODEC_FLAG_QSCALE;
 571             p_context->global_quality = p_sys->i_quality;
 572         }
 573         else
 574         {
 575             p_context->rc_qsquish = 1.0;
 576             p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
 577             p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
 578             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
 579             /* This is from ffmpeg's ffmpeg.c : */
 580             p_context->rc_initial_buffer_occupancy
 581                 = p_sys->i_rc_buffer_size * 3/4;
 582             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
 583         }
 584     }
 585     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
 586     {
 587         /* work around bug in libmp3lame encoding */
 588         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
 589             p_enc->fmt_in.audio.i_channels = 2;
 590
 591         p_context->codec_type  = AVMEDIA_TYPE_AUDIO;
 592         p_context->sample_fmt  = p_codec->sample_fmts ?
 593                                     p_codec->sample_fmts[0] :
 594                                     AV_SAMPLE_FMT_S16;
 595         p_enc->fmt_in.i_codec  = VLC_CODEC_S16N;
 596         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
 597         p_context->time_base.num = 1;
 598         p_context->time_base.den = p_context->sample_rate;
 599         p_context->channels    = p_enc->fmt_out.audio.i_channels;
 600
 601         if ( p_enc->fmt_out.i_codec == VLC_CODEC_MP4A )
 602         {
 603             /* XXX: FAAC does resample only when setting the INPUT samplerate
 604              * to the desired value (-R option of the faac frontend)
 605             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
 606             /* vlc should default to low-complexity profile, faac encoder
 607              * has bug and aac audio has issues otherwise atm */
 608             p_context->profile = p_sys->i_aac_profile;
 609         }
 610     }
 611
 612     /* Misc parameters */
 613     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 614
 615 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT( 52, 69, 2 )
 616     /* Set reasonable defaults to VP8, based on
 617        libvpx-720p preset from libvpx ffmpeg-patch */
 618     if( i_codec_id == CODEC_ID_VP8 )
 619     {
 620         /* Lets give bitrate tolerance */
 621         p_context->bit_rate_tolerance = __MAX(2 * (int)p_enc->fmt_out.i_bitrate, p_sys->i_vtolerance );
 622         /* default to 120 frames between keyframe */
 623         if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" ) )
 624             p_context->gop_size = 120;
 625         /* Don't set rc-values atm, they were from time before
 626            libvpx was officially in FFmpeg */
 627         //p_context->rc_max_rate = 24 * 1000 * 1000; //24M
 628         //p_context->rc_min_rate = 40 * 1000; // 40k
 629         /* seems that FFmpeg presets have 720p as divider for buffers */
 630         if( p_enc->fmt_out.video.i_height >= 720 )
 631         {
 632             /* Check that we don't overrun users qmin/qmax values */
 633             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
 634             {
 635                 p_context->qmin = 10;
 636                 p_context->mb_lmin = p_context->lmin = 10 * FF_QP2LAMBDA;
 637             }
 638
 639             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" ) )
 640             {
 641                 p_context->qmax = 42;
 642                 p_context->mb_lmax = p_context->lmax = 42 * FF_QP2LAMBDA;
 643             }
 644
 645             } else {
 646             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
 647             {
 648                 p_context->qmin = 1;
 649                 p_context->mb_lmin = p_context->lmin = FF_QP2LAMBDA;
 650             }
 651         }
 652
 653
 654 #if 0 /* enable when/if vp8 encoder is accepted in libavcodec */
 655         p_context->lag = 16;
 656         p_context->level = 216;
 657         p_context->profile = 0;
 658         p_context->rc_buffer_aggressivity = 0.95;
 659         p_context->token_partitions = 4;
 660         p_context->mb_static_threshold = 0;
 661 #endif
 662     }
 663 #endif
 664
 665     if( i_codec_id == CODEC_ID_RAWVIDEO )
 666     {
 667         /* XXX: hack: Force same codec (will be handled by transcode) */
 668         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 669         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 670     }
 671
 672     /* Make sure we get extradata filled by the encoder */
 673     p_context->extradata_size = 0;
 674     p_context->extradata = NULL;
 675     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 676
 677     if( p_enc->i_threads >= 1)
 678         p_context->thread_count = p_enc->i_threads;
 679     else
 680         p_context->thread_count = vlc_GetCPUCount();
 681
 682     int ret;
 683     vlc_avcodec_lock();
 684 #if LIBAVCODEC_VERSION_MAJOR < 54
 685     ret = avcodec_open( p_context, p_codec );
 686 #else
 687     ret = avcodec_open2( p_context, p_codec, NULL /* options */ );
 688 #endif
 689     vlc_avcodec_unlock();
 690     if( ret )
 691     {
 692         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
 693              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
 694                || i_codec_id == CODEC_ID_MP3) )
 695         {
 696             if( p_context->channels > 2 )
 697             {
 698                 p_context->channels = 2;
 699                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
 700                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 701             }
 702
 703             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
 704             {
 705                 int i_frequency, i;
 706
 707                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 708                 {
 709                     if ( p_enc->fmt_out.audio.i_rate
 710                             == mpa_freq_tab[i_frequency] )
 711                         break;
 712                 }
 713                 if ( i_frequency == 6 )
 714                 {
 715                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 716                              p_enc->fmt_out.audio.i_rate );
 717                     free( p_sys );
 718                     return VLC_EGENERIC;
 719                 }
 720
 721                 for ( i = 1; i < 14; i++ )
 722                 {
 723                     if ( p_enc->fmt_out.i_bitrate / 1000
 724                           <= mpa_bitrate_tab[i_frequency / 3][i] )
 725                         break;
 726                 }
 727                 if ( p_enc->fmt_out.i_bitrate / 1000
 728                       != mpa_bitrate_tab[i_frequency / 3][i] )
 729                 {
 730                     msg_Warn( p_enc,
 731                               "MPEG audio doesn't support bitrate=%d, using %d",
 732                               p_enc->fmt_out.i_bitrate,
 733                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 734                     p_enc->fmt_out.i_bitrate =
 735                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 736                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 737                 }
 738             }
 739
 740             p_context->codec = NULL;
 741             vlc_avcodec_lock();
 742 #if LIBAVCODEC_VERSION_MAJOR < 54
 743             ret = avcodec_open( p_context, p_codec );
 744 #else
 745             ret = avcodec_open2( p_context, p_codec, NULL /* options */ );
 746 #endif
 747             vlc_avcodec_unlock();
 748             if( ret )
 749             {
 750                 msg_Err( p_enc, "cannot open encoder" );
 751                 dialog_Fatal( p_enc,
 752                                 _("Streaming / Transcoding failed"),
 753                                 "%s", _("VLC could not open the encoder.") );
 754                 free( p_sys );
 755                 return VLC_EGENERIC;
 756             }
 757         }
 758         else
 759         {
 760             msg_Err( p_enc, "cannot open encoder" );
 761             dialog_Fatal( p_enc, _("Streaming / Transcoding failed"),
 762                             "%s", _("VLC could not open the encoder.") );
 763             free( p_sys );
 764             return VLC_EGENERIC;
 765         }
 766     }
 767
 768     if( i_codec_id == CODEC_ID_FLAC )
 769     {
 770         p_enc->fmt_out.i_extra = 4 + 1 + 3 + p_context->extradata_size;
 771         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 772         if( p_enc->fmt_out.p_extra )
 773         {
 774             uint8_t *p = p_enc->fmt_out.p_extra;
 775             p[0] = 0x66;    /* f */
 776             p[1] = 0x4C;    /* L */
 777             p[2] = 0x61;    /* a */
 778             p[3] = 0x43;    /* C */
 779             p[4] = 0x80;    /* streaminfo block, last block before audio */
 780             p[5] = ( p_context->extradata_size >> 16 ) & 0xff;
 781             p[6] = ( p_context->extradata_size >>  8 ) & 0xff;
 782             p[7] = ( p_context->extradata_size       ) & 0xff;
 783             memcpy( &p[8], p_context->extradata, p_context->extradata_size );
 784         }
 785         else
 786         {
 787             p_enc->fmt_out.i_extra = 0;
 788         }
 789     }
 790     else
 791     {
 792         p_enc->fmt_out.i_extra = p_context->extradata_size;
 793         if( p_enc->fmt_out.i_extra )
 794         {
 795             p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 796             if ( p_enc->fmt_out.p_extra == NULL )
 797             {
 798                 goto error;
 799             }
 800             memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 801                     p_enc->fmt_out.i_extra );
 802         }
 803     }
 804
 805     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 806
 807     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 808     {
 809         GetVlcAudioFormat( &p_enc->fmt_in.i_codec,
 810                            &p_enc->fmt_in.audio.i_bitspersample,
 811                            p_sys->p_context->sample_fmt );
 812         p_sys->i_sample_bytes = (p_enc->fmt_in.audio.i_bitspersample / 8) *
 813                                 p_context->channels;
 814         p_sys->i_frame_size = p_context->frame_size > 1 ?
 815                                     p_context->frame_size :
 816                                     RAW_AUDIO_FRAME_SIZE;
 817         p_sys->p_buffer = malloc( p_sys->i_frame_size * p_sys->i_sample_bytes );
 818         if ( p_sys->p_buffer == NULL )
 819         {
 820             goto error;
 821         }
 822         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 823         p_enc->fmt_out.audio.i_bitspersample = aout_BitsPerSample( vlc_fourcc_GetCodec( AUDIO_ES, p_enc->fmt_out.i_codec ) );
 824
 825         if( p_context->frame_size > 1 )
 826             p_sys->i_buffer_out = 8 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
 827         else
 828             p_sys->i_buffer_out = p_sys->i_frame_size * p_sys->i_sample_bytes;
 829     }
 830
 831     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 832
 833     return VLC_SUCCESS;
 834 error:
 835     free( p_enc->fmt_out.p_extra );
 836     free( p_sys->p_buffer );
 837     free( p_sys );
 838     return VLC_ENOMEM;
 839 }
 840
 841 /****************************************************************************
 842  * EncodeVideo: the whole thing
 843  ****************************************************************************/
 844 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 845 {
 846     encoder_sys_t *p_sys = p_enc->p_sys;
 847     int i_out, i_plane;
 848
 849     /* Initialize the video output buffer the first time.
 850      * This is done here instead of OpenEncoder() because we need the actual
 851      * bits_per_pixel value, without having to assume anything.
 852      */
 853     const int bytesPerPixel = p_enc->fmt_out.video.i_bits_per_pixel ?
 854                          p_enc->fmt_out.video.i_bits_per_pixel / 8 : 3;
 855     const int blocksize = __MAX( FF_MIN_BUFFER_SIZE,bytesPerPixel * p_sys->p_context->height * p_sys->p_context->width + 200 );
 856     block_t *p_block = block_New( p_enc, blocksize );
 857
 858     if( likely(p_pict) ) {
 859         AVFrame *frame;
 860         frame = avcodec_alloc_frame();
 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 libavcodec 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 */
 875         frame->pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 876
 877         if ( p_sys->b_hurry_up && frame->pts != (int64_t)AV_NOPTS_VALUE )
 878         {
 879             mtime_t current_date = mdate();
 880
 881             if ( current_date + HURRY_UP_GUARD3 > frame->pts )
 882             {
 883                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 884                 p_sys->p_context->trellis = 0;
 885                 msg_Dbg( p_enc, "hurry up mode 3" );
 886             }
 887             else
 888             {
 889                 p_sys->p_context->mb_decision = p_sys->i_hq;
 890
 891                 if ( current_date + HURRY_UP_GUARD2 > frame->pts )
 892                 {
 893                     p_sys->p_context->trellis = 0;
 894                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 895                         + (HURRY_UP_GUARD2 + current_date - frame->pts) / 500;
 896                     msg_Dbg( p_enc, "hurry up mode 2" );
 897                 }
 898                 else
 899                 {
 900                     p_sys->p_context->trellis = p_sys->b_trellis;
 901
 902                     p_sys->p_context->noise_reduction =
 903                        p_sys->i_noise_reduction;
 904                 }
 905             }
 906
 907             if ( current_date + HURRY_UP_GUARD1 > frame->pts )
 908             {
 909                 frame->pict_type = AV_PICTURE_TYPE_P;
 910                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 911             }
 912         }
 913
 914         if ( frame->pts != (int64_t)AV_NOPTS_VALUE && frame->pts != 0 )
 915         {
 916             if ( p_sys->i_last_pts == frame->pts )
 917             {
 918                 msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 919                          "same PTS (%"PRId64 ")", frame->pts );
 920                 avcodec_free_frame( &frame );
 921                 return NULL;
 922             }
 923             else if ( p_sys->i_last_pts > frame->pts )
 924             {
 925                 msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 926                          "past (current: %"PRId64 ", last: %"PRId64")",
 927                          frame->pts, p_sys->i_last_pts );
 928                 avcodec_free_frame( &frame );
 929                 return NULL;
 930             }
 931             else
 932             {
 933                 p_sys->i_last_pts = frame->pts;
 934             }
 935         }
 936
 937         frame->quality = p_sys->i_quality;
 938
 939         i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer,
 940                                      p_block->i_buffer, frame );
 941         avcodec_free_frame( &frame );
 942     }
 943     else
 944     {
 945         i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer,
 946                                      p_block->i_buffer, NULL);
 947     }
 948
 949     if( i_out <= 0 )
 950     {
 951         block_Release( p_block );
 952         return NULL;
 953     }
 954
 955     p_block->i_buffer = i_out;
 956
 957     /* FIXME, 3-2 pulldown is not handled correctly */
 958     p_block->i_length = INT64_C(1000000) *
 959         p_enc->fmt_in.video.i_frame_rate_base /
 960             p_enc->fmt_in.video.i_frame_rate;
 961
 962     if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 963     {
 964         /* No delay -> output pts == input pts */
 965         if( p_pict )
 966             p_block->i_dts = p_pict->date;
 967         p_block->i_pts = p_block->i_dts;
 968     }
 969     else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 970         p_sys->p_context->coded_frame->pts != 0 &&
 971         p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 972     {
 973         p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 974         p_block->i_pts = p_sys->p_context->coded_frame->pts;
 975
 976         if( p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_I &&
 977             p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_P )
 978         {
 979             p_block->i_dts = p_block->i_pts;
 980         }
 981         else
 982         {
 983             if( p_sys->i_last_ref_pts )
 984             {
 985                 p_block->i_dts = p_sys->i_last_ref_pts;
 986             }
 987             else
 988             {
 989                 /* Let's put something sensible */
 990                 p_block->i_dts = p_block->i_pts;
 991             }
 992
 993             p_sys->i_last_ref_pts = p_block->i_pts;
 994         }
 995     }
 996     else if( p_pict )
 997     {
 998         /* Buggy libavcodec which doesn't update coded_frame->pts
 999          * correctly */
1000         p_block->i_dts = p_block->i_pts = p_pict->date;
1001     }
1002
1003     switch ( p_sys->p_context->coded_frame->pict_type )
1004     {
1005     case AV_PICTURE_TYPE_I:
1006         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1007         break;
1008     case AV_PICTURE_TYPE_P:
1009         p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1010         break;
1011     case AV_PICTURE_TYPE_B:
1012         p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1013         break;
1014
1015     }
1016
1017     return p_block;
1018 }
1019
1020 /****************************************************************************
1021  * EncodeAudio: the whole thing
1022  ****************************************************************************/
1023 static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
1024 {
1025     encoder_sys_t *p_sys = p_enc->p_sys;
1026
1027     block_t *p_block, *p_chain = NULL;
1028
1029     /*FIXME: change to use  avcodec_encode_audio2 to be able to flush*/
1030     if( unlikely( !p_aout_buf ) ) return NULL;
1031
1032     uint8_t *p_buffer = p_aout_buf->p_buffer;
1033     int i_samples = p_aout_buf->i_nb_samples;
1034     int i_samples_delay = p_sys->i_samples_delay;
1035
1036     p_sys->i_pts = p_aout_buf->i_pts -
1037                 (mtime_t)1000000 * (mtime_t)p_sys->i_samples_delay /
1038                 (mtime_t)p_enc->fmt_in.audio.i_rate;
1039
1040     p_sys->i_samples_delay += i_samples;
1041
1042     while( p_sys->i_samples_delay >= p_sys->i_frame_size )
1043     {
1044         void *p_samples;
1045         int i_out;
1046         p_block = block_New( p_enc, p_sys->i_buffer_out );
1047
1048         if( i_samples_delay )
1049         {
1050             /* Take care of the left-over from last time */
1051             int i_delay_size = i_samples_delay;
1052             int i_size = (p_sys->i_frame_size - i_delay_size) *
1053                          p_sys->i_sample_bytes;
1054
1055             memcpy( p_sys->p_buffer + i_delay_size * p_sys->i_sample_bytes,
1056                     p_buffer, i_size );
1057             p_buffer -= i_delay_size * p_sys->i_sample_bytes;
1058             i_samples += i_samples_delay;
1059             i_samples_delay = 0;
1060
1061             p_samples = p_sys->p_buffer;
1062         }
1063         else
1064         {
1065             p_samples = p_buffer;
1066         }
1067
1068         i_out = avcodec_encode_audio( p_sys->p_context, p_block->p_buffer,
1069                                       p_block->i_buffer, p_samples );
1070
1071 #if 0
1072         msg_Warn( p_enc, "avcodec_encode_audio: %d", i_out );
1073 #endif
1074         p_buffer += p_sys->i_frame_size * p_sys->i_sample_bytes;
1075         p_sys->i_samples_delay -= p_sys->i_frame_size;
1076         i_samples -= p_sys->i_frame_size;
1077
1078         if( i_out <= 0 )
1079         {
1080             block_Release( p_block );
1081             continue;
1082         }
1083
1084         p_block->i_buffer = i_out;
1085
1086         p_block->i_length = (mtime_t)1000000 *
1087             (mtime_t)p_sys->i_frame_size /
1088             (mtime_t)p_sys->p_context->sample_rate;
1089
1090         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
1091
1092         /* Update pts */
1093         p_sys->i_pts += p_block->i_length;
1094         block_ChainAppend( &p_chain, p_block );
1095     }
1096
1097     /* Backup the remaining raw samples */
1098     if( i_samples )
1099     {
1100         memcpy( &p_sys->p_buffer[i_samples_delay * p_sys->i_sample_bytes],
1101                 p_buffer,
1102                 i_samples * p_sys->i_sample_bytes );
1103     }
1104
1105     return p_chain;
1106 }
1107
1108 /*****************************************************************************
1109  * CloseEncoder: libavcodec encoder destruction
1110  *****************************************************************************/
1111 void CloseEncoder( vlc_object_t *p_this )
1112 {
1113     encoder_t *p_enc = (encoder_t *)p_this;
1114     encoder_sys_t *p_sys = p_enc->p_sys;
1115
1116     vlc_avcodec_lock();
1117     avcodec_close( p_sys->p_context );
1118     vlc_avcodec_unlock();
1119     av_free( p_sys->p_context );
1120
1121     free( p_sys->p_buffer );
1122
1123     free( p_sys );
1124 }