[libvpx] Update to v1.17.0-97-gd3335af9e

This commit is contained in:
Andrey Volk committed 2026-11-16 23:18:46 +03:00
1 parent 7481baed18
commit a55111af58
615 files changed
+68654 -28912

No files matched your search

+471 -4
View File
@@ -8,19 +8,30 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "third_party/googletest/src/include/gtest/gtest.h"
#include <array>
#include <vector>
#include "gtest/gtest.h"
#include "./vpx_config.h"
#if CONFIG_VP8_DECODER && CONFIG_MULTITHREAD && defined(__linux__)
#include <sys/resource.h>
#endif
#include "test/ivf_video_source.h"
#include "test/video_source.h"
#if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER
#include "vpx/vp8cx.h"
#endif
#include "vpx/vp8dx.h"
#include "vpx/vpx_decoder.h"
#include "vpx/vpx_encoder.h"
namespace {
#define NELEMENTS(x) static_cast<int>(sizeof(x) / sizeof(x[0]))
TEST(DecodeAPI, InvalidParams) {
static const vpx_codec_iface_t *kCodecs[] = {
static vpx_codec_iface_t *kCodecs[] = {
#if CONFIG_VP8_DECODER
&vpx_codec_vp8_dx_algo,
#endif
@@ -77,6 +88,369 @@ TEST(DecodeAPI, OptionalParams) {
VPX_CODEC_USE_ERROR_CONCEALMENT));
#endif // CONFIG_ERROR_CONCEALMENT
}
TEST(DecodeAPI, Vp8FlushAfterFragmentError) {
static constexpr uint8_t kInvalidKeyframe[10] = { 0 };
vpx_codec_ctx_t dec;
ASSERT_EQ(VPX_CODEC_OK,
vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, nullptr,
VPX_CODEC_USE_INPUT_FRAGMENTS));
EXPECT_EQ(VPX_CODEC_OK,
vpx_codec_decode(&dec, kInvalidKeyframe, sizeof(kInvalidKeyframe),
nullptr, 0));
EXPECT_EQ(VPX_CODEC_UNSUP_BITSTREAM,
vpx_codec_decode(&dec, nullptr, 0, nullptr, 0));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_decode(&dec, nullptr, 0, nullptr, 0));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));
}
#if CONFIG_SIZE_LIMIT && \
(DECODE_WIDTH_LIMIT < 16383 || DECODE_HEIGHT_LIMIT < 16383)
TEST(DecodeAPI, Vp8RejectsOversizedKeyframeBeforeInitialization) {
vpx_codec_ctx_t dec;
ASSERT_EQ(VPX_CODEC_OK,
vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, nullptr, 0));
#if DECODE_WIDTH_LIMIT < 16383
constexpr uint16_t kWidth = DECODE_WIDTH_LIMIT + 1;
constexpr uint16_t kHeight = 1;
#else
constexpr uint16_t kWidth = 1;
constexpr uint16_t kHeight = DECODE_HEIGHT_LIMIT + 1;
#endif
static constexpr uint8_t kOversizedKeyframe[10] = {
0x00,
0x00,
0x00,
0x9d,
0x01,
0x2a,
static_cast<uint8_t>(kWidth),
static_cast<uint8_t>(kWidth >> 8),
static_cast<uint8_t>(kHeight),
static_cast<uint8_t>(kHeight >> 8),
};
EXPECT_EQ(
VPX_CODEC_CORRUPT_FRAME,
vpx_codec_decode(&dec, kOversizedKeyframe,
static_cast<unsigned int>(sizeof(kOversizedKeyframe)),
nullptr, 0));
static constexpr uint8_t kInterframe[10] = { 0x01 };
EXPECT_EQ(VPX_CODEC_UNSUP_BITSTREAM,
vpx_codec_decode(&dec, kInterframe,
static_cast<unsigned int>(sizeof(kInterframe)),
nullptr, 0));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));
}
#endif // CONFIG_SIZE_LIMIT && dimension limit is representable in VP8
TEST(DecodeAPI, Vp8FlushWithNoFragments) {
vpx_codec_ctx_t dec;
vpx_codec_dec_cfg_t cfg = { 1, 0, 0 };
vpx_codec_flags_t flags = VPX_CODEC_USE_INPUT_FRAGMENTS;
EXPECT_EQ(VPX_CODEC_OK,
vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, &cfg, flags));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_decode(&dec, nullptr, 0, nullptr, 0));
EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));
}
#if CONFIG_VP8_ENCODER && CONFIG_MULTITHREAD
// Encodes a sequence of key frames using two token partitions, truncates the
// second token partition of one frame so that the worker thread's bool decoder
// runs past the end of its partition, and then verifies that the
// multi-threaded decoder still reports subsequent well-formed key frames as
// not corrupted.
TEST(DecodeAPI, Vp8MultiThreadedCorruptedStateResetAcrossFrames) {
constexpr int kWidth = 16;
constexpr int kHeight = 32;
constexpr int kFrames = 4;
std::vector<std::vector<uint8_t>> frames;
{
vpx_codec_ctx_t enc;
vpx_codec_enc_cfg_t cfg;
ASSERT_EQ(vpx_codec_enc_config_default(&vpx_codec_vp8_cx_algo, &cfg, 0),
VPX_CODEC_OK);
cfg.g_w = kWidth;
cfg.g_h = kHeight;
cfg.g_lag_in_frames = 0;
ASSERT_EQ(vpx_codec_enc_init(&enc, &vpx_codec_vp8_cx_algo, &cfg, 0),
VPX_CODEC_OK);
ASSERT_EQ(vpx_codec_control(&enc, VP8E_SET_TOKEN_PARTITIONS,
VP8_TWO_TOKENPARTITION),
VPX_CODEC_OK);
libvpx_test::RandomVideoSource video;
video.SetSize(kWidth, kHeight);
video.set_limit(kFrames);
for (video.Begin(); video.img() != nullptr; video.Next()) {
ASSERT_EQ(
vpx_codec_encode(&enc, video.img(), video.pts(), video.duration(),
VPX_EFLAG_FORCE_KF, VPX_DL_REALTIME),
VPX_CODEC_OK);
vpx_codec_iter_t iter = nullptr;
const vpx_codec_cx_pkt_t *pkt;
while ((pkt = vpx_codec_get_cx_data(&enc, &iter)) != nullptr) {
if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) continue;
ASSERT_NE(pkt->data.frame.flags & VPX_FRAME_IS_KEY, 0u);
const uint8_t *buf = static_cast<const uint8_t *>(pkt->data.frame.buf);
frames.emplace_back(buf, buf + pkt->data.frame.sz);
}
}
ASSERT_EQ(vpx_codec_destroy(&enc), VPX_CODEC_OK);
}
ASSERT_EQ(frames.size(), static_cast<size_t>(kFrames));
// Truncate frame 1 so that only a single byte of the second token partition
// remains. The first token partition (used by the main thread) is left
// intact.
{
std::vector<uint8_t> &f = frames[1];
ASSERT_GT(f.size(), 10u);
const size_t first_part_sz =
(static_cast<size_t>(f[0]) | (static_cast<size_t>(f[1]) << 8) |
(static_cast<size_t>(f[2]) << 16)) >>
5;
const size_t part_sizes = 10 + first_part_sz;
ASSERT_LT(part_sizes + 3, f.size());
const size_t part0_sz = static_cast<size_t>(f[part_sizes]) |
(static_cast<size_t>(f[part_sizes + 1]) << 8) |
(static_cast<size_t>(f[part_sizes + 2]) << 16);
const size_t part1_start = part_sizes + 3 + part0_sz;
ASSERT_LT(part1_start, f.size());
f.resize(part1_start + 1);
}
vpx_codec_ctx_t dec;
vpx_codec_dec_cfg_t dec_cfg = { /*threads=*/4, /*w=*/0, /*h=*/0 };
ASSERT_EQ(vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, &dec_cfg, 0),
VPX_CODEC_OK);
for (int i = 0; i < kFrames; ++i) {
const vpx_codec_err_t res = vpx_codec_decode(
&dec, frames[i].data(), static_cast<unsigned int>(frames[i].size()),
/*user_priv=*/nullptr, /*deadline=*/0);
vpx_codec_iter_t iter = nullptr;
while (vpx_codec_get_frame(&dec, &iter)) {
}
if (i == 1) continue;
EXPECT_EQ(res, VPX_CODEC_OK)
<< "frame " << i << ": " << vpx_codec_error_detail(&dec);
int corrupted = -1;
EXPECT_EQ(vpx_codec_control(&dec, VP8D_GET_FRAME_CORRUPTED, &corrupted),
VPX_CODEC_OK);
EXPECT_EQ(corrupted, 0) << "frame " << i;
}
EXPECT_EQ(vpx_codec_destroy(&dec), VPX_CODEC_OK);
}
// Issue: 559707641
// Encodes a sequence of frames with two token partitions, truncates the second
// token partition of one frame (used by a worker thread), and verifies that
// the multi-threaded decoder returns VPX_CODEC_CORRUPT_FRAME and does not emit
// a partially written frame. Also verifies that subsequent well-formed frames
// still decode correctly.
TEST(DecodeAPI, Vp8MultiThreadedWorkerDecodeErrorFailsFrame) {
constexpr int kWidth = 32;
constexpr int kHeight = 32;
class PatternVideoSource : public libvpx_test::DummyVideoSource {
protected:
void FillFrame() override {
if (!img_) return;
// Keep row 0 flat so partition 0 size is small.
memset(img_->planes[VPX_PLANE_Y], 128, img_->stride[VPX_PLANE_Y] * 16);
// Fill row 1 with varying pattern so partition 1 has tokens to truncate.
for (int y = 16; y < 32; ++y) {
uint8_t *row =
img_->planes[VPX_PLANE_Y] + y * img_->stride[VPX_PLANE_Y];
for (int x = 0; x < 32; ++x) {
row[x] = static_cast<uint8_t>((x * 37 + y * 73) ^ (frame_ * 19));
}
}
memset(img_->planes[VPX_PLANE_U], 128, img_->stride[VPX_PLANE_U] * 16);
memset(img_->planes[VPX_PLANE_V], 128, img_->stride[VPX_PLANE_V] * 16);
}
};
constexpr int kFrames = 4;
std::vector<std::vector<uint8_t>> frames;
{
vpx_codec_ctx_t enc;
vpx_codec_enc_cfg_t cfg;
ASSERT_EQ(vpx_codec_enc_config_default(&vpx_codec_vp8_cx_algo, &cfg, 0),
VPX_CODEC_OK);
cfg.g_w = kWidth;
cfg.g_h = kHeight;
cfg.g_lag_in_frames = 0;
ASSERT_EQ(vpx_codec_enc_init(&enc, &vpx_codec_vp8_cx_algo, &cfg, 0),
VPX_CODEC_OK);
ASSERT_EQ(vpx_codec_control(&enc, VP8E_SET_TOKEN_PARTITIONS,
VP8_TWO_TOKENPARTITION),
VPX_CODEC_OK);
PatternVideoSource video;
video.SetSize(kWidth, kHeight);
video.set_limit(kFrames);
for (video.Begin(); video.img() != nullptr; video.Next()) {
ASSERT_EQ(
vpx_codec_encode(&enc, video.img(), video.pts(), video.duration(),
VPX_EFLAG_FORCE_KF, VPX_DL_REALTIME),
VPX_CODEC_OK);
vpx_codec_iter_t iter = nullptr;
const vpx_codec_cx_pkt_t *pkt;
while ((pkt = vpx_codec_get_cx_data(&enc, &iter)) != nullptr) {
if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) continue;
ASSERT_NE(pkt->data.frame.flags & VPX_FRAME_IS_KEY, 0u);
const uint8_t *buf = static_cast<const uint8_t *>(pkt->data.frame.buf);
frames.emplace_back(buf, buf + pkt->data.frame.sz);
}
}
ASSERT_EQ(vpx_codec_destroy(&enc), VPX_CODEC_OK);
}
ASSERT_EQ(frames.size(), static_cast<size_t>(kFrames));
// Truncate frame 1 so that only a single byte of the second token partition
// remains. The first token partition (used by the main thread) is left
// intact.
{
std::vector<uint8_t> &f = frames[1];
ASSERT_GT(f.size(), 10u);
const size_t first_part_sz =
(static_cast<size_t>(f[0]) | (static_cast<size_t>(f[1]) << 8) |
(static_cast<size_t>(f[2]) << 16)) >>
5;
const size_t part_sizes = 10 + first_part_sz;
ASSERT_LT(part_sizes + 3, f.size());
const size_t part0_sz = static_cast<size_t>(f[part_sizes]) |
(static_cast<size_t>(f[part_sizes + 1]) << 8) |
(static_cast<size_t>(f[part_sizes + 2]) << 16);
const size_t part1_start = part_sizes + 3 + part0_sz;
ASSERT_LT(part1_start, f.size());
f.resize(part1_start + 1);
}
vpx_codec_ctx_t dec;
vpx_codec_dec_cfg_t dec_cfg = { /*threads=*/4, /*w=*/0, /*h=*/0 };
ASSERT_EQ(vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, &dec_cfg, 0),
VPX_CODEC_OK);
for (int i = 0; i < kFrames; ++i) {
const vpx_codec_err_t res = vpx_codec_decode(
&dec, frames[i].data(), static_cast<unsigned int>(frames[i].size()),
/*user_priv=*/nullptr, /*deadline=*/0);
vpx_codec_iter_t iter = nullptr;
const vpx_image_t *img = vpx_codec_get_frame(&dec, &iter);
if (i == 1) {
EXPECT_EQ(res, VPX_CODEC_CORRUPT_FRAME);
EXPECT_EQ(img, nullptr);
continue;
}
EXPECT_EQ(res, VPX_CODEC_OK)
<< "frame " << i << ": " << vpx_codec_error_detail(&dec);
EXPECT_NE(img, nullptr) << "frame " << i;
int corrupted = -1;
EXPECT_EQ(vpx_codec_control(&dec, VP8D_GET_FRAME_CORRUPTED, &corrupted),
VPX_CODEC_OK);
EXPECT_EQ(corrupted, 0) << "frame " << i;
}
EXPECT_EQ(vpx_codec_destroy(&dec), VPX_CODEC_OK);
}
#endif // CONFIG_VP8_ENCODER && CONFIG_MULTITHREAD
#if CONFIG_MULTITHREAD && defined(__linux__)
// Issue: 571147583
// Verifies that when restarting decode threads fails on a keyframe with a new
// resolution, the cached dimensions (ctx->si.w, ctx->si.h) are cleared so a
// subsequent decode triggers a resolution change and reallocates frame buffers.
TEST(DecodeAPI, Vp8MultiThreadedRestartResolutionChange) {
// Minimal 2-partition VP8 keyframe buffer (first partition = 256 bytes).
std::vector<uint8_t> frame(1500, 0);
frame[0] = 0x10;
frame[1] = 0x20;
frame[3] = 0x9d;
frame[4] = 0x01;
frame[5] = 0x2a;
frame[6] = 0x00; // width = 256
frame[7] = 0x01;
frame[8] = 0x00; // height = 256
frame[9] = 0x01;
frame[10] = 0x0f; // 2 token partitions
frame[11] = 0xc1;
frame[12] = 0x28;
frame[266] = 0x58; // token partition 0 size = 600
frame[267] = 0x02;
vpx_codec_ctx_t dec;
vpx_codec_dec_cfg_t cfg = { /*threads=*/2, /*w=*/0, /*h=*/0 };
ASSERT_EQ(vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, &cfg, 0),
VPX_CODEC_OK);
// Frame 0: valid 256x256 keyframe initializes 256x256 frame buffers
// (yv12_fb_new->y_width = 256, pc->Width = 256) and worker threads.
ASSERT_EQ(
vpx_codec_decode(&dec, frame.data(),
static_cast<unsigned int>(frame.size()), nullptr, 0),
VPX_CODEC_OK);
// Frame 1: truncate token partition 0 to 1 byte so the worker thread fails in
// vp8mt_decode_mb_rows(), shutting down threads and setting
// ctx->restart_threads = 1.
frame[266] = 1;
frame[267] = 0;
EXPECT_EQ(
vpx_codec_decode(&dec, frame.data(),
static_cast<unsigned int>(frame.size()), nullptr, 0),
VPX_CODEC_CORRUPT_FRAME);
// Change keyframe header to 16x64. In each iteration:
// 1. Set RLIMIT_NPROC = 0 so pthread_create fails inside restart_threads and
// vpx_codec_decode returns VPX_CODEC_ERROR after vp8_peek_si_internal()
// has updated ctx->si.w = 16, ctx->si.h = 64.
// 2. Restore RLIMIT_NPROC and decode again so restart_threads succeeds and
// allocates mt_yabove_row for pc->Width.
//
// Without the fix:
// - ctx->si.w = 16, ctx->si.h = 64 remain cached after step 1, so step 2
// sees resolution_change == 0 and skips vp8_alloc_frame_buffers()
// (leaving yv12_fb_new->y_width = 256).
// - In iteration 0 step 2, vp8_decode_frame() sets pc->Width = 16 from the
// keyframe header before failing on the truncated token partition
// (setting ctx->restart_threads = 1 again).
// - In iteration 1 step 2, restart_threads allocates mt_yabove_row for
// pc->Width = 16 (103 bytes) while yv12_fb_new->y_width is still 256,
// causing a 261-byte write (heap-buffer-overflow) in
// vp8mt_decode_mb_rows().
//
// With the fix:
// - Step 1 clears ctx->si.w = 0, ctx->si.h = 0 on thread restart failure.
// - Step 2 detects resolution_change == 1, reallocates frame buffers to
// 16x64, and cleanly returns VPX_CODEC_CORRUPT_FRAME on the truncated
// partition.
frame[6] = 16;
frame[7] = 0;
frame[8] = 64;
frame[9] = 0;
struct rlimit old_lim;
ASSERT_EQ(getrlimit(RLIMIT_NPROC, &old_lim), 0);
const struct rlimit zero_lim = { 0, old_lim.rlim_max };
for (int i = 0; i < 2; ++i) {
ASSERT_EQ(setrlimit(RLIMIT_NPROC, &zero_lim), 0);
const vpx_codec_err_t res =
vpx_codec_decode(&dec, frame.data(),
static_cast<unsigned int>(frame.size()), nullptr, 0);
ASSERT_EQ(setrlimit(RLIMIT_NPROC, &old_lim), 0);
EXPECT_EQ(res, VPX_CODEC_ERROR);
EXPECT_EQ(
vpx_codec_decode(&dec, frame.data(),
static_cast<unsigned int>(frame.size()), nullptr, 0),
VPX_CODEC_CORRUPT_FRAME);
}
EXPECT_EQ(vpx_codec_destroy(&dec), VPX_CODEC_OK);
}
#endif // CONFIG_MULTITHREAD && defined(__linux__)
#endif // CONFIG_VP8_DECODER
#if CONFIG_VP9_DECODER
@@ -120,7 +494,7 @@ void TestVp9Controls(vpx_codec_ctx_t *dec) {
}
TEST(DecodeAPI, Vp9InvalidDecode) {
const vpx_codec_iface_t *const codec = &vpx_codec_vp9_dx_algo;
vpx_codec_iface_t *const codec = &vpx_codec_vp9_dx_algo;
const char filename[] =
"invalid-vp90-2-00-quantizer-00.webm.ivf.s5861_r01-05_b6-.v2.ivf";
libvpx_test::IVFVideoSource video(filename);
@@ -147,7 +521,7 @@ TEST(DecodeAPI, Vp9InvalidDecode) {
void TestPeekInfo(const uint8_t *const data, uint32_t data_sz,
uint32_t peek_size) {
const vpx_codec_iface_t *const codec = &vpx_codec_vp9_dx_algo;
vpx_codec_iface_t *const codec = &vpx_codec_vp9_dx_algo;
// Verify behavior of vpx_codec_decode. vpx_codec_decode doesn't even get
// to decoder_peek_si_internal on frames of size < 8.
if (data_sz >= 8) {
@@ -193,6 +567,49 @@ TEST(DecodeAPI, Vp9PeekStreamInfoTruncated) {
TestPeekInfo(profile1_data, data_sz, 11);
}
}
TEST(DecodeAPI, Buganizer499206650) {
vpx_codec_ctx_t dec;
ASSERT_EQ(vpx_codec_dec_init(&dec, vpx_codec_vp9_dx(), /*cfg=*/nullptr,
/*flags=*/0),
VPX_CODEC_OK);
// Frame 1: VP9 intra_only, profile 0, 8x8, error_resilient=1,
// refresh_frame_flags=0x00. Clears need_resync without updating ref slots.
static constexpr std::array<uint8_t, 83> frame1 = {
0x85, 0xa4, 0xc1, 0xa1, 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x40,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
EXPECT_EQ(vpx_codec_decode(&dec, frame1.data(),
static_cast<unsigned int>(frame1.size()),
/*user_priv=*/nullptr, /*deadline=*/0),
VPX_CODEC_OK)
<< vpx_codec_error_detail(&dec);
vpx_codec_iter_t it = nullptr;
while (vpx_codec_get_frame(&dec, &it)) {
}
// Frame 2: VP9 inter, profile 0, show_frame=1, error_resilient=1,
// refresh=0xFF, references slot 0 (ref_frame_map[0] == -1).
static constexpr std::array<uint8_t, 16> frame2 = {
0x87, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
// Ensure there is no out of bounds read using the invalid index and that the
// decoder reports an error.
EXPECT_EQ(vpx_codec_decode(&dec, frame2.data(),
static_cast<unsigned int>(frame2.size()),
/*user_priv=*/nullptr, /*deadline=*/0),
VPX_CODEC_CORRUPT_FRAME);
EXPECT_EQ(vpx_codec_destroy(&dec), VPX_CODEC_OK);
}
#endif // CONFIG_VP9_DECODER
TEST(DecodeAPI, HighBitDepthCapability) {
@@ -212,4 +629,54 @@ TEST(DecodeAPI, HighBitDepthCapability) {
#endif
}
#if CONFIG_VP8_DECODER
TEST(DecodeAPI, SetReferenceValidationVp8) {
vpx_codec_ctx_t dec;
ASSERT_EQ(vpx_codec_dec_init(&dec, vpx_codec_vp8_dx(), nullptr, 0),
VPX_CODEC_OK);
vpx_image_t ref_img;
ASSERT_NE(vpx_img_alloc(&ref_img, VPX_IMG_FMT_I420, 64, 64, 1), nullptr);
for (const int plane : { VPX_PLANE_Y, VPX_PLANE_U, VPX_PLANE_V }) {
vpx_ref_frame_t ref_frame;
ref_frame.frame_type = VP8_LAST_FRAME;
ref_frame.img = ref_img;
ref_frame.img.planes[plane] = nullptr;
EXPECT_EQ(vpx_codec_control(&dec, VP8_SET_REFERENCE, &ref_frame),
VPX_CODEC_INVALID_PARAM);
EXPECT_EQ(vpx_codec_control(&dec, VP8_COPY_REFERENCE, &ref_frame),
VPX_CODEC_INVALID_PARAM);
}
vpx_img_free(&ref_img);
EXPECT_EQ(vpx_codec_destroy(&dec), VPX_CODEC_OK);
}
#endif // CONFIG_VP8_DECODER
#if CONFIG_VP9_DECODER
TEST(DecodeAPI, SetReferenceValidationVp9) {
vpx_codec_ctx_t dec;
ASSERT_EQ(vpx_codec_dec_init(&dec, vpx_codec_vp9_dx(), nullptr, 0),
VPX_CODEC_OK);
vpx_image_t ref_img;
ASSERT_NE(vpx_img_alloc(&ref_img, VPX_IMG_FMT_I420, 64, 64, 1), nullptr);
for (const int plane : { VPX_PLANE_Y, VPX_PLANE_U, VPX_PLANE_V }) {
vpx_ref_frame_t ref_frame;
ref_frame.frame_type = VP8_LAST_FRAME;
ref_frame.img = ref_img;
ref_frame.img.planes[plane] = nullptr;
EXPECT_EQ(vpx_codec_control(&dec, VP8_SET_REFERENCE, &ref_frame),
VPX_CODEC_INVALID_PARAM);
EXPECT_EQ(vpx_codec_control(&dec, VP8_COPY_REFERENCE, &ref_frame),
VPX_CODEC_INVALID_PARAM);
}
vpx_img_free(&ref_img);
EXPECT_EQ(vpx_codec_destroy(&dec), VPX_CODEC_OK);
}
#endif // CONFIG_VP9_DECODER
} // namespace