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