FFmpeg: libavcodec/libxavs.c Source File

FFmpeg

[フレーム]

libavcodec

libxavs.c

Go to the documentation of this file.

1 /*

2 * AVS encoding using the xavs library

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 */

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 "codec_internal.h"

31 #include "encode.h"

32 #include "packet_internal.h"

33 #include "libavutil/internal.h"

34 #include "libavutil/mem.h"

35 #include "libavutil/opt.h"

37 #define END_OF_STREAM 0x001

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*/

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;

50 int end_of_stream;

51 float crf;

52 int cqp;

53 int b_bias;

54 float cplxblur;

55 int direct_pred;

56 int aud;

57 int fast_pskip;

58 int motion_est;

59 int mbtree;

60 int mixed_refs;

61 int b_frame_strategy;

62 int chroma_offset;

63 int scenechange_threshold;

64 int noise_reduction;

66 int64_t *pts_buffer;

67 int out_frame_count;

68 } XavsContext;

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 };

79 if (level < 0 || level > XAVS_LOG_DEBUG)

80 return;

82 av_vlog(p, level_map[level], fmt, args);

83 }

85 static int encode_nals(AVCodecContext *ctx, AVPacket *pkt,

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;

93 if (!nnal)

94 return 0;

96 for (i = 0; i < nnal; i++)

97 size += 3U + nals[i].i_payload;

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)];

167 x4->end_of_stream = END_OF_STREAM;

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) {

201 pkt->flags |= AV_PKT_FLAG_KEY;

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

211 static av_cold int XAVS_close(AVCodecContext *avctx)

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 FFCodecDefault xavs_defaults[] = {

420 { "b", "0" },

421 { NULL },

422 };

423

424 const FFCodec ff_libxavs_encoder = {

425 .p.name = "libxavs",

426 CODEC_LONG_NAME("libxavs Chinese AVS (Audio Video Standard)"),

427 .p.type = AVMEDIA_TYPE_VIDEO,

428 .p.id = AV_CODEC_ID_CAVS,

429 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

430 AV_CODEC_CAP_OTHER_THREADS,

431 .priv_data_size = sizeof(XavsContext),

432 .init = XAVS_init,

433 FF_CODEC_ENCODE_CB(XAVS_frame),

434 .close = XAVS_close,

435 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |

436 FF_CODEC_CAP_AUTO_THREADS,

437 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },

438 .p.priv_class = &xavs_class,

439 .defaults = xavs_defaults,

440 .p.wrapper_name = "libxavs",

441 };

FF_ALLOCZ_TYPED_ARRAY

#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)

Definition: internal.h:97

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:426

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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:967

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:602

#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:330

XavsContext::sei

uint8_t * sei

Definition: libxavs.c:48

AVPacket::data

uint8_t * data

Definition: packet.h:374

AVOption

AVOption.

Definition: opt.h:251

encode.h

FF_CODEC_CAP_NOT_INIT_THREADSAFE

#define FF_CODEC_CAP_NOT_INIT_THREADSAFE

The codec is not known to be init-threadsafe (i.e.

Definition: codec_internal.h:34

FFCodec

Definition: codec_internal.h:127

float.h

AV_CODEC_FLAG_PSNR

#define AV_CODEC_FLAG_PSNR

error[?] variables will be set during encoding.

Definition: avcodec.h:305

AVCodecContext::qmax

int qmax

maximum quantizer

Definition: avcodec.h:1225

AVCodecContext::me_subpel_quality

int me_subpel_quality

subpel ME quality

Definition: avcodec.h:872

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:429

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:30

AV_CODEC_FLAG_GLOBAL_HEADER

#define AV_CODEC_FLAG_GLOBAL_HEADER

Place global headers in extradata instead of every keyframe.

Definition: avcodec.h:317

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:730

XAVS_close

static av_cold int XAVS_close(AVCodecContext *avctx)

Definition: libxavs.c:211

FFCodecDefault

Definition: codec_internal.h:97

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

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:1502

XavsContext::aud

int aud

Definition: libxavs.c:56

AVCodecContext::refs

int refs

number of reference frames

Definition: avcodec.h:974

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:506

FF_CMP_CHROMA

#define FF_CMP_CHROMA

Definition: avcodec.h:837

AVCodecContext::bit_rate_tolerance

int bit_rate_tolerance

number of bits the bitstream is allowed to diverge from the reference.

Definition: avcodec.h:484

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:315

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:309

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:1282

XavsContext::motion_est

int motion_est

Definition: libxavs.c:58

float

Definition: af_crystalizer.c:122

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:528

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:721

#define s(width, name)

Definition: cbs_vp9.c:256

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:121

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

xavs_defaults

static const FFCodecDefault xavs_defaults[]

Definition: libxavs.c:419

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

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:1254

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

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

if(ret)

Definition: filter_design.txt:179

AVCodecContext::rc_buffer_size

int rc_buffer_size

decoder bitstream buffer size

Definition: avcodec.h:1239

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:1211

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:476

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

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:802

AVCodecContext::trellis

int trellis

trellis RD quantization

Definition: avcodec.h:1289

XavsContext::b_bias

int b_bias

Definition: libxavs.c:53

AVCodecContext::level

int level

level

Definition: avcodec.h:1691

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:1210

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:548

aud

static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)

Definition: cbs_h264_syntax_template.c:842

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

AVCodecContext::gop_size

int gop_size

the number of pictures in a group of pictures, or 0 for intra_only

Definition: avcodec.h:620

codec_internal.h

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:881

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:373

AV_CODEC_FLAG_PASS2

#define AV_CODEC_FLAG_PASS2

Use internal 2pass ratecontrol in second pass mode.

Definition: avcodec.h:293

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:380

ff_libxavs_encoder

const FFCodec ff_libxavs_encoder

Definition: libxavs.c:424

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:706

AV_OPT_TYPE_FLOAT

@ AV_OPT_TYPE_FLOAT

Definition: opt.h:228

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:367

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:527

internal.h

AV_CODEC_ID_CAVS

@ AV_CODEC_ID_CAVS

Definition: codec_id.h:139

XavsContext::direct_pred

int direct_pred

Definition: libxavs.c:55

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

AVCodecContext::height

int height

Definition: avcodec.h:598

avcodec.h

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

#define U(x)

Definition: vpx_arith.h:37

AVCodecContext::max_qdiff

int max_qdiff

maximum quantizer difference between frames