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 "encode.h"
31 #include "internal.h"
32 #include "packet_internal.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/mem.h"
35 #include "libavutil/opt.h"
36 
37 #define END_OF_STREAM 0x001
38 
39 #define XAVS_PART_I8X8 0x002 /* Analyze i8x8 (requires 8x8 transform) */
40 #define XAVS_PART_P8X8 0x010 /* Analyze p16x8, p8x16 and p8x8 */
41 #define XAVS_PART_B8X8 0x100 /* Analyze b16x8, b*/
42 
43 typedef struct XavsContext {
44  AVClass *class;
45  xavs_param_t params;
46  xavs_t *enc;
47  xavs_picture_t pic;
48  uint8_t *sei;
49  int sei_size;
51  float crf;
52  int cqp;
53  int b_bias;
54  float cplxblur;
56  int aud;
59  int mbtree;
65 
66  int64_t *pts_buffer;
68 } XavsContext;
69 
70 static void XAVS_log(void *p, int level, const char *fmt, va_list args)
71 {
72  static const int level_map[] = {
73  [XAVS_LOG_ERROR] = AV_LOG_ERROR,
74  [XAVS_LOG_WARNING] = AV_LOG_WARNING,
75  [XAVS_LOG_INFO] = AV_LOG_INFO,
76  [XAVS_LOG_DEBUG] = AV_LOG_DEBUG
77  };
78 
79  if (level < 0 || level > XAVS_LOG_DEBUG)
80  return;
81 
82  av_vlog(p, level_map[level], fmt, args);
83 }
84 
86  xavs_nal_t *nals, int nnal)
87 {
88  XavsContext *x4 = ctx->priv_data;
89  int64_t size = x4->sei_size;
90  uint8_t *p, *p_end;
91  int i, s, ret;
92 
93  if (!nnal)
94  return 0;
95 
96  for (i = 0; i < nnal; i++)
97  size += 3U + nals[i].i_payload;
98 
99  if ((ret = ff_get_encode_buffer(ctx, pkt, size, 0)) < 0)
100  return ret;
101  p = pkt->data;
102  p_end = pkt->data + size;
103 
104  /* Write the SEI as part of the first frame. */
105  if (x4->sei_size > 0 && nnal > 0) {
106  memcpy(p, x4->sei, x4->sei_size);
107  p += x4->sei_size;
108  x4->sei_size = 0;
109  }
110 
111  for (i = 0; i < nnal; i++) {
112  int size = p_end - p;
113  s = xavs_nal_encode(p, &size, 1, nals + i);
114  if (s < 0)
115  return AVERROR_EXTERNAL;
116  if (s != 3U + nals[i].i_payload)
117  return AVERROR_EXTERNAL;
118  p += s;
119  }
120 
121  return 1;
122 }
123 
124 static int XAVS_frame(AVCodecContext *avctx, AVPacket *pkt,
125  const AVFrame *frame, int *got_packet)
126 {
127  XavsContext *x4 = avctx->priv_data;
128  xavs_nal_t *nal;
129  int nnal, i, ret;
130  xavs_picture_t pic_out;
131  int pict_type;
132 
133  x4->pic.img.i_csp = XAVS_CSP_I420;
134  x4->pic.img.i_plane = 3;
135 
136  if (frame) {
137  for (i = 0; i < 3; i++) {
138  x4->pic.img.plane[i] = frame->data[i];
139  x4->pic.img.i_stride[i] = frame->linesize[i];
140  }
141 
142  x4->pic.i_pts = frame->pts;
143  x4->pic.i_type = XAVS_TYPE_AUTO;
144  x4->pts_buffer[avctx->frame_number % (avctx->max_b_frames+1)] = frame->pts;
145  }
146 
147  if (xavs_encoder_encode(x4->enc, &nal, &nnal,
148  frame? &x4->pic: NULL, &pic_out) < 0)
149  return AVERROR_EXTERNAL;
150 
151  ret = encode_nals(avctx, pkt, nal, nnal);
152 
153  if (ret < 0)
154  return ret;
155 
156  if (!ret) {
157  if (!frame && !(x4->end_of_stream)) {
158  if ((ret = ff_get_encode_buffer(avctx, pkt, 4, 0)) < 0)
159  return ret;
160 
161  pkt->data[0] = 0x0;
162  pkt->data[1] = 0x0;
163  pkt->data[2] = 0x01;
164  pkt->data[3] = 0xb1;
165  pkt->dts = 2*x4->pts_buffer[(x4->out_frame_count-1)%(avctx->max_b_frames+1)] -
166  x4->pts_buffer[(x4->out_frame_count-2)%(avctx->max_b_frames+1)];
168  *got_packet = 1;
169  }
170  return 0;
171  }
172 
173  pkt->pts = pic_out.i_pts;
174  if (avctx->has_b_frames) {
175  if (!x4->out_frame_count)
176  pkt->dts = pkt->pts - (x4->pts_buffer[1] - x4->pts_buffer[0]);
177  else
178  pkt->dts = x4->pts_buffer[(x4->out_frame_count-1)%(avctx->max_b_frames+1)];
179  } else
180  pkt->dts = pkt->pts;
181 
182  switch (pic_out.i_type) {
183  case XAVS_TYPE_IDR:
184  case XAVS_TYPE_I:
185  pict_type = AV_PICTURE_TYPE_I;
186  break;
187  case XAVS_TYPE_P:
188  pict_type = AV_PICTURE_TYPE_P;
189  break;
190  case XAVS_TYPE_B:
191  case XAVS_TYPE_BREF:
192  pict_type = AV_PICTURE_TYPE_B;
193  break;
194  default:
195  pict_type = AV_PICTURE_TYPE_NONE;
196  }
197 
198  /* There is no IDR frame in AVS JiZhun */
199  /* Sequence header is used as a flag */
200  if (pic_out.i_type == XAVS_TYPE_I) {
202  }
203 
204  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
205 
206  x4->out_frame_count++;
207  *got_packet = ret;
208  return 0;
209 }
210 
212 {
213  XavsContext *x4 = avctx->priv_data;
214 
215  av_freep(&x4->sei);
216  av_freep(&x4->pts_buffer);
217 
218  if (x4->enc)
219  xavs_encoder_close(x4->enc);
220 
221  return 0;
222 }
223 
224 static av_cold int XAVS_init(AVCodecContext *avctx)
225 {
226  XavsContext *x4 = avctx->priv_data;
227 
228  x4->sei_size = 0;
229  xavs_param_default(&x4->params);
230 
231  x4->params.pf_log = XAVS_log;
232  x4->params.p_log_private = avctx;
233  x4->params.i_keyint_max = avctx->gop_size;
234  if (avctx->bit_rate) {
235  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
236  x4->params.rc.i_rc_method = XAVS_RC_ABR;
237  }
238  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
239  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
240  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
241  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
242  x4->params.rc.b_stat_read = 1;
243  } else {
244  if (x4->crf >= 0) {
245  x4->params.rc.i_rc_method = XAVS_RC_CRF;
246  x4->params.rc.f_rf_constant = x4->crf;
247  } else if (x4->cqp >= 0) {
248  x4->params.rc.i_rc_method = XAVS_RC_CQP;
249  x4->params.rc.i_qp_constant = x4->cqp;
250  }
251  }
252 
253  if (x4->aud >= 0)
254  x4->params.b_aud = x4->aud;
255  if (x4->mbtree >= 0)
256  x4->params.rc.b_mb_tree = x4->mbtree;
257  if (x4->direct_pred >= 0)
258  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
259  if (x4->fast_pskip >= 0)
260  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
261  if (x4->motion_est >= 0)
262  x4->params.analyse.i_me_method = x4->motion_est;
263  if (x4->mixed_refs >= 0)
264  x4->params.analyse.b_mixed_references = x4->mixed_refs;
265  if (x4->b_bias != INT_MIN)
266  x4->params.i_bframe_bias = x4->b_bias;
267  if (x4->cplxblur >= 0)
268  x4->params.rc.f_complexity_blur = x4->cplxblur;
269 
270  x4->params.i_bframe = avctx->max_b_frames;
271  /* cabac is not included in AVS JiZhun Profile */
272  x4->params.b_cabac = 0;
273 
274  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
275 
276  avctx->has_b_frames = !!avctx->max_b_frames;
277 
278  /* AVS doesn't allow B picture as reference */
279  /* The max allowed reference frame number of B is 2 */
280  x4->params.i_keyint_min = avctx->keyint_min;
281  if (x4->params.i_keyint_min > x4->params.i_keyint_max)
282  x4->params.i_keyint_min = x4->params.i_keyint_max;
283 
284  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
285 
286  // x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
287 
288  x4->params.rc.i_qp_min = avctx->qmin;
289  x4->params.rc.i_qp_max = avctx->qmax;
290  x4->params.rc.i_qp_step = avctx->max_qdiff;
291 
292  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
293  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
294 
295  x4->params.i_frame_reference = avctx->refs;
296 
297  x4->params.i_width = avctx->width;
298  x4->params.i_height = avctx->height;
299  x4->params.vui.i_sar_width = avctx->sample_aspect_ratio.num;
300  x4->params.vui.i_sar_height = avctx->sample_aspect_ratio.den;
301  /* This is only used for counting the fps */
302  x4->params.i_fps_num = avctx->time_base.den;
303  x4->params.i_fps_den = avctx->time_base.num;
304  x4->params.analyse.inter = XAVS_ANALYSE_I8x8 |XAVS_ANALYSE_PSUB16x16| XAVS_ANALYSE_BSUB16x16;
305 
306  x4->params.analyse.i_me_range = avctx->me_range;
307  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
308 
309  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
310  /* AVS P2 only enables 8x8 transform */
311  x4->params.analyse.b_transform_8x8 = 1; //avctx->flags2 & AV_CODEC_FLAG2_8X8DCT;
312 
313  x4->params.analyse.i_trellis = avctx->trellis;
314 
315  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
316 
317  if (avctx->level > 0)
318  x4->params.i_level_idc = avctx->level;
319 
320  if (avctx->bit_rate > 0)
321  x4->params.rc.f_rate_tolerance =
322  (float)avctx->bit_rate_tolerance / avctx->bit_rate;
323 
324  if ((avctx->rc_buffer_size) &&
325  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
326  x4->params.rc.f_vbv_buffer_init =
327  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
328  } else
329  x4->params.rc.f_vbv_buffer_init = 0.9;
330 
331  /* TAG:do we have MB tree RC method */
332  /* what is the RC method we are now using? Default NO */
333  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
334  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
335 
336  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
337 
338  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
339  x4->params.i_log_level = XAVS_LOG_DEBUG;
340  x4->params.i_threads = avctx->thread_count;
341  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
342 
343  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
344  x4->params.b_repeat_headers = 0;
345 
346  x4->enc = xavs_encoder_open(&x4->params);
347  if (!x4->enc)
348  return AVERROR_EXTERNAL;
349 
350  if (!FF_ALLOCZ_TYPED_ARRAY(x4->pts_buffer, avctx->max_b_frames + 1))
351  return AVERROR(ENOMEM);
352 
353  /* TAG: Do we have GLOBAL HEADER in AVS */
354  /* We Have PPS and SPS in AVS */
355  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER && 0) {
356  xavs_nal_t *nal;
357  int nnal, s, i, size;
358  uint8_t *p;
359 
360  s = xavs_encoder_headers(x4->enc, &nal, &nnal);
361 
362  avctx->extradata = p = av_malloc(s);
363  for (i = 0; i < nnal; i++) {
364  /* Don't put the SEI in extradata. */
365  if (nal[i].i_type == NAL_SEI) {
366  x4->sei = av_malloc( 5 + nal[i].i_payload * 4 / 3 );
367  if (xavs_nal_encode(x4->sei, &x4->sei_size, 1, nal + i) < 0)
368  return -1;
369 
370  continue;
371  }
372  size = xavs_nal_encode(p, &s, 1, nal + i);
373  if (size < 0)
374  return -1;
375  p += size;
376  }
377  avctx->extradata_size = p - avctx->extradata;
378  }
379  return 0;
380 }
381 
382 #define OFFSET(x) offsetof(XavsContext, x)
383 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
384 static const AVOption options[] = {
385  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
386  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, VE },
387  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, {.i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
388  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
389  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
390  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
391  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
392  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
393  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
394  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},
395  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},
396  { "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 },
397  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},
398  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = XAVS_ME_DIA }, -1, XAVS_ME_TESA, VE, "motion-est"},
399  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
400  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
401  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
402  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
403  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
404  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, VE},
405  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE},
406  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, VE},
407  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, VE},
408 
409  { NULL },
410 };
411 
412 static const AVClass xavs_class = {
413  .class_name = "libxavs",
414  .item_name = av_default_item_name,
415  .option = options,
416  .version = LIBAVUTIL_VERSION_INT,
417 };
418 
419 static const AVCodecDefault xavs_defaults[] = {
420  { "b", "0" },
421  { NULL },
422 };
423 
425  .name = "libxavs",
426  .long_name = NULL_IF_CONFIG_SMALL("libxavs Chinese AVS (Audio Video Standard)"),
427  .type = AVMEDIA_TYPE_VIDEO,
428  .id = AV_CODEC_ID_CAVS,
429  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
431  .priv_data_size = sizeof(XavsContext),
432  .init = XAVS_init,
433  .encode2 = XAVS_frame,
434  .close = XAVS_close,
435  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
437  .priv_class = &xavs_class,
438  .defaults = xavs_defaults,
439  .wrapper_name = "libxavs",
440 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:98
av_vlog
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:424
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:925
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
options
static const AVOption options[]
Definition: libxavs.c:384
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
XavsContext::sei_size
int sei_size
Definition: libxavs.c:49
opt.h
XavsContext
Definition: libxavs.c:43
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:601
VE
#define VE
Definition: libxavs.c:383
OFFSET
#define OFFSET(x)
Definition: libxavs.c:382
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
internal.h
XavsContext::sei
uint8_t * sei
Definition: libxavs.c:48
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
encode.h
float.h
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:247
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1165
AVCodecContext::me_subpel_quality
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:830
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
XAVS_log
static void XAVS_log(void *p, int level, const char *fmt, va_list args)
Definition: libxavs.c:70
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
XAVS_init
static av_cold int XAVS_init(AVCodecContext *avctx)
Definition: libxavs.c:224
AVCodecContext::i_quant_factor
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:688
XAVS_close
static av_cold int XAVS_close(AVCodecContext *avctx)
Definition: libxavs.c:211
U
#define U(x)
Definition: vp56_arith.h:37
XavsContext::noise_reduction
int noise_reduction
Definition: libxavs.c:64
XavsContext::end_of_stream
int end_of_stream
Definition: libxavs.c:50
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
XavsContext::aud
int aud
Definition: libxavs.c:56
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:932
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
FF_CMP_CHROMA
#define FF_CMP_CHROMA
Definition: avcodec.h:795
AVCodecContext::bit_rate_tolerance
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
Definition: avcodec.h:441
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:260
XavsContext::params
xavs_param_t params
Definition: libxavs.c:45
END_OF_STREAM
#define END_OF_STREAM
Definition: libxavs.c:37
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
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1222
XavsContext::motion_est
int motion_est
Definition: libxavs.c:58
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:679
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:127
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
XavsContext::chroma_offset
int chroma_offset
Definition: libxavs.c:62
ff_libxavs_encoder
const AVCodec ff_libxavs_encoder
Definition: libxavs.c:424
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::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1194
encode_nals
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, xavs_nal_t *nals, int nnal)
Definition: libxavs.c:85
XavsContext::pic
xavs_picture_t pic
Definition: libxavs.c:47
if
if(ret)
Definition: filter_design.txt:179
AVCodecDefault
Definition: internal.h:206
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1179
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1151
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
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVCodecContext::me_cmp
int me_cmp
motion estimation comparison function
Definition: avcodec.h:760
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1229
XavsContext::b_bias
int b_bias
Definition: libxavs.c:53
AVCodecContext::level
int level
level
Definition: avcodec.h:1651
XavsContext::out_frame_count
int out_frame_count
Definition: libxavs.c:67
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1150
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
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:842
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:81
xavs_defaults
static const AVCodecDefault xavs_defaults[]
Definition: libxavs.c:419
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
XAVS_frame
static int XAVS_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libxavs.c:124
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
size
int size
Definition: twinvq_data.h:10344
xavs_class
static const AVClass xavs_class
Definition: libxavs.c:412
AVCodecContext::me_range
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:839
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:273
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:235
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
XavsContext::mixed_refs
int mixed_refs
Definition: libxavs.c:60
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
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:227
i
int i
Definition: input.c:406
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
internal.h
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:137
XavsContext::direct_pred
int direct_pred
Definition: libxavs.c:55
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
avcodec.h
ret
ret
Definition: filter_design.txt:187
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
frame
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
Definition: filter_design.txt:264
XavsContext::b_frame_strategy
int b_frame_strategy
Definition: libxavs.c:61
XavsContext::enc
xavs_t * enc
Definition: libxavs.c:46
AVCodecContext::max_qdiff
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1172
AVCodecContext
main external API structure.
Definition: avcodec.h:383
XavsContext::scenechange_threshold
int scenechange_threshold
Definition: libxavs.c:63
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
XavsContext::fast_pskip
int fast_pskip
Definition: libxavs.c:57
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
XavsContext::cqp
int cqp
Definition: libxavs.c:52
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
AV_CODEC_CAP_DELAY
#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: codec.h:82
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
XavsContext::mbtree
int mbtree
Definition: libxavs.c:59
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1023
XavsContext::cplxblur
float cplxblur
Definition: libxavs.c:54
XavsContext::crf
float crf
Definition: libxavs.c:51
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
XavsContext::pts_buffer
int64_t * pts_buffer
Definition: libxavs.c:66
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1125
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