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 VLC authors and VideoLAN
   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 it
  14  * under the terms of the GNU Lesser General Public License as published by
  15  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this program; if not, write to the Free Software Foundation,
  25  * 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             if( p_sys->i_rc_buffer_size )
 577             {
 578                 p_context->rc_max_rate = p_enc->fmt_out.i_bitrate;
 579                 p_context->rc_min_rate = p_enc->fmt_out.i_bitrate;
 580             }
 581             p_context->rc_buffer_size = p_sys->i_rc_buffer_size;
 582             /* This is from ffmpeg's ffmpeg.c : */
 583             p_context->rc_initial_buffer_occupancy
 584                 = p_sys->i_rc_buffer_size * 3/4;
 585             p_context->rc_buffer_aggressivity = p_sys->f_rc_buffer_aggressivity;
 586         }
 587     }
 588     else if( p_enc->fmt_in.i_cat == AUDIO_ES )
 589     {
 590         /* work around bug in libmp3lame encoding */
 591         if( i_codec_id == CODEC_ID_MP3 && p_enc->fmt_in.audio.i_channels > 2 )
 592             p_enc->fmt_in.audio.i_channels = 2;
 593
 594         p_context->codec_type  = AVMEDIA_TYPE_AUDIO;
 595         p_context->sample_fmt  = p_codec->sample_fmts ?
 596                                     p_codec->sample_fmts[0] :
 597                                     AV_SAMPLE_FMT_S16;
 598         p_enc->fmt_in.i_codec  = VLC_CODEC_S16N;
 599         p_context->sample_rate = p_enc->fmt_out.audio.i_rate;
 600         p_context->time_base.num = 1;
 601         p_context->time_base.den = p_context->sample_rate;
 602         p_context->channels    = p_enc->fmt_out.audio.i_channels;
 603
 604         if ( p_enc->fmt_out.i_codec == VLC_CODEC_MP4A )
 605         {
 606             /* XXX: FAAC does resample only when setting the INPUT samplerate
 607              * to the desired value (-R option of the faac frontend)
 608             p_enc->fmt_in.audio.i_rate = p_context->sample_rate;*/
 609             /* vlc should default to low-complexity profile, faac encoder
 610              * has bug and aac audio has issues otherwise atm */
 611             p_context->profile = p_sys->i_aac_profile;
 612         }
 613     }
 614
 615     /* Misc parameters */
 616     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 617
 618     /* Set reasonable defaults to VP8, based on
 619        libvpx-720p preset from libvpx ffmpeg-patch */
 620     if( i_codec_id == CODEC_ID_VP8 )
 621     {
 622         /* Lets give bitrate tolerance */
 623         p_context->bit_rate_tolerance = __MAX(2 * (int)p_enc->fmt_out.i_bitrate, p_sys->i_vtolerance );
 624         /* default to 120 frames between keyframe */
 625         if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "keyint" ) )
 626             p_context->gop_size = 120;
 627         /* Don't set rc-values atm, they were from time before
 628            libvpx was officially in FFmpeg */
 629         //p_context->rc_max_rate = 24 * 1000 * 1000; //24M
 630         //p_context->rc_min_rate = 40 * 1000; // 40k
 631         /* seems that FFmpeg presets have 720p as divider for buffers */
 632         if( p_enc->fmt_out.video.i_height >= 720 )
 633         {
 634             /* Check that we don't overrun users qmin/qmax values */
 635             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
 636             {
 637                 p_context->qmin = 10;
 638                 p_context->mb_lmin = p_context->lmin = 10 * FF_QP2LAMBDA;
 639             }
 640
 641             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmax" ) )
 642             {
 643                 p_context->qmax = 42;
 644                 p_context->mb_lmax = p_context->lmax = 42 * FF_QP2LAMBDA;
 645             }
 646
 647             } else {
 648             if( !var_GetInteger( p_enc, ENC_CFG_PREFIX "qmin" ) )
 649             {
 650                 p_context->qmin = 1;
 651                 p_context->mb_lmin = p_context->lmin = FF_QP2LAMBDA;
 652             }
 653         }
 654
 655
 656 #if 0 /* enable when/if vp8 encoder is accepted in libavcodec */
 657         p_context->lag = 16;
 658         p_context->level = 216;
 659         p_context->profile = 0;
 660         p_context->rc_buffer_aggressivity = 0.95;
 661         p_context->token_partitions = 4;
 662         p_context->mb_static_threshold = 0;
 663 #endif
 664     }
 665
 666     if( i_codec_id == CODEC_ID_RAWVIDEO )
 667     {
 668         /* XXX: hack: Force same codec (will be handled by transcode) */
 669         p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
 670         GetFfmpegChroma( &p_context->pix_fmt, p_enc->fmt_in.video );
 671     }
 672
 673     /* Make sure we get extradata filled by the encoder */
 674     p_context->extradata_size = 0;
 675     p_context->extradata = NULL;
 676     p_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 677
 678     if( p_enc->i_threads >= 1)
 679         p_context->thread_count = p_enc->i_threads;
 680     else
 681         p_context->thread_count = vlc_GetCPUCount();
 682
 683     int ret;
 684     vlc_avcodec_lock();
 685 #if LIBAVCODEC_VERSION_MAJOR < 54
 686     ret = avcodec_open( p_context, p_codec );
 687 #else
 688     ret = avcodec_open2( p_context, p_codec, NULL /* options */ );
 689 #endif
 690     vlc_avcodec_unlock();
 691     if( ret )
 692     {
 693         if( p_enc->fmt_in.i_cat == AUDIO_ES &&
 694              (p_context->channels > 2 || i_codec_id == CODEC_ID_MP2
 695                || i_codec_id == CODEC_ID_MP3) )
 696         {
 697             if( p_context->channels > 2 )
 698             {
 699                 p_context->channels = 2;
 700                 p_enc->fmt_in.audio.i_channels = 2; // FIXME
 701                 msg_Warn( p_enc, "stereo mode selected (codec limitation)" );
 702             }
 703
 704             if( i_codec_id == CODEC_ID_MP2 || i_codec_id == CODEC_ID_MP3 )
 705             {
 706                 int i_frequency, i;
 707
 708                 for ( i_frequency = 0; i_frequency < 6; i_frequency++ )
 709                 {
 710                     if ( p_enc->fmt_out.audio.i_rate
 711                             == mpa_freq_tab[i_frequency] )
 712                         break;
 713                 }
 714                 if ( i_frequency == 6 )
 715                 {
 716                     msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",
 717                              p_enc->fmt_out.audio.i_rate );
 718                     free( p_sys );
 719                     return VLC_EGENERIC;
 720                 }
 721
 722                 for ( i = 1; i < 14; i++ )
 723                 {
 724                     if ( p_enc->fmt_out.i_bitrate / 1000
 725                           <= mpa_bitrate_tab[i_frequency / 3][i] )
 726                         break;
 727                 }
 728                 if ( p_enc->fmt_out.i_bitrate / 1000
 729                       != mpa_bitrate_tab[i_frequency / 3][i] )
 730                 {
 731                     msg_Warn( p_enc,
 732                               "MPEG audio doesn't support bitrate=%d, using %d",
 733                               p_enc->fmt_out.i_bitrate,
 734                               mpa_bitrate_tab[i_frequency / 3][i] * 1000 );
 735                     p_enc->fmt_out.i_bitrate =
 736                         mpa_bitrate_tab[i_frequency / 3][i] * 1000;
 737                     p_context->bit_rate = p_enc->fmt_out.i_bitrate;
 738                 }
 739             }
 740
 741             p_context->codec = NULL;
 742             vlc_avcodec_lock();
 743 #if LIBAVCODEC_VERSION_MAJOR < 54
 744             ret = avcodec_open( p_context, p_codec );
 745 #else
 746             ret = avcodec_open2( p_context, p_codec, NULL /* options */ );
 747 #endif
 748             vlc_avcodec_unlock();
 749             if( ret )
 750             {
 751                 msg_Err( p_enc, "cannot open encoder" );
 752                 dialog_Fatal( p_enc,
 753                                 _("Streaming / Transcoding failed"),
 754                                 "%s", _("VLC could not open the encoder.") );
 755                 free( p_sys );
 756                 return VLC_EGENERIC;
 757             }
 758         }
 759         else
 760         {
 761             msg_Err( p_enc, "cannot open encoder" );
 762             dialog_Fatal( p_enc, _("Streaming / Transcoding failed"),
 763                             "%s", _("VLC could not open the encoder.") );
 764             free( p_sys );
 765             return VLC_EGENERIC;
 766         }
 767     }
 768
 769     if( i_codec_id == CODEC_ID_FLAC )
 770     {
 771         p_enc->fmt_out.i_extra = 4 + 1 + 3 + p_context->extradata_size;
 772         p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 773         if( p_enc->fmt_out.p_extra )
 774         {
 775             uint8_t *p = p_enc->fmt_out.p_extra;
 776             p[0] = 0x66;    /* f */
 777             p[1] = 0x4C;    /* L */
 778             p[2] = 0x61;    /* a */
 779             p[3] = 0x43;    /* C */
 780             p[4] = 0x80;    /* streaminfo block, last block before audio */
 781             p[5] = ( p_context->extradata_size >> 16 ) & 0xff;
 782             p[6] = ( p_context->extradata_size >>  8 ) & 0xff;
 783             p[7] = ( p_context->extradata_size       ) & 0xff;
 784             memcpy( &p[8], p_context->extradata, p_context->extradata_size );
 785         }
 786         else
 787         {
 788             p_enc->fmt_out.i_extra = 0;
 789         }
 790     }
 791     else
 792     {
 793         p_enc->fmt_out.i_extra = p_context->extradata_size;
 794         if( p_enc->fmt_out.i_extra )
 795         {
 796             p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
 797             if ( p_enc->fmt_out.p_extra == NULL )
 798             {
 799                 goto error;
 800             }
 801             memcpy( p_enc->fmt_out.p_extra, p_context->extradata,
 802                     p_enc->fmt_out.i_extra );
 803         }
 804     }
 805
 806     p_context->flags &= ~CODEC_FLAG_GLOBAL_HEADER;
 807
 808     if( p_enc->fmt_in.i_cat == AUDIO_ES )
 809     {
 810         p_enc->fmt_in.i_codec = GetVlcAudioFormat( p_sys->p_context->sample_fmt );
 811         p_enc->fmt_in.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_in.i_codec );
 812
 813         p_sys->i_sample_bytes = (p_enc->fmt_in.audio.i_bitspersample / 8) *
 814                                 p_context->channels;
 815         p_sys->i_frame_size = p_context->frame_size > 1 ?
 816                                     p_context->frame_size :
 817                                     RAW_AUDIO_FRAME_SIZE;
 818         p_sys->p_buffer = malloc( p_sys->i_frame_size * p_sys->i_sample_bytes );
 819         if ( p_sys->p_buffer == NULL )
 820         {
 821             goto error;
 822         }
 823         p_enc->fmt_out.audio.i_blockalign = p_context->block_align;
 824         p_enc->fmt_out.audio.i_bitspersample = aout_BitsPerSample( p_enc->fmt_out.i_codec );
 825
 826         if( p_context->frame_size > 1 )
 827             p_sys->i_buffer_out = 8 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
 828         else
 829             p_sys->i_buffer_out = p_sys->i_frame_size * p_sys->i_sample_bytes;
 830     }
 831
 832     msg_Dbg( p_enc, "found encoder %s", psz_namecodec );
 833
 834     return VLC_SUCCESS;
 835 error:
 836     free( p_enc->fmt_out.p_extra );
 837     free( p_sys->p_buffer );
 838     free( p_sys );
 839     return VLC_ENOMEM;
 840 }
 841
 842 /****************************************************************************
 843  * EncodeVideo: the whole thing
 844  ****************************************************************************/
 845 static block_t *EncodeVideo( encoder_t *p_enc, picture_t *p_pict )
 846 {
 847     encoder_sys_t *p_sys = p_enc->p_sys;
 848     int i_out, i_plane;
 849
 850     /* Initialize the video output buffer the first time.
 851      * This is done here instead of OpenEncoder() because we need the actual
 852      * bits_per_pixel value, without having to assume anything.
 853      */
 854     const int bytesPerPixel = p_enc->fmt_out.video.i_bits_per_pixel ?
 855                          p_enc->fmt_out.video.i_bits_per_pixel / 8 : 3;
 856     const int blocksize = __MAX( FF_MIN_BUFFER_SIZE,bytesPerPixel * p_sys->p_context->height * p_sys->p_context->width + 200 );
 857     block_t *p_block = block_Alloc( blocksize );
 858
 859     if( likely(p_pict) ) {
 860         AVFrame *frame;
 861         frame = avcodec_alloc_frame();
 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 libavcodec 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 */
 876         frame->pts = p_pict->date ? p_pict->date : (int64_t)AV_NOPTS_VALUE;
 877
 878         if ( p_sys->b_hurry_up && frame->pts != (int64_t)AV_NOPTS_VALUE )
 879         {
 880             mtime_t current_date = mdate();
 881
 882             if ( current_date + HURRY_UP_GUARD3 > frame->pts )
 883             {
 884                 p_sys->p_context->mb_decision = FF_MB_DECISION_SIMPLE;
 885                 p_sys->p_context->trellis = 0;
 886                 msg_Dbg( p_enc, "hurry up mode 3" );
 887             }
 888             else
 889             {
 890                 p_sys->p_context->mb_decision = p_sys->i_hq;
 891
 892                 if ( current_date + HURRY_UP_GUARD2 > frame->pts )
 893                 {
 894                     p_sys->p_context->trellis = 0;
 895                     p_sys->p_context->noise_reduction = p_sys->i_noise_reduction
 896                         + (HURRY_UP_GUARD2 + current_date - frame->pts) / 500;
 897                     msg_Dbg( p_enc, "hurry up mode 2" );
 898                 }
 899                 else
 900                 {
 901                     p_sys->p_context->trellis = p_sys->b_trellis;
 902
 903                     p_sys->p_context->noise_reduction =
 904                        p_sys->i_noise_reduction;
 905                 }
 906             }
 907
 908             if ( current_date + HURRY_UP_GUARD1 > frame->pts )
 909             {
 910                 frame->pict_type = AV_PICTURE_TYPE_P;
 911                 /* msg_Dbg( p_enc, "hurry up mode 1 %lld", current_date + HURRY_UP_GUARD1 - frame.pts ); */
 912             }
 913         }
 914
 915         if ( frame->pts != (int64_t)AV_NOPTS_VALUE && frame->pts != 0 )
 916         {
 917             if ( p_sys->i_last_pts == frame->pts )
 918             {
 919                 msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
 920                          "same PTS (%"PRId64 ")", frame->pts );
 921                 av_freep( &frame );
 922                 return NULL;
 923             }
 924             else if ( p_sys->i_last_pts > frame->pts )
 925             {
 926                 msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
 927                          "past (current: %"PRId64 ", last: %"PRId64")",
 928                          frame->pts, p_sys->i_last_pts );
 929                 av_freep( &frame );
 930                 return NULL;
 931             }
 932             else
 933             {
 934                 p_sys->i_last_pts = frame->pts;
 935             }
 936         }
 937
 938         frame->quality = p_sys->i_quality;
 939
 940         i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer,
 941                                      p_block->i_buffer, frame );
 942         av_freep( &frame );
 943     }
 944     else
 945     {
 946         i_out = avcodec_encode_video( p_sys->p_context, p_block->p_buffer,
 947                                      p_block->i_buffer, NULL);
 948     }
 949
 950     if( i_out <= 0 )
 951     {
 952         block_Release( p_block );
 953         return NULL;
 954     }
 955
 956     p_block->i_buffer = i_out;
 957
 958     /* FIXME, 3-2 pulldown is not handled correctly */
 959     p_block->i_length = INT64_C(1000000) *
 960         p_enc->fmt_in.video.i_frame_rate_base /
 961             p_enc->fmt_in.video.i_frame_rate;
 962
 963     if( !p_sys->p_context->max_b_frames || !p_sys->p_context->delay )
 964     {
 965         /* No delay -> output pts == input pts */
 966         if( p_pict )
 967             p_block->i_dts = p_pict->date;
 968         p_block->i_pts = p_block->i_dts;
 969     }
 970     else if( p_sys->p_context->coded_frame->pts != (int64_t)AV_NOPTS_VALUE &&
 971         p_sys->p_context->coded_frame->pts != 0 &&
 972         p_sys->i_buggy_pts_detect != p_sys->p_context->coded_frame->pts )
 973     {
 974         p_sys->i_buggy_pts_detect = p_sys->p_context->coded_frame->pts;
 975         p_block->i_pts = p_sys->p_context->coded_frame->pts;
 976
 977         if( p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_I &&
 978             p_sys->p_context->coded_frame->pict_type != AV_PICTURE_TYPE_P )
 979         {
 980             p_block->i_dts = p_block->i_pts;
 981         }
 982         else
 983         {
 984             if( p_sys->i_last_ref_pts )
 985             {
 986                 p_block->i_dts = p_sys->i_last_ref_pts;
 987             }
 988             else
 989             {
 990                 /* Let's put something sensible */
 991                 p_block->i_dts = p_block->i_pts;
 992             }
 993
 994             p_sys->i_last_ref_pts = p_block->i_pts;
 995         }
 996     }
 997     else if( p_pict )
 998     {
 999         /* Buggy libavcodec which doesn't update coded_frame->pts
1000          * correctly */
1001         p_block->i_dts = p_block->i_pts = p_pict->date;
1002     }
1003
1004     switch ( p_sys->p_context->coded_frame->pict_type )
1005     {
1006     case AV_PICTURE_TYPE_I:
1007         p_block->i_flags |= BLOCK_FLAG_TYPE_I;
1008         break;
1009     case AV_PICTURE_TYPE_P:
1010         p_block->i_flags |= BLOCK_FLAG_TYPE_P;
1011         break;
1012     case AV_PICTURE_TYPE_B:
1013         p_block->i_flags |= BLOCK_FLAG_TYPE_B;
1014         break;
1015
1016     }
1017
1018     return p_block;
1019 }
1020
1021 /****************************************************************************
1022  * EncodeAudio: the whole thing
1023  ****************************************************************************/
1024 static block_t *EncodeAudio( encoder_t *p_enc, block_t *p_aout_buf )
1025 {
1026     encoder_sys_t *p_sys = p_enc->p_sys;
1027
1028     block_t *p_block, *p_chain = NULL;
1029     AVFrame *frame;
1030     AVPacket packet;
1031     int got_packet,i_out;
1032
1033     /*FIXME: change to use  avcodec_encode_audio2 to be able to flush*/
1034     if( unlikely( !p_aout_buf ) )
1035     {
1036         msg_Dbg(p_enc,"Flushing..");
1037         do {
1038             p_block = block_Alloc( p_sys->i_buffer_out );
1039             av_init_packet( &packet );
1040             packet.data = p_block->p_buffer;
1041             packet.size = p_block->i_buffer;
1042
1043             i_out = avcodec_encode_audio2( p_sys->p_context, &packet, NULL, &got_packet );
1044             if( !i_out && got_packet )
1045                 block_ChainAppend( &p_chain, p_block );
1046         } while( got_packet && !i_out );
1047         return p_chain;
1048     }
1049
1050     frame = avcodec_alloc_frame();
1051
1052     frame->nb_samples = p_aout_buf->i_nb_samples;
1053     avcodec_fill_audio_frame( frame, p_enc->fmt_in.audio.i_channels,
1054                               p_sys->p_context->sample_fmt,
1055                               p_aout_buf->p_buffer, p_aout_buf->i_buffer,
1056                               0);
1057
1058
1059     frame->pts = p_aout_buf->i_pts;
1060
1061     p_block = block_Alloc( p_sys->i_buffer_out );
1062     av_init_packet( &packet );
1063     packet.data = p_block->p_buffer;
1064     packet.size = p_block->i_buffer;
1065
1066     i_out = avcodec_encode_audio2( p_sys->p_context, &packet, frame, &got_packet );
1067     p_block->i_buffer = packet.size;
1068
1069     av_freep( &frame );
1070     if( unlikely( !got_packet || i_out ) )
1071     {
1072         if( i_out )
1073            msg_Err( p_enc,"Encoding problem..");
1074         block_Release( p_block );
1075         return NULL;
1076     }
1077
1078     p_block->i_buffer = packet.size;
1079
1080     p_block->i_length = (mtime_t)1000000 *
1081         (mtime_t)p_sys->i_frame_size /
1082         (mtime_t)p_sys->p_context->sample_rate;
1083
1084     p_block->i_dts = p_block->i_pts = packet.pts;
1085
1086     return p_block;
1087 }
1088
1089 /*****************************************************************************
1090  * CloseEncoder: libavcodec encoder destruction
1091  *****************************************************************************/
1092 void CloseEncoder( vlc_object_t *p_this )
1093 {
1094     encoder_t *p_enc = (encoder_t *)p_this;
1095     encoder_sys_t *p_sys = p_enc->p_sys;
1096
1097     vlc_avcodec_lock();
1098     avcodec_close( p_sys->p_context );
1099     vlc_avcodec_unlock();
1100     av_free( p_sys->p_context );
1101
1102     free( p_sys->p_buffer );
1103
1104     free( p_sys );
1105 }