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