FFmpeg: libavcodec/libxvid.c Source File

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.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 "encode.h"
42 #include "internal.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;
132  snprintf(log, BUFFER_REMAINING(log),
133  "# ffmpeg 2-pass log file, using xvid codec\n");
134  snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
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  */
151  static int xvid_ff_2pass_destroy(struct xvid_context *ref,
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  */
168  static int xvid_ff_2pass_before(struct xvid_context *ref,
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  */
212  static int xvid_ff_2pass_after(struct xvid_context *ref,
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 
229  snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
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  */
281  static int xvid_strip_vol_header(AVCodecContext *avctx, AVPacket *pkt,
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  */
323  static void xvid_correct_framerate(AVCodecContext *avctx)
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 
373  static av_cold int xvid_encode_init(AVCodecContext *avctx)
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 2:
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 1:
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;
501  x->twopassbuffer = av_malloc(BUFFER_SIZE);
502  x->old_twopassbuffer = av_malloc(BUFFER_SIZE);
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  avctx->codec_id = AV_CODEC_ID_MPEG4;
661  } else {
662  /* We are claiming to be Xvid */
663  x->quicktime_format = 0;
664  if (!avctx->codec_tag)
665  avctx->codec_tag = AV_RL32("xvid");
666  }
667 
668  /* Bframes */
669  xvid_enc_create.max_bframes = avctx->max_b_frames;
670  xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
671  xvid_enc_create.bquant_ratio = 100 * avctx->b_quant_factor;
672  if (avctx->max_b_frames > 0 && !x->quicktime_format)
673  xvid_enc_create.global |= XVID_GLOBAL_PACKED;
674 
675  av_assert0(xvid_enc_create.num_plugins + (!!x->ssim) + (!!x->variance_aq) + (!!x->lumi_aq) <= FF_ARRAY_ELEMS(plugins));
676 
677  /* Encode a dummy frame to get the extradata immediately */
678  if (x->quicktime_format) {
679  AVFrame *picture;
680  AVPacket *packet;
681  int size, got_packet;
682 
683  packet = av_packet_alloc();
684  if (!packet)
685  return AVERROR(ENOMEM);
686 
687  picture = av_frame_alloc();
688  if (!picture) {
689  av_packet_free(&packet);
690  return AVERROR(ENOMEM);
691  }
692 
693  xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
694  if( xerr ) {
695  av_packet_free(&packet);
696  av_frame_free(&picture);
697  av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
698  return AVERROR_EXTERNAL;
699  }
700  x->encoder_handle = xvid_enc_create.handle;
701  size = ((avctx->width + 1) & ~1) * ((avctx->height + 1) & ~1);
702  picture->data[0] = av_malloc(size + size / 2);
703  if (!picture->data[0]) {
704  av_packet_free(&packet);
705  av_frame_free(&picture);
706  return AVERROR(ENOMEM);
707  }
708  picture->data[1] = picture->data[0] + size;
709  picture->data[2] = picture->data[1] + size / 4;
710  memset(picture->data[0], 0, size);
711  memset(picture->data[1], 128, size / 2);
712  xvid_encode_frame(avctx, packet, picture, &got_packet);
713  av_packet_free(&packet);
714  av_free(picture->data[0]);
715  av_frame_free(&picture);
716  xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
717  }
718 
719  /* Create encoder context */
720  xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
721  if (xerr) {
722  av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
723  return AVERROR_EXTERNAL;
724  }
725 
726  x->encoder_handle = xvid_enc_create.handle;
727 
728  return 0;
729 }
730 
731  static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
732  const AVFrame *picture, int *got_packet)
733 {
734  int xerr, i, ret;
735  struct xvid_context *x = avctx->priv_data;
736  int mb_width = (avctx->width + 15) / 16;
737  int mb_height = (avctx->height + 15) / 16;
738  char *tmp;
739 
740  xvid_enc_frame_t xvid_enc_frame = { 0 };
741  xvid_enc_stats_t xvid_enc_stats = { 0 };
742 
743  if ((ret = ff_alloc_packet(avctx, pkt, mb_width*(int64_t)mb_height*MAX_MB_BYTES + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
744  return ret;
745 
746  /* Start setting up the frame */
747  xvid_enc_frame.version = XVID_VERSION;
748  xvid_enc_stats.version = XVID_VERSION;
749 
750  /* Let Xvid know where to put the frame. */
751  xvid_enc_frame.bitstream = pkt->data;
752  xvid_enc_frame.length = pkt->size;
753 
754  /* Initialize input image fields */
755  if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
756  av_log(avctx, AV_LOG_ERROR,
757  "Xvid: Color spaces other than 420P not supported\n");
758  return AVERROR(EINVAL);
759  }
760 
761  xvid_enc_frame.input.csp = XVID_CSP_PLANAR; /* YUV420P */
762 
763  for (i = 0; i < 4; i++) {
764  xvid_enc_frame.input.plane[i] = picture->data[i];
765  xvid_enc_frame.input.stride[i] = picture->linesize[i];
766  }
767 
768  /* Encoder Flags */
769  xvid_enc_frame.vop_flags = x->vop_flags;
770  xvid_enc_frame.vol_flags = x->vol_flags;
771  xvid_enc_frame.motion = x->me_flags;
772  xvid_enc_frame.type =
773  picture->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :
774  picture->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :
775  picture->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :
776  XVID_TYPE_AUTO;
777 
778  /* Pixel aspect ratio setting */
779  if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.num > 255 ||
780  avctx->sample_aspect_ratio.den < 0 || avctx->sample_aspect_ratio.den > 255) {
781  av_log(avctx, AV_LOG_WARNING,
782  "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
783  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
784  av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
785  avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 255);
786  }
787  xvid_enc_frame.par = XVID_PAR_EXT;
788  xvid_enc_frame.par_width = avctx->sample_aspect_ratio.num;
789  xvid_enc_frame.par_height = avctx->sample_aspect_ratio.den;
790 
791  /* Quant Setting */
792  if (x->qscale)
793  xvid_enc_frame.quant = picture->quality / FF_QP2LAMBDA;
794  else
795  xvid_enc_frame.quant = 0;
796 
797  /* Matrices */
798  xvid_enc_frame.quant_intra_matrix = x->intra_matrix;
799  xvid_enc_frame.quant_inter_matrix = x->inter_matrix;
800 
801  /* Encode */
802  xerr = xvid_encore(x->encoder_handle, XVID_ENC_ENCODE,
803  &xvid_enc_frame, &xvid_enc_stats);
804 
805  /* Two-pass log buffer swapping */
806  avctx->stats_out = NULL;
807  if (x->twopassbuffer) {
808  tmp = x->old_twopassbuffer;
809  x->old_twopassbuffer = x->twopassbuffer;
810  x->twopassbuffer = tmp;
811  x->twopassbuffer[0] = 0;
812  if (x->old_twopassbuffer[0] != 0) {
813  avctx->stats_out = x->old_twopassbuffer;
814  }
815  }
816 
817  if (xerr > 0) {
818  int pict_type;
819 
820  *got_packet = 1;
821 
822  if (xvid_enc_stats.type == XVID_TYPE_PVOP)
823  pict_type = AV_PICTURE_TYPE_P;
824  else if (xvid_enc_stats.type == XVID_TYPE_BVOP)
825  pict_type = AV_PICTURE_TYPE_B;
826  else if (xvid_enc_stats.type == XVID_TYPE_SVOP)
827  pict_type = AV_PICTURE_TYPE_S;
828  else
829  pict_type = AV_PICTURE_TYPE_I;
830 
831  ff_side_data_set_encoder_stats(pkt, xvid_enc_stats.quant * FF_QP2LAMBDA, NULL, 0, pict_type);
832 
833  if (xvid_enc_frame.out_flags & XVID_KEYFRAME) {
834  pkt->flags |= AV_PKT_FLAG_KEY;
835  if (x->quicktime_format)
836  return xvid_strip_vol_header(avctx, pkt,
837  xvid_enc_stats.hlength, xerr);
838  }
839 
840  pkt->size = xerr;
841 
842  return 0;
843  } else {
844  if (!xerr)
845  return 0;
846  av_log(avctx, AV_LOG_ERROR,
847  "Xvid: Encoding Error Occurred: %i\n", xerr);
848  return AVERROR_EXTERNAL;
849  }
850 }
851 
852  static av_cold int xvid_encode_close(AVCodecContext *avctx)
853 {
854  struct xvid_context *x = avctx->priv_data;
855 
856  if (x->encoder_handle) {
857  xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
858  x->encoder_handle = NULL;
859  }
860 
861  if (x->twopassbuffer) {
862  av_freep(&x->twopassbuffer);
863  av_freep(&x->old_twopassbuffer);
864  avctx->stats_out = NULL;
865  }
866  if (x->twopassfd>=0) {
867  unlink(x->twopassfile);
868  close(x->twopassfd);
869  x->twopassfd = -1;
870  }
871  av_freep(&x->twopassfile);
872  av_freep(&x->intra_matrix);
873  av_freep(&x->inter_matrix);
874 
875  return 0;
876 }
877 
878  #define OFFSET(x) offsetof(struct xvid_context, x)
879  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
880  static const AVOption options[] = {
881  { "lumi_aq", "Luminance masking AQ", OFFSET(lumi_aq), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
882  { "variance_aq", "Variance AQ", OFFSET(variance_aq), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
883  { "ssim", "Show SSIM information to stdout", OFFSET(ssim), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE, "ssim" },
884  { "off", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "ssim" },
885  { "avg", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "ssim" },
886  { "frame", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "ssim" },
887  { "ssim_acc", "SSIM accuracy", OFFSET(ssim_acc), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, 4, VE },
888  { "gmc", "use GMC", OFFSET(gmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
889  { "me_quality", "Motion estimation quality", OFFSET(me_quality), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 6, VE },
890  { "mpeg_quant", "Use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
891  { NULL },
892 };
893 
894  static const AVClass xvid_class = {
895  .class_name = "libxvid",
896  .item_name = av_default_item_name,
897  .option = options,
898  .version = LIBAVUTIL_VERSION_INT,
899 };
900 
901  const AVCodec ff_libxvid_encoder = {
902  .name = "libxvid",
903  .long_name = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
904  .type = AVMEDIA_TYPE_VIDEO,
905  .id = AV_CODEC_ID_MPEG4,
906  .priv_data_size = sizeof(struct xvid_context),
907  .init = xvid_encode_init,
908  .encode2 = xvid_encode_frame,
909  .close = xvid_encode_close,
910  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
911  .priv_class = &xvid_class,
912  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
913  FF_CODEC_CAP_INIT_CLEANUP,
914  .wrapper_name = "libxvid",
915 };
AVCodec
AVCodec.
Definition: codec.h:202
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:186
FF_CODEC_CAP_INIT_THREADSAFE
#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:42
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ff_libxvid_encoder
const AVCodec ff_libxvid_encoder
Definition: libxvid.c:901
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
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: avpacket.c:604
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:210
AVCodecContext::intra_matrix
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions,...
Definition: avcodec.h:868
xvid_context::qscale
int qscale
Do we use constant scale?
Definition: libxvid.c:73
AVCodecContext::lumi_masking
float lumi_masking
luminance masking (0-> disabled)
Definition: avcodec.h:702
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
xvid_encode_frame
static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *picture, int *got_packet)
Definition: libxvid.c:731
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
encode.h
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:671
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:856
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1165
mpegutils.h
AV_CODEC_FLAG_4MV
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:214
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
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:338
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:268
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:36
init
static int init
Definition: av_tx.c:47
xvid_ff_pass1::context
struct xvid_context * context
Pointer to private context.
Definition: libxvid.c:95
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
xvid_context::intra_matrix
unsigned char * intra_matrix
P-Frame Quant Matrix.
Definition: libxvid.c:79
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:97
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
MAX_MB_BYTES
#define MAX_MB_BYTES
Definition: mpegutils.h:46
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:1244
xvid_context::ssim_acc
int ssim_acc
SSIM accuracy.
Definition: libxvid.c:84
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:185
OFFSET
#define OFFSET(x)
Definition: libxvid.c:878
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:66
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
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:66
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:433
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
BUFFER_CAT
#define BUFFER_CAT(x)
Definition: libxvid.c:59
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AV_CODEC_FLAG_AC_PRED
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
Definition: avcodec.h:277
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1229
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:880
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:506
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1236
AV_CODEC_FLAG_QPEL
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:222
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:110
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:414
xvid_class
static const AVClass xvid_class
Definition: libxvid.c:894
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:243
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:578
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:453
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:852
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:235
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:379
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
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:664
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:271
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:484
xvid_context::inter_matrix
unsigned char * inter_matrix
I-Frame Quant Matrix.
Definition: libxvid.c:80
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: internal.h:50
internal.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
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:282
ret
ret
Definition: filter_design.txt:187
VE
#define VE
Definition: libxvid.c:879
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:71
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:383
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:276
xvid_context::ssim
int ssim
SSIM information display mode.
Definition: libxvid.c:83
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1158
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
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
file.h
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:275
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:655
packet_internal.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:408
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::inter_matrix
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions,...
Definition: avcodec.h:877
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:556
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:362
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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
int
int
Definition: ffmpeg_filter.c:153
AV_PICTURE_TYPE_S
@ AV_PICTURE_TYPE_S
S(GMC)-VOP MPEG-4.
Definition: avutil.h:277
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
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:34
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:753
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:231
Generated on Wed Aug 24 2022 21:37:40 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /