FFmpeg
libxvid.c
Go to the documentation of this file.
1 /*
2  * Interface to xvidcore for MPEG-4 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 <stdio.h>
29 #include <string.h>
30 #include <xvid.h>
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/cpu.h"
34 #include "libavutil/file.h"
35 #include "libavutil/internal.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/mem.h"
39 #include "libavutil/opt.h"
40 
41 #include "avcodec.h"
42 #include "internal.h"
43 #include "libxvid.h"
44 #include "mpegutils.h"
45 #include "packet_internal.h"
46 
47 #if HAVE_UNISTD_H
48 #include <unistd.h>
49 #endif
50 
51 #if HAVE_IO_H
52 #include <io.h>
53 #endif
54 
55 /**
56  * Buffer management macros.
57  */
58 #define BUFFER_SIZE 1024
59 #define BUFFER_REMAINING(x) (BUFFER_SIZE - strlen(x))
60 #define BUFFER_CAT(x) (&((x)[strlen(x)]))
61 
62 /**
63  * Structure for the private Xvid context.
64  * This stores all the private context for the codec.
65  */
66 struct xvid_context {
67  AVClass *class;
68  void *encoder_handle; /**< Handle for Xvid encoder */
69  int xsize; /**< Frame x size */
70  int ysize; /**< Frame y size */
71  int vop_flags; /**< VOP flags for Xvid encoder */
72  int vol_flags; /**< VOL flags for Xvid encoder */
73  int me_flags; /**< Motion Estimation flags */
74  int qscale; /**< Do we use constant scale? */
75  int quicktime_format; /**< Are we in a QT-based format? */
76  char *twopassbuffer; /**< Character buffer for two-pass */
77  char *old_twopassbuffer; /**< Old character buffer (two-pass) */
78  char *twopassfile; /**< second pass temp file name */
79  int twopassfd;
80  unsigned char *intra_matrix; /**< P-Frame Quant Matrix */
81  unsigned char *inter_matrix; /**< I-Frame Quant Matrix */
82  int lumi_aq; /**< Lumi masking as an aq method */
83  int variance_aq; /**< Variance adaptive quantization */
84  int ssim; /**< SSIM information display mode */
85  int ssim_acc; /**< SSIM accuracy. 0: accurate. 4: fast. */
86  int gmc;
87  int me_quality; /**< Motion estimation quality. 0: fast 6: best. */
88  int mpeg_quant; /**< Quantization type. 0: H.263, 1: MPEG */
89 };
90 
91 /**
92  * Structure for the private first-pass plugin.
93  */
94 struct xvid_ff_pass1 {
95  int version; /**< Xvid version */
96  struct xvid_context *context; /**< Pointer to private context */
97 };
98 
99 static int xvid_encode_close(AVCodecContext *avctx);
100 static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
101  const AVFrame *picture, int *got_packet);
102 
103 
104 /*
105  * Xvid 2-Pass Kludge Section
106  *
107  * Xvid's default 2-pass doesn't allow us to create data as we need to, so
108  * this section spends time replacing the first pass plugin so we can write
109  * statistic information as libavcodec requests in. We have another kludge
110  * that allows us to pass data to the second pass in Xvid without a custom
111  * rate-control plugin.
112  */
113 
114 /**
115  * Initialize the two-pass plugin and context.
116  *
117  * @param param Input construction parameter structure
118  * @param handle Private context handle
119  * @return Returns XVID_ERR_xxxx on failure, or 0 on success.
120  */
121 static int xvid_ff_2pass_create(xvid_plg_create_t *param, void **handle)
122 {
123  struct xvid_ff_pass1 *x = (struct xvid_ff_pass1 *) param->param;
124  char *log = x->context->twopassbuffer;
125 
126  /* Do a quick bounds check */
127  if (!log)
128  return XVID_ERR_FAIL;
129 
130  /* We use snprintf() */
131  /* This is because we can safely prevent a buffer overflow */
132  log[0] = 0;
133  snprintf(log, BUFFER_REMAINING(log),
134  "# ffmpeg 2-pass log file, using xvid codec\n");
136  "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
137  XVID_VERSION_MAJOR(XVID_VERSION),
138  XVID_VERSION_MINOR(XVID_VERSION),
139  XVID_VERSION_PATCH(XVID_VERSION));
140 
141  *handle = x->context;
142  return 0;
143 }
144 
145 /**
146  * Destroy the two-pass plugin context.
147  *
148  * @param ref Context pointer for the plugin
149  * @param param Destroy context
150  * @return Returns 0, success guaranteed
151  */
153  xvid_plg_destroy_t *param)
154 {
155  /* Currently cannot think of anything to do on destruction */
156  /* Still, the framework should be here for reference/use */
157  if (ref->twopassbuffer)
158  ref->twopassbuffer[0] = 0;
159  return 0;
160 }
161 
162 /**
163  * Enable fast encode mode during the first pass.
164  *
165  * @param ref Context pointer for the plugin
166  * @param param Frame data
167  * @return Returns 0, success guaranteed
168  */
170  xvid_plg_data_t *param)
171 {
172  int motion_remove;
173  int motion_replacements;
174  int vop_remove;
175 
176  /* Nothing to do here, result is changed too much */
177  if (param->zone && param->zone->mode == XVID_ZONE_QUANT)
178  return 0;
179 
180  /* We can implement a 'turbo' first pass mode here */
181  param->quant = 2;
182 
183  /* Init values */
184  motion_remove = ~XVID_ME_CHROMA_PVOP &
185  ~XVID_ME_CHROMA_BVOP &
186  ~XVID_ME_EXTSEARCH16 &
187  ~XVID_ME_ADVANCEDDIAMOND16;
188  motion_replacements = XVID_ME_FAST_MODEINTERPOLATE |
189  XVID_ME_SKIP_DELTASEARCH |
190  XVID_ME_FASTREFINE16 |
191  XVID_ME_BFRAME_EARLYSTOP;
192  vop_remove = ~XVID_VOP_MODEDECISION_RD &
193  ~XVID_VOP_FAST_MODEDECISION_RD &
194  ~XVID_VOP_TRELLISQUANT &
195  ~XVID_VOP_INTER4V &
196  ~XVID_VOP_HQACPRED;
197 
198  param->vol_flags &= ~XVID_VOL_GMC;
199  param->vop_flags &= vop_remove;
200  param->motion_flags &= motion_remove;
201  param->motion_flags |= motion_replacements;
202 
203  return 0;
204 }
205 
206 /**
207  * Capture statistic data and write it during first pass.
208  *
209  * @param ref Context pointer for the plugin
210  * @param param Statistic data
211  * @return Returns XVID_ERR_xxxx on failure, or 0 on success
212  */
214  xvid_plg_data_t *param)
215 {
216  char *log = ref->twopassbuffer;
217  const char *frame_types = " ipbs";
218  char frame_type;
219 
220  /* Quick bounds check */
221  if (!log)
222  return XVID_ERR_FAIL;
223 
224  /* Convert the type given to us into a character */
225  if (param->type < 5 && param->type > 0)
226  frame_type = frame_types[param->type];
227  else
228  return XVID_ERR_FAIL;
229 
231  "%c %d %d %d %d %d %d\n",
232  frame_type, param->stats.quant, param->stats.kblks,
233  param->stats.mblks, param->stats.ublks,
234  param->stats.length, param->stats.hlength);
235 
236  return 0;
237 }
238 
239 /**
240  * Dispatch function for our custom plugin.
241  * This handles the dispatch for the Xvid plugin. It passes data
242  * on to other functions for actual processing.
243  *
244  * @param ref Context pointer for the plugin
245  * @param cmd The task given for us to complete
246  * @param p1 First parameter (varies)
247  * @param p2 Second parameter (varies)
248  * @return Returns XVID_ERR_xxxx on failure, or 0 on success
249  */
250 static int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2)
251 {
252  switch (cmd) {
253  case XVID_PLG_INFO:
254  case XVID_PLG_FRAME:
255  return 0;
256  case XVID_PLG_BEFORE:
257  return xvid_ff_2pass_before(ref, p1);
258  case XVID_PLG_CREATE:
259  return xvid_ff_2pass_create(p1, p2);
260  case XVID_PLG_AFTER:
261  return xvid_ff_2pass_after(ref, p1);
262  case XVID_PLG_DESTROY:
263  return xvid_ff_2pass_destroy(ref, p1);
264  default:
265  return XVID_ERR_FAIL;
266  }
267 }
268 
269 /**
270  * Routine to create a global VO/VOL header for MP4 container.
271  * What we do here is extract the header from the Xvid bitstream
272  * as it is encoded. We also strip the repeated headers from the
273  * bitstream when a global header is requested for MPEG-4 ISO
274  * compliance.
275  *
276  * @param avctx AVCodecContext pointer to context
277  * @param frame Pointer to encoded frame data
278  * @param header_len Length of header to search
279  * @param frame_len Length of encoded frame data
280  * @return Returns new length of frame data
281  */
283  unsigned int header_len,
284  unsigned int frame_len)
285 {
286  int vo_len = 0, i;
287 
288  for (i = 0; i < header_len - 3; i++) {
289  if (pkt->data[i] == 0x00 &&
290  pkt->data[i + 1] == 0x00 &&
291  pkt->data[i + 2] == 0x01 &&
292  pkt->data[i + 3] == 0xB6) {
293  vo_len = i;
294  break;
295  }
296  }
297 
298  if (vo_len > 0) {
299  /* We need to store the header, so extract it */
300  if (!avctx->extradata) {
301  avctx->extradata = av_malloc(vo_len);
302  if (!avctx->extradata)
303  return AVERROR(ENOMEM);
304  memcpy(avctx->extradata, pkt->data, vo_len);
305  avctx->extradata_size = vo_len;
306  }
307  /* Less dangerous now, memmove properly copies the two
308  * chunks of overlapping data */
309  memmove(pkt->data, &pkt->data[vo_len], frame_len - vo_len);
310  pkt->size = frame_len - vo_len;
311  }
312  return 0;
313 }
314 
315 /**
316  * Routine to correct a possibly erroneous framerate being fed to us.
317  * Xvid currently chokes on framerates where the ticks per frame is
318  * extremely large. This function works to correct problems in this area
319  * by estimating a new framerate and taking the simpler fraction of
320  * the two presented.
321  *
322  * @param avctx Context that contains the framerate to correct.
323  */
325 {
326  int frate, fbase;
327  int est_frate, est_fbase;
328  int gcd;
329  float est_fps, fps;
330 
331  frate = avctx->time_base.den;
332  fbase = avctx->time_base.num;
333 
334  gcd = av_gcd(frate, fbase);
335  if (gcd > 1) {
336  frate /= gcd;
337  fbase /= gcd;
338  }
339 
340  if (frate <= 65000 && fbase <= 65000) {
341  avctx->time_base.den = frate;
342  avctx->time_base.num = fbase;
343  return;
344  }
345 
346  fps = (float) frate / (float) fbase;
347  est_fps = roundf(fps * 1000.0) / 1000.0;
348 
349  est_frate = (int) est_fps;
350  if (est_fps > (int) est_fps) {
351  est_frate = (est_frate + 1) * 1000;
352  est_fbase = (int) roundf((float) est_frate / est_fps);
353  } else
354  est_fbase = 1;
355 
356  gcd = av_gcd(est_frate, est_fbase);
357  if (gcd > 1) {
358  est_frate /= gcd;
359  est_fbase /= gcd;
360  }
361 
362  if (fbase > est_fbase) {
363  avctx->time_base.den = est_frate;
364  avctx->time_base.num = est_fbase;
365  av_log(avctx, AV_LOG_DEBUG,
366  "Xvid: framerate re-estimated: %.2f, %.3f%% correction\n",
367  est_fps, (((est_fps - fps) / fps) * 100.0));
368  } else {
369  avctx->time_base.den = frate;
370  avctx->time_base.num = fbase;
371  }
372 }
373 
375 {
376  int xerr, i, ret = -1;
377  int xvid_flags = avctx->flags;
378  struct xvid_context *x = avctx->priv_data;
379  uint16_t *intra, *inter;
380  int fd;
381 
382  xvid_plugin_single_t single = { 0 };
383  struct xvid_ff_pass1 rc2pass1 = { 0 };
384  xvid_plugin_2pass2_t rc2pass2 = { 0 };
385  xvid_plugin_lumimasking_t masking_l = { 0 }; /* For lumi masking */
386  xvid_plugin_lumimasking_t masking_v = { 0 }; /* For variance AQ */
387  xvid_plugin_ssim_t ssim = { 0 };
388  xvid_gbl_init_t xvid_gbl_init = { 0 };
389  xvid_enc_create_t xvid_enc_create = { 0 };
390  xvid_enc_plugin_t plugins[4];
391 
392  x->twopassfd = -1;
393 
394  /* Bring in VOP flags from ffmpeg command-line */
395  x->vop_flags = XVID_VOP_HALFPEL; /* Bare minimum quality */
396  if (xvid_flags & AV_CODEC_FLAG_4MV)
397  x->vop_flags |= XVID_VOP_INTER4V; /* Level 3 */
398  if (avctx->trellis)
399  x->vop_flags |= XVID_VOP_TRELLISQUANT; /* Level 5 */
400  if (xvid_flags & AV_CODEC_FLAG_AC_PRED)
401  x->vop_flags |= XVID_VOP_HQACPRED; /* Level 6 */
402  if (xvid_flags & AV_CODEC_FLAG_GRAY)
403  x->vop_flags |= XVID_VOP_GREYSCALE;
404 
405  /* Decide which ME quality setting to use */
406  x->me_flags = 0;
407  switch (x->me_quality) {
408  case 6:
409  case 5:
410  x->me_flags |= XVID_ME_EXTSEARCH16 |
411  XVID_ME_EXTSEARCH8;
412  case 4:
413  case 3:
414  x->me_flags |= XVID_ME_ADVANCEDDIAMOND8 |
415  XVID_ME_HALFPELREFINE8 |
416  XVID_ME_CHROMA_PVOP |
417  XVID_ME_CHROMA_BVOP;
418  case 2:
419  case 1:
420  x->me_flags |= XVID_ME_ADVANCEDDIAMOND16 |
421  XVID_ME_HALFPELREFINE16;
422  }
423 
424  /* Decide how we should decide blocks */
425  switch (avctx->mb_decision) {
426  case 2:
427  x->vop_flags |= XVID_VOP_MODEDECISION_RD;
428  x->me_flags |= XVID_ME_HALFPELREFINE8_RD |
429  XVID_ME_QUARTERPELREFINE8_RD |
430  XVID_ME_EXTSEARCH_RD |
431  XVID_ME_CHECKPREDICTION_RD;
432  case 1:
433  if (!(x->vop_flags & XVID_VOP_MODEDECISION_RD))
434  x->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;
435  x->me_flags |= XVID_ME_HALFPELREFINE16_RD |
436  XVID_ME_QUARTERPELREFINE16_RD;
437  default:
438  break;
439  }
440 
441  /* Bring in VOL flags from ffmpeg command-line */
442  x->vol_flags = 0;
443  if (x->gmc) {
444  x->vol_flags |= XVID_VOL_GMC;
445  x->me_flags |= XVID_ME_GME_REFINE;
446  }
447  if (xvid_flags & AV_CODEC_FLAG_QPEL) {
448  x->vol_flags |= XVID_VOL_QUARTERPEL;
449  x->me_flags |= XVID_ME_QUARTERPELREFINE16;
450  if (x->vop_flags & XVID_VOP_INTER4V)
451  x->me_flags |= XVID_ME_QUARTERPELREFINE8;
452  }
453 
454  xvid_gbl_init.version = XVID_VERSION;
455  xvid_gbl_init.debug = 0;
456  xvid_gbl_init.cpu_flags = 0;
457 
458  /* Initialize */
459  xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
460 
461  /* Create the encoder reference */
462  xvid_enc_create.version = XVID_VERSION;
463 
464  /* Store the desired frame size */
465  xvid_enc_create.width =
466  x->xsize = avctx->width;
467  xvid_enc_create.height =
468  x->ysize = avctx->height;
469 
470  /* Xvid can determine the proper profile to use */
471  /* xvid_enc_create.profile = XVID_PROFILE_S_L3; */
472 
473  /* We don't use zones */
474  xvid_enc_create.zones = NULL;
475  xvid_enc_create.num_zones = 0;
476 
477  xvid_enc_create.num_threads = avctx->thread_count;
478 #if (XVID_VERSION <= 0x010303) && (XVID_VERSION >= 0x010300)
479  /* workaround for a bug in libxvidcore */
480  if (avctx->height <= 16) {
481  if (avctx->thread_count < 2) {
482  xvid_enc_create.num_threads = 0;
483  } else {
484  av_log(avctx, AV_LOG_ERROR,
485  "Too small height for threads > 1.");
486  return AVERROR(EINVAL);
487  }
488  }
489 #endif
490 
491  xvid_enc_create.plugins = plugins;
492  xvid_enc_create.num_plugins = 0;
493 
494  /* Initialize Buffers */
495  x->twopassbuffer = NULL;
496  x->old_twopassbuffer = NULL;
497  x->twopassfile = NULL;
498 
499  if (xvid_flags & AV_CODEC_FLAG_PASS1) {
500  rc2pass1.version = XVID_VERSION;
501  rc2pass1.context = x;
504  if (!x->twopassbuffer || !x->old_twopassbuffer) {
505  av_log(avctx, AV_LOG_ERROR,
506  "Xvid: Cannot allocate 2-pass log buffers\n");
507  return AVERROR(ENOMEM);
508  }
509  x->twopassbuffer[0] =
510  x->old_twopassbuffer[0] = 0;
511 
512  plugins[xvid_enc_create.num_plugins].func = xvid_ff_2pass;
513  plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
514  xvid_enc_create.num_plugins++;
515  } else if (xvid_flags & AV_CODEC_FLAG_PASS2) {
516  rc2pass2.version = XVID_VERSION;
517  rc2pass2.bitrate = avctx->bit_rate;
518 
519  fd = avpriv_tempfile("xvidff.", &x->twopassfile, 0, avctx);
520  if (fd < 0) {
521  av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write 2-pass pipe\n");
522  return fd;
523  }
524  x->twopassfd = fd;
525 
526  if (!avctx->stats_in) {
527  av_log(avctx, AV_LOG_ERROR,
528  "Xvid: No 2-pass information loaded for second pass\n");
529  return AVERROR(EINVAL);
530  }
531 
532  ret = write(fd, avctx->stats_in, strlen(avctx->stats_in));
533  if (ret == -1)
534  ret = AVERROR(errno);
535  else if (strlen(avctx->stats_in) > ret) {
536  av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write to 2-pass pipe\n");
537  ret = AVERROR(EIO);
538  }
539  if (ret < 0)
540  return ret;
541 
542  rc2pass2.filename = x->twopassfile;
543  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass2;
544  plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
545  xvid_enc_create.num_plugins++;
546  } else if (!(xvid_flags & AV_CODEC_FLAG_QSCALE)) {
547  /* Single Pass Bitrate Control! */
548  single.version = XVID_VERSION;
549  single.bitrate = avctx->bit_rate;
550 
551  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_single;
552  plugins[xvid_enc_create.num_plugins].param = &single;
553  xvid_enc_create.num_plugins++;
554  }
555 
556  if (avctx->lumi_masking != 0.0)
557  x->lumi_aq = 1;
558 
559  /* Luminance Masking */
560  if (x->lumi_aq) {
561  masking_l.method = 0;
562  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
563 
564  /* The old behavior is that when avctx->lumi_masking is specified,
565  * plugins[...].param = NULL. Trying to keep the old behavior here. */
566  plugins[xvid_enc_create.num_plugins].param =
567  avctx->lumi_masking ? NULL : &masking_l;
568  xvid_enc_create.num_plugins++;
569  }
570 
571  /* Variance AQ */
572  if (x->variance_aq) {
573  masking_v.method = 1;
574  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
575  plugins[xvid_enc_create.num_plugins].param = &masking_v;
576  xvid_enc_create.num_plugins++;
577  }
578 
579  if (x->lumi_aq && x->variance_aq )
580  av_log(avctx, AV_LOG_INFO,
581  "Both lumi_aq and variance_aq are enabled. The resulting quality"
582  "will be the worse one of the two effects made by the AQ.\n");
583 
584  /* SSIM */
585  if (x->ssim) {
586  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_ssim;
587  ssim.b_printstat = x->ssim == 2;
588  ssim.acc = x->ssim_acc;
589  ssim.cpu_flags = xvid_gbl_init.cpu_flags;
590  ssim.b_visualize = 0;
591  plugins[xvid_enc_create.num_plugins].param = &ssim;
592  xvid_enc_create.num_plugins++;
593  }
594 
595  /* Frame Rate and Key Frames */
596  xvid_correct_framerate(avctx);
597  xvid_enc_create.fincr = avctx->time_base.num;
598  xvid_enc_create.fbase = avctx->time_base.den;
599  if (avctx->gop_size > 0)
600  xvid_enc_create.max_key_interval = avctx->gop_size;
601  else
602  xvid_enc_create.max_key_interval = 240; /* Xvid's best default */
603 
604  /* Quants */
605  if (xvid_flags & AV_CODEC_FLAG_QSCALE)
606  x->qscale = 1;
607  else
608  x->qscale = 0;
609 
610  xvid_enc_create.min_quant[0] = avctx->qmin;
611  xvid_enc_create.min_quant[1] = avctx->qmin;
612  xvid_enc_create.min_quant[2] = avctx->qmin;
613  xvid_enc_create.max_quant[0] = avctx->qmax;
614  xvid_enc_create.max_quant[1] = avctx->qmax;
615  xvid_enc_create.max_quant[2] = avctx->qmax;
616 
617  /* Quant Matrices */
618  x->intra_matrix =
619  x->inter_matrix = NULL;
620 
621 #if FF_API_PRIVATE_OPT
623  if (avctx->mpeg_quant)
624  x->mpeg_quant = avctx->mpeg_quant;
626 #endif
627 
628  if (x->mpeg_quant)
629  x->vol_flags |= XVID_VOL_MPEGQUANT;
630  if ((avctx->intra_matrix || avctx->inter_matrix)) {
631  x->vol_flags |= XVID_VOL_MPEGQUANT;
632 
633  if (avctx->intra_matrix) {
634  intra = avctx->intra_matrix;
635  x->intra_matrix = av_malloc(sizeof(unsigned char) * 64);
636  if (!x->intra_matrix)
637  return AVERROR(ENOMEM);
638  } else
639  intra = NULL;
640  if (avctx->inter_matrix) {
641  inter = avctx->inter_matrix;
642  x->inter_matrix = av_malloc(sizeof(unsigned char) * 64);
643  if (!x->inter_matrix)
644  return AVERROR(ENOMEM);
645  } else
646  inter = NULL;
647 
648  for (i = 0; i < 64; i++) {
649  if (intra)
650  x->intra_matrix[i] = (unsigned char) intra[i];
651  if (inter)
652  x->inter_matrix[i] = (unsigned char) inter[i];
653  }
654  }
655 
656  /* Misc Settings */
657  xvid_enc_create.frame_drop_ratio = 0;
658  xvid_enc_create.global = 0;
659  if (xvid_flags & AV_CODEC_FLAG_CLOSED_GOP)
660  xvid_enc_create.global |= XVID_GLOBAL_CLOSED_GOP;
661 
662  /* Determines which codec mode we are operating in */
663  avctx->extradata = NULL;
664  avctx->extradata_size = 0;
665  if (xvid_flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
666  /* In this case, we are claiming to be MPEG-4 */
667  x->quicktime_format = 1;
668  avctx->codec_id = AV_CODEC_ID_MPEG4;
669  } else {
670  /* We are claiming to be Xvid */
671  x->quicktime_format = 0;
672  if (!avctx->codec_tag)
673  avctx->codec_tag = AV_RL32("xvid");
674  }
675 
676  /* Bframes */
677  xvid_enc_create.max_bframes = avctx->max_b_frames;
678  xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
679  xvid_enc_create.bquant_ratio = 100 * avctx->b_quant_factor;
680  if (avctx->max_b_frames > 0 && !x->quicktime_format)
681  xvid_enc_create.global |= XVID_GLOBAL_PACKED;
682 
683  av_assert0(xvid_enc_create.num_plugins + (!!x->ssim) + (!!x->variance_aq) + (!!x->lumi_aq) <= FF_ARRAY_ELEMS(plugins));
684 
685  /* Encode a dummy frame to get the extradata immediately */
686  if (x->quicktime_format) {
687  AVFrame *picture;
688  AVPacket packet = {0};
689  int size, got_packet, ret;
690 
691  av_init_packet(&packet);
692 
693  picture = av_frame_alloc();
694  if (!picture)
695  return AVERROR(ENOMEM);
696 
697  xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
698  if( xerr ) {
699  av_frame_free(&picture);
700  av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
701  return AVERROR_EXTERNAL;
702  }
703  x->encoder_handle = xvid_enc_create.handle;
704  size = ((avctx->width + 1) & ~1) * ((avctx->height + 1) & ~1);
705  picture->data[0] = av_malloc(size + size / 2);
706  if (!picture->data[0]) {
707  av_frame_free(&picture);
708  return AVERROR(ENOMEM);
709  }
710  picture->data[1] = picture->data[0] + size;
711  picture->data[2] = picture->data[1] + size / 4;
712  memset(picture->data[0], 0, size);
713  memset(picture->data[1], 128, size / 2);
714  ret = xvid_encode_frame(avctx, &packet, picture, &got_packet);
715  if (!ret && got_packet)
716  av_packet_unref(&packet);
717  av_free(picture->data[0]);
718  av_frame_free(&picture);
719  xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
720  }
721 
722  /* Create encoder context */
723  xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
724  if (xerr) {
725  av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
726  return AVERROR_EXTERNAL;
727  }
728 
729  x->encoder_handle = xvid_enc_create.handle;
730 
731  return 0;
732 }
733 
735  const AVFrame *picture, int *got_packet)
736 {
737  int xerr, i, ret, user_packet = !!pkt->data;
738  struct xvid_context *x = avctx->priv_data;
739  int mb_width = (avctx->width + 15) / 16;
740  int mb_height = (avctx->height + 15) / 16;
741  char *tmp;
742 
743  xvid_enc_frame_t xvid_enc_frame = { 0 };
744  xvid_enc_stats_t xvid_enc_stats = { 0 };
745 
746  if ((ret = ff_alloc_packet2(avctx, pkt, mb_width*(int64_t)mb_height*MAX_MB_BYTES + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
747  return ret;
748 
749  /* Start setting up the frame */
750  xvid_enc_frame.version = XVID_VERSION;
751  xvid_enc_stats.version = XVID_VERSION;
752 
753  /* Let Xvid know where to put the frame. */
754  xvid_enc_frame.bitstream = pkt->data;
755  xvid_enc_frame.length = pkt->size;
756 
757  /* Initialize input image fields */
758  if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
759  av_log(avctx, AV_LOG_ERROR,
760  "Xvid: Color spaces other than 420P not supported\n");
761  return AVERROR(EINVAL);
762  }
763 
764  xvid_enc_frame.input.csp = XVID_CSP_PLANAR; /* YUV420P */
765 
766  for (i = 0; i < 4; i++) {
767  xvid_enc_frame.input.plane[i] = picture->data[i];
768  xvid_enc_frame.input.stride[i] = picture->linesize[i];
769  }
770 
771  /* Encoder Flags */
772  xvid_enc_frame.vop_flags = x->vop_flags;
773  xvid_enc_frame.vol_flags = x->vol_flags;
774  xvid_enc_frame.motion = x->me_flags;
775  xvid_enc_frame.type =
776  picture->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :
777  picture->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :
778  picture->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :
779  XVID_TYPE_AUTO;
780 
781  /* Pixel aspect ratio setting */
782  if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.num > 255 ||
783  avctx->sample_aspect_ratio.den < 0 || avctx->sample_aspect_ratio.den > 255) {
784  av_log(avctx, AV_LOG_WARNING,
785  "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
788  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
789  }
790  xvid_enc_frame.par = XVID_PAR_EXT;
791  xvid_enc_frame.par_width = avctx->sample_aspect_ratio.num;
792  xvid_enc_frame.par_height = avctx->sample_aspect_ratio.den;
793 
794  /* Quant Setting */
795  if (x->qscale)
796  xvid_enc_frame.quant = picture->quality / FF_QP2LAMBDA;
797  else
798  xvid_enc_frame.quant = 0;
799 
800  /* Matrices */
801  xvid_enc_frame.quant_intra_matrix = x->intra_matrix;
802  xvid_enc_frame.quant_inter_matrix = x->inter_matrix;
803 
804  /* Encode */
805  xerr = xvid_encore(x->encoder_handle, XVID_ENC_ENCODE,
806  &xvid_enc_frame, &xvid_enc_stats);
807 
808  /* Two-pass log buffer swapping */
809  avctx->stats_out = NULL;
810  if (x->twopassbuffer) {
811  tmp = x->old_twopassbuffer;
813  x->twopassbuffer = tmp;
814  x->twopassbuffer[0] = 0;
815  if (x->old_twopassbuffer[0] != 0) {
816  avctx->stats_out = x->old_twopassbuffer;
817  }
818  }
819 
820  if (xerr > 0) {
821  int pict_type;
822 
823  *got_packet = 1;
824 
825  if (xvid_enc_stats.type == XVID_TYPE_PVOP)
826  pict_type = AV_PICTURE_TYPE_P;
827  else if (xvid_enc_stats.type == XVID_TYPE_BVOP)
828  pict_type = AV_PICTURE_TYPE_B;
829  else if (xvid_enc_stats.type == XVID_TYPE_SVOP)
830  pict_type = AV_PICTURE_TYPE_S;
831  else
832  pict_type = AV_PICTURE_TYPE_I;
833 
834 #if FF_API_CODED_FRAME
836  avctx->coded_frame->pict_type = pict_type;
837  avctx->coded_frame->quality = xvid_enc_stats.quant * FF_QP2LAMBDA;
839 #endif
840 
841  ff_side_data_set_encoder_stats(pkt, xvid_enc_stats.quant * FF_QP2LAMBDA, NULL, 0, pict_type);
842 
843  if (xvid_enc_frame.out_flags & XVID_KEYFRAME) {
844 #if FF_API_CODED_FRAME
846  avctx->coded_frame->key_frame = 1;
848 #endif
849  pkt->flags |= AV_PKT_FLAG_KEY;
850  if (x->quicktime_format)
851  return xvid_strip_vol_header(avctx, pkt,
852  xvid_enc_stats.hlength, xerr);
853  } else {
854 #if FF_API_CODED_FRAME
856  avctx->coded_frame->key_frame = 0;
858 #endif
859  }
860 
861  pkt->size = xerr;
862 
863  return 0;
864  } else {
865  if (!user_packet)
866  av_packet_unref(pkt);
867  if (!xerr)
868  return 0;
869  av_log(avctx, AV_LOG_ERROR,
870  "Xvid: Encoding Error Occurred: %i\n", xerr);
871  return AVERROR_EXTERNAL;
872  }
873 }
874 
876 {
877  struct xvid_context *x = avctx->priv_data;
878 
879  if (x->encoder_handle) {
880  xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
881  x->encoder_handle = NULL;
882  }
883 
884  av_freep(&avctx->extradata);
885  if (x->twopassbuffer) {
886  av_freep(&x->twopassbuffer);
888  avctx->stats_out = NULL;
889  }
890  if (x->twopassfd>=0) {
891  unlink(x->twopassfile);
892  close(x->twopassfd);
893  x->twopassfd = -1;
894  }
895  av_freep(&x->twopassfile);
896  av_freep(&x->intra_matrix);
897  av_freep(&x->inter_matrix);
898 
899  return 0;
900 }
901 
902 #define OFFSET(x) offsetof(struct xvid_context, x)
903 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
904 static const AVOption options[] = {
905  { "lumi_aq", "Luminance masking AQ", OFFSET(lumi_aq), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
906  { "variance_aq", "Variance AQ", OFFSET(variance_aq), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
907  { "ssim", "Show SSIM information to stdout", OFFSET(ssim), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE, "ssim" },
908  { "off", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "ssim" },
909  { "avg", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "ssim" },
910  { "frame", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "ssim" },
911  { "ssim_acc", "SSIM accuracy", OFFSET(ssim_acc), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, 4, VE },
912  { "gmc", "use GMC", OFFSET(gmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
913  { "me_quality", "Motion estimation quality", OFFSET(me_quality), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 6, VE },
914  { "mpeg_quant", "Use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
915  { NULL },
916 };
917 
918 static const AVClass xvid_class = {
919  .class_name = "libxvid",
920  .item_name = av_default_item_name,
921  .option = options,
922  .version = LIBAVUTIL_VERSION_INT,
923 };
924 
926  .name = "libxvid",
927  .long_name = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
928  .type = AVMEDIA_TYPE_VIDEO,
929  .id = AV_CODEC_ID_MPEG4,
930  .priv_data_size = sizeof(struct xvid_context),
931  .init = xvid_encode_init,
932  .encode2 = xvid_encode_frame,
933  .close = xvid_encode_close,
934  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
935  .priv_class = &xvid_class,
936  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
938  .wrapper_name = "libxvid",
939 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define NULL
Definition: coverity.c:32
S(GMC)-VOP MPEG-4.
Definition: avutil.h:277
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
AVOption.
Definition: opt.h:248
char * old_twopassbuffer
Old character buffer (two-pass)
Definition: libxvid.c:77
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:796
AVCodec ff_libxvid_encoder
Definition: libxvid.c:925
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Memory handling functions.
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:786
#define BUFFER_REMAINING(x)
Definition: libxvid.c:59
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
int avpriv_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx)
Wrapper to work around the lack of mkstemp() on mingw.
Definition: file_open.c:110
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1553
unsigned char * intra_matrix
P-Frame Quant Matrix.
Definition: libxvid.c:80
static AVPacket pkt
int ysize
Frame y size.
Definition: libxvid.c:70
AVCodec.
Definition: codec.h:190
int me_flags
Motion Estimation flags.
Definition: libxvid.c:73
frame_type
common functions for use with the Xvid wrappers
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
int xsize
Frame x size.
Definition: libxvid.c:69
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AVOptions.
static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *picture, int *got_packet)
Definition: libxvid.c:734
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:795
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
int quicktime_format
Are we in a QT-based format?
Definition: libxvid.c:75
Misc file utilities.
uint8_t * data
Definition: packet.h:363
struct xvid_context * context
Pointer to private context.
Definition: libxvid.c:96
static int xvid_strip_vol_header(AVCodecContext *avctx, AVPacket *pkt, unsigned int header_len, unsigned int frame_len)
Routine to create a global VO/VOL header for MP4 container.
Definition: libxvid.c:282
ptrdiff_t size
Definition: opengl_enc.c:100
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
float lumi_masking
luminance masking (0-> disabled)
Definition: avcodec.h:845
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1545
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2)
Dispatch function for our custom plugin.
Definition: libxvid.c:250
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int twopassfd
Definition: libxvid.c:79
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:279
#define MAX_MB_BYTES
Definition: mpegutils.h:47
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int qmax
maximum quantizer
Definition: avcodec.h:1375
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
const char * name
Name of the codec implementation.
Definition: codec.h:197
int me_quality
Motion estimation quality.
Definition: libxvid.c:87
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
#define OFFSET(x)
Definition: libxvid.c:902
static int xvid_encode_close(AVCodecContext *avctx)
Definition: libxvid.c:875
char * twopassfile
second pass temp file name
Definition: libxvid.c:78
common internal API header
static const AVOption options[]
Definition: libxvid.c:904
#define BUFFER_SIZE
Buffer management macros.
Definition: libxvid.c:58
int vop_flags
VOP flags for Xvid encoder.
Definition: libxvid.c:71
Structure for the private first-pass plugin.
Definition: libxvid.c:94
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
int variance_aq
Variance adaptive quantization.
Definition: libxvid.c:83
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
Definition: avcodec.h:338
Structure for the private Xvid context.
Definition: libxvid.c:66
int width
picture width / height.
Definition: avcodec.h:699
static const AVClass xvid_class
Definition: libxvid.c:918
unsigned char * inter_matrix
I-Frame Quant Matrix.
Definition: libxvid.c:81
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
int mb_decision
macroblock decision mode
Definition: avcodec.h:1014
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1785
if(ret)
int ssim_acc
SSIM accuracy.
Definition: libxvid.c:85
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
Libavcodec external API header.
attribute_deprecated int mpeg_quant
Definition: avcodec.h:821
#define BUFFER_CAT(x)
Definition: libxvid.c:60
enum AVCodecID codec_id
Definition: avcodec.h:536
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
main external API structure.
Definition: avcodec.h:526
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
int qmin
minimum quantizer
Definition: avcodec.h:1368
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:551
int extradata_size
Definition: avcodec.h:628
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1026
Describe the class of an AVClass context structure.
Definition: log.h:67
char * twopassbuffer
Character buffer for two-pass.
Definition: libxvid.c:76
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:808
#define snprintf
Definition: snprintf.h:34
static av_cold int xvid_encode_init(AVCodecContext *avctx)
Definition: libxvid.c:374
int version
Xvid version.
Definition: libxvid.c:95
static av_always_inline av_const float roundf(float x)
Definition: libm.h:451
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1035
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:287
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
int mpeg_quant
Quantization type.
Definition: libxvid.c:88
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
int ssim
SSIM information display mode.
Definition: libxvid.c:84
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int vol_flags
VOL flags for Xvid encoder.
Definition: libxvid.c:72
Bi-dir predicted.
Definition: avutil.h:276
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1776
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int den
Denominator.
Definition: rational.h:60
static int xvid_ff_2pass_create(xvid_plg_create_t *param, void **handle)
Initialize the two-pass plugin and context.
Definition: libxvid.c:121
int trellis
trellis RD quantization
Definition: avcodec.h:1475
static int xvid_ff_2pass_before(struct xvid_context *ref, xvid_plg_data_t *param)
Enable fast encode mode during the first pass.
Definition: libxvid.c:169
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
void * encoder_handle
Handle for Xvid encoder.
Definition: libxvid.c:68
void * priv_data
Definition: avcodec.h:553
static int xvid_ff_2pass_after(struct xvid_context *ref, xvid_plg_data_t *param)
Capture statistic data and write it during first pass.
Definition: libxvid.c:213
#define av_free(p)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
#define VE
Definition: libxvid.c:903
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
static int xvid_ff_2pass_destroy(struct xvid_context *ref, xvid_plg_destroy_t *param)
Destroy the two-pass plugin context.
Definition: libxvid.c:152
static void xvid_correct_framerate(AVCodecContext *avctx)
Routine to correct a possibly erroneous framerate being fed to us.
Definition: libxvid.c:324
#define av_freep(p)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:343
int qscale
Do we use constant scale?
Definition: libxvid.c:74
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
int lumi_aq
Lumi masking as an aq method.
Definition: libxvid.c:82
static uint8_t tmp[11]
Definition: aes_ctr.c:26