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