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

31 #include "libavutil/internal.h"

32 #include "libavutil/mem.h"

33 #include "libavutil/opt.h"

35 #define END_OF_STREAM 0x001

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

41 typedef struct XavsContext {

42 AVClass *class;

43 xavs_param_t params;

44 xavs_t *enc;

45 xavs_picture_t pic;

46 uint8_t *sei;

47 int sei_size;

48 int end_of_stream;

49 float crf;

50 int cqp;

51 int b_bias;

52 float cplxblur;

53 int direct_pred;

54 int aud;

55 int fast_pskip;

56 int motion_est;

57 int mbtree;

58 int mixed_refs;

59 int b_frame_strategy;

60 int chroma_offset;

61 int scenechange_threshold;

62 int noise_reduction;

64 int64_t *pts_buffer;

65 int out_frame_count;

66 } XavsContext;

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

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

78 return;

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

81 }

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

84 xavs_nal_t *nals, int nnal)

85 {

86 XavsContext *x4 = ctx->priv_data;

87 uint8_t *p;

88 int i, s, ret, size = x4->sei_size + AV_INPUT_BUFFER_MIN_SIZE;

90 if (!nnal)

91 return 0;

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

94 size += nals[i].i_payload;

96 if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)

97 return ret;

98 p = pkt->data;

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

161 x4->end_of_stream = END_OF_STREAM;

162 *got_packet = 1;

163 }

164 return 0;

165 }

166

167 #if FF_API_CODED_FRAME

168 FF_DISABLE_DEPRECATION_WARNINGS

169 avctx->coded_frame->pts = pic_out.i_pts;

170 FF_ENABLE_DEPRECATION_WARNINGS

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

197 FF_DISABLE_DEPRECATION_WARNINGS

198 avctx->coded_frame->pict_type = pict_type;

199 FF_ENABLE_DEPRECATION_WARNINGS

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

206 FF_DISABLE_DEPRECATION_WARNINGS

207 avctx->coded_frame->key_frame = 1;

208 FF_ENABLE_DEPRECATION_WARNINGS

209 #endif

210 pkt->flags |= AV_PKT_FLAG_KEY;

211 }

212

213 #if FF_API_CODED_FRAME

214 FF_DISABLE_DEPRECATION_WARNINGS

215 avctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;

216 FF_ENABLE_DEPRECATION_WARNINGS

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

226 static av_cold int XAVS_close(AVCodecContext *avctx)

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 #if FF_API_MOTION_EST

287 FF_DISABLE_DEPRECATION_WARNINGS

288 if (x4->motion_est < 0) {

289 switch (avctx->me_method) {

290 case ME_EPZS:

291 x4->params.analyse.i_me_method = XAVS_ME_DIA;

292 break;

293 case ME_HEX:

294 x4->params.analyse.i_me_method = XAVS_ME_HEX;

295 break;

296 case ME_UMH:

297 x4->params.analyse.i_me_method = XAVS_ME_UMH;

298 break;

299 case ME_FULL:

300 x4->params.analyse.i_me_method = XAVS_ME_ESA;

301 break;

302 case ME_TESA:

303 x4->params.analyse.i_me_method = XAVS_ME_TESA;

304 break;

305 default:

306 x4->params.analyse.i_me_method = XAVS_ME_HEX;

307 }

308 }

309 FF_ENABLE_DEPRECATION_WARNINGS

310 #endif

311

312 x4->params.i_bframe = avctx->max_b_frames;

313 /* cabac is not included in AVS JiZhun Profile */

314 x4->params.b_cabac = 0;

315

316 #if FF_API_PRIVATE_OPT

317 FF_DISABLE_DEPRECATION_WARNINGS

318 if (avctx->b_frame_strategy)

319 x4->b_frame_strategy = avctx->b_frame_strategy;

320 FF_ENABLE_DEPRECATION_WARNINGS

321 #endif

322

323 x4->params.i_bframe_adaptive = x4->b_frame_strategy;

324

325 avctx->has_b_frames = !!avctx->max_b_frames;

326

327 /* AVS doesn't allow B picture as reference */

328 /* The max allowed reference frame number of B is 2 */

329 x4->params.i_keyint_min = avctx->keyint_min;

330 if (x4->params.i_keyint_min > x4->params.i_keyint_max)

331 x4->params.i_keyint_min = x4->params.i_keyint_max;

332

333 #if FF_API_PRIVATE_OPT

334 FF_DISABLE_DEPRECATION_WARNINGS

335 if (avctx->scenechange_threshold)

336 x4->scenechange_threshold = avctx->scenechange_threshold;

337 FF_ENABLE_DEPRECATION_WARNINGS

338 #endif

339

340 x4->params.i_scenecut_threshold = x4->scenechange_threshold;

341

342 // x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;

343

344 x4->params.rc.i_qp_min = avctx->qmin;

345 x4->params.rc.i_qp_max = avctx->qmax;

346 x4->params.rc.i_qp_step = avctx->max_qdiff;

347

348 x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */

349 x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */

350

351 x4->params.i_frame_reference = avctx->refs;

352

353 x4->params.i_width = avctx->width;

354 x4->params.i_height = avctx->height;

355 x4->params.vui.i_sar_width = avctx->sample_aspect_ratio.num;

356 x4->params.vui.i_sar_height = avctx->sample_aspect_ratio.den;

357 /* This is only used for counting the fps */

358 x4->params.i_fps_num = avctx->time_base.den;

359 x4->params.i_fps_den = avctx->time_base.num;

360 x4->params.analyse.inter = XAVS_ANALYSE_I8x8 |XAVS_ANALYSE_PSUB16x16| XAVS_ANALYSE_BSUB16x16;

361

362 x4->params.analyse.i_me_range = avctx->me_range;

363 x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;

364

365 x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;

366 /* AVS P2 only enables 8x8 transform */

367 x4->params.analyse.b_transform_8x8 = 1; //avctx->flags2 & AV_CODEC_FLAG2_8X8DCT;

368

369 x4->params.analyse.i_trellis = avctx->trellis;

370

371 #if FF_API_PRIVATE_OPT

372 FF_DISABLE_DEPRECATION_WARNINGS

373 if (avctx->noise_reduction >= 0)

374 x4->noise_reduction = avctx->noise_reduction;

375 FF_ENABLE_DEPRECATION_WARNINGS

376 #endif

377

378 x4->params.analyse.i_noise_reduction = x4->noise_reduction;

379

380 if (avctx->level > 0)

381 x4->params.i_level_idc = avctx->level;

382

383 if (avctx->bit_rate > 0)

384 x4->params.rc.f_rate_tolerance =

385 (float)avctx->bit_rate_tolerance / avctx->bit_rate;

386

387 if ((avctx->rc_buffer_size) &&

388 (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {

389 x4->params.rc.f_vbv_buffer_init =

390 (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;

391 } else

392 x4->params.rc.f_vbv_buffer_init = 0.9;

393

394 /* TAG:do we have MB tree RC method */

395 /* what is the RC method we are now using? Default NO */

396 x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);

397 x4->params.rc.f_pb_factor = avctx->b_quant_factor;

398

399 #if FF_API_PRIVATE_OPT

400 FF_DISABLE_DEPRECATION_WARNINGS

401 if (avctx->chromaoffset)

402 x4->chroma_offset = avctx->chromaoffset;

403 FF_ENABLE_DEPRECATION_WARNINGS

404 #endif

405

406 x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;

407

408 x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;

409 x4->params.i_log_level = XAVS_LOG_DEBUG;

410 x4->params.i_threads = avctx->thread_count;

411 x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;

412

413 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)

414 x4->params.b_repeat_headers = 0;

415

416 x4->enc = xavs_encoder_open(&x4->params);

417 if (!x4->enc)

418 return -1;

419

420 if (!(x4->pts_buffer = av_mallocz_array((avctx->max_b_frames+1), sizeof(*x4->pts_buffer))))

421 return AVERROR(ENOMEM);

422

423 /* TAG: Do we have GLOBAL HEADER in AVS */

424 /* We Have PPS and SPS in AVS */

425 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER && 0) {

426 xavs_nal_t *nal;

427 int nnal, s, i, size;

428 uint8_t *p;

429

430 s = xavs_encoder_headers(x4->enc, &nal, &nnal);

431

432 avctx->extradata = p = av_malloc(s);

433 for (i = 0; i < nnal; i++) {

434 /* Don't put the SEI in extradata. */

435 if (nal[i].i_type == NAL_SEI) {

436 x4->sei = av_malloc( 5 + nal[i].i_payload * 4 / 3 );

437 if (xavs_nal_encode(x4->sei, &x4->sei_size, 1, nal + i) < 0)

438 return -1;

439

440 continue;

441 }

442 size = xavs_nal_encode(p, &s, 1, nal + i);

443 if (size < 0)

444 return -1;

445 p += size;

446 }

447 avctx->extradata_size = p - avctx->extradata;

448 }

449 return 0;

450 }

451

452 #define OFFSET(x) offsetof(XavsContext, x)

453 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

454 static const AVOption options[] = {

455 { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },

456 { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, VE },

457 { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, {.i64 = INT_MIN}, INT_MIN, INT_MAX, VE },

458 { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},

459 { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },

460 { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },

461 { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },

462 { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },

463 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },

464 { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},

465 { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},

466 { "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 },

467 { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, {.i64 = -1 }, -1, 1, VE},

468 { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, XAVS_ME_TESA, VE, "motion-est"},

469 { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },

470 { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },

471 { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },

472 { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },

473 { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = XAVS_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },

474 { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, VE},

475 { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE},

476 { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, VE},

477 { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, VE},

478

479 { NULL },

480 };

481

482 static const AVClass xavs_class = {

483 .class_name = "libxavs",

484 .item_name = av_default_item_name,

485 .option = options,

486 .version = LIBAVUTIL_VERSION_INT,

487 };

488

489 static const AVCodecDefault xavs_defaults[] = {

490 { "b", "0" },

491 { NULL },

492 };

493

494 AVCodec ff_libxavs_encoder = {

495 .name = "libxavs",

496 .long_name = NULL_IF_CONFIG_SMALL("libxavs Chinese AVS (Audio Video Standard)"),

497 .type = AVMEDIA_TYPE_VIDEO,

498 .id = AV_CODEC_ID_CAVS,

499 .priv_data_size = sizeof(XavsContext),

500 .init = XAVS_init,

501 .encode2 = XAVS_frame,

502 .close = XAVS_close,

503 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,

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

505 .priv_class = &xavs_class,

506 .defaults = xavs_defaults,

507 };

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:631

#define VE

Definition: libxavs.c:453

XavsContext::chroma_offset

int chroma_offset

Definition: libxavs.c:60

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:181

AV_PIX_FMT_NONE

Definition: pixfmt.h:62

AVOption

AVOption.

Definition: opt.h:245

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

AV_CODEC_FLAG_INTERLACED_DCT

#define AV_CODEC_FLAG_INTERLACED_DCT

Use interlaced DCT.

Definition: avcodec.h:775

ctx

AVFormatContext * ctx

Definition: movenc-test.c:48

fmt

const char * fmt

Definition: avisynth_c.h:632

AVCodecContext::qblur

float qblur

amount of qscale smoothing over time (0.0-1.0)

Definition: avcodec.h:2459

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:1597

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:70

mem.h

memory handling functions

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AV_OPT_TYPE_INT

Definition: opt.h:223

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

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

XavsContext::enc

xavs_t * enc

Definition: libxavs.c:44

AVRational::num

int num

numerator

Definition: rational.h:44

AVPacket::size

int size

Definition: avcodec.h:1468

ME_EPZS

enhanced predictive zonal search

Definition: avcodec.h:667

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

XavsContext::end_of_stream

int end_of_stream

Definition: libxavs.c:48

AVS_Value

Definition: avisynth_c.h:462

XAVS_log

static void XAVS_log(void *p, int level, const char *fmt, va_list args)

Definition: libxavs.c:68

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

AV_CODEC_CAP_AUTO_THREADS

#define AV_CODEC_CAP_AUTO_THREADS

Codec supports avctx->thread_count == 0 (auto).

Definition: avcodec.h:931

AVCodec

AVCodec.

Definition: avcodec.h:3392

options

static const AVOption options[]

Definition: libxavs.c:454

AVCodecContext::me_method

attribute_deprecated int me_method

This option does nothing.

Definition: avcodec.h:1759

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

AV_PICTURE_TYPE_NONE

Undefined.

Definition: avutil.h:265

XAVS_close

static av_cold int XAVS_close(AVCodecContext *avctx)

Definition: libxavs.c:226

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

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: avcodec.h:881

AV_OPT_TYPE_CONST

Definition: opt.h:231

AVCodecContext::bit_rate_tolerance

int bit_rate_tolerance

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

Definition: avcodec.h:1605

XavsContext::sei

uint8_t * sei

Definition: libxavs.c:46

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

opt.h

AVOptions.

AVCodecContext::me_range

int me_range

maximum motion estimation search range in subpel units If 0 then no limit.

Definition: avcodec.h:2046

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

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:262

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1647

AVCodecContext::me_cmp

int me_cmp

motion estimation comparison function

Definition: avcodec.h:1942

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

float.h

size

ptrdiff_t size

Definition: opengl_enc.c:101

FF_CMP_CHROMA

#define FF_CMP_CHROMA

Definition: avcodec.h:1976

AV_INPUT_BUFFER_MIN_SIZE

#define AV_INPUT_BUFFER_MIN_SIZE

minimum encoding buffer size Used to avoid some checks during header writing.

Definition: avcodec.h:642

encode_nals

static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, xavs_nal_t *nals, int nnal)

Definition: libxavs.c:83

XavsContext::b_frame_strategy

int b_frame_strategy

Definition: libxavs.c:59

ME_HEX

hexagon based search

Definition: avcodec.h:669

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: avcodec.h:1499

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:1846

END_OF_STREAM

#define END_OF_STREAM

Definition: libxavs.c:35

av_default_item_name

Definition: libopenh264enc.c:68

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVCodecDefault

Definition: internal.h:165

AVCodecContext::qmax

int qmax

maximum quantizer

Definition: avcodec.h:2473

XAVS_init

static av_cold int XAVS_init(AVCodecContext *avctx)

Definition: libxavs.c:240

AV_OPT_TYPE_FLOAT

Definition: opt.h:226

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

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

XavsContext::b_bias

int b_bias

Definition: libxavs.c:51

XavsContext

Definition: libxavs.c:41

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1627

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3399

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_q*...

Definition: avcodec.h:1861

XavsContext::mixed_refs

int mixed_refs

Definition: libxavs.c:58

XavsContext::fast_pskip

int fast_pskip

Definition: libxavs.c:55

ME_TESA

transformed exhaustive search algorithm

Definition: avcodec.h:671

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: avcodec.h:1473

AVCodecContext::rc_buffer_size

int rc_buffer_size

decoder bitstream buffer size

Definition: avcodec.h:2500

XavsContext::direct_pred

int direct_pred

Definition: libxavs.c:53

internal.h

common internal API header

AVCodecContext::refs

int refs

number of reference frames

Definition: avcodec.h:2205

xavs_defaults

static const AVCodecDefault xavs_defaults[]

Definition: libxavs.c:489

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:266

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:252

XavsContext::out_frame_count

int out_frame_count

Definition: libxavs.c:65

XavsContext::noise_reduction

int noise_reduction

Definition: libxavs.c:62

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1711

AVCodecContext::noise_reduction

attribute_deprecated int noise_reduction

Definition: avcodec.h:2112

AV_CODEC_FLAG_PSNR

#define AV_CODEC_FLAG_PSNR

error[?] variables will be set during encoding.

Definition: avcodec.h:766

AV_OPT_TYPE_BOOL

Definition: opt.h:239

AV_CODEC_FLAG_PASS1

#define AV_CODEC_FLAG_PASS1

Use internal 2pass ratecontrol in first pass mode.

Definition: avcodec.h:750

AVCodecContext::level

int level

level

Definition: avcodec.h:3117

AVFrame::quality

int quality

quality (between 1 (good) and FF_LAMBDA_MAX (bad))

Definition: frame.h:288

xavs_class

static const AVClass xavs_class

Definition: libxavs.c:482

AVCodecContext::max_qdiff

int max_qdiff

maximum quantizer difference between frames

Definition: avcodec.h:2480

XavsContext::params

xavs_param_t params

Definition: libxavs.c:43

AVCodecContext::height

int height

Definition: avcodec.h:1711

AVCodecContext::thread_count

int thread_count

thread count is used to decide how many independent tasks should be passed to execute() ...

Definition: avcodec.h:2954

XAVS_frame

static int XAVS_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)

Definition: libxavs.c:118

XavsContext::motion_est

int motion_est

Definition: libxavs.c:56

XavsContext::cplxblur

float cplxblur

Definition: libxavs.c:52

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

avcodec.h

Libavcodec external API header.

AVCodecContext::scenechange_threshold

attribute_deprecated int scenechange_threshold

Definition: avcodec.h:2108

XavsContext::mbtree

int mbtree

Definition: libxavs.c:57

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

AVCodecContext::b_frame_strategy

attribute_deprecated int b_frame_strategy

Definition: avcodec.h:1830

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

AVCodecContext::qmin

int qmin

minimum quantizer

Definition: avcodec.h:2466

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:1648

XavsContext::scenechange_threshold

int scenechange_threshold

Definition: libxavs.c:61

XavsContext::sei_size

int sei_size

Definition: libxavs.c:47

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

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

AVCodecContext::chromaoffset

attribute_deprecated int chromaoffset

Definition: avcodec.h:2210

ff_alloc_packet2

int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)

Check AVPacket size and/or allocate data.

Definition: utils.c:1621

AVCodecContext::qcompress

float qcompress

amount of qscale change between easy & hard scenes (0.0-1.0)

Definition: avcodec.h:2458

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:262

AV_CODEC_ID_CAVS

Definition: avcodec.h:194

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

level

uint8_t level

Definition: svq3.c:150

AV_CODEC_FLAG_GLOBAL_HEADER

#define AV_CODEC_FLAG_GLOBAL_HEADER

Place global headers in extradata instead of every keyframe.

Definition: avcodec.h:783

AVCodecContext::gop_size

int gop_size

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

Definition: avcodec.h:1737

XavsContext::cqp

int cqp

Definition: libxavs.c:50

AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:63

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:80

internal.h

common internal api header.

if(ret< 0)

Definition: vf_mcdeint.c:282

AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:268

AVCodecContext::coded_frame

attribute_deprecated AVFrame * coded_frame

the picture in the bitstream

Definition: avcodec.h:2945

AVRational::den

int den

denominator

Definition: rational.h:45

AVCodecContext::trellis

int trellis

trellis RD quantization

Definition: avcodec.h:2622

AV_CODEC_FLAG_PASS2

#define AV_CODEC_FLAG_PASS2

Use internal 2pass ratecontrol in second pass mode.

Definition: avcodec.h:754

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1574

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:81

ME_UMH

uneven multi-hexagon search

Definition: avcodec.h:670

ff_libxavs_encoder

AVCodec ff_libxavs_encoder

Definition: libxavs.c:494

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:247

FF_QP2LAMBDA

#define FF_QP2LAMBDA

factor to convert from H.263 QP to lambda

Definition: avutil.h:219

XavsContext::crf

float crf

Definition: libxavs.c:49

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...

Definition: avcodec.h:1466

av_mallocz_array

static void * av_mallocz_array(size_t nmemb, size_t size)

Definition: mem.h:229

AVCodecContext::frame_number

int frame_number

Frame counter, set by libavcodec.

Definition: avcodec.h:2318

NAL_SEI

Definition: h264.h:118

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:193

XavsContext::pts_buffer

int64_t * pts_buffer

Definition: libxavs.c:64

OFFSET

#define OFFSET(x)

Definition: libxavs.c:452

AVPixelFormat

Pixel format.

Definition: pixfmt.h:61

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

XavsContext::aud

int aud

Definition: libxavs.c:54

AVCodecContext::me_subpel_quality

int me_subpel_quality

subpel ME quality

Definition: avcodec.h:2017

AVPacket::pts

int64_t pts

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

Definition: avcodec.h:1460

AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:267

ME_FULL

Definition: avcodec.h:664

XavsContext::pic

xavs_picture_t pic

Definition: libxavs.c:45

AVCodecContext::rc_max_rate

int64_t rc_max_rate

maximum bitrate

Definition: avcodec.h:2523

AVCodecContext::keyint_min

int keyint_min

minimum GOP size

Definition: avcodec.h:2198

Generated on Mon Feb 15 2016 15:20:39 for FFmpeg by doxygen 1.8.6