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