Replace memset(0) by zero initializations.
[ffmpeg.git] / libavcodec / libxvidff.c
1 /*
2  * Interface to xvidcore for mpeg4 encoding
3  * Copyright (c) 2004 Adam Thayer <krevnik@comcast.net>
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * Interface to xvidcore for MPEG-4 compliant encoding.
25  * @author Adam Thayer (krevnik@comcast.net)
26  */
27
28 #include <xvid.h>
29 #include <unistd.h>
30 #include "avcodec.h"
31 #include "libavutil/cpu.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mathematics.h"
34 #include "libxvid_internal.h"
35 #include "mpegvideo.h"
36 #if !HAVE_MKSTEMP
37 #include <fcntl.h>
38 #endif
39
40 /**
41  * Buffer management macros.
42  */
43 #define BUFFER_SIZE                 1024
44 #define BUFFER_REMAINING(x)         (BUFFER_SIZE - strlen(x))
45 #define BUFFER_CAT(x)               (&((x)[strlen(x)]))
46
47 /**
48  * Structure for the private Xvid context.
49  * This stores all the private context for the codec.
50  */
51 struct xvid_context {
52     void *encoder_handle;          /**< Handle for Xvid encoder */
53     int xsize;                     /**< Frame x size */
54     int ysize;                     /**< Frame y size */
55     int vop_flags;                 /**< VOP flags for Xvid encoder */
56     int vol_flags;                 /**< VOL flags for Xvid encoder */
57     int me_flags;                  /**< Motion Estimation flags */
58     int qscale;                    /**< Do we use constant scale? */
59     int quicktime_format;          /**< Are we in a QT-based format? */
60     AVFrame encoded_picture;       /**< Encoded frame information */
61     char *twopassbuffer;           /**< Character buffer for two-pass */
62     char *old_twopassbuffer;       /**< Old character buffer (two-pass) */
63     char *twopassfile;             /**< second pass temp file name */
64     unsigned char *intra_matrix;   /**< P-Frame Quant Matrix */
65     unsigned char *inter_matrix;   /**< I-Frame Quant Matrix */
66 };
67
68 /**
69  * Structure for the private first-pass plugin.
70  */
71 struct xvid_ff_pass1 {
72     int     version;                /**< Xvid version */
73     struct xvid_context *context;   /**< Pointer to private context */
74 };
75
76 /* Prototypes - See function implementation for details */
77 int xvid_strip_vol_header(AVCodecContext *avctx, AVPacket *pkt, unsigned int header_len, unsigned int frame_len);
78 int xvid_ff_2pass(void *ref, int opt, void *p1, void *p2);
79 void xvid_correct_framerate(AVCodecContext *avctx);
80
81 /* Wrapper to work around the lack of mkstemp() on mingw.
82  * Also, tries to create file in /tmp first, if possible.
83  * *prefix can be a character constant; *filename will be allocated internally.
84  * @return file descriptor of opened file (or -1 on error)
85  * and opened file name in **filename. */
86 int ff_tempfile(const char *prefix, char **filename) {
87     int fd=-1;
88 #if !HAVE_MKSTEMP
89     *filename = tempnam(".", prefix);
90 #else
91     size_t len = strlen(prefix) + 12; /* room for "/tmp/" and "XXXXXX\0" */
92     *filename = av_malloc(len);
93 #endif
94     /* -----common section-----*/
95     if (*filename == NULL) {
96         av_log(NULL, AV_LOG_ERROR, "ff_tempfile: Cannot allocate file name\n");
97         return -1;
98     }
99 #if !HAVE_MKSTEMP
100     fd = open(*filename, O_RDWR | O_BINARY | O_CREAT, 0444);
101 #else
102     snprintf(*filename, len, "/tmp/%sXXXXXX", prefix);
103     fd = mkstemp(*filename);
104     if (fd < 0) {
105         snprintf(*filename, len, "./%sXXXXXX", prefix);
106         fd = mkstemp(*filename);
107     }
108 #endif
109     /* -----common section-----*/
110     if (fd < 0) {
111         av_log(NULL, AV_LOG_ERROR, "ff_tempfile: Cannot open temporary file %s\n", *filename);
112         return -1;
113     }
114     return fd; /* success */
115 }
116
117 #if CONFIG_LIBXVID_ENCODER
118
119 /**
120  * Create the private context for the encoder.
121  * All buffers are allocated, settings are loaded from the user,
122  * and the encoder context created.
123  *
124  * @param avctx AVCodecContext pointer to context
125  * @return Returns 0 on success, -1 on failure
126  */
127 static av_cold int xvid_encode_init(AVCodecContext *avctx)  {
128     int xerr, i;
129     int xvid_flags = avctx->flags;
130     struct xvid_context *x = avctx->priv_data;
131     uint16_t *intra, *inter;
132     int fd;
133
134     xvid_plugin_single_t single       = { 0 };
135     struct xvid_ff_pass1 rc2pass1     = { 0 };
136     xvid_plugin_2pass2_t rc2pass2     = { 0 };
137     xvid_gbl_init_t xvid_gbl_init     = { 0 };
138     xvid_enc_create_t xvid_enc_create = { 0 };
139     xvid_enc_plugin_t plugins[7];
140
141     /* Bring in VOP flags from avconv command-line */
142     x->vop_flags = XVID_VOP_HALFPEL; /* Bare minimum quality */
143     if( xvid_flags & CODEC_FLAG_4MV )
144         x->vop_flags |= XVID_VOP_INTER4V; /* Level 3 */
145     if( avctx->trellis
146         )
147         x->vop_flags |= XVID_VOP_TRELLISQUANT; /* Level 5 */
148     if( xvid_flags & CODEC_FLAG_AC_PRED )
149         x->vop_flags |= XVID_VOP_HQACPRED; /* Level 6 */
150     if( xvid_flags & CODEC_FLAG_GRAY )
151         x->vop_flags |= XVID_VOP_GREYSCALE;
152
153     /* Decide which ME quality setting to use */
154     x->me_flags = 0;
155     switch( avctx->me_method ) {
156        case ME_FULL:   /* Quality 6 */
157            x->me_flags |=  XVID_ME_EXTSEARCH16
158                        |   XVID_ME_EXTSEARCH8;
159
160        case ME_EPZS:   /* Quality 4 */
161            x->me_flags |=  XVID_ME_ADVANCEDDIAMOND8
162                        |   XVID_ME_HALFPELREFINE8
163                        |   XVID_ME_CHROMA_PVOP
164                        |   XVID_ME_CHROMA_BVOP;
165
166        case ME_LOG:    /* Quality 2 */
167        case ME_PHODS:
168        case ME_X1:
169            x->me_flags |=  XVID_ME_ADVANCEDDIAMOND16
170                        |   XVID_ME_HALFPELREFINE16;
171
172        case ME_ZERO:   /* Quality 0 */
173        default:
174            break;
175     }
176
177     /* Decide how we should decide blocks */
178     switch( avctx->mb_decision ) {
179        case 2:
180            x->vop_flags |= XVID_VOP_MODEDECISION_RD;
181            x->me_flags |=  XVID_ME_HALFPELREFINE8_RD
182                        |   XVID_ME_QUARTERPELREFINE8_RD
183                        |   XVID_ME_EXTSEARCH_RD
184                        |   XVID_ME_CHECKPREDICTION_RD;
185        case 1:
186            if( !(x->vop_flags & XVID_VOP_MODEDECISION_RD) )
187                x->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;
188            x->me_flags |=  XVID_ME_HALFPELREFINE16_RD
189                        |   XVID_ME_QUARTERPELREFINE16_RD;
190
191        default:
192            break;
193     }
194
195     /* Bring in VOL flags from avconv command-line */
196     x->vol_flags = 0;
197     if( xvid_flags & CODEC_FLAG_GMC ) {
198         x->vol_flags |= XVID_VOL_GMC;
199         x->me_flags |= XVID_ME_GME_REFINE;
200     }
201     if( xvid_flags & CODEC_FLAG_QPEL ) {
202         x->vol_flags |= XVID_VOL_QUARTERPEL;
203         x->me_flags |= XVID_ME_QUARTERPELREFINE16;
204         if( x->vop_flags & XVID_VOP_INTER4V )
205             x->me_flags |= XVID_ME_QUARTERPELREFINE8;
206     }
207
208     xvid_gbl_init.version = XVID_VERSION;
209     xvid_gbl_init.debug = 0;
210
211 #if ARCH_PPC
212     /* Xvid's PPC support is borked, use libavcodec to detect */
213 #if HAVE_ALTIVEC
214     if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {
215         xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_ALTIVEC;
216     } else
217 #endif
218         xvid_gbl_init.cpu_flags = XVID_CPU_FORCE;
219 #else
220     /* Xvid can detect on x86 */
221     xvid_gbl_init.cpu_flags = 0;
222 #endif
223
224     /* Initialize */
225     xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
226
227     /* Create the encoder reference */
228     xvid_enc_create.version = XVID_VERSION;
229
230     /* Store the desired frame size */
231     xvid_enc_create.width = x->xsize = avctx->width;
232     xvid_enc_create.height = x->ysize = avctx->height;
233
234     /* Xvid can determine the proper profile to use */
235     /* xvid_enc_create.profile = XVID_PROFILE_S_L3; */
236
237     /* We don't use zones */
238     xvid_enc_create.zones = NULL;
239     xvid_enc_create.num_zones = 0;
240
241     xvid_enc_create.num_threads = avctx->thread_count;
242
243     xvid_enc_create.plugins = plugins;
244     xvid_enc_create.num_plugins = 0;
245
246     /* Initialize Buffers */
247     x->twopassbuffer = NULL;
248     x->old_twopassbuffer = NULL;
249     x->twopassfile = NULL;
250
251     if( xvid_flags & CODEC_FLAG_PASS1 ) {
252         rc2pass1.version = XVID_VERSION;
253         rc2pass1.context = x;
254         x->twopassbuffer = av_malloc(BUFFER_SIZE);
255         x->old_twopassbuffer = av_malloc(BUFFER_SIZE);
256         if( x->twopassbuffer == NULL || x->old_twopassbuffer == NULL ) {
257             av_log(avctx, AV_LOG_ERROR,
258                 "Xvid: Cannot allocate 2-pass log buffers\n");
259             return -1;
260         }
261         x->twopassbuffer[0] = x->old_twopassbuffer[0] = 0;
262
263         plugins[xvid_enc_create.num_plugins].func = xvid_ff_2pass;
264         plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
265         xvid_enc_create.num_plugins++;
266     } else if( xvid_flags & CODEC_FLAG_PASS2 ) {
267         rc2pass2.version = XVID_VERSION;
268         rc2pass2.bitrate = avctx->bit_rate;
269
270         fd = ff_tempfile("xvidff.", &x->twopassfile);
271         if( fd == -1 ) {
272             av_log(avctx, AV_LOG_ERROR,
273                 "Xvid: Cannot write 2-pass pipe\n");
274             return -1;
275         }
276
277         if( avctx->stats_in == NULL ) {
278             av_log(avctx, AV_LOG_ERROR,
279                 "Xvid: No 2-pass information loaded for second pass\n");
280             return -1;
281         }
282
283         if( strlen(avctx->stats_in) >
284               write(fd, avctx->stats_in, strlen(avctx->stats_in)) ) {
285             close(fd);
286             av_log(avctx, AV_LOG_ERROR,
287                 "Xvid: Cannot write to 2-pass pipe\n");
288             return -1;
289         }
290
291         close(fd);
292         rc2pass2.filename = x->twopassfile;
293         plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass2;
294         plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
295         xvid_enc_create.num_plugins++;
296     } else if( !(xvid_flags & CODEC_FLAG_QSCALE) ) {
297         /* Single Pass Bitrate Control! */
298         single.version = XVID_VERSION;
299         single.bitrate = avctx->bit_rate;
300
301         plugins[xvid_enc_create.num_plugins].func = xvid_plugin_single;
302         plugins[xvid_enc_create.num_plugins].param = &single;
303         xvid_enc_create.num_plugins++;
304     }
305
306     /* Luminance Masking */
307     if( 0.0 != avctx->lumi_masking ) {
308         plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
309         plugins[xvid_enc_create.num_plugins].param = NULL;
310         xvid_enc_create.num_plugins++;
311     }
312
313     /* Frame Rate and Key Frames */
314     xvid_correct_framerate(avctx);
315     xvid_enc_create.fincr = avctx->time_base.num;
316     xvid_enc_create.fbase = avctx->time_base.den;
317     if( avctx->gop_size > 0 )
318         xvid_enc_create.max_key_interval = avctx->gop_size;
319     else
320         xvid_enc_create.max_key_interval = 240; /* Xvid's best default */
321
322     /* Quants */
323     if( xvid_flags & CODEC_FLAG_QSCALE ) x->qscale = 1;
324     else x->qscale = 0;
325
326     xvid_enc_create.min_quant[0] = avctx->qmin;
327     xvid_enc_create.min_quant[1] = avctx->qmin;
328     xvid_enc_create.min_quant[2] = avctx->qmin;
329     xvid_enc_create.max_quant[0] = avctx->qmax;
330     xvid_enc_create.max_quant[1] = avctx->qmax;
331     xvid_enc_create.max_quant[2] = avctx->qmax;
332
333     /* Quant Matrices */
334     x->intra_matrix = x->inter_matrix = NULL;
335     if( avctx->mpeg_quant )
336        x->vol_flags |= XVID_VOL_MPEGQUANT;
337     if( (avctx->intra_matrix || avctx->inter_matrix) ) {
338        x->vol_flags |= XVID_VOL_MPEGQUANT;
339
340        if( avctx->intra_matrix ) {
341            intra = avctx->intra_matrix;
342            x->intra_matrix = av_malloc(sizeof(unsigned char) * 64);
343        } else
344            intra = NULL;
345        if( avctx->inter_matrix ) {
346            inter = avctx->inter_matrix;
347            x->inter_matrix = av_malloc(sizeof(unsigned char) * 64);
348        } else
349            inter = NULL;
350
351        for( i = 0; i < 64; i++ ) {
352            if( intra )
353                x->intra_matrix[i] = (unsigned char)intra[i];
354            if( inter )
355                x->inter_matrix[i] = (unsigned char)inter[i];
356        }
357     }
358
359     /* Misc Settings */
360     xvid_enc_create.frame_drop_ratio = 0;
361     xvid_enc_create.global = 0;
362     if( xvid_flags & CODEC_FLAG_CLOSED_GOP )
363         xvid_enc_create.global |= XVID_GLOBAL_CLOSED_GOP;
364
365     /* Determines which codec mode we are operating in */
366     avctx->extradata = NULL;
367     avctx->extradata_size = 0;
368     if( xvid_flags & CODEC_FLAG_GLOBAL_HEADER ) {
369         /* In this case, we are claiming to be MPEG4 */
370         x->quicktime_format = 1;
371         avctx->codec_id = CODEC_ID_MPEG4;
372     } else {
373         /* We are claiming to be Xvid */
374         x->quicktime_format = 0;
375         if(!avctx->codec_tag)
376             avctx->codec_tag = AV_RL32("xvid");
377     }
378
379     /* Bframes */
380     xvid_enc_create.max_bframes = avctx->max_b_frames;
381     xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
382     xvid_enc_create.bquant_ratio = 100 * avctx->b_quant_factor;
383     if( avctx->max_b_frames > 0  && !x->quicktime_format ) xvid_enc_create.global |= XVID_GLOBAL_PACKED;
384
385     /* Create encoder context */
386     xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
387     if( xerr ) {
388         av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
389         return -1;
390     }
391
392     x->encoder_handle = xvid_enc_create.handle;
393     avctx->coded_frame = &x->encoded_picture;
394
395     return 0;
396 }
397
398 /**
399  * Encode a single frame.
400  *
401  * @param avctx AVCodecContext pointer to context
402  * @param frame Pointer to encoded frame buffer
403  * @param buf_size Size of encoded frame buffer
404  * @param data Pointer to AVFrame of unencoded frame
405  * @return Returns 0 on success, -1 on failure
406  */
407 static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
408                              const AVFrame *picture, int *got_packet)
409 {
410     int xerr, i, ret, user_packet = !!pkt->data;
411     char *tmp;
412     struct xvid_context *x = avctx->priv_data;
413     AVFrame *p = &x->encoded_picture;
414     int mb_width   = (avctx->width  + 15) / 16;
415     int mb_height  = (avctx->height + 15) / 16;
416
417     xvid_enc_frame_t xvid_enc_frame = { 0 };
418     xvid_enc_stats_t xvid_enc_stats = { 0 };
419
420     if (!user_packet &&
421         (ret = av_new_packet(pkt, mb_width*mb_height*MAX_MB_BYTES + FF_MIN_BUFFER_SIZE)) < 0) {
422         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
423         return ret;
424     }
425
426     /* Start setting up the frame */
427     xvid_enc_frame.version = XVID_VERSION;
428     xvid_enc_stats.version = XVID_VERSION;
429     *p = *picture;
430
431     /* Let Xvid know where to put the frame. */
432     xvid_enc_frame.bitstream = pkt->data;
433     xvid_enc_frame.length    = pkt->size;
434
435     /* Initialize input image fields */
436     if( avctx->pix_fmt != PIX_FMT_YUV420P ) {
437         av_log(avctx, AV_LOG_ERROR, "Xvid: Color spaces other than 420p not supported\n");
438         return -1;
439     }
440
441     xvid_enc_frame.input.csp = XVID_CSP_PLANAR; /* YUV420P */
442
443     for( i = 0; i < 4; i++ ) {
444         xvid_enc_frame.input.plane[i] = picture->data[i];
445         xvid_enc_frame.input.stride[i] = picture->linesize[i];
446     }
447
448     /* Encoder Flags */
449     xvid_enc_frame.vop_flags = x->vop_flags;
450     xvid_enc_frame.vol_flags = x->vol_flags;
451     xvid_enc_frame.motion = x->me_flags;
452     xvid_enc_frame.type =
453         picture->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :
454         picture->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :
455         picture->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :
456                                           XVID_TYPE_AUTO;
457
458     /* Pixel aspect ratio setting */
459     if (avctx->sample_aspect_ratio.num < 1 || avctx->sample_aspect_ratio.num > 255 ||
460         avctx->sample_aspect_ratio.den < 1 || avctx->sample_aspect_ratio.den > 255) {
461         av_log(avctx, AV_LOG_ERROR, "Invalid pixel aspect ratio %i/%i\n",
462                avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
463         return -1;
464     }
465     xvid_enc_frame.par = XVID_PAR_EXT;
466     xvid_enc_frame.par_width  = avctx->sample_aspect_ratio.num;
467     xvid_enc_frame.par_height = avctx->sample_aspect_ratio.den;
468
469     /* Quant Setting */
470     if( x->qscale ) xvid_enc_frame.quant = picture->quality / FF_QP2LAMBDA;
471     else xvid_enc_frame.quant = 0;
472
473     /* Matrices */
474     xvid_enc_frame.quant_intra_matrix = x->intra_matrix;
475     xvid_enc_frame.quant_inter_matrix = x->inter_matrix;
476
477     /* Encode */
478     xerr = xvid_encore(x->encoder_handle, XVID_ENC_ENCODE,
479         &xvid_enc_frame, &xvid_enc_stats);
480
481     /* Two-pass log buffer swapping */
482     avctx->stats_out = NULL;
483     if( x->twopassbuffer ) {
484         tmp = x->old_twopassbuffer;
485         x->old_twopassbuffer = x->twopassbuffer;
486         x->twopassbuffer = tmp;
487         x->twopassbuffer[0] = 0;
488         if( x->old_twopassbuffer[0] != 0 ) {
489             avctx->stats_out = x->old_twopassbuffer;
490         }
491     }
492
493     if (xerr > 0) {
494         *got_packet = 1;
495
496         p->quality = xvid_enc_stats.quant * FF_QP2LAMBDA;
497         if( xvid_enc_stats.type == XVID_TYPE_PVOP )
498             p->pict_type = AV_PICTURE_TYPE_P;
499         else if( xvid_enc_stats.type == XVID_TYPE_BVOP )
500             p->pict_type = AV_PICTURE_TYPE_B;
501         else if( xvid_enc_stats.type == XVID_TYPE_SVOP )
502             p->pict_type = AV_PICTURE_TYPE_S;
503         else
504             p->pict_type = AV_PICTURE_TYPE_I;
505         if( xvid_enc_frame.out_flags & XVID_KEYFRAME ) {
506             p->key_frame = 1;
507             pkt->flags |= AV_PKT_FLAG_KEY;
508             if( x->quicktime_format )
509                 return xvid_strip_vol_header(avctx, pkt,
510                     xvid_enc_stats.hlength, xerr);
511          } else
512             p->key_frame = 0;
513
514         pkt->size = xerr;
515
516         return 0;
517     } else {
518         if (!user_packet)
519             av_free_packet(pkt);
520         if (!xerr)
521             return 0;
522         av_log(avctx, AV_LOG_ERROR, "Xvid: Encoding Error Occurred: %i\n", xerr);
523         return -1;
524     }
525 }
526
527 /**
528  * Destroy the private context for the encoder.
529  * All buffers are freed, and the Xvid encoder context is destroyed.
530  *
531  * @param avctx AVCodecContext pointer to context
532  * @return Returns 0, success guaranteed
533  */
534 static av_cold int xvid_encode_close(AVCodecContext *avctx) {
535     struct xvid_context *x = avctx->priv_data;
536
537     xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
538
539     av_freep(&avctx->extradata);
540     if( x->twopassbuffer != NULL ) {
541         av_free(x->twopassbuffer);
542         av_free(x->old_twopassbuffer);
543     }
544     av_free(x->twopassfile);
545     av_free(x->intra_matrix);
546     av_free(x->inter_matrix);
547
548     return 0;
549 }
550
551 /**
552  * Routine to create a global VO/VOL header for MP4 container.
553  * What we do here is extract the header from the Xvid bitstream
554  * as it is encoded. We also strip the repeated headers from the
555  * bitstream when a global header is requested for MPEG-4 ISO
556  * compliance.
557  *
558  * @param avctx AVCodecContext pointer to context
559  * @param frame Pointer to encoded frame data
560  * @param header_len Length of header to search
561  * @param frame_len Length of encoded frame data
562  * @return Returns new length of frame data
563  */
564 int xvid_strip_vol_header(AVCodecContext *avctx,
565                   AVPacket *pkt,
566                   unsigned int header_len,
567                   unsigned int frame_len) {
568     int vo_len = 0, i;
569
570     for( i = 0; i < header_len - 3; i++ ) {
571         if( pkt->data[i] == 0x00 &&
572             pkt->data[i+1] == 0x00 &&
573             pkt->data[i+2] == 0x01 &&
574             pkt->data[i+3] == 0xB6 ) {
575             vo_len = i;
576             break;
577         }
578     }
579
580     if( vo_len > 0 ) {
581         /* We need to store the header, so extract it */
582         if( avctx->extradata == NULL ) {
583             avctx->extradata = av_malloc(vo_len);
584             memcpy(avctx->extradata, pkt->data, vo_len);
585             avctx->extradata_size = vo_len;
586         }
587         /* Less dangerous now, memmove properly copies the two
588            chunks of overlapping data */
589         memmove(pkt->data, &pkt->data[vo_len], frame_len - vo_len);
590         pkt->size = frame_len - vo_len;
591     }
592     return 0;
593 }
594
595 /**
596  * Routine to correct a possibly erroneous framerate being fed to us.
597  * Xvid currently chokes on framerates where the ticks per frame is
598  * extremely large. This function works to correct problems in this area
599  * by estimating a new framerate and taking the simpler fraction of
600  * the two presented.
601  *
602  * @param avctx Context that contains the framerate to correct.
603  */
604 void xvid_correct_framerate(AVCodecContext *avctx) {
605     int frate, fbase;
606     int est_frate, est_fbase;
607     int gcd;
608     float est_fps, fps;
609
610     frate = avctx->time_base.den;
611     fbase = avctx->time_base.num;
612
613     gcd = av_gcd(frate, fbase);
614     if( gcd > 1 ) {
615         frate /= gcd;
616         fbase /= gcd;
617     }
618
619     if( frate <= 65000 && fbase <= 65000 ) {
620         avctx->time_base.den = frate;
621         avctx->time_base.num = fbase;
622         return;
623     }
624
625     fps = (float)frate / (float)fbase;
626     est_fps = roundf(fps * 1000.0) / 1000.0;
627
628     est_frate = (int)est_fps;
629     if( est_fps > (int)est_fps ) {
630         est_frate = (est_frate + 1) * 1000;
631         est_fbase = (int)roundf((float)est_frate / est_fps);
632     } else
633         est_fbase = 1;
634
635     gcd = av_gcd(est_frate, est_fbase);
636     if( gcd > 1 ) {
637         est_frate /= gcd;
638         est_fbase /= gcd;
639     }
640
641     if( fbase > est_fbase ) {
642         avctx->time_base.den = est_frate;
643         avctx->time_base.num = est_fbase;
644         av_log(avctx, AV_LOG_DEBUG,
645             "Xvid: framerate re-estimated: %.2f, %.3f%% correction\n",
646             est_fps, (((est_fps - fps)/fps) * 100.0));
647     } else {
648         avctx->time_base.den = frate;
649         avctx->time_base.num = fbase;
650     }
651 }
652
653 /*
654  * Xvid 2-Pass Kludge Section
655  *
656  * Xvid's default 2-pass doesn't allow us to create data as we need to, so
657  * this section spends time replacing the first pass plugin so we can write
658  * statistic information as libavcodec requests in. We have another kludge
659  * that allows us to pass data to the second pass in Xvid without a custom
660  * rate-control plugin.
661  */
662
663 /**
664  * Initialize the two-pass plugin and context.
665  *
666  * @param param Input construction parameter structure
667  * @param handle Private context handle
668  * @return Returns XVID_ERR_xxxx on failure, or 0 on success.
669  */
670 static int xvid_ff_2pass_create(xvid_plg_create_t * param,
671                                 void ** handle) {
672     struct xvid_ff_pass1 *x = (struct xvid_ff_pass1 *)param->param;
673     char *log = x->context->twopassbuffer;
674
675     /* Do a quick bounds check */
676     if( log == NULL )
677         return XVID_ERR_FAIL;
678
679     /* We use snprintf() */
680     /* This is because we can safely prevent a buffer overflow */
681     log[0] = 0;
682     snprintf(log, BUFFER_REMAINING(log),
683         "# avconv 2-pass log file, using xvid codec\n");
684     snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
685         "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
686         XVID_VERSION_MAJOR(XVID_VERSION),
687         XVID_VERSION_MINOR(XVID_VERSION),
688         XVID_VERSION_PATCH(XVID_VERSION));
689
690     *handle = x->context;
691     return 0;
692 }
693
694 /**
695  * Destroy the two-pass plugin context.
696  *
697  * @param ref Context pointer for the plugin
698  * @param param Destrooy context
699  * @return Returns 0, success guaranteed
700  */
701 static int xvid_ff_2pass_destroy(struct xvid_context *ref,
702                                 xvid_plg_destroy_t *param) {
703     /* Currently cannot think of anything to do on destruction */
704     /* Still, the framework should be here for reference/use */
705     if( ref->twopassbuffer != NULL )
706         ref->twopassbuffer[0] = 0;
707     return 0;
708 }
709
710 /**
711  * Enable fast encode mode during the first pass.
712  *
713  * @param ref Context pointer for the plugin
714  * @param param Frame data
715  * @return Returns 0, success guaranteed
716  */
717 static int xvid_ff_2pass_before(struct xvid_context *ref,
718                                 xvid_plg_data_t *param) {
719     int motion_remove;
720     int motion_replacements;
721     int vop_remove;
722
723     /* Nothing to do here, result is changed too much */
724     if( param->zone && param->zone->mode == XVID_ZONE_QUANT )
725         return 0;
726
727     /* We can implement a 'turbo' first pass mode here */
728     param->quant = 2;
729
730     /* Init values */
731     motion_remove = ~XVID_ME_CHROMA_PVOP &
732                     ~XVID_ME_CHROMA_BVOP &
733                     ~XVID_ME_EXTSEARCH16 &
734                     ~XVID_ME_ADVANCEDDIAMOND16;
735     motion_replacements = XVID_ME_FAST_MODEINTERPOLATE |
736                           XVID_ME_SKIP_DELTASEARCH |
737                           XVID_ME_FASTREFINE16 |
738                           XVID_ME_BFRAME_EARLYSTOP;
739     vop_remove = ~XVID_VOP_MODEDECISION_RD &
740                  ~XVID_VOP_FAST_MODEDECISION_RD &
741                  ~XVID_VOP_TRELLISQUANT &
742                  ~XVID_VOP_INTER4V &
743                  ~XVID_VOP_HQACPRED;
744
745     param->vol_flags &= ~XVID_VOL_GMC;
746     param->vop_flags &= vop_remove;
747     param->motion_flags &= motion_remove;
748     param->motion_flags |= motion_replacements;
749
750     return 0;
751 }
752
753 /**
754  * Capture statistic data and write it during first pass.
755  *
756  * @param ref Context pointer for the plugin
757  * @param param Statistic data
758  * @return Returns XVID_ERR_xxxx on failure, or 0 on success
759  */
760 static int xvid_ff_2pass_after(struct xvid_context *ref,
761                                 xvid_plg_data_t *param) {
762     char *log = ref->twopassbuffer;
763     const char *frame_types = " ipbs";
764     char frame_type;
765
766     /* Quick bounds check */
767     if( log == NULL )
768         return XVID_ERR_FAIL;
769
770     /* Convert the type given to us into a character */
771     if( param->type < 5 && param->type > 0 ) {
772         frame_type = frame_types[param->type];
773     } else {
774         return XVID_ERR_FAIL;
775     }
776
777     snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
778         "%c %d %d %d %d %d %d\n",
779         frame_type, param->stats.quant, param->stats.kblks, param->stats.mblks,
780         param->stats.ublks, param->stats.length, param->stats.hlength);
781
782     return 0;
783 }
784
785 /**
786  * Dispatch function for our custom plugin.
787  * This handles the dispatch for the Xvid plugin. It passes data
788  * on to other functions for actual processing.
789  *
790  * @param ref Context pointer for the plugin
791  * @param cmd The task given for us to complete
792  * @param p1 First parameter (varies)
793  * @param p2 Second parameter (varies)
794  * @return Returns XVID_ERR_xxxx on failure, or 0 on success
795  */
796 int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2) {
797     switch( cmd ) {
798         case XVID_PLG_INFO:
799         case XVID_PLG_FRAME:
800             return 0;
801
802         case XVID_PLG_BEFORE:
803             return xvid_ff_2pass_before(ref, p1);
804
805         case XVID_PLG_CREATE:
806             return xvid_ff_2pass_create(p1, p2);
807
808         case XVID_PLG_AFTER:
809             return xvid_ff_2pass_after(ref, p1);
810
811         case XVID_PLG_DESTROY:
812             return xvid_ff_2pass_destroy(ref, p1);
813
814         default:
815             return XVID_ERR_FAIL;
816     }
817 }
818
819 /**
820  * Xvid codec definition for libavcodec.
821  */
822 AVCodec ff_libxvid_encoder = {
823     .name           = "libxvid",
824     .type           = AVMEDIA_TYPE_VIDEO,
825     .id             = CODEC_ID_MPEG4,
826     .priv_data_size = sizeof(struct xvid_context),
827     .init           = xvid_encode_init,
828     .encode2        = xvid_encode_frame,
829     .close          = xvid_encode_close,
830     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
831     .long_name= NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
832 };
833
834 #endif /* CONFIG_LIBXVID_ENCODER */