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 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 "libavutil/base64.h"

35 #include "libavutil/common.h"

36 #include "libavutil/mathematics.h"

37 #include "libavutil/opt.h"

39 /**

40 * Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.

41 * One encoded frame returned from the library.

42 */

43 struct FrameListData {

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

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

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

47 (in timebase units) */

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

49 (in timebase units) */

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

51 struct FrameListData *next;

52 };

54 typedef struct VP8EncoderContext {

55 AVClass *class;

56 struct vpx_codec_ctx encoder;

57 struct vpx_image rawimg;

58 struct vpx_fixed_buf twopass_stats;

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

60 struct FrameListData *coded_frame_list;

62 int cpu_used;

63 /**

64 * VP8 specific flags, see VP8F_* below.

65 */

66 int flags;

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

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

70 int auto_alt_ref;

72 int arnr_max_frames;

73 int arnr_strength;

74 int arnr_type;

76 int lag_in_frames;

77 int error_resilient;

78 int crf;

79 int max_intra_rate;

80 } VP8Context;

82 /** String mappings for enum vp8e_enc_control_id */

83 static const char *const ctlidstr[] = {

84 [VP8E_UPD_ENTROPY] = "VP8E_UPD_ENTROPY",

85 [VP8E_UPD_REFERENCE] = "VP8E_UPD_REFERENCE",

86 [VP8E_USE_REFERENCE] = "VP8E_USE_REFERENCE",

87 [VP8E_SET_ROI_MAP] = "VP8E_SET_ROI_MAP",

88 [VP8E_SET_ACTIVEMAP] = "VP8E_SET_ACTIVEMAP",

89 [VP8E_SET_SCALEMODE] = "VP8E_SET_SCALEMODE",

90 [VP8E_SET_CPUUSED] = "VP8E_SET_CPUUSED",

91 [VP8E_SET_ENABLEAUTOALTREF] = "VP8E_SET_ENABLEAUTOALTREF",

92 [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",

93 [VP8E_SET_SHARPNESS] = "VP8E_SET_SHARPNESS",

94 [VP8E_SET_STATIC_THRESHOLD] = "VP8E_SET_STATIC_THRESHOLD",

95 [VP8E_SET_TOKEN_PARTITIONS] = "VP8E_SET_TOKEN_PARTITIONS",

96 [VP8E_GET_LAST_QUANTIZER] = "VP8E_GET_LAST_QUANTIZER",

97 [VP8E_SET_ARNR_MAXFRAMES] = "VP8E_SET_ARNR_MAXFRAMES",

98 [VP8E_SET_ARNR_STRENGTH] = "VP8E_SET_ARNR_STRENGTH",

99 [VP8E_SET_ARNR_TYPE] = "VP8E_SET_ARNR_TYPE",

100 [VP8E_SET_CQ_LEVEL] = "VP8E_SET_CQ_LEVEL",

101 [VP8E_SET_MAX_INTRA_BITRATE_PCT] = "VP8E_SET_MAX_INTRA_BITRATE_PCT",

102 };

103

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

105 {

106 VP8Context *ctx = avctx->priv_data;

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

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

109

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

111 if (detail)

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

113 }

114

115 static av_cold void dump_enc_cfg(AVCodecContext *avctx,

116 const struct vpx_codec_enc_cfg *cfg)

117 {

118 int width = -30;

119 int level = AV_LOG_DEBUG;

120

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

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

123 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"

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

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

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

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

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

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

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

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

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

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

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

135 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"

136 " %*s%d\n %*s%p(%zu)\n %*s%u\n",

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

168 }

169

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

171 {

172 struct FrameListData **p = list;

173

174 while (*p != NULL)

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

176 *p = cx_frame;

177 cx_frame->next = NULL;

178 }

179

180 static av_cold void free_coded_frame(struct FrameListData *cx_frame)

181 {

182 av_freep(&cx_frame->buf);

183 av_freep(&cx_frame);

184 }

185

186 static av_cold void free_frame_list(struct FrameListData *list)

187 {

188 struct FrameListData *p = list;

189

190 while (p) {

191 list = list->next;

192 free_coded_frame(p);

193 p = list;

194 }

195 }

196

197 static av_cold int codecctl_int(AVCodecContext *avctx,

198 enum vp8e_enc_control_id id, int val)

199 {

200 VP8Context *ctx = avctx->priv_data;

201 char buf[80];

202 int width = -30;

203 int res;

204

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

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

207

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

209 if (res != VPX_CODEC_OK) {

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

211 ctlidstr[id]);

212 log_encoder_error(avctx, buf);

213 }

214

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

216 }

217

218 static av_cold int vp8_free(AVCodecContext *avctx)

219 {

220 VP8Context *ctx = avctx->priv_data;

221

222 vpx_codec_destroy(&ctx->encoder);

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

224 av_freep(&avctx->coded_frame);

225 av_freep(&avctx->stats_out);

226 free_frame_list(ctx->coded_frame_list);

227 return 0;

228 }

229

230 static av_cold int vp8_init(AVCodecContext *avctx)

231 {

232 VP8Context *ctx = avctx->priv_data;

233 const struct vpx_codec_iface *iface = &vpx_codec_vp8_cx_algo;

234 struct vpx_codec_enc_cfg enccfg;

235 int res;

236

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

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

239

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

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

242 vpx_codec_err_to_string(res));

243 return AVERROR(EINVAL);

244 }

245

246 if(!avctx->bit_rate)

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

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

249 return AVERROR(EINVAL);

250 }

251

252 dump_enc_cfg(avctx, &enccfg);

253

254 enccfg.g_w = avctx->width;

255 enccfg.g_h = avctx->height;

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

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

258 enccfg.g_threads = avctx->thread_count;

259 enccfg.g_lag_in_frames= ctx->lag_in_frames;

260

261 if (avctx->flags & CODEC_FLAG_PASS1)

262 enccfg.g_pass = VPX_RC_FIRST_PASS;

263 else if (avctx->flags & CODEC_FLAG_PASS2)

264 enccfg.g_pass = VPX_RC_LAST_PASS;

265 else

266 enccfg.g_pass = VPX_RC_ONE_PASS;

267

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

269 avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate)

270 enccfg.rc_end_usage = VPX_CBR;

271 else if (ctx->crf)

272 enccfg.rc_end_usage = VPX_CQ;

273

274 if (avctx->bit_rate) {

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

276 AV_ROUND_NEAR_INF);

277 } else {

278 if (enccfg.rc_end_usage == VPX_CQ) {

279 enccfg.rc_target_bitrate = 1000000;

280 } else {

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

282 av_log(avctx, AV_LOG_WARNING,

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

284 enccfg.rc_target_bitrate);

285 }

286 }

287

288 if (avctx->qmin > 0)

289 enccfg.rc_min_quantizer = avctx->qmin;

290 if (avctx->qmax > 0)

291 enccfg.rc_max_quantizer = avctx->qmax;

292 enccfg.rc_dropframe_thresh = avctx->frame_skip_threshold;

293

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

295 enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);

296 if (avctx->bit_rate)

297 enccfg.rc_2pass_vbr_minsection_pct =

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

299 if (avctx->rc_max_rate)

300 enccfg.rc_2pass_vbr_maxsection_pct =

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

302

303 if (avctx->rc_buffer_size)

304 enccfg.rc_buf_sz =

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

306 if (avctx->rc_initial_buffer_occupancy)

307 enccfg.rc_buf_initial_sz =

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

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

310 enccfg.rc_undershoot_pct = round(avctx->rc_buffer_aggressivity * 100);

311

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

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

314 enccfg.kf_min_dist = avctx->keyint_min;

315 if (avctx->gop_size >= 0)

316 enccfg.kf_max_dist = avctx->gop_size;

317

318 if (enccfg.g_pass == VPX_RC_FIRST_PASS)

319 enccfg.g_lag_in_frames = 0;

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

321 int decode_size;

322

323 if (!avctx->stats_in) {

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

325 return AVERROR_INVALIDDATA;

326 }

327

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

329 ctx->twopass_stats.buf = av_malloc(ctx->twopass_stats.sz);

330 if (!ctx->twopass_stats.buf) {

331 av_log(avctx, AV_LOG_ERROR,

332 "Stat buffer alloc (%zu bytes) failed\n",

333 ctx->twopass_stats.sz);

334 return AVERROR(ENOMEM);

335 }

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

337 ctx->twopass_stats.sz);

338 if (decode_size < 0) {

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

340 return AVERROR_INVALIDDATA;

341 }

342

343 ctx->twopass_stats.sz = decode_size;

344 enccfg.rc_twopass_stats_in = ctx->twopass_stats;

345 }

346

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

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

349 quality. */

350 if (avctx->profile != FF_PROFILE_UNKNOWN)

351 enccfg.g_profile = avctx->profile;

352

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

354

355 dump_enc_cfg(avctx, &enccfg);

356 /* Construct Encoder Context */

357 res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, 0);

358 if (res != VPX_CODEC_OK) {

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

360 return AVERROR(EINVAL);

361 }

362

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

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

365 if (ctx->cpu_used != INT_MIN)

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

367 if (ctx->flags & VP8F_AUTO_ALT_REF)

368 ctx->auto_alt_ref = 1;

369 if (ctx->auto_alt_ref >= 0)

370 codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);

371 if (ctx->arnr_max_frames >= 0)

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

373 if (ctx->arnr_strength >= 0)

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

375 if (ctx->arnr_type >= 0)

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

377 codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, avctx->noise_reduction);

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

379 codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD, avctx->mb_threshold);

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

381 if (ctx->max_intra_rate >= 0)

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

383

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

385

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

387 vpx_img_wrap(&ctx->rawimg, VPX_IMG_FMT_I420, avctx->width, avctx->height, 1,

388 (unsigned char*)1);

389

390 avctx->coded_frame = avcodec_alloc_frame();

391 if (!avctx->coded_frame) {

392 av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");

393 vp8_free(avctx);

394 return AVERROR(ENOMEM);

395 }

396 return 0;

397 }

398

399 static inline void cx_pktcpy(struct FrameListData *dst,

400 const struct vpx_codec_cx_pkt *src)

401 {

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

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

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

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

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

407 }

408

409 /**

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

411 *

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

413 * @return packet data size on success

414 * @return a negative AVERROR on error

415 */

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

417 AVPacket *pkt, AVFrame *coded_frame)

418 {

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

420 if (ret >= 0) {

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

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

423 coded_frame->pts = cx_frame->pts;

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

425

426 if (coded_frame->key_frame) {

427 coded_frame->pict_type = AV_PICTURE_TYPE_I;

428 pkt->flags |= AV_PKT_FLAG_KEY;

429 } else

430 coded_frame->pict_type = AV_PICTURE_TYPE_P;

431 } else {

432 return ret;

433 }

434 return pkt->size;

435 }

436

437 /**

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

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

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

441 * @return Stored frame size

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

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

444 */

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

446 AVFrame *coded_frame)

447 {

448 VP8Context *ctx = avctx->priv_data;

449 const struct vpx_codec_cx_pkt *pkt;

450 const void *iter = NULL;

451 int size = 0;

452

453 if (ctx->coded_frame_list) {

454 struct FrameListData *cx_frame = ctx->coded_frame_list;

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

456 size = storeframe(avctx, cx_frame, pkt_out, coded_frame);

457 if (size < 0)

458 return size;

459 ctx->coded_frame_list = cx_frame->next;

460 free_coded_frame(cx_frame);

461 }

462

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

464 are only good through the next vpx_codec call */

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

466 switch (pkt->kind) {

467 case VPX_CODEC_CX_FRAME_PKT:

468 if (!size) {

469 struct FrameListData cx_frame;

470

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

472 provided a frame for output */

473 av_assert0(!ctx->coded_frame_list);

474 cx_pktcpy(&cx_frame, pkt);

475 size = storeframe(avctx, &cx_frame, pkt_out, coded_frame);

476 if (size < 0)

477 return size;

478 } else {

479 struct FrameListData *cx_frame =

480 av_malloc(sizeof(struct FrameListData));

481

482 if (!cx_frame) {

483 av_log(avctx, AV_LOG_ERROR,

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

485 return AVERROR(ENOMEM);

486 }

487 cx_pktcpy(cx_frame, pkt);

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

489

490 if (!cx_frame->buf) {

491 av_log(avctx, AV_LOG_ERROR,

492 "Data buffer alloc (%zu bytes) failed\n",

493 cx_frame->sz);

494 av_free(cx_frame);

495 return AVERROR(ENOMEM);

496 }

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

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

499 }

500 break;

501 case VPX_CODEC_STATS_PKT: {

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

503 stats->buf = av_realloc_f(stats->buf, 1,

504 stats->sz + pkt->data.twopass_stats.sz);

505 if (!stats->buf) {

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

507 return AVERROR(ENOMEM);

508 }

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

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

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

512 break;

513 }

514 case VPX_CODEC_PSNR_PKT: //FIXME add support for CODEC_FLAG_PSNR

515 case VPX_CODEC_CUSTOM_PKT:

516 //ignore unsupported/unrecognized packet types

517 break;

518 }

519 }

520

521 return size;

522 }

523

524 static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt,

525 const AVFrame *frame, int *got_packet)

526 {

527 VP8Context *ctx = avctx->priv_data;

528 struct vpx_image *rawimg = NULL;

529 int64_t timestamp = 0;

530 int res, coded_size;

531 vpx_enc_frame_flags_t flags = 0;

532

533 if (frame) {

534 rawimg = &ctx->rawimg;

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

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

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

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

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

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

541 timestamp = frame->pts;

542 if (frame->pict_type == AV_PICTURE_TYPE_I)

543 flags |= VPX_EFLAG_FORCE_KF;

544 }

545

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

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

548 if (res != VPX_CODEC_OK) {

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

550 return AVERROR_INVALIDDATA;

551 }

552 coded_size = queue_frames(avctx, pkt, avctx->coded_frame);

553

554 if (!frame && avctx->flags & CODEC_FLAG_PASS1) {

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

556

557 avctx->stats_out = av_malloc(b64_size);

558 if (!avctx->stats_out) {

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

560 b64_size);

561 return AVERROR(ENOMEM);

562 }

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

564 ctx->twopass_stats.sz);

565 }

566

567 *got_packet = !!coded_size;

568 return 0;

569 }

570

571 #define OFFSET(x) offsetof(VP8Context, x)

572 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

573 static const AVOption options[] = {

574 { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = INT_MIN}, INT_MIN, INT_MAX, VE},

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

591 #ifdef VPX_ERROR_RESILIENT_DEFAULT

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

593 { "partitions", "The frame partitions are independently decodable "

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

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

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

597 #endif

598 {"speed", "", offsetof(VP8Context, cpu_used), AV_OPT_TYPE_INT, {.i64 = 3}, -16, 16, VE},

599 {"quality", "", offsetof(VP8Context, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"},

600 {"vp8flags", "", offsetof(VP8Context, flags), FF_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"},

601 {"error_resilient", "enable error resilience", 0, FF_OPT_TYPE_CONST, {.dbl = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"},

602 {"altref", "enable use of alternate reference frames (VP8/2-pass only)", 0, FF_OPT_TYPE_CONST, {.dbl = VP8F_AUTO_ALT_REF}, INT_MIN, INT_MAX, VE, "flags"},

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

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

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

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

607 { "crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 63, VE },

608 { NULL }

609 };

610

611 static const AVClass class = {

612 .class_name = "libvpx encoder",

613 .item_name = av_default_item_name,

614 .option = options,

615 .version = LIBAVUTIL_VERSION_INT,

616 };

617

618 static const AVCodecDefault defaults[] = {