FFmpeg: libavcodec/libvpxenc.c Source File

FFmpeg

[フレーム]

libavcodec

libvpxenc.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 /**

22 * @file

23 * VP8/9 encoder support via libvpx

24 */

26 #define VPX_DISABLE_CTRL_TYPECHECKS 1

27 #define VPX_CODEC_DISABLE_COMPAT 1

28 #include <vpx/vpx_encoder.h>

29 #include <vpx/vp8cx.h>

31 #include "avcodec.h"

32 #include "internal.h"

33 #include "libavutil/avassert.h"

34 #include "libvpx.h"

35 #include "profiles.h"

36 #include "libavutil/base64.h"

37 #include "libavutil/common.h"

38 #include "libavutil/internal.h"

39 #include "libavutil/intreadwrite.h"

40 #include "libavutil/mathematics.h"

41 #include "libavutil/opt.h"

43 /**

44 * Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.

45 * One encoded frame returned from the library.

46 */

47 struct FrameListData {

48 void *buf; /**< compressed data buffer */

49 size_t sz; /**< length of compressed data */

50 void *buf_alpha;

51 size_t sz_alpha;

52 int64_t pts; /**< time stamp to show frame

53 (in timebase units) */

54 unsigned long duration; /**< duration to show frame

55 (in timebase units) */

56 uint32_t flags; /**< flags for this frame */

57 uint64_t sse[4];

58 int have_sse; /**< true if we have pending sse[] */

59 uint64_t frame_number;

60 struct FrameListData *next;

61 };

63 typedef struct VPxEncoderContext {

64 AVClass *class;

65 struct vpx_codec_ctx encoder;

66 struct vpx_image rawimg;

67 struct vpx_codec_ctx encoder_alpha;

68 struct vpx_image rawimg_alpha;

69 uint8_t is_alpha;

70 struct vpx_fixed_buf twopass_stats;

71 int deadline; //i.e., RT/GOOD/BEST

72 uint64_t sse[4];

73 int have_sse; /**< true if we have pending sse[] */

74 uint64_t frame_number;

75 struct FrameListData *coded_frame_list;

77 int cpu_used;

78 /**

79 * VP8 specific flags, see VP8F_* below.

80 */

81 int flags;

82 #define VP8F_ERROR_RESILIENT 0x00000001 ///< Enable measures appropriate for streaming over lossy links

83 #define VP8F_AUTO_ALT_REF 0x00000002 ///< Enable automatic alternate reference frame generation

85 int auto_alt_ref;

87 int arnr_max_frames;

88 int arnr_strength;

89 int arnr_type;

91 int tune;

93 int lag_in_frames;

94 int error_resilient;

95 int crf;

96 int static_thresh;

97 int max_intra_rate;

98 int rc_undershoot_pct;

99 int rc_overshoot_pct;

100

101 // VP9-only

102 int lossless;

103 int tile_columns;

104 int tile_rows;

105 int frame_parallel;

106 int aq_mode;

107 int drop_threshold;

108 int noise_sensitivity;

109 int vpx_cs;

110 float level;

111 int row_mt;

112 int tune_content;

113 int corpus_complexity;

114 } VPxContext;

115

116 /** String mappings for enum vp8e_enc_control_id */

117 static const char *const ctlidstr[] = {

118 [VP8E_SET_CPUUSED] = "VP8E_SET_CPUUSED",

119 [VP8E_SET_ENABLEAUTOALTREF] = "VP8E_SET_ENABLEAUTOALTREF",

120 [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",

121 [VP8E_SET_STATIC_THRESHOLD] = "VP8E_SET_STATIC_THRESHOLD",

122 [VP8E_SET_TOKEN_PARTITIONS] = "VP8E_SET_TOKEN_PARTITIONS",

123 [VP8E_SET_ARNR_MAXFRAMES] = "VP8E_SET_ARNR_MAXFRAMES",

124 [VP8E_SET_ARNR_STRENGTH] = "VP8E_SET_ARNR_STRENGTH",

125 [VP8E_SET_ARNR_TYPE] = "VP8E_SET_ARNR_TYPE",

126 [VP8E_SET_TUNING] = "VP8E_SET_TUNING",

127 [VP8E_SET_CQ_LEVEL] = "VP8E_SET_CQ_LEVEL",

128 [VP8E_SET_MAX_INTRA_BITRATE_PCT] = "VP8E_SET_MAX_INTRA_BITRATE_PCT",

129 #if CONFIG_LIBVPX_VP9_ENCODER

130 [VP9E_SET_LOSSLESS] = "VP9E_SET_LOSSLESS",

131 [VP9E_SET_TILE_COLUMNS] = "VP9E_SET_TILE_COLUMNS",

132 [VP9E_SET_TILE_ROWS] = "VP9E_SET_TILE_ROWS",

133 [VP9E_SET_FRAME_PARALLEL_DECODING] = "VP9E_SET_FRAME_PARALLEL_DECODING",

134 [VP9E_SET_AQ_MODE] = "VP9E_SET_AQ_MODE",

135 [VP9E_SET_COLOR_SPACE] = "VP9E_SET_COLOR_SPACE",

136 #if VPX_ENCODER_ABI_VERSION >= 11

137 [VP9E_SET_COLOR_RANGE] = "VP9E_SET_COLOR_RANGE",

138 #endif

139 #if VPX_ENCODER_ABI_VERSION >= 12

140 [VP9E_SET_TARGET_LEVEL] = "VP9E_SET_TARGET_LEVEL",

141 [VP9E_GET_LEVEL] = "VP9E_GET_LEVEL",

142 #endif

143 #ifdef VPX_CTRL_VP9E_SET_ROW_MT

144 [VP9E_SET_ROW_MT] = "VP9E_SET_ROW_MT",

145 #endif

146 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT

147 [VP9E_SET_TUNE_CONTENT] = "VP9E_SET_TUNE_CONTENT",

148 #endif

149 #endif

150 };

151

152 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)

153 {

154 VPxContext *ctx = avctx->priv_data;

155 const char *error = vpx_codec_error(&ctx->encoder);

156 const char *detail = vpx_codec_error_detail(&ctx->encoder);

157

158 av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);

159 if (detail)

160 av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);

161 }

162

163 static av_cold void dump_enc_cfg(AVCodecContext *avctx,

164 const struct vpx_codec_enc_cfg *cfg)

165 {

166 int width = -30;

167 int level = AV_LOG_DEBUG;

168

169 av_log(avctx, level, "vpx_codec_enc_cfg\n");

170 av_log(avctx, level, "generic settings\n"

171 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"

172 #if CONFIG_LIBVPX_VP9_ENCODER

173 " %*s%u\n %*s%u\n"

174 #endif

175 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",

176 width, "g_usage:", cfg->g_usage,

177 width, "g_threads:", cfg->g_threads,

178 width, "g_profile:", cfg->g_profile,

179 width, "g_w:", cfg->g_w,

180 width, "g_h:", cfg->g_h,

181 #if CONFIG_LIBVPX_VP9_ENCODER

182 width, "g_bit_depth:", cfg->g_bit_depth,

183 width, "g_input_bit_depth:", cfg->g_input_bit_depth,

184 #endif

185 width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,

186 width, "g_error_resilient:", cfg->g_error_resilient,

187 width, "g_pass:", cfg->g_pass,

188 width, "g_lag_in_frames:", cfg->g_lag_in_frames);

189 av_log(avctx, level, "rate control settings\n"

190 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"

191 " %*s%d\n %*s%p(%"SIZE_SPECIFIER ")\n %*s%u\n",

192 width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,

193 width, "rc_resize_allowed:", cfg->rc_resize_allowed,

194 width, "rc_resize_up_thresh:", cfg->rc_resize_up_thresh,

195 width, "rc_resize_down_thresh:", cfg->rc_resize_down_thresh,

196 width, "rc_end_usage:", cfg->rc_end_usage,

197 width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,

198 width, "rc_target_bitrate:", cfg->rc_target_bitrate);

199 av_log(avctx, level, "quantizer settings\n"

200 " %*s%u\n %*s%u\n",

201 width, "rc_min_quantizer:", cfg->rc_min_quantizer,

202 width, "rc_max_quantizer:", cfg->rc_max_quantizer);

203 av_log(avctx, level, "bitrate tolerance\n"

204 " %*s%u\n %*s%u\n",

205 width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,

206 width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);

207 av_log(avctx, level, "decoder buffer model\n"

208 " %*s%u\n %*s%u\n %*s%u\n",

209 width, "rc_buf_sz:", cfg->rc_buf_sz,

210 width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,

211 width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);

212 av_log(avctx, level, "2 pass rate control settings\n"

213 " %*s%u\n %*s%u\n %*s%u\n",

214 width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,

215 width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,

216 width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);

217 #if VPX_ENCODER_ABI_VERSION >= 14

218 av_log(avctx, level, " %*s%u\n",

219 width, "rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);

220 #endif

221 av_log(avctx, level, "keyframing settings\n"

222 " %*s%d\n %*s%u\n %*s%u\n",

223 width, "kf_mode:", cfg->kf_mode,

224 width, "kf_min_dist:", cfg->kf_min_dist,

225 width, "kf_max_dist:", cfg->kf_max_dist);

226 av_log(avctx, level, "\n");

227 }

228

229 static void coded_frame_add(void *list, struct FrameListData *cx_frame)

230 {

231 struct FrameListData **p = list;

232

233 while (*p)

234 p = &(*p)->next;

235 *p = cx_frame;

236 cx_frame->next = NULL;

237 }

238

239 static av_cold void free_coded_frame(struct FrameListData *cx_frame)

240 {

241 av_freep(&cx_frame->buf);

242 if (cx_frame->buf_alpha)

243 av_freep(&cx_frame->buf_alpha);

244 av_freep(&cx_frame);

245 }

246

247 static av_cold void free_frame_list(struct FrameListData *list)

248 {

249 struct FrameListData *p = list;

250

251 while (p) {

252 list = list->next;

253 free_coded_frame(p);

254 p = list;

255 }

256 }

257

258 static av_cold int codecctl_int(AVCodecContext *avctx,

259 enum vp8e_enc_control_id id, int val)

260 {

261 VPxContext *ctx = avctx->priv_data;

262 char buf[80];

263 int width = -30;

264 int res;

265

266 snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);

267 av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);

268

269 res = vpx_codec_control(&ctx->encoder, id, val);

270 if (res != VPX_CODEC_OK) {

271 snprintf(buf, sizeof(buf), "Failed to set %s codec control",

272 ctlidstr[id]);

273 log_encoder_error(avctx, buf);

274 }

275

276 return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);

277 }

278

279 #if VPX_ENCODER_ABI_VERSION >= 12

280 static av_cold int codecctl_intp(AVCodecContext *avctx,

281 enum vp8e_enc_control_id id, int *val)

282 {

283 VPxContext *ctx = avctx->priv_data;

284 char buf[80];

285 int width = -30;

286 int res;

287

288 snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);

289 av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, *val);

290

291 res = vpx_codec_control(&ctx->encoder, id, val);

292 if (res != VPX_CODEC_OK) {

293 snprintf(buf, sizeof(buf), "Failed to set %s codec control",

294 ctlidstr[id]);

295 log_encoder_error(avctx, buf);

296 }

297

298 return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);

299 }

300 #endif

301

302 static av_cold int vpx_free(AVCodecContext *avctx)

303 {

304 VPxContext *ctx = avctx->priv_data;

305

306 #if VPX_ENCODER_ABI_VERSION >= 12

307 if (avctx->codec_id == AV_CODEC_ID_VP9 && ctx->level >= 0 &&

308 !(avctx->flags & AV_CODEC_FLAG_PASS1)) {

309 int level_out = 0;

310 if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))

311 av_log(avctx, AV_LOG_INFO, "Encoded level %.1f\n", level_out * 0.1);

312 }

313 #endif

314

315 vpx_codec_destroy(&ctx->encoder);

316 if (ctx->is_alpha)

317 vpx_codec_destroy(&ctx->encoder_alpha);

318 av_freep(&ctx->twopass_stats.buf);

319 av_freep(&avctx->stats_out);

320 free_frame_list(ctx->coded_frame_list);

321 return 0;

322 }

323

324 #if CONFIG_LIBVPX_VP9_ENCODER

325 static int set_pix_fmt(AVCodecContext *avctx, vpx_codec_caps_t codec_caps,

326 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *flags,

327 vpx_img_fmt_t *img_fmt)

328 {

329 VPxContext av_unused *ctx = avctx->priv_data;

330 enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;

331 switch (avctx->pix_fmt) {

332 case AV_PIX_FMT_YUV420P:

333 case AV_PIX_FMT_YUVA420P:

334 enccfg->g_profile = 0;

335 *img_fmt = VPX_IMG_FMT_I420;

336 return 0;

337 case AV_PIX_FMT_YUV422P:

338 enccfg->g_profile = 1;

339 *img_fmt = VPX_IMG_FMT_I422;

340 return 0;

341 case AV_PIX_FMT_YUV440P:

342 enccfg->g_profile = 1;

343 *img_fmt = VPX_IMG_FMT_I440;

344 return 0;

345 case AV_PIX_FMT_GBRP:

346 ctx->vpx_cs = VPX_CS_SRGB;

347 case AV_PIX_FMT_YUV444P:

348 enccfg->g_profile = 1;

349 *img_fmt = VPX_IMG_FMT_I444;

350 return 0;

351 case AV_PIX_FMT_YUV420P10:

352 case AV_PIX_FMT_YUV420P12:

353 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

354 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

355 avctx->pix_fmt == AV_PIX_FMT_YUV420P10 ? 10 : 12;

356 enccfg->g_profile = 2;

357 *img_fmt = VPX_IMG_FMT_I42016;

358 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

359 return 0;

360 }

361 break;

362 case AV_PIX_FMT_YUV422P10:

363 case AV_PIX_FMT_YUV422P12:

364 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

365 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

366 avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12;

367 enccfg->g_profile = 3;

368 *img_fmt = VPX_IMG_FMT_I42216;

369 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

370 return 0;

371 }

372 break;

373 case AV_PIX_FMT_YUV440P10:

374 case AV_PIX_FMT_YUV440P12:

375 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

376 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

377 avctx->pix_fmt == AV_PIX_FMT_YUV440P10 ? 10 : 12;

378 enccfg->g_profile = 3;

379 *img_fmt = VPX_IMG_FMT_I44016;

380 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

381 return 0;

382 }

383 break;

384 case AV_PIX_FMT_GBRP10:

385 case AV_PIX_FMT_GBRP12:

386 ctx->vpx_cs = VPX_CS_SRGB;

387 case AV_PIX_FMT_YUV444P10:

388 case AV_PIX_FMT_YUV444P12:

389 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

390 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

391 avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||

392 avctx->pix_fmt == AV_PIX_FMT_GBRP10 ? 10 : 12;

393 enccfg->g_profile = 3;

394 *img_fmt = VPX_IMG_FMT_I44416;

395 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

396 return 0;

397 }

398 break;

399 default:

400 break;

401 }

402 av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");

403 return AVERROR_INVALIDDATA;

404 }

405

406 static void set_colorspace(AVCodecContext *avctx)

407 {

408 enum vpx_color_space vpx_cs;

409 VPxContext *ctx = avctx->priv_data;

410

411 if (ctx->vpx_cs) {

412 vpx_cs = ctx->vpx_cs;

413 } else {

414 switch (avctx->colorspace) {

415 case AVCOL_SPC_RGB: vpx_cs = VPX_CS_SRGB; break;

416 case AVCOL_SPC_BT709: vpx_cs = VPX_CS_BT_709; break;

417 case AVCOL_SPC_UNSPECIFIED: vpx_cs = VPX_CS_UNKNOWN; break;

418 case AVCOL_SPC_RESERVED: vpx_cs = VPX_CS_RESERVED; break;

419 case AVCOL_SPC_BT470BG: vpx_cs = VPX_CS_BT_601; break;

420 case AVCOL_SPC_SMPTE170M: vpx_cs = VPX_CS_SMPTE_170; break;

421 case AVCOL_SPC_SMPTE240M: vpx_cs = VPX_CS_SMPTE_240; break;

422 case AVCOL_SPC_BT2020_NCL: vpx_cs = VPX_CS_BT_2020; break;

423 default:

424 av_log(avctx, AV_LOG_WARNING, "Unsupported colorspace (%d)\n",

425 avctx->colorspace);

426 return;

427 }

428 }

429 codecctl_int(avctx, VP9E_SET_COLOR_SPACE, vpx_cs);

430 }

431

432 #if VPX_ENCODER_ABI_VERSION >= 11

433 static void set_color_range(AVCodecContext *avctx)

434 {

435 enum vpx_color_range vpx_cr;

436 switch (avctx->color_range) {

437 case AVCOL_RANGE_UNSPECIFIED:

438 case AVCOL_RANGE_MPEG: vpx_cr = VPX_CR_STUDIO_RANGE; break;

439 case AVCOL_RANGE_JPEG: vpx_cr = VPX_CR_FULL_RANGE; break;

440 default:

441 av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",

442 avctx->color_range);

443 return;

444 }

445

446 codecctl_int(avctx, VP9E_SET_COLOR_RANGE, vpx_cr);

447 }

448 #endif

449 #endif

450

451 static av_cold int vpx_init(AVCodecContext *avctx,

452 const struct vpx_codec_iface *iface)

453 {

454 VPxContext *ctx = avctx->priv_data;

455 struct vpx_codec_enc_cfg enccfg = { 0 };

456 struct vpx_codec_enc_cfg enccfg_alpha;

457 vpx_codec_flags_t flags = (avctx->flags & AV_CODEC_FLAG_PSNR) ? VPX_CODEC_USE_PSNR : 0;

458 AVCPBProperties *cpb_props;

459 int res;

460 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;

461 #if CONFIG_LIBVPX_VP9_ENCODER

462 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);

463 #endif

464

465 av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());

466 av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());

467

468 if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P)

469 ctx->is_alpha = 1;

470

471 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {

472 av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",

473 vpx_codec_err_to_string(res));

474 return AVERROR(EINVAL);

475 }

476

477 #if CONFIG_LIBVPX_VP9_ENCODER

478 if (avctx->codec_id == AV_CODEC_ID_VP9) {

479 if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))

480 return AVERROR(EINVAL);

481 }

482 #endif

483

484 if(!avctx->bit_rate)

485 if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {

486 av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");

487 return AVERROR(EINVAL);

488 }

489

490 dump_enc_cfg(avctx, &enccfg);

491

492 enccfg.g_w = avctx->width;

493 enccfg.g_h = avctx->height;

494 enccfg.g_timebase.num = avctx->time_base.num;

495 enccfg.g_timebase.den = avctx->time_base.den;

496 enccfg.g_threads = avctx->thread_count;

497 enccfg.g_lag_in_frames= ctx->lag_in_frames;

498

499 if (avctx->flags & AV_CODEC_FLAG_PASS1)

500 enccfg.g_pass = VPX_RC_FIRST_PASS;

501 else if (avctx->flags & AV_CODEC_FLAG_PASS2)

502 enccfg.g_pass = VPX_RC_LAST_PASS;

503 else

504 enccfg.g_pass = VPX_RC_ONE_PASS;

505

506 if (avctx->rc_min_rate == avctx->rc_max_rate &&

507 avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {

508 enccfg.rc_end_usage = VPX_CBR;

509 } else if (ctx->crf >= 0) {

510 enccfg.rc_end_usage = VPX_CQ;

511 #if CONFIG_LIBVPX_VP9_ENCODER

512 if (!avctx->bit_rate && avctx->codec_id == AV_CODEC_ID_VP9)

513 enccfg.rc_end_usage = VPX_Q;

514 #endif

515 }

516

517 if (avctx->bit_rate) {

518 enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,

519 AV_ROUND_NEAR_INF);

520 #if CONFIG_LIBVPX_VP9_ENCODER

521 } else if (enccfg.rc_end_usage == VPX_Q) {

522 #endif

523 } else {

524 if (enccfg.rc_end_usage == VPX_CQ) {

525 enccfg.rc_target_bitrate = 1000000;

526 } else {

527 avctx->bit_rate = enccfg.rc_target_bitrate * 1000;

528 av_log(avctx, AV_LOG_WARNING,

529 "Neither bitrate nor constrained quality specified, using default bitrate of %dkbit/sec\n",

530 enccfg.rc_target_bitrate);

531 }

532 }

533

534 if (avctx->codec_id == AV_CODEC_ID_VP9 && ctx->lossless == 1) {

535 enccfg.rc_min_quantizer =

536 enccfg.rc_max_quantizer = 0;

537 } else {

538 if (avctx->qmin >= 0)

539 enccfg.rc_min_quantizer = avctx->qmin;

540 if (avctx->qmax >= 0)

541 enccfg.rc_max_quantizer = avctx->qmax;

542 }

543

544 if (enccfg.rc_end_usage == VPX_CQ

545 #if CONFIG_LIBVPX_VP9_ENCODER

546 || enccfg.rc_end_usage == VPX_Q

547 #endif

548 ) {

549 if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {

550 av_log(avctx, AV_LOG_ERROR,

551 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",

552 ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);

553 return AVERROR(EINVAL);

554 }

555 }

556

557 #if FF_API_PRIVATE_OPT

558 FF_DISABLE_DEPRECATION_WARNINGS

559 if (avctx->frame_skip_threshold)

560 ctx->drop_threshold = avctx->frame_skip_threshold;

561 FF_ENABLE_DEPRECATION_WARNINGS

562 #endif

563 enccfg.rc_dropframe_thresh = ctx->drop_threshold;

564

565 //0-100 (0 => CBR, 100 => VBR)

566 enccfg.rc_2pass_vbr_bias_pct = lrint(avctx->qcompress * 100);

567 if (avctx->bit_rate)

568 enccfg.rc_2pass_vbr_minsection_pct =

569 avctx->rc_min_rate * 100LL / avctx->bit_rate;

570 if (avctx->rc_max_rate)

571 enccfg.rc_2pass_vbr_maxsection_pct =

572 avctx->rc_max_rate * 100LL / avctx->bit_rate;

573 #if CONFIG_LIBVPX_VP9_ENCODER

574 if (avctx->codec_id == AV_CODEC_ID_VP9) {

575 #if VPX_ENCODER_ABI_VERSION >= 14

576 if (ctx->corpus_complexity >= 0)

577 enccfg.rc_2pass_vbr_corpus_complexity = ctx->corpus_complexity;

578 #endif

579 }

580 #endif

581

582 if (avctx->rc_buffer_size)

583 enccfg.rc_buf_sz =

584 avctx->rc_buffer_size * 1000LL / avctx->bit_rate;

585 if (avctx->rc_initial_buffer_occupancy)

586 enccfg.rc_buf_initial_sz =

587 avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;

588 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;

589 if (ctx->rc_undershoot_pct >= 0)

590 enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;

591 if (ctx->rc_overshoot_pct >= 0)

592 enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;

593

594 //_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO

595 if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)

596 enccfg.kf_min_dist = avctx->keyint_min;

597 if (avctx->gop_size >= 0)

598 enccfg.kf_max_dist = avctx->gop_size;

599

600 if (enccfg.g_pass == VPX_RC_FIRST_PASS)

601 enccfg.g_lag_in_frames = 0;

602 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {

603 int decode_size, ret;

604

605 if (!avctx->stats_in) {

606 av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");

607 return AVERROR_INVALIDDATA;

608 }

609

610 ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;

611 ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);

612 if (ret < 0) {

613 av_log(avctx, AV_LOG_ERROR,

614 "Stat buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",

615 ctx->twopass_stats.sz);

616 ctx->twopass_stats.sz = 0;

617 return ret;

618 }

619 decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,

620 ctx->twopass_stats.sz);

621 if (decode_size < 0) {

622 av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");

623 return AVERROR_INVALIDDATA;

624 }

625

626 ctx->twopass_stats.sz = decode_size;

627 enccfg.rc_twopass_stats_in = ctx->twopass_stats;

628 }

629

630 /* 0-3: For non-zero values the encoder increasingly optimizes for reduced

631 complexity playback on low powered devices at the expense of encode

632 quality. */

633 if (avctx->profile != FF_PROFILE_UNKNOWN)

634 enccfg.g_profile = avctx->profile;

635

636 enccfg.g_error_resilient = ctx->error_resilient || ctx->flags & VP8F_ERROR_RESILIENT;

637

638 dump_enc_cfg(avctx, &enccfg);

639 /* Construct Encoder Context */

640 res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);

641 if (res != VPX_CODEC_OK) {

642 log_encoder_error(avctx, "Failed to initialize encoder");

643 return AVERROR(EINVAL);

644 }

645

646 if (ctx->is_alpha) {

647 enccfg_alpha = enccfg;

648 res = vpx_codec_enc_init(&ctx->encoder_alpha, iface, &enccfg_alpha, flags);

649 if (res != VPX_CODEC_OK) {

650 log_encoder_error(avctx, "Failed to initialize alpha encoder");

651 return AVERROR(EINVAL);

652 }

653 }

654

655 //codec control failures are currently treated only as warnings

656 av_log(avctx, AV_LOG_DEBUG, "vpx_codec_control\n");

657 codecctl_int(avctx, VP8E_SET_CPUUSED, ctx->cpu_used);

658 if (ctx->flags & VP8F_AUTO_ALT_REF)

659 ctx->auto_alt_ref = 1;

660 if (ctx->auto_alt_ref >= 0)

661 codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF,

662 avctx->codec_id == AV_CODEC_ID_VP8 ? !!ctx->auto_alt_ref : ctx->auto_alt_ref);

663 if (ctx->arnr_max_frames >= 0)

664 codecctl_int(avctx, VP8E_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);

665 if (ctx->arnr_strength >= 0)

666 codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH, ctx->arnr_strength);

667 if (ctx->arnr_type >= 0)

668 codecctl_int(avctx, VP8E_SET_ARNR_TYPE, ctx->arnr_type);

669 if (ctx->tune >= 0)

670 codecctl_int(avctx, VP8E_SET_TUNING, ctx->tune);

671

672 if (ctx->auto_alt_ref && ctx->is_alpha && avctx->codec_id == AV_CODEC_ID_VP8) {

673 av_log(avctx, AV_LOG_ERROR, "Transparency encoding with auto_alt_ref does not work\n");

674 return AVERROR(EINVAL);

675 }

676

677 if (CONFIG_LIBVPX_VP8_ENCODER && avctx->codec_id == AV_CODEC_ID_VP8) {

678 #if FF_API_PRIVATE_OPT

679 FF_DISABLE_DEPRECATION_WARNINGS

680 if (avctx->noise_reduction)

681 ctx->noise_sensitivity = avctx->noise_reduction;

682 FF_ENABLE_DEPRECATION_WARNINGS

683 #endif

684 codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, ctx->noise_sensitivity);

685 codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS, av_log2(avctx->slices));

686 }

687 codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD, ctx->static_thresh);

688 if (ctx->crf >= 0)

689 codecctl_int(avctx, VP8E_SET_CQ_LEVEL, ctx->crf);

690 if (ctx->max_intra_rate >= 0)

691 codecctl_int(avctx, VP8E_SET_MAX_INTRA_BITRATE_PCT, ctx->max_intra_rate);

692

693 #if CONFIG_LIBVPX_VP9_ENCODER

694 if (avctx->codec_id == AV_CODEC_ID_VP9) {

695 if (ctx->lossless >= 0)

696 codecctl_int(avctx, VP9E_SET_LOSSLESS, ctx->lossless);

697 if (ctx->tile_columns >= 0)

698 codecctl_int(avctx, VP9E_SET_TILE_COLUMNS, ctx->tile_columns);

699 if (ctx->tile_rows >= 0)

700 codecctl_int(avctx, VP9E_SET_TILE_ROWS, ctx->tile_rows);

701 if (ctx->frame_parallel >= 0)

702 codecctl_int(avctx, VP9E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);

703 if (ctx->aq_mode >= 0)

704 codecctl_int(avctx, VP9E_SET_AQ_MODE, ctx->aq_mode);

705 set_colorspace(avctx);

706 #if VPX_ENCODER_ABI_VERSION >= 11

707 set_color_range(avctx);

708 #endif

709 #if VPX_ENCODER_ABI_VERSION >= 12

710 codecctl_int(avctx, VP9E_SET_TARGET_LEVEL, ctx->level < 0 ? 255 : lrint(ctx->level * 10));

711 #endif

712 #ifdef VPX_CTRL_VP9E_SET_ROW_MT

713 if (ctx->row_mt >= 0)

714 codecctl_int(avctx, VP9E_SET_ROW_MT, ctx->row_mt);

715 #endif

716 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT

717 if (ctx->tune_content >= 0)

718 codecctl_int(avctx, VP9E_SET_TUNE_CONTENT, ctx->tune_content);

719 #endif

720 }

721 #endif

722

723 av_log(avctx, AV_LOG_DEBUG, "Using deadline: %d\n", ctx->deadline);

724

725 //provide dummy value to initialize wrapper, values will be updated each _encode()

726 vpx_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,

727 (unsigned char*)1);

728 #if CONFIG_LIBVPX_VP9_ENCODER

729 if (avctx->codec_id == AV_CODEC_ID_VP9 && (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH))

730 ctx->rawimg.bit_depth = enccfg.g_bit_depth;

731 #endif

732

733 if (ctx->is_alpha)

734 vpx_img_wrap(&ctx->rawimg_alpha, VPX_IMG_FMT_I420, avctx->width, avctx->height, 1,

735 (unsigned char*)1);

736

737 cpb_props = ff_add_cpb_side_data(avctx);

738 if (!cpb_props)

739 return AVERROR(ENOMEM);

740

741 if (enccfg.rc_end_usage == VPX_CBR ||

742 enccfg.g_pass != VPX_RC_ONE_PASS) {

743 cpb_props->max_bitrate = avctx->rc_max_rate;

744 cpb_props->min_bitrate = avctx->rc_min_rate;

745 cpb_props->avg_bitrate = avctx->bit_rate;

746 }

747 cpb_props->buffer_size = avctx->rc_buffer_size;

748

749 return 0;

750 }

751

752 static inline void cx_pktcpy(struct FrameListData *dst,

753 const struct vpx_codec_cx_pkt *src,

754 const struct vpx_codec_cx_pkt *src_alpha,

755 VPxContext *ctx)

756 {

757 dst->pts = src->data.frame.pts;

758 dst->duration = src->data.frame.duration;

759 dst->flags = src->data.frame.flags;

760 dst->sz = src->data.frame.sz;

761 dst->buf = src->data.frame.buf;

762 dst->have_sse = 0;

763 /* For alt-ref frame, don't store PSNR or increment frame_number */

764 if (!(dst->flags & VPX_FRAME_IS_INVISIBLE)) {

765 dst->frame_number = ++ctx->frame_number;

766 dst->have_sse = ctx->have_sse;

767 if (ctx->have_sse) {

768 /* associate last-seen SSE to the frame. */

769 /* Transfers ownership from ctx to dst. */

770 /* WARNING! This makes the assumption that PSNR_PKT comes

771 just before the frame it refers to! */

772 memcpy(dst->sse, ctx->sse, sizeof(dst->sse));

773 ctx->have_sse = 0;

774 }

775 } else {

776 dst->frame_number = -1; /* sanity marker */

777 }

778 if (src_alpha) {

779 dst->buf_alpha = src_alpha->data.frame.buf;

780 dst->sz_alpha = src_alpha->data.frame.sz;

781 } else {

782 dst->buf_alpha = NULL;

783 dst->sz_alpha = 0;

784 }

785 }

786

787 /**

788 * Store coded frame information in format suitable for return from encode2().

789 *

790 * Write information from @a cx_frame to @a pkt

791 * @return packet data size on success

792 * @return a negative AVERROR on error

793 */

794 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,

795 AVPacket *pkt)

796 {

797 int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);

798 uint8_t *side_data;

799 if (ret >= 0) {

800 int pict_type;

801 memcpy(pkt->data, cx_frame->buf, pkt->size);

802 pkt->pts = pkt->dts = cx_frame->pts;

803 #if FF_API_CODED_FRAME

804 FF_DISABLE_DEPRECATION_WARNINGS

805 avctx->coded_frame->pts = cx_frame->pts;

806 avctx->coded_frame->key_frame = !!(cx_frame->flags & VPX_FRAME_IS_KEY);

807 FF_ENABLE_DEPRECATION_WARNINGS

808 #endif

809

810 if (!!(cx_frame->flags & VPX_FRAME_IS_KEY)) {

811 pict_type = AV_PICTURE_TYPE_I;

812 #if FF_API_CODED_FRAME

813 FF_DISABLE_DEPRECATION_WARNINGS

814 avctx->coded_frame->pict_type = pict_type;

815 FF_ENABLE_DEPRECATION_WARNINGS

816 #endif

817 pkt->flags |= AV_PKT_FLAG_KEY;

818 } else {

819 pict_type = AV_PICTURE_TYPE_P;

820 #if FF_API_CODED_FRAME

821 FF_DISABLE_DEPRECATION_WARNINGS

822 avctx->coded_frame->pict_type = pict_type;

823 FF_ENABLE_DEPRECATION_WARNINGS

824 #endif

825 }

826

827 ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,

828 cx_frame->have_sse ? 3 : 0, pict_type);

829

830 if (cx_frame->have_sse) {

831 int i;

832 /* Beware of the Y/U/V/all order! */

833 #if FF_API_CODED_FRAME

834 FF_DISABLE_DEPRECATION_WARNINGS

835 avctx->coded_frame->error[0] = cx_frame->sse[1];

836 avctx->coded_frame->error[1] = cx_frame->sse[2];

837 avctx->coded_frame->error[2] = cx_frame->sse[3];

838 avctx->coded_frame->error[3] = 0; // alpha

839 FF_ENABLE_DEPRECATION_WARNINGS

840 #endif

841 for (i = 0; i < 3; ++i) {

842 avctx->error[i] += cx_frame->sse[i + 1];

843 }

844 cx_frame->have_sse = 0;

845 }

846 if (cx_frame->sz_alpha > 0) {

847 side_data = av_packet_new_side_data(pkt,

848 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,

849 cx_frame->sz_alpha + 8);

850 if(!side_data) {

851 av_packet_unref(pkt);

852 av_free(pkt);

853 return AVERROR(ENOMEM);

854 }

855 AV_WB64(side_data, 1);

856 memcpy(side_data + 8, cx_frame->buf_alpha, cx_frame->sz_alpha);

857 }

858 } else {

859 return ret;

860 }

861 return pkt->size;

862 }

863

864 /**

865 * Queue multiple output frames from the encoder, returning the front-most.

866 * In cases where vpx_codec_get_cx_data() returns more than 1 frame append

867 * the frame queue. Return the head frame if available.

868 * @return Stored frame size

869 * @return AVERROR(EINVAL) on output size error

870 * @return AVERROR(ENOMEM) on coded frame queue data allocation error

871 */

872 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)

873 {

874 VPxContext *ctx = avctx->priv_data;

875 const struct vpx_codec_cx_pkt *pkt;

876 const struct vpx_codec_cx_pkt *pkt_alpha = NULL;

877 const void *iter = NULL;

878 const void *iter_alpha = NULL;

879 int size = 0;

880

881 if (ctx->coded_frame_list) {

882 struct FrameListData *cx_frame = ctx->coded_frame_list;

883 /* return the leading frame if we've already begun queueing */

884 size = storeframe(avctx, cx_frame, pkt_out);

885 if (size < 0)

886 return size;

887 ctx->coded_frame_list = cx_frame->next;

888 free_coded_frame(cx_frame);

889 }

890

891 /* consume all available output from the encoder before returning. buffers

892 are only good through the next vpx_codec call */

893 while ((pkt = vpx_codec_get_cx_data(&ctx->encoder, &iter)) &&

894 (!ctx->is_alpha ||

895 (ctx->is_alpha && (pkt_alpha = vpx_codec_get_cx_data(&ctx->encoder_alpha, &iter_alpha))))) {

896 switch (pkt->kind) {

897 case VPX_CODEC_CX_FRAME_PKT:

898 if (!size) {

899 struct FrameListData cx_frame;

900

901 /* avoid storing the frame when the list is empty and we haven't yet

902 provided a frame for output */

903 av_assert0(!ctx->coded_frame_list);

904 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);

905 size = storeframe(avctx, &cx_frame, pkt_out);

906 if (size < 0)

907 return size;

908 } else {

909 struct FrameListData *cx_frame =

910 av_malloc(sizeof(struct FrameListData));

911

912 if (!cx_frame) {

913 av_log(avctx, AV_LOG_ERROR,

914 "Frame queue element alloc failed\n");

915 return AVERROR(ENOMEM);

916 }

917 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);

918 cx_frame->buf = av_malloc(cx_frame->sz);

919

920 if (!cx_frame->buf) {

921 av_log(avctx, AV_LOG_ERROR,

922 "Data buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",

923 cx_frame->sz);

924 av_freep(&cx_frame);

925 return AVERROR(ENOMEM);

926 }

927 memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);

928 if (ctx->is_alpha) {

929 cx_frame->buf_alpha = av_malloc(cx_frame->sz_alpha);

930 if (!cx_frame->buf_alpha) {

931 av_log(avctx, AV_LOG_ERROR,

932 "Data buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",

933 cx_frame->sz_alpha);

934 av_free(cx_frame);

935 return AVERROR(ENOMEM);

936 }

937 memcpy(cx_frame->buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);

938 }

939 coded_frame_add(&ctx->coded_frame_list, cx_frame);

940 }

941 break;

942 case VPX_CODEC_STATS_PKT: {

943 struct vpx_fixed_buf *stats = &ctx->twopass_stats;

944 int err;

945 if ((err = av_reallocp(&stats->buf,

946 stats->sz +

947 pkt->data.twopass_stats.sz)) < 0) {

948 stats->sz = 0;

949 av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");

950 return err;

951 }

952 memcpy((uint8_t*)stats->buf + stats->sz,

953 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);

954 stats->sz += pkt->data.twopass_stats.sz;

955 break;

956 }

957 case VPX_CODEC_PSNR_PKT:

958 av_assert0(!ctx->have_sse);

959 ctx->sse[0] = pkt->data.psnr.sse[0];

960 ctx->sse[1] = pkt->data.psnr.sse[1];

961 ctx->sse[2] = pkt->data.psnr.sse[2];

962 ctx->sse[3] = pkt->data.psnr.sse[3];

963 ctx->have_sse = 1;

964 break;

965 case VPX_CODEC_CUSTOM_PKT:

966 //ignore unsupported/unrecognized packet types

967 break;

968 }

969 }

970

971 return size;

972 }

973

974 static int vpx_encode(AVCodecContext *avctx, AVPacket *pkt,

975 const AVFrame *frame, int *got_packet)

976 {

977 VPxContext *ctx = avctx->priv_data;

978 struct vpx_image *rawimg = NULL;

979 struct vpx_image *rawimg_alpha = NULL;

980 int64_t timestamp = 0;

981 int res, coded_size;

982 vpx_enc_frame_flags_t flags = 0;

983

984 if (frame) {

985 rawimg = &ctx->rawimg;

986 rawimg->planes[VPX_PLANE_Y] = frame->data[0];

987 rawimg->planes[VPX_PLANE_U] = frame->data[1];

988 rawimg->planes[VPX_PLANE_V] = frame->data[2];

989 rawimg->stride[VPX_PLANE_Y] = frame->linesize[0];

990 rawimg->stride[VPX_PLANE_U] = frame->linesize[1];

991 rawimg->stride[VPX_PLANE_V] = frame->linesize[2];

992 if (ctx->is_alpha) {

993 uint8_t *u_plane, *v_plane;

994 rawimg_alpha = &ctx->rawimg_alpha;

995 rawimg_alpha->planes[VPX_PLANE_Y] = frame->data[3];

996 u_plane = av_malloc(frame->linesize[1] * frame->height);

997 v_plane = av_malloc(frame->linesize[2] * frame->height);

998 if (!u_plane || !v_plane) {

999 av_free(u_plane);

1000 av_free(v_plane);

1001 return AVERROR(ENOMEM);

1002 }

1003 memset(u_plane, 0x80, frame->linesize[1] * frame->height);

1004 rawimg_alpha->planes[VPX_PLANE_U] = u_plane;

1005 memset(v_plane, 0x80, frame->linesize[2] * frame->height);

1006 rawimg_alpha->planes[VPX_PLANE_V] = v_plane;

1007 rawimg_alpha->stride[VPX_PLANE_Y] = frame->linesize[0];

1008 rawimg_alpha->stride[VPX_PLANE_U] = frame->linesize[1];

1009 rawimg_alpha->stride[VPX_PLANE_V] = frame->linesize[2];

1010 }

1011 timestamp = frame->pts;

1012 #if VPX_IMAGE_ABI_VERSION >= 4

1013 switch (frame->color_range) {

1014 case AVCOL_RANGE_MPEG:

1015 rawimg->range = VPX_CR_STUDIO_RANGE;

1016 break;

1017 case AVCOL_RANGE_JPEG:

1018 rawimg->range = VPX_CR_FULL_RANGE;

1019 break;

1020 }

1021 #endif

1022 if (frame->pict_type == AV_PICTURE_TYPE_I)

1023 flags |= VPX_EFLAG_FORCE_KF;

1024 }

1025

1026 res = vpx_codec_encode(&ctx->encoder, rawimg, timestamp,

1027 avctx->ticks_per_frame, flags, ctx->deadline);

1028 if (res != VPX_CODEC_OK) {

1029 log_encoder_error(avctx, "Error encoding frame");

1030 return AVERROR_INVALIDDATA;

1031 }

1032

1033 if (ctx->is_alpha) {

1034 res = vpx_codec_encode(&ctx->encoder_alpha, rawimg_alpha, timestamp,

1035 avctx->ticks_per_frame, flags, ctx->deadline);

1036 if (res != VPX_CODEC_OK) {

1037 log_encoder_error(avctx, "Error encoding alpha frame");

1038 return AVERROR_INVALIDDATA;

1039 }

1040 }

1041

1042 coded_size = queue_frames(avctx, pkt);

1043

1044 if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {

1045 unsigned int b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);

1046

1047 avctx->stats_out = av_malloc(b64_size);

1048 if (!avctx->stats_out) {

1049 av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%d bytes) failed\n",

1050 b64_size);

1051 return AVERROR(ENOMEM);

1052 }

1053 av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,

1054 ctx->twopass_stats.sz);

1055 }

1056

1057 if (rawimg_alpha) {

1058 av_freep(&rawimg_alpha->planes[VPX_PLANE_U]);

1059 av_freep(&rawimg_alpha->planes[VPX_PLANE_V]);

1060 }

1061

1062 *got_packet = !!coded_size;

1063 return 0;

1064 }

1065

1066 #define OFFSET(x) offsetof(VPxContext, x)

1067 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

1068

1069 #define COMMON_OPTIONS \

1070 { "auto-alt-ref", "Enable use of alternate reference " \

1071 "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE}, \

1072 { "lag-in-frames", "Number of frames to look ahead for " \

1073 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1074 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1075 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1076 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \

1077 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \

1078 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \

1079 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \

1080 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \

1081 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \

1082 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \

1083 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \

1084 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \

1085 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \

1086 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \

1087 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \

1088 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1089 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \

1090 { "partitions", "The frame partitions are independently decodable " \

1091 "by the bool decoder, meaning that partitions can be decoded even " \

1092 "though earlier partitions have been lost. Note that intra predicition" \

1093 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \

1094 { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \

1095 { "static-thresh", "A change threshold on blocks below which they will be skipped by the encoder", OFFSET(static_thresh), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE }, \

1096 { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \

1097 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \

1098 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \

1099 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \

1100

1101 #define LEGACY_OPTIONS \

1102 {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \

1103 {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \

1104 {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \

1105 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \

1106 {"altref", "enable use of alternate reference frames (VP8/2-pass only)", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_AUTO_ALT_REF}, INT_MIN, INT_MAX, VE, "flags"}, \

1107 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \

1108 {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \

1109 {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \

1110 {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VPxContext, lag_in_frames), AV_OPT_TYPE_INT, {.i64 = 25}, 0, 25, VE}, \

1111

1112 #if CONFIG_LIBVPX_VP8_ENCODER

1113 static const AVOption vp8_options[] = {

1114 COMMON_OPTIONS

1115 { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE},

1116 LEGACY_OPTIONS

1117 { NULL }

1118 };

1119 #endif

1120

1121 #if CONFIG_LIBVPX_VP9_ENCODER

1122 static const AVOption vp9_options[] = {

1123 COMMON_OPTIONS

1124 { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -8, 8, VE},

1125 { "lossless", "Lossless mode", OFFSET(lossless), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},

1126 { "tile-columns", "Number of tile columns to use, log2", OFFSET(tile_columns), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},

1127 { "tile-rows", "Number of tile rows to use, log2", OFFSET(tile_rows), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},

1128 { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1, VE},

1129 #if VPX_ENCODER_ABI_VERSION >= 12

1130 { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},

1131 #else

1132 { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3, VE, "aq_mode"},

1133 #endif

1134 { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode" },

1135 { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode" },

1136 { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode" },

1137 { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode" },

1138 #if VPX_ENCODER_ABI_VERSION >= 12

1139 { "equator360", "360 video Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 4}, 0, 0, VE, "aq_mode" },

1140 {"level", "Specify level", OFFSET(level), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 6.2, VE},

1141 #endif

1142 #ifdef VPX_CTRL_VP9E_SET_ROW_MT

1143 {"row-mt", "Row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},

1144 #endif

1145 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT

1146 #if VPX_ENCODER_ABI_VERSION >= 14

1147 { "tune-content", "Tune content type", OFFSET(tune_content), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE, "tune_content" },

1148 #else

1149 { "tune-content", "Tune content type", OFFSET(tune_content), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE, "tune_content" },

1150 #endif

1151 { "default", "Regular video content", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "tune_content" },

1152 { "screen", "Screen capture content", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "tune_content" },

1153 #if VPX_ENCODER_ABI_VERSION >= 14

1154 { "film", "Film content; improves grain retention", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "tune_content" },

1155 #endif

1156 #endif

1157 #if VPX_ENCODER_ABI_VERSION >= 14

1158 { "corpus-complexity", "corpus vbr complexity midpoint", OFFSET(corpus_complexity), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000, VE },

1159 #endif

1160 LEGACY_OPTIONS

1161 { NULL }

1162 };

1163 #endif

1164

1165 #undef COMMON_OPTIONS

1166 #undef LEGACY_OPTIONS

1167

1168 static const AVCodecDefault defaults[] = {

1169 { "qmin", "-1" },

1170 { "qmax", "-1" },

1171 { "g", "-1" },

1172 { "keyint_min", "-1" },

1173 { NULL },

1174 };

1175

1176 #if CONFIG_LIBVPX_VP8_ENCODER

1177 static av_cold int vp8_init(AVCodecContext *avctx)

1178 {

1179 return vpx_init(avctx, vpx_codec_vp8_cx());

1180 }

1181

1182 static const AVClass class_vp8 = {

1183 .class_name = "libvpx-vp8 encoder",

1184 .item_name = av_default_item_name,

1185 .option = vp8_options,

1186 .version = LIBAVUTIL_VERSION_INT,

1187 };

1188

1189 AVCodec ff_libvpx_vp8_encoder = {

1190 .name = "libvpx",

1191 .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),

1192 .type = AVMEDIA_TYPE_VIDEO,

1193 .id = AV_CODEC_ID_VP8,

1194 .priv_data_size = sizeof(VPxContext),

1195 .init = vp8_init,

1196 .encode2 = vpx_encode,

1197 .close = vpx_free,

1198 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,

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

1200 .priv_class = &class_vp8,

1201 .defaults = defaults,

1202 .wrapper_name = "libvpx",

1203 };

1204 #endif /* CONFIG_LIBVPX_VP8_ENCODER */

1205

1206 #if CONFIG_LIBVPX_VP9_ENCODER

1207 static av_cold int vp9_init(AVCodecContext *avctx)

1208 {

1209 return vpx_init(avctx, vpx_codec_vp9_cx());

1210 }

1211

1212 static const AVClass class_vp9 = {

1213 .class_name = "libvpx-vp9 encoder",

1214 .item_name = av_default_item_name,

1215 .option = vp9_options,

1216 .version = LIBAVUTIL_VERSION_INT,

1217 };

1218

1219 AVCodec ff_libvpx_vp9_encoder = {

1220 .name = "libvpx-vp9",

1221 .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"),

1222 .type = AVMEDIA_TYPE_VIDEO,

1223 .id = AV_CODEC_ID_VP9,

1224 .priv_data_size = sizeof(VPxContext),

1225 .init = vp9_init,

1226 .encode2 = vpx_encode,

1227 .close = vpx_free,

1228 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,

1229 .profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),

1230 .priv_class = &class_vp9,

1231 .defaults = defaults,

1232 .init_static_data = ff_vp9_init_static,

1233 .wrapper_name = "libvpx",

1234 };

1235 #endif /* CONFIG_LIBVPX_VP9_ENCODER */

VPxContext::is_alpha

uint8_t is_alpha

Definition: libvpxenc.c:69

FrameListData::sse

uint64_t sse[4]

Definition: libvpxenc.c:57

AVCOL_SPC_BT709

also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B

Definition: pixfmt.h:475

VPxContext::rawimg

struct vpx_image rawimg

Definition: libvpxenc.c:66

VPxContext::arnr_max_frames

int arnr_max_frames

Definition: libvpxenc.c:87

NULL

#define NULL

Definition: coverity.c:32

AV_CODEC_ID_VP9

Definition: avcodec.h:386

val

const char const char void * val

Definition: avisynth_c.h:771

VPxContext::row_mt

int row_mt

Definition: libvpxenc.c:111

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AV_PIX_FMT_YUV440P10

#define AV_PIX_FMT_YUV440P10

Definition: pixfmt.h:370

AVFrame

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

Definition: frame.h:218

AV_PIX_FMT_NONE

Definition: pixfmt.h:61

vpx_free

static av_cold int vpx_free(AVCodecContext *avctx)

Definition: libvpxenc.c:302

AVOption

AVOption.

Definition: opt.h:246

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

AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:476

AVCodecContext::error

uint64_t error[AV_NUM_DATA_POINTERS]

error

Definition: avcodec.h:2693

OFFSET

#define OFFSET(x)

Definition: libvpxenc.c:1066

AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:67

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

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

VPxContext::rc_overshoot_pct

int rc_overshoot_pct

Definition: libvpxenc.c:99

desc

const char * desc

Definition: nvenc.c:65

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AV_OPT_TYPE_INT

Definition: opt.h:223

VPxContext::coded_frame_list

struct FrameListData * coded_frame_list

Definition: libvpxenc.c:75

AVCPBProperties::max_bitrate

int max_bitrate

Maximum bitrate of the stream, in bits per second.

Definition: avcodec.h:1104

AVCOL_SPC_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...

Definition: pixfmt.h:479

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

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:2148

AV_PIX_FMT_GBRP

planar GBR 4:4:4 24bpp

Definition: pixfmt.h:164

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVPacket::size

int size

Definition: avcodec.h:1431

FrameListData::buf

void * buf

compressed data buffer

Definition: libaomenc.c:46

AV_PIX_FMT_GBRP10

#define AV_PIX_FMT_GBRP10

Definition: pixfmt.h:384

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

VPxContext::aq_mode

int aq_mode

Definition: libvpxenc.c:106

AVCOL_SPC_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC

Definition: pixfmt.h:480

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

FrameListData::sz

size_t sz

length of compressed data

Definition: libaomenc.c:47

sse

static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)

Definition: mpegvideo_enc.c:2715

AV_PIX_FMT_YUV420P12

#define AV_PIX_FMT_YUV420P12

Definition: pixfmt.h:372

AVCodecContext::stats_in

char * stats_in

pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...

Definition: avcodec.h:2540

cx_pktcpy

static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VPxContext *ctx)

Definition: libvpxenc.c:752

VPxContext::frame_parallel

int frame_parallel

Definition: libvpxenc.c:105

VPxContext::static_thresh

int static_thresh

Definition: libvpxenc.c:96

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

src

#define src

Definition: vp8dsp.c:254

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:2843

AVCodec

AVCodec.

Definition: avcodec.h:3408

VPxContext::twopass_stats

struct vpx_fixed_buf twopass_stats

Definition: libvpxenc.c:70

VPxContext::error_resilient

int error_resilient

Definition: libvpxenc.c:94

AVCOL_SPC_RGB

order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)

Definition: pixfmt.h:474

VPxContext::tile_rows

int tile_rows

Definition: libvpxenc.c:104

VPxContext::frame_number

uint64_t frame_number

Definition: libvpxenc.c:74

AVCPBProperties::min_bitrate

int min_bitrate

Minimum bitrate of the stream, in bits per second.

Definition: avcodec.h:1109

AVCOL_SPC_SMPTE240M

functionally identical to above

Definition: pixfmt.h:481

libvpx.h

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

VP8F_AUTO_ALT_REF

#define VP8F_AUTO_ALT_REF

Enable automatic alternate reference frame generation.

Definition: libvpxenc.c:83

mathematics.h

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_WB64

#define AV_WB64(p, v)

Definition: intreadwrite.h:433

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

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

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: encode.c:32

AV_OPT_TYPE_CONST

Definition: opt.h:232

AV_PIX_FMT_YUVA420P

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

Definition: pixfmt.h:97

FrameListData::next

struct FrameListData * next

Definition: libaomenc.c:53

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

codecctl_int

static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)

Definition: libvpxenc.c:258

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

FrameListData::pts

int64_t pts

time stamp to show frame (in timebase units)

Definition: libaomenc.c:48

opt.h

AVOptions.

AVCOL_SPC_RESERVED

Definition: pixfmt.h:477

ff_libvpx_vp8_encoder

AVCodec ff_libvpx_vp8_encoder

coded_frame_add

static void coded_frame_add(void *list, struct FrameListData *cx_frame)

Definition: libvpxenc.c:229

AVFrame::pts

int64_t pts

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

Definition: frame.h:311

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

VPxContext::auto_alt_ref

int auto_alt_ref

Definition: libvpxenc.c:85

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

flags

static int flags

Definition: log.c:55

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

VPxContext::vpx_cs

int vpx_cs

Definition: libvpxenc.c:109

VPxContext::sse

uint64_t sse[4]

Definition: libvpxenc.c:72

AVCPBProperties::buffer_size

int buffer_size

The size of the buffer to which the ratecontrol is applied, in bits.

Definition: avcodec.h:1120

size

ptrdiff_t size

Definition: opengl_enc.c:101

AV_PIX_FMT_YUV422P12

#define AV_PIX_FMT_YUV422P12

Definition: pixfmt.h:373

AVCodecContext::stats_out

char * stats_out

pass1 encoding statistics output buffer

Definition: avcodec.h:2532

AVFrame::error

attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]

Definition: frame.h:353

AVCodecContext::frame_skip_threshold

attribute_deprecated int frame_skip_threshold

Definition: avcodec.h:2442

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

VPxContext::noise_sensitivity

int noise_sensitivity

Definition: libvpxenc.c:108

LEGACY_OPTIONS

#define LEGACY_OPTIONS

Definition: libvpxenc.c:1101

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: avcodec.h:1462

vpx_encode

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

Definition: libvpxenc.c:974

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

VPxContext::arnr_type

int arnr_type

Definition: libvpxenc.c:89

VPxContext::tune

int tune

Definition: libvpxenc.c:91

storeframe

static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)

Store coded frame information in format suitable for return from encode2().

Definition: libvpxenc.c:794

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVCodecDefault

Definition: internal.h:223

COMMON_OPTIONS

#define COMMON_OPTIONS

Definition: libvpxenc.c:1069

AVCodecContext::qmax

int qmax

maximum quantizer

Definition: avcodec.h:2362

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

AVFrame::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: frame.h:463

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1598

width

uint16_t width

Definition: gdv.c:47

AV_ROUND_NEAR_INF

Round to nearest and halfway cases away from zero.

Definition: mathematics.h:84

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3415

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:371

av_base64_encode

char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)

Encode data to base64 and null-terminate.

Definition: base64.c:138

set_color_range

static void set_color_range(AVCodecContext *avctx)

Definition: libaomenc.c:269

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: avcodec.h:1436

AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:66

AVCodecContext::rc_buffer_size

int rc_buffer_size

decoder bitstream buffer size

Definition: avcodec.h:2376

AVCodecContext::rc_min_rate

int64_t rc_min_rate

minimum bitrate

Definition: avcodec.h:2398

internal.h

common internal API header

VPxContext::level

float level

Definition: libvpxenc.c:110

VPxContext::lossless

int lossless

Definition: libvpxenc.c:102

dump_enc_cfg

static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)

Definition: libvpxenc.c:163

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:301

profiles.h

VPxContext::rawimg_alpha

struct vpx_image rawimg_alpha

Definition: libvpxenc.c:68

AV_BASE64_SIZE

#define AV_BASE64_SIZE(x)

Calculate the output size needed to base64-encode x bytes to a null-terminated string.

Definition: base64.h:66

intreadwrite.h

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1690

FF_PROFILE_UNKNOWN

#define FF_PROFILE_UNKNOWN

Definition: avcodec.h:2844

AVCOL_SPC_BT2020_NCL

ITU-R BT2020 non-constant luminance system.

Definition: pixfmt.h:484

AVCodecContext::noise_reduction

attribute_deprecated int noise_reduction

Definition: avcodec.h:2031

ctx

AVFormatContext * ctx

Definition: movenc.c:48

AV_CODEC_FLAG_PSNR

#define AV_CODEC_FLAG_PSNR

error[?] variables will be set during encoding.

Definition: avcodec.h:865

AV_OPT_TYPE_BOOL

Definition: opt.h:240

AV_CODEC_FLAG_PASS1

#define AV_CODEC_FLAG_PASS1

Use internal 2pass ratecontrol in first pass mode.

Definition: avcodec.h:849

stats

static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)

Definition: vp9_superframe_bsf.c:33

VPxContext::deadline

int deadline

Definition: libvpxenc.c:71

AVCodecContext::ticks_per_frame

int ticks_per_frame

For some codecs, the time base is closer to the field rate than the frame rate.

Definition: avcodec.h:1649

log_encoder_error

static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)

Definition: libvpxenc.c:152

AV_CODEC_ID_VP8

Definition: avcodec.h:358

VPxContext::crf

int crf

Definition: libvpxenc.c:95

AVCodecContext::height

int height

Definition: avcodec.h:1690

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:58

error

static void error(const char *err)

Definition: target_dec_fuzzer.c:59

AVCodecContext::thread_count

int thread_count

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

Definition: avcodec.h:2769

AVCOL_RANGE_JPEG

the normal 2^n-1 "JPEG" YUV ranges

Definition: pixfmt.h:499

ff_libvpx_vp9_encoder

AVCodec ff_libvpx_vp9_encoder

VP8F_ERROR_RESILIENT

#define VP8F_ERROR_RESILIENT

Enable measures appropriate for streaming over lossy links.

Definition: libvpxenc.c:82

VPxContext::cpu_used

int cpu_used

Definition: libvpxenc.c:77

vpx_init

static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)

Definition: libvpxenc.c:451

AVCPBProperties

This structure describes the bitrate properties of an encoded bitstream.

Definition: avcodec.h:1099

defaults

static const AVCodecDefault defaults[]

Definition: libvpxenc.c:1168

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

VPxContext::max_intra_rate

int max_intra_rate

Definition: libvpxenc.c:97

#define VE

Definition: libvpxenc.c:1067

av_reallocp

int av_reallocp(void *ptr, size_t size)

Allocate, reallocate, or free a block of memory through a pointer to a pointer.

Definition: mem.c:163

VPxContext::tune_content

int tune_content

Definition: libvpxenc.c:112

avcodec.h

Libavcodec external API header.

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1528

ff_vp9_init_static

av_cold void ff_vp9_init_static(AVCodec *codec)

Definition: libvpx.c:68

VPxContext::lag_in_frames

int lag_in_frames

Definition: libvpxenc.c:93

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:249

vp9_init

static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)

Definition: rtpdec_vp9.c:34

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

queue_frames

static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)

Queue multiple output frames from the encoder, returning the front-most.

Definition: libvpxenc.c:872

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:592

AVCodecContext::qmin

int qmin

minimum quantizer

Definition: avcodec.h:2355

buf

void * buf

Definition: avisynth_c.h:690

AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL

Data found in BlockAdditional element of matroska container.

Definition: avcodec.h:1294

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:368

base64.h

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

profiles

static const AVProfile profiles[]

Definition: libfdk-aacenc.c:381

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:2141

set_pix_fmt

static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)

Definition: libaomdec.c:87

FrameListData::flags

uint32_t flags

flags for this frame

Definition: libaomenc.c:52

AV_PIX_FMT_YUV440P12

#define AV_PIX_FMT_YUV440P12

Definition: pixfmt.h:374

snprintf

#define snprintf

Definition: snprintf.h:34

free_coded_frame

static av_cold void free_coded_frame(struct FrameListData *cx_frame)

Definition: libvpxenc.c:239

FrameListData::frame_number

uint64_t frame_number

Definition: libvpxenc.c:59

AVCodecContext::qcompress

float qcompress

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

Definition: avcodec.h:2347

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:266

FrameListData::sz_alpha

size_t sz_alpha

Definition: libvpxenc.c:51

AV_PIX_FMT_GBRP12

#define AV_PIX_FMT_GBRP12

Definition: pixfmt.h:385

FrameListData::have_sse

int have_sse

true if we have pending sse[]

Definition: libvpxenc.c:58

SIZE_SPECIFIER

#define SIZE_SPECIFIER

Definition: internal.h:262

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:369

AV_PIX_FMT_YUV444P12

#define AV_PIX_FMT_YUV444P12

Definition: pixfmt.h:375

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:232

level

uint8_t level

Definition: svq3.c:207

AVCOL_RANGE_MPEG

the normal 219*2^(n-8) "MPEG" YUV ranges

Definition: pixfmt.h:498

VPxContext::flags

int flags

VP8 specific flags, see VP8F_* below.

Definition: libvpxenc.c:81

AVCodecContext::gop_size

int gop_size

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

Definition: avcodec.h:1712

ctlidstr

static const char *const ctlidstr[]

String mappings for enum vp8e_enc_control_id.

Definition: libvpxenc.c:117

VPxContext::encoder_alpha

struct vpx_codec_ctx encoder_alpha

Definition: libvpxenc.c:67

vp8_init

static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)

Definition: rtpdec_vp8.c:263

AV_PIX_FMT_YUV420P

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

Definition: pixfmt.h:62

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:84

internal.h

common internal api header.

common.h

common internal and external API header

VPxContext::encoder

struct vpx_codec_ctx encoder

Definition: libvpxenc.c:65

AVCodecContext::coded_frame

attribute_deprecated AVFrame * coded_frame

the picture in the bitstream

Definition: avcodec.h:2760

AVRational::den

int den

Denominator.

Definition: rational.h:60

ff_add_cpb_side_data

AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)

Add a CPB properties side data to an encoding context.

Definition: utils.c:1936

free_frame_list

static av_cold void free_frame_list(struct FrameListData *list)

Definition: libvpxenc.c:247

AV_CODEC_FLAG_PASS2

#define AV_CODEC_FLAG_PASS2

Use internal 2pass ratecontrol in second pass mode.

Definition: avcodec.h:853

FrameListData::buf_alpha

void * buf_alpha

Definition: libvpxenc.c:50

AVCodecContext::slices

int slices

Number of slices.

Definition: avcodec.h:2164

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:85

FrameListData

Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.

Definition: libaomenc.c:45

AVCPBProperties::avg_bitrate

int avg_bitrate

Average bitrate of the stream, in bits per second.

Definition: avcodec.h:1114

VPxContext::arnr_strength

int arnr_strength

Definition: libvpxenc.c:88

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:296

FrameListData::duration

unsigned long duration

duration to show frame (in timebase units)

Definition: libaomenc.c:50

av_base64_decode

int av_base64_decode(uint8_t *out, const char *in_str, int out_size)

Decode a base64-encoded string.

Definition: base64.c:79

lrint

#define lrint

Definition: tablegen.h:53

VPxContext

Definition: libvpxdec.c:38

VPxContext::drop_threshold

int drop_threshold

Definition: libvpxenc.c:107

AVPacket::dts

int64_t dts

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

Definition: avcodec.h:1429

VPxContext::have_sse

int have_sse

true if we have pending sse[]

Definition: libvpxenc.c:73

AVFrame::height

int height

Definition: frame.h:276

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

VPxContext::rc_undershoot_pct

int rc_undershoot_pct

Definition: libvpxenc.c:98

AV_PIX_FMT_YUV440P

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

Definition: pixfmt.h:95

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

av_packet_new_side_data

uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)

Allocate new information of a packet.

Definition: avpacket.c:329

ff_vp9_profiles

const AVProfile ff_vp9_profiles[]

Definition: profiles.c:135

VPxContext::corpus_complexity

int corpus_complexity

Definition: libvpxenc.c:113

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

AVPacket::pts

int64_t pts

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

Definition: avcodec.h:1423

AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:275

av_unused

#define av_unused

Definition: attributes.h:125

VPxContext::tile_columns

int tile_columns

Definition: libvpxenc.c:103

AVCodecContext::rc_max_rate

int64_t rc_max_rate

maximum bitrate

Definition: avcodec.h:2391

AVCodecContext::keyint_min

int keyint_min

minimum GOP size

Definition: avcodec.h:2094

AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:497

Generated on Sun May 13 2018 02:03:49 for FFmpeg by doxygen 1.8.6