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