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

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