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

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