FFmpeg
libxavs.c
Go to the documentation of this file.
1 /*
2  * AVS encoding using the xavs library
3  * Copyright (C) 2010 Amanda, Y.N. Wu <amanda11192003@gmail.com>
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 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <math.h>
26 #include <stdint.h>
27 #include <float.h>
28 #include <xavs.h>
29 #include "avcodec.h"
30 #include "internal.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/opt.h"
34 
35 #define END_OF_STREAM 0x001
36 
37 #define XAVS_PART_I8X8 0x002 /* Analyze i8x8 (requires 8x8 transform) */
38 #define XAVS_PART_P8X8 0x010 /* Analyze p16x8, p8x16 and p8x8 */
39 #define XAVS_PART_B8X8 0x100 /* Analyze b16x8, b*/
40 
41 typedef struct XavsContext {
42  AVClass *class;
43  xavs_param_t params;
44  xavs_t *enc;
45  xavs_picture_t pic;
47  int sei_size;
49  float crf;
50  int cqp;
51  int b_bias;
52  float cplxblur;
54  int aud;
57  int mbtree;
63 
64  int64_t *pts_buffer;
66 } XavsContext;
67 
68 static void XAVS_log(void *p, int level, const char *fmt, va_list args)
69 {
70  static const int level_map[] = {
71  [XAVS_LOG_ERROR] = AV_LOG_ERROR,
72  [XAVS_LOG_WARNING] = AV_LOG_WARNING,
73  [XAVS_LOG_INFO] = AV_LOG_INFO,
74  [XAVS_LOG_DEBUG] = AV_LOG_DEBUG
75  };
76 
77  if (level < 0 || level > XAVS_LOG_DEBUG)
78  return;
79 
80  av_vlog(p, level_map[level], fmt, args);
81 }
82 
84  xavs_nal_t *nals, int nnal)
85 {
86  XavsContext *x4 = ctx->priv_data;
87  uint8_t *p;
89 
90  if (!nnal)
91  return 0;
92 
93  for (i = 0; i < nnal; i++)
94  size += nals[i].i_payload;
95 
96  if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)
97  return ret;
98  p = pkt->data;
99 
100  /* Write the SEI as part of the first frame. */
101  if (x4->sei_size > 0 && nnal > 0) {
102  memcpy(p, x4->sei, x4->sei_size);
103  p += x4->sei_size;
104  x4->sei_size = 0;
105  }
106 
107  for (i = 0; i < nnal; i++) {
108  s = xavs_nal_encode(p, &size, 1, nals + i);
109  if (s < 0)
110  return -1;
111  p += s;
112  }
113  pkt->size = p - pkt->data;
114 
115  return 1;
116 }
117 
118 static int XAVS_frame(AVCodecContext *avctx, AVPacket *pkt,
119  const AVFrame *frame, int *got_packet)
120 {
121  XavsContext *x4 = avctx->priv_data;
122  xavs_nal_t *nal;
123  int nnal, i, ret;
124  xavs_picture_t pic_out;
125  int pict_type;
126 
127  x4->pic.img.i_csp = XAVS_CSP_I420;
128  x4->pic.img.i_plane = 3;
129 
130  if (frame) {
131  for (i = 0; i < 3; i++) {
132  x4->pic.img.plane[i] = frame->data[i];
133  x4->pic.img.i_stride[i] = frame->linesize[i];
134  }
135 
136  x4->pic.i_pts = frame->pts;
137  x4->pic.i_type = XAVS_TYPE_AUTO;
138  x4->pts_buffer[avctx->frame_number % (avctx->max_b_frames+1)] = frame->pts;
139  }
140 
141  if (xavs_encoder_encode(x4->enc, &nal, &nnal,
142  frame? &x4->pic: NULL, &pic_out) < 0)
143  return -1;
144 
145  ret = encode_nals(avctx, pkt, nal, nnal);
146 
147  if (ret < 0)
148  return -1;
149 
150  if (!ret) {
151  if (!frame && !(x4->end_of_stream)) {
152  if ((ret = ff_alloc_packet2(avctx, pkt, 4, 0)) < 0)
153  return ret;
154 
155  pkt->data[0] = 0x0;
156  pkt->data[1] = 0x0;
157  pkt->data[2] = 0x01;
158  pkt->data[3] = 0xb1;
159  pkt->dts = 2*x4->pts_buffer[(x4->out_frame_count-1)%(avctx->max_b_frames+1)] -
160  x4->pts_buffer[(x4->out_frame_count-2)%(avctx->max_b_frames+1)];
162  *got_packet = 1;
163  }
164  return 0;
165  }
166 
167 #if FF_API_CODED_FRAME
169  avctx->coded_frame->pts = pic_out.i_pts;
171 #endif
172  pkt->pts = pic_out.i_pts;
173  if (avctx->has_b_frames) {
174  if (!x4->out_frame_count)
175  pkt->dts = pkt->pts - (x4->pts_buffer[1] - x4->pts_buffer[0]);
176  else
177  pkt->dts = x4->pts_buffer[(x4->out_frame_count-1)%(avctx->max_b_frames+1)];
178  } else
179  pkt->dts = pkt->pts;
180 
181  switch (pic_out.i_type) {
182  case XAVS_TYPE_IDR:
183  case XAVS_TYPE_I:
184  pict_type = AV_PICTURE_TYPE_I;
185  break;
186  case XAVS_TYPE_P:
187  pict_type = AV_PICTURE_TYPE_P;
188  break;
189  case XAVS_TYPE_B:
190  case XAVS_TYPE_BREF:
191  pict_type = AV_PICTURE_TYPE_B;
192  break;
193  default:
194  pict_type = AV_PICTURE_TYPE_NONE;
195  }
196 #if FF_API_CODED_FRAME
198  avctx->coded_frame->pict_type = pict_type;
200 #endif
201 
202  /* There is no IDR frame in AVS JiZhun */
203  /* Sequence header is used as a flag */
204  if (pic_out.i_type == XAVS_TYPE_I) {
205 #if FF_API_CODED_FRAME
207  avctx->coded_frame->key_frame = 1;
209 #endif
210  pkt->flags |= AV_PKT_FLAG_KEY;
211  }
212 
213 #if FF_API_CODED_FRAME
215  avctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
217 #endif
218 
219  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
220 
221  x4->out_frame_count++;
222  *got_packet = ret;
223  return 0;
224 }
225 
227 {
228  XavsContext *x4 = avctx->priv_data;
229 
230  av_freep(&avctx->extradata);
231  av_freep(&x4->sei);
232  av_freep(&x4->pts_buffer);
233 
234  if (x4->enc)
235  xavs_encoder_close(x4->enc);
236 
237  return 0;
238 }
239 
240 static av_cold int XAVS_init(AVCodecContext *avctx)
241 {
242  XavsContext *x4 = avctx->priv_data;
243 
244  x4->sei_size = 0;
245  xavs_param_default(&x4->params);
246 
247  x4->params.pf_log = XAVS_log;
248  x4->params.p_log_private = avctx;
249  x4->params.i_keyint_max = avctx->gop_size;
250  if (avctx->bit_rate) {
251  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
252  x4->params.rc.i_rc_method = XAVS_RC_ABR;
253  }
254  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
255  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
256  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
257  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
258  x4->params.rc.b_stat_read = 1;
259  } else {
260  if (x4->crf >= 0) {
261  x4->params.rc.i_rc_method = XAVS_RC_CRF;
262  x4->params.rc.f_rf_constant = x4->crf;
263  } else if (x4->cqp >= 0) {
264  x4->params.rc.i_rc_method = XAVS_RC_CQP;
265  x4->params.rc.i_qp_constant = x4->cqp;
266  }
267  }
268 
269  if (x4->aud >= 0)
270  x4->params.b_aud = x4->aud;
271  if (x4->mbtree >= 0)
272  x4->params.rc.b_mb_tree = x4->mbtree;
273  if (x4->direct_pred >= 0)
274  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
275  if (x4->fast_pskip >= 0)
276  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
277  if (x4->motion_est >= 0)
278  x4->params.analyse.i_me_method = x4->motion_est;
279  if (x4->mixed_refs >= 0)
280  x4->params.analyse.b_mixed_references = x4->mixed_refs;
281  if (x4->b_bias != INT_MIN)
282  x4->params.i_bframe_bias = x4->b_bias;
283  if (x4->cplxblur >= 0)
284  x4->params.rc.f_complexity_blur = x4->cplxblur;
285 
286  x4->params.i_bframe = avctx->max_b_frames;
287  /* cabac is not included in AVS JiZhun Profile */
288  x4->params.b_cabac = 0;
289 
290 #if FF_API_PRIVATE_OPT
292  if (avctx->b_frame_strategy)
293  x4->b_frame_strategy = avctx->b_frame_strategy;
295 #endif
296 
297  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
298 
299  avctx->has_b_frames = !!avctx->max_b_frames;
300 
301  /* AVS doesn't allow B picture as reference */
302  /* The max allowed reference frame number of B is 2 */
303  x4->params.i_keyint_min = avctx->keyint_min;
304  if (x4->params.i_keyint_min > x4->params.i_keyint_max)
305  x4->params.i_keyint_min = x4->params.i_keyint_max;
306 
307 #if FF_API_PRIVATE_OPT
309  if (avctx->scenechange_threshold)
312 #endif
313 
314  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
315 
316  // x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
317 
318  x4->params.rc.i_qp_min = avctx->qmin;
319  x4->params.rc.i_qp_max = avctx->qmax;
320  x4->params.rc.i_qp_step = avctx->max_qdiff;
321 
322  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
323  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
324 
325  x4->params.i_frame_reference = avctx->refs;
326 
327  x4->params.i_width = avctx->width;
328  x4->params.i_height = avctx->height;
329  x4->params.vui.i_sar_width = avctx->sample_aspect_ratio.num;
330  x4->params.vui.i_sar_height = avctx->sample_aspect_ratio.den;
331  /* This is only used for counting the fps */
332  x4->params.i_fps_num = avctx->time_base.den;
333  x4->params.i_fps_den = avctx->time_base.num;
334  x4->params.analyse.inter = XAVS_ANALYSE_I8x8 |XAVS_ANALYSE_PSUB16x16| XAVS_ANALYSE_BSUB16x16;
335 
336  x4->params.analyse.i_me_range = avctx->me_range;
337  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
338 
339  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
340  /* AVS P2 only enables 8x8 transform */
341  x4->params.analyse.b_transform_8x8 = 1; //avctx->flags2 & AV_CODEC_FLAG2_8X8DCT;
342 
343  x4->params.analyse.i_trellis = avctx->trellis;
344 
345 #if FF_API_PRIVATE_OPT
347  if (avctx->noise_reduction >= 0)
348  x4->noise_reduction = avctx->noise_reduction;
350 #endif
351 
352  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
353 
354  if (avctx->level > 0)
355  x4->params.i_level_idc = avctx->level;
356 
357  if (avctx->bit_rate > 0)
358  x4->params.rc.f_rate_tolerance =
359  (float)avctx->bit_rate_tolerance / avctx->bit_rate;
360 
361  if ((avctx->rc_buffer_size) &&
362  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
363  x4->params.rc.f_vbv_buffer_init =
364  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
365  } else
366  x4->params.rc.f_vbv_buffer_init = 0.9;
367 
368  /* TAG:do we have MB tree RC method */
369  /* what is the RC method we are now using? Default NO */
370  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
371  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
372 
373 #if FF_API_PRIVATE_OPT
375  if (avctx->chromaoffset)
376  x4->chroma_offset = avctx->chromaoffset;
378 #endif
379 
380  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
381 
382  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
383  x4->params.i_log_level = XAVS_LOG_DEBUG;
384  x4->params.i_threads = avctx->thread_count;
385  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
386 
387  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
388  x4->params.b_repeat_headers = 0;
389 
390  x4->enc = xavs_encoder_open(&x4->params);
391  if (!x4->enc)
392  return -1;
393 
394  if (!(x4->pts_buffer = av_mallocz_array((avctx->max_b_frames+1), sizeof(*x4->pts_buffer))))
395  return AVERROR(ENOMEM);
396 
397  /* TAG: Do we have GLOBAL HEADER in AVS */
398  /* We Have PPS and SPS in AVS */
399  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER && 0) {
400  xavs_nal_t *nal;
401  int nnal, s, i, size;
402  uint8_t *p;
403 
404  s = xavs_encoder_headers(x4->enc, &nal, &nnal);
405 
406  avctx->extradata = p = av_malloc(s);
407  for (i = 0; i < nnal; i++) {
408  /* Don't put the SEI in extradata. */
409  if (nal[i].i_type == NAL_SEI) {
410  x4->sei = av_malloc( 5 + nal[i].i_payload * 4 / 3 );
411  if (xavs_nal_encode(x4->sei, &x4->sei_size, 1, nal + i) < 0)
412  return -1;
413 
414  continue;
415  }
416  size = xavs_nal_encode(p, &s, 1, nal + i);
417  if (size < 0)
418  return -1;
419  p += size;
420  }
421  avctx->extradata_size = p - avctx->extradata;
422  }
423  return 0;
424 }
425 
426 #define OFFSET(x) offsetof(XavsContext, x)
427 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
428 static const AVOption options[] = {
429  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
430  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, VE },
431  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, {.i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
432  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
433  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
434  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
435  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
436  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
437  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
438  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},
439  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},
440  { "mixed-refs", "One reference per partition, as opposed to one reference per macroblock", OFFSET(mixed_refs), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE },
441  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},
442  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = XAVS_ME_DIA }, -1, XAVS_ME_TESA, VE, "motion-est"},
443  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
444  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
445  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
446  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
447  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
448  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, VE},
449  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE},
450  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, VE},
451  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, VE},
452 
453  { NULL },
454 };
455 
456 static const AVClass xavs_class = {
457  .class_name = "libxavs",
458  .item_name = av_default_item_name,
459  .option = options,
460  .version = LIBAVUTIL_VERSION_INT,
461 };
462 
463 static const AVCodecDefault xavs_defaults[] = {
464  { "b", "0" },
465  { NULL },
466 };
467 
469  .name = "libxavs",
470  .long_name = NULL_IF_CONFIG_SMALL("libxavs Chinese AVS (Audio Video Standard)"),
471  .type = AVMEDIA_TYPE_VIDEO,
472  .id = AV_CODEC_ID_CAVS,
473  .priv_data_size = sizeof(XavsContext),
474  .init = XAVS_init,
475  .encode2 = XAVS_frame,
476  .close = XAVS_close,
479  .priv_class = &xavs_class,
480  .defaults = xavs_defaults,
481  .wrapper_name = "libxavs",
482 };
#define NULL
Definition: coverity.c:32
#define VE
Definition: libxavs.c:427
int chroma_offset
Definition: libxavs.c:60
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:720
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:896
const char * fmt
Definition: avisynth_c.h:861
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:2400
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Memory handling functions.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:1825
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2471
xavs_t * enc
Definition: libxavs.c:44
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
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:1944
int end_of_stream
Definition: libxavs.c:48
static void XAVS_log(void *p, int level, const char *fmt, va_list args)
Definition: libxavs.c:68
static AVPacket pkt
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1049
AVCodec.
Definition: avcodec.h:3481
static const AVOption options[]
Definition: libxavs.c:428
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
Undefined.
Definition: avutil.h:273
static av_cold int XAVS_close(AVCodecContext *avctx)
Definition: libxavs.c:226
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1006
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
Definition: avcodec.h:1623
uint8_t * sei
Definition: libxavs.c:46
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:2036
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:1834
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1951
uint8_t * data
Definition: avcodec.h:1477
ptrdiff_t size
Definition: opengl_enc.c:100
#define FF_CMP_CHROMA
Definition: avcodec.h:1986
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:797
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, xavs_nal_t *nals, int nnal)
Definition: libxavs.c:83
int b_frame_strategy
Definition: libxavs.c:59
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1855
#define END_OF_STREAM
Definition: libxavs.c:35
int qmax
maximum quantizer
Definition: avcodec.h:2414
static av_cold int XAVS_init(AVCodecContext *avctx)
Definition: libxavs.c:240
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int b_bias
Definition: libxavs.c:51
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:1870
int mixed_refs
Definition: libxavs.c:58
int fast_pskip
Definition: libxavs.c:55
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2428
int direct_pred
Definition: libxavs.c:53
common internal API header
int refs
number of reference frames
Definition: avcodec.h:2153
static const AVCodecDefault xavs_defaults[]
Definition: libxavs.c:463
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int out_frame_count
Definition: libxavs.c:65
int noise_reduction
Definition: libxavs.c:62
int width
picture width / height.
Definition: avcodec.h:1738
attribute_deprecated int noise_reduction
Definition: avcodec.h:2083
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:887
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:871
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:3018
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:418
static const AVClass xavs_class
Definition: libxavs.c:456
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:2421
xavs_param_t params
Definition: libxavs.c:43
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2824
if(ret)
static int XAVS_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libxavs.c:118
int motion_est
Definition: libxavs.c:56
float cplxblur
Definition: libxavs.c:52
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Libavcodec external API header.
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:2079
int mbtree
Definition: libxavs.c:57
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1839
main external API structure.
Definition: avcodec.h:1565
int qmin
minimum quantizer
Definition: avcodec.h:2407
int extradata_size
Definition: avcodec.h:1667
int scenechange_threshold
Definition: libxavs.c:61
int sei_size
Definition: libxavs.c:47
Describe the class of an AVClass context structure.
Definition: log.h:67
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level...
Definition: log.c:373
attribute_deprecated int chromaoffset
Definition: avcodec.h:2158
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2399
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:904
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1760
int cqp
Definition: libxavs.c:50
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
Bi-dir predicted.
Definition: avutil.h:276
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2815
int den
Denominator.
Definition: rational.h:60
int trellis
trellis RD quantization
Definition: avcodec.h:2514
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:875
void * priv_data
Definition: avcodec.h:1592
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
AVCodec ff_libxavs_encoder
Definition: libxavs.c:468
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
float crf
Definition: libxavs.c:49
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2256
#define av_freep(p)
int64_t * pts_buffer
Definition: libxavs.c:64
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define OFFSET(x)
Definition: libxavs.c:426
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
int aud
Definition: libxavs.c:54
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:2027
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
Predicted.
Definition: avutil.h:275
xavs_picture_t pic
Definition: libxavs.c:45
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2443
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
int keyint_min
minimum GOP size
Definition: avcodec.h:2146