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

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