Skip to content

GitLab

T
tangled
Commit 07ed5f6e authored by Dale Curtis's avatar Dale Curtis Committed by Chromium LUCI CQ
Browse files
Options

Implement support for uploading RGB VideoFrame resources. 

Now that we allow RGB VideoFrames through WebCodecs, we need to add
support in VideoResourceUpdater since BreakoutBox allows them to
reach our normal compositing path.

R=sandersd

Bug: 1167206,1167412
Test: Updated unittests.
Change-Id: Ie7a72128ab4bf65c72a5a8a41014700b9db7d677
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2634049
Commit-Queue: Dale Curtis <dalecurtis@chromium.org>
Auto-Submit: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: default avatarDan Sanders <sandersd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#844918}
parent d4781d14
Show whitespace changes
Inline Side-by-side
Showing with 178 additions and 119 deletions
media/base/video_frame.cc
View file @ 07ed5f6e
......@@ -233,6 +233,9 @@ static base::Optional<VideoFrameLayout> GetDefaultLayout(
break;
case PIXEL_FORMAT_ARGB:
case PIXEL_FORMAT_XRGB:
case PIXEL_FORMAT_ABGR:
case PIXEL_FORMAT_XBGR:
planes = std::vector<ColorPlaneLayout>{ColorPlaneLayout(
coded_size.width() * 4, 0, coded_size.GetArea() * 4)};
break;
......@@ -252,9 +255,7 @@ static base::Optional<VideoFrameLayout> GetDefaultLayout(
default:
// TODO(miu): This function should support any pixel format.
// http://crbug.com/555909 .
DLOG(ERROR)
<< "Only PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_NV12, "
"and PIXEL_FORMAT_ARGB formats are supported: "
DLOG(ERROR) << "Unsupported pixel format"
<< VideoPixelFormatToString(format);
return base::nullopt;
}
......
media/renderers/paint_canvas_video_renderer.cc
View file @ 07ed5f6e
......@@ -49,6 +49,7 @@
// shown here to indicate where ideal conversions are currently missing.
#if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \
SK_A32_SHIFT == 24
#define OUTPUT_ARGB 1
#define LIBYUV_I400_TO_ARGB libyuv::I400ToARGB
#define LIBYUV_I420_TO_ARGB libyuv::I420ToARGB
#define LIBYUV_I422_TO_ARGB libyuv::I422ToARGB
......@@ -86,8 +87,11 @@
// #define LIBYUV_U410_TO_ARGB libyuv::U410ToARGB
#define LIBYUV_NV12_TO_ARGB libyuv::NV12ToARGB
#define LIBYUV_ABGR_TO_ARGB libyuv::ABGRToARGB
#elif SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \
SK_A32_SHIFT == 24
#define OUTPUT_ARGB 0
#define LIBYUV_I400_TO_ARGB libyuv::I400ToARGB
#define LIBYUV_I420_TO_ARGB libyuv::I420ToABGR
#define LIBYUV_I422_TO_ARGB libyuv::I422ToABGR
......@@ -125,6 +129,8 @@
// #define LIBYUV_U410_TO_ARGB libyuv::U410ToABGR
#define LIBYUV_NV12_TO_ARGB libyuv::NV12ToABGR
#define LIBYUV_ABGR_TO_ARGB libyuv::ARGBToABGR
#else
#error Unexpected Skia ARGB_8888 layout!
#endif
......@@ -390,11 +396,21 @@ void ConvertVideoFrameToRGBPixelsTask(const VideoFrame* video_frame,
format == PIXEL_FORMAT_ABGR || format == PIXEL_FORMAT_XBGR) {
DCHECK_LE(width, static_cast<int>(row_bytes));
const uint8_t* data = plane_meta[VideoFrame::kARGBPlane].data;
if ((OUTPUT_ARGB &&
(format == PIXEL_FORMAT_ARGB || format == PIXEL_FORMAT_XRGB)) ||
(!OUTPUT_ARGB &&
(format == PIXEL_FORMAT_ABGR || format == PIXEL_FORMAT_XBGR))) {
for (size_t i = 0; i < rows; i++) {
memcpy(pixels, data, width * 4);
pixels += row_bytes;
data += plane_meta[VideoFrame::kARGBPlane].stride;
}
} else {
LIBYUV_ABGR_TO_ARGB(plane_meta[VideoFrame::kARGBPlane].data,
plane_meta[VideoFrame::kARGBPlane].stride, pixels,
row_bytes, width, rows);
}
done->Run();
return;
}
......
media/renderers/video_resource_updater.cc
View file @ 07ed5f6e
......@@ -943,13 +943,25 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
size_t bits_per_channel = video_frame->BitDepth();
// Only YUV and Y16 software video frames are supported.
const bool is_rgb = input_frame_format == PIXEL_FORMAT_XBGR ||
input_frame_format == PIXEL_FORMAT_XRGB ||
input_frame_format == PIXEL_FORMAT_ABGR ||
input_frame_format == PIXEL_FORMAT_ARGB;
DCHECK(IsYuvPlanar(input_frame_format) ||
input_frame_format == PIXEL_FORMAT_Y16);
input_frame_format == PIXEL_FORMAT_Y16 || is_rgb);
viz::ResourceFormat output_resource_format;
gfx::ColorSpace output_color_space = video_frame->ColorSpace();
if (input_frame_format == PIXEL_FORMAT_Y16) {
if (input_frame_format == PIXEL_FORMAT_XBGR) {
output_resource_format = viz::RGBX_8888;
} else if (input_frame_format == PIXEL_FORMAT_XRGB) {
output_resource_format = viz::BGRX_8888;
} else if (input_frame_format == PIXEL_FORMAT_ABGR) {
output_resource_format = viz::RGBA_8888;
} else if (input_frame_format == PIXEL_FORMAT_ARGB) {
output_resource_format = viz::BGRA_8888;
} else if (input_frame_format == PIXEL_FORMAT_Y16) {
// Unable to display directly as yuv planes so convert it to RGBA for
// compositing.
output_resource_format = viz::RGBA_8888;
......@@ -963,9 +975,10 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
// returned by the resource provider is viz::RGBA_8888, then a GPU driver
// bug workaround requires that YUV frames must be converted to RGB
// before texture upload.
bool texture_needs_rgb_conversion =
!software_compositor() &&
output_resource_format == viz::ResourceFormat::RGBA_8888;
const bool texture_needs_rgb_conversion =
input_frame_format == PIXEL_FORMAT_Y16 ||
(!software_compositor() && IsYuvPlanar(input_frame_format) &&
output_resource_format == viz::ResourceFormat::RGBA_8888);
size_t output_plane_count = VideoFrame::NumPlanes(input_frame_format);
......@@ -1026,14 +1039,15 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
external_resources.bits_per_channel = bits_per_channel;
if (software_compositor() || texture_needs_rgb_conversion) {
if (software_compositor() || texture_needs_rgb_conversion || is_rgb) {
DCHECK_EQ(plane_resources.size(), 1u);
PlaneResource* plane_resource = plane_resources[0];
DCHECK_EQ(plane_resource->resource_format(), viz::RGBA_8888);
if (!plane_resource->Matches(video_frame->unique_id(), 0)) {
// We need to transfer data from |video_frame| to the plane resource.
if (software_compositor()) {
DCHECK_EQ(plane_resource->resource_format(), viz::RGBA_8888);
if (!video_renderer_)
video_renderer_ = std::make_unique<PaintCanvasVideoRenderer>();
......@@ -1062,7 +1076,7 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
} else {
HardwarePlaneResource* hardware_resource = plane_resource->AsHardware();
size_t bytes_per_row = viz::ResourceSizes::CheckedWidthInBytes<size_t>(
video_frame->coded_size().width(), viz::ResourceFormat::RGBA_8888);
video_frame->coded_size().width(), output_resource_format);
size_t needed_size = bytes_per_row * video_frame->coded_size().height();
if (upload_pixels_size_ < needed_size) {
// Free the existing data first so that the memory can be reused,
......@@ -1084,8 +1098,8 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
scope.texture_id());
gl->TexSubImage2D(
hardware_resource->texture_target(), 0, 0, 0, plane_size.width(),
plane_size.height(), GLDataFormat(viz::ResourceFormat::RGBA_8888),
GLDataType(viz::ResourceFormat::RGBA_8888), upload_pixels_.get());
plane_size.height(), GLDataFormat(output_resource_format),
GLDataType(output_resource_format), upload_pixels_.get());
}
}
plane_resource->SetUniqueId(video_frame->unique_id(), 0);
......@@ -1113,7 +1127,7 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
}
transferable_resource.color_space = output_color_space;
transferable_resource.format = viz::ResourceFormat::RGBA_8888;
transferable_resource.format = output_resource_format;
external_resources.resources.push_back(std::move(transferable_resource));
external_resources.release_callbacks.push_back(base::BindOnce(
&VideoResourceUpdater::RecycleResource, weak_ptr_factory_.GetWeakPtr(),
......
media/renderers/video_resource_updater_unittest.cc
View file @ 07ed5f6e
......@@ -105,7 +105,7 @@ class VideoResourceUpdaterTest : public testing::Test {
// Note that the number of pixels needed for |size| must be less than or equal
// to the number of pixels needed for size of 100x100.
scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame(
scoped_refptr<VideoFrame> CreateTestYUVVideoFrame(
const gfx::Size& size = gfx::Size(10, 10)) {
constexpr int kMaxDimension = 100;
static uint8_t y_data[kMaxDimension * kMaxDimension] = {0};
......@@ -114,9 +114,8 @@ class VideoResourceUpdaterTest : public testing::Test {
CHECK_LE(size.width() * size.height(), kMaxDimension * kMaxDimension);
scoped_refptr<media::VideoFrame> video_frame =
media::VideoFrame::WrapExternalYuvData(
media::PIXEL_FORMAT_I422, // format
scoped_refptr<VideoFrame> video_frame =
VideoFrame::WrapExternalYuvData(PIXEL_FORMAT_I422, // format
size, // coded_size
gfx::Rect(size), // visible_rect
size, // natural_size
......@@ -131,7 +130,7 @@ class VideoResourceUpdaterTest : public testing::Test {
return video_frame;
}
scoped_refptr<media::VideoFrame> CreateWonkyTestYUVVideoFrame() {
scoped_refptr<VideoFrame> CreateWonkyTestYUVVideoFrame() {
const int kDimension = 10;
const int kYWidth = kDimension + 5;
const int kUWidth = (kYWidth + 1) / 2 + 200;
......@@ -140,9 +139,8 @@ class VideoResourceUpdaterTest : public testing::Test {
static uint8_t u_data[kUWidth * kDimension] = {0};
static uint8_t v_data[kVWidth * kDimension] = {0};
scoped_refptr<media::VideoFrame> video_frame =
media::VideoFrame::WrapExternalYuvData(
media::PIXEL_FORMAT_I422, // format
scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapExternalYuvData(
PIXEL_FORMAT_I422, // format
gfx::Size(kYWidth, kDimension), // coded_size
gfx::Rect(2, 0, kDimension, kDimension), // visible_rect
gfx::Size(kDimension, kDimension), // natural_size
......@@ -157,13 +155,29 @@ class VideoResourceUpdaterTest : public testing::Test {
return video_frame;
}
scoped_refptr<media::VideoFrame> CreateTestHighBitFrame() {
scoped_refptr<VideoFrame> CreateTestRGBVideoFrame(VideoPixelFormat format) {
constexpr int kMaxDimension = 10;
constexpr gfx::Size kSize = gfx::Size(kMaxDimension, kMaxDimension);
static uint32_t rgb_data[kMaxDimension * kMaxDimension] = {0};
scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapExternalData(
format, // format
kSize, // coded_size
gfx::Rect(kSize), // visible_rect
kSize, // natural_size
reinterpret_cast<uint8_t*>(rgb_data), // data,
sizeof(rgb_data), // data_size
base::TimeDelta()); // timestamp
EXPECT_TRUE(video_frame);
return video_frame;
}
scoped_refptr<VideoFrame> CreateTestHighBitFrame() {
const int kDimension = 10;
gfx::Size size(kDimension, kDimension);
scoped_refptr<media::VideoFrame> video_frame(media::VideoFrame::CreateFrame(
media::PIXEL_FORMAT_YUV420P10, size, gfx::Rect(size), size,
base::TimeDelta()));
scoped_refptr<VideoFrame> video_frame(
VideoFrame::CreateFrame(PIXEL_FORMAT_YUV420P10, size, gfx::Rect(size),
size, base::TimeDelta()));
EXPECT_TRUE(video_frame);
return video_frame;
}
......@@ -172,18 +186,17 @@ class VideoResourceUpdaterTest : public testing::Test {
release_sync_token_ = sync_token;
}
scoped_refptr<media::VideoFrame> CreateTestHardwareVideoFrame(
media::VideoPixelFormat format,
scoped_refptr<VideoFrame> CreateTestHardwareVideoFrame(
VideoPixelFormat format,
unsigned target) {
const int kDimension = 10;
gfx::Size size(kDimension, kDimension);
auto mailbox = gpu::Mailbox::GenerateForSharedImage();
gpu::MailboxHolder mailbox_holders[media::VideoFrame::kMaxPlanes] = {
gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes] = {
gpu::MailboxHolder(mailbox, kMailboxSyncToken, target)};
scoped_refptr<media::VideoFrame> video_frame =
media::VideoFrame::WrapNativeTextures(
scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapNativeTextures(
format, mailbox_holders,
base::BindOnce(&VideoResourceUpdaterTest::SetReleaseSyncToken,
base::Unretained(this)),
......@@ -195,35 +208,33 @@ class VideoResourceUpdaterTest : public testing::Test {
return video_frame;
}
scoped_refptr<media::VideoFrame> CreateTestRGBAHardwareVideoFrame() {
return CreateTestHardwareVideoFrame(media::PIXEL_FORMAT_ARGB,
GL_TEXTURE_2D);
scoped_refptr<VideoFrame> CreateTestRGBAHardwareVideoFrame() {
return CreateTestHardwareVideoFrame(PIXEL_FORMAT_ARGB, GL_TEXTURE_2D);
}
scoped_refptr<media::VideoFrame> CreateTestStreamTextureHardwareVideoFrame(
base::Optional<media::VideoFrameMetadata::CopyMode> copy_mode) {
scoped_refptr<media::VideoFrame> video_frame = CreateTestHardwareVideoFrame(
media::PIXEL_FORMAT_ARGB, GL_TEXTURE_EXTERNAL_OES);
scoped_refptr<VideoFrame> CreateTestStreamTextureHardwareVideoFrame(
base::Optional<VideoFrameMetadata::CopyMode> copy_mode) {
scoped_refptr<VideoFrame> video_frame = CreateTestHardwareVideoFrame(
PIXEL_FORMAT_ARGB, GL_TEXTURE_EXTERNAL_OES);
video_frame->metadata().copy_mode = std::move(copy_mode);
return video_frame;
}
scoped_refptr<media::VideoFrame> CreateTestYuvHardwareVideoFrame(
media::VideoPixelFormat format,
scoped_refptr<VideoFrame> CreateTestYuvHardwareVideoFrame(
VideoPixelFormat format,
size_t num_textures,
unsigned target) {
const int kDimension = 10;
gfx::Size size(kDimension, kDimension);
gpu::MailboxHolder mailbox_holders[media::VideoFrame::kMaxPlanes];
gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
for (size_t i = 0; i < num_textures; ++i) {
gpu::Mailbox mailbox;
mailbox.name[0] = 50 + 1;
mailbox_holders[i] =
gpu::MailboxHolder(mailbox, kMailboxSyncToken, target);
}
scoped_refptr<media::VideoFrame> video_frame =
media::VideoFrame::WrapNativeTextures(
scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapNativeTextures(
format, mailbox_holders,
base::BindOnce(&VideoResourceUpdaterTest::SetReleaseSyncToken,
base::Unretained(this)),
......@@ -259,16 +270,27 @@ const gpu::SyncToken VideoResourceUpdaterTest::kMailboxSyncToken =
TEST_F(VideoResourceUpdaterTest, SoftwareFrame) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestYUVVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::YUV, resources.type);
}
TEST_F(VideoResourceUpdaterTest, SoftwareFrameRGB) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
for (const auto& fmt : {PIXEL_FORMAT_XBGR, PIXEL_FORMAT_XRGB,
PIXEL_FORMAT_ABGR, PIXEL_FORMAT_ARGB}) {
scoped_refptr<VideoFrame> video_frame = CreateTestRGBVideoFrame(fmt);
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::RGBA, resources.type);
}
}
TEST_F(VideoResourceUpdaterTest, HighBitFrameNoF16) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestHighBitFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -284,7 +306,7 @@ class VideoResourceUpdaterTestWithF16 : public VideoResourceUpdaterTest {
TEST_F(VideoResourceUpdaterTestWithF16, HighBitFrame) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestHighBitFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -311,7 +333,7 @@ class VideoResourceUpdaterTestWithR16 : public VideoResourceUpdaterTest {
TEST_F(VideoResourceUpdaterTestWithR16, HighBitFrame) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestHighBitFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -333,7 +355,7 @@ TEST_F(VideoResourceUpdaterTestWithR16, HighBitFrame) {
TEST_F(VideoResourceUpdaterTest, HighBitFrameSoftwareCompositor) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForSoftware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestHighBitFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestHighBitFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -342,7 +364,7 @@ TEST_F(VideoResourceUpdaterTest, HighBitFrameSoftwareCompositor) {
TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrame) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -351,7 +373,7 @@ TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrame) {
TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrameSoftwareCompositor) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForSoftware();
scoped_refptr<media::VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateWonkyTestYUVVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -360,7 +382,7 @@ TEST_F(VideoResourceUpdaterTest, WonkySoftwareFrameSoftwareCompositor) {
TEST_F(VideoResourceUpdaterTest, ReuseResource) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestYUVVideoFrame();
video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
// Allocate the resources for a YUV video frame.
......@@ -390,7 +412,7 @@ TEST_F(VideoResourceUpdaterTest, ReuseResource) {
TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDelete) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestYUVVideoFrame();
video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
// Allocate the resources for a YUV video frame.
......@@ -415,16 +437,27 @@ TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDelete) {
TEST_F(VideoResourceUpdaterTest, SoftwareFrameSoftwareCompositor) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForSoftware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestYUVVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::RGBA_PREMULTIPLIED, resources.type);
}
TEST_F(VideoResourceUpdaterTest, SoftwareFrameRGBSoftwareCompositor) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForSoftware();
for (const auto& fmt : {PIXEL_FORMAT_XBGR, PIXEL_FORMAT_XRGB,
PIXEL_FORMAT_ABGR, PIXEL_FORMAT_ARGB}) {
scoped_refptr<VideoFrame> video_frame = CreateTestRGBVideoFrame(fmt);
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::RGBA_PREMULTIPLIED, resources.type);
}
}
TEST_F(VideoResourceUpdaterTest, ReuseResourceSoftwareCompositor) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForSoftware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestYUVVideoFrame();
video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
// Allocate the resources for a software video frame.
......@@ -453,7 +486,7 @@ TEST_F(VideoResourceUpdaterTest, ReuseResourceSoftwareCompositor) {
TEST_F(VideoResourceUpdaterTest, ReuseResourceNoDeleteSoftwareCompositor) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForSoftware();
scoped_refptr<media::VideoFrame> video_frame = CreateTestYUVVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestYUVVideoFrame();
video_frame->set_timestamp(base::TimeDelta::FromSeconds(1234));
// Allocate the resources for a software video frame.
......@@ -508,8 +541,7 @@ TEST_F(VideoResourceUpdaterTest, ChangeResourceSizeSoftwareCompositor) {
TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame =
CreateTestRGBAHardwareVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestRGBAHardwareVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -517,7 +549,7 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes) {
EXPECT_EQ(1u, resources.resources.size());
EXPECT_EQ(1u, resources.release_callbacks.size());
video_frame = CreateTestYuvHardwareVideoFrame(media::PIXEL_FORMAT_I420, 3,
video_frame = CreateTestYuvHardwareVideoFrame(PIXEL_FORMAT_I420, 3,
GL_TEXTURE_RECTANGLE_ARB);
resources = updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -528,7 +560,7 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes) {
EXPECT_FALSE(resources.resources[1].read_lock_fences_enabled);
EXPECT_FALSE(resources.resources[2].read_lock_fences_enabled);
video_frame = CreateTestYuvHardwareVideoFrame(media::PIXEL_FORMAT_I420, 3,
video_frame = CreateTestYuvHardwareVideoFrame(PIXEL_FORMAT_I420, 3,
GL_TEXTURE_RECTANGLE_ARB);
video_frame->metadata().read_lock_fences_enabled = true;
......@@ -544,7 +576,7 @@ TEST_F(VideoResourceUpdaterTest,
std::unique_ptr<VideoResourceUpdater> updater =
CreateUpdaterForHardware(true);
EXPECT_EQ(0u, GetSharedImageCount());
scoped_refptr<media::VideoFrame> video_frame =
scoped_refptr<VideoFrame> video_frame =
CreateTestStreamTextureHardwareVideoFrame(base::nullopt);
VideoFrameExternalResources resources =
......@@ -559,7 +591,7 @@ TEST_F(VideoResourceUpdaterTest,
// A copied stream texture should return an RGBA resource in a new
// GL_TEXTURE_2D texture.
video_frame = CreateTestStreamTextureHardwareVideoFrame(
media::VideoFrameMetadata::CopyMode::kCopyToNewTexture);
VideoFrameMetadata::CopyMode::kCopyToNewTexture);
resources = updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::RGBA_PREMULTIPLIED, resources.type);
EXPECT_EQ(1u, resources.resources.size());
......@@ -575,7 +607,7 @@ TEST_F(VideoResourceUpdaterTest,
std::unique_ptr<VideoResourceUpdater> updater =
CreateUpdaterForHardware(true);
EXPECT_EQ(0u, GetSharedImageCount());
scoped_refptr<media::VideoFrame> video_frame =
scoped_refptr<VideoFrame> video_frame =
CreateTestStreamTextureHardwareVideoFrame(base::nullopt);
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -589,7 +621,7 @@ TEST_F(VideoResourceUpdaterTest,
// If mailbox is copied, the texture target should still be
// GL_TEXTURE_EXTERNAL_OES and resource type should be STREAM_TEXTURE.
video_frame = CreateTestStreamTextureHardwareVideoFrame(
media::VideoFrameMetadata::CopyMode::kCopyMailboxesOnly);
VideoFrameMetadata::CopyMode::kCopyMailboxesOnly);
resources = updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::STREAM_TEXTURE, resources.type);
EXPECT_EQ(1u, resources.resources.size());
......@@ -604,7 +636,7 @@ TEST_F(VideoResourceUpdaterTest,
TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_TextureQuad) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
EXPECT_EQ(0u, GetSharedImageCount());
scoped_refptr<media::VideoFrame> video_frame =
scoped_refptr<VideoFrame> video_frame =
CreateTestStreamTextureHardwareVideoFrame(base::nullopt);
VideoFrameExternalResources resources =
......@@ -627,8 +659,7 @@ TEST_F(VideoResourceUpdaterTest, PassReleaseSyncToken) {
123);
{
scoped_refptr<media::VideoFrame> video_frame =
CreateTestRGBAHardwareVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestRGBAHardwareVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -653,8 +684,7 @@ TEST_F(VideoResourceUpdaterTest, GenerateReleaseSyncToken) {
234);
{
scoped_refptr<media::VideoFrame> video_frame =
CreateTestRGBAHardwareVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestRGBAHardwareVideoFrame();
VideoFrameExternalResources resources1 =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -677,8 +707,7 @@ TEST_F(VideoResourceUpdaterTest, GenerateReleaseSyncToken) {
TEST_F(VideoResourceUpdaterTest, PassMailboxSyncToken) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame =
CreateTestRGBAHardwareVideoFrame();
scoped_refptr<VideoFrame> video_frame = CreateTestRGBAHardwareVideoFrame();
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -693,9 +722,9 @@ TEST_F(VideoResourceUpdaterTest, PassMailboxSyncToken) {
TEST_F(VideoResourceUpdaterTest, GenerateSyncTokenOnTextureCopy) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
scoped_refptr<media::VideoFrame> video_frame =
scoped_refptr<VideoFrame> video_frame =
CreateTestStreamTextureHardwareVideoFrame(
media::VideoFrameMetadata::CopyMode::kCopyToNewTexture);
VideoFrameMetadata::CopyMode::kCopyToNewTexture);
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -712,8 +741,8 @@ TEST_F(VideoResourceUpdaterTest, GenerateSyncTokenOnTextureCopy) {
TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_SingleNV12) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
EXPECT_EQ(0u, GetSharedImageCount());
scoped_refptr<media::VideoFrame> video_frame = CreateTestHardwareVideoFrame(
media::PIXEL_FORMAT_NV12, GL_TEXTURE_EXTERNAL_OES);
scoped_refptr<VideoFrame> video_frame =
CreateTestHardwareVideoFrame(PIXEL_FORMAT_NV12, GL_TEXTURE_EXTERNAL_OES);
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -723,7 +752,7 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_SingleNV12) {
resources.resources[0].mailbox_holder.texture_target);
EXPECT_EQ(viz::YUV_420_BIPLANAR, resources.resources[0].format);
video_frame = CreateTestYuvHardwareVideoFrame(media::PIXEL_FORMAT_NV12, 1,
video_frame = CreateTestYuvHardwareVideoFrame(PIXEL_FORMAT_NV12, 1,
GL_TEXTURE_RECTANGLE_ARB);
resources = updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::RGB, resources.type);
......@@ -738,9 +767,8 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_SingleNV12) {
TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_DualNV12) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
EXPECT_EQ(0u, GetSharedImageCount());
scoped_refptr<media::VideoFrame> video_frame =
CreateTestYuvHardwareVideoFrame(media::PIXEL_FORMAT_NV12, 2,
GL_TEXTURE_EXTERNAL_OES);
scoped_refptr<VideoFrame> video_frame = CreateTestYuvHardwareVideoFrame(
PIXEL_FORMAT_NV12, 2, GL_TEXTURE_EXTERNAL_OES);
VideoFrameExternalResources resources =
updater->CreateExternalResourcesFromVideoFrame(video_frame);
......@@ -753,7 +781,7 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_DualNV12) {
EXPECT_EQ(viz::RED_8, resources.resources[0].format);
EXPECT_EQ(viz::RG_88, resources.resources[1].format);
video_frame = CreateTestYuvHardwareVideoFrame(media::PIXEL_FORMAT_NV12, 2,
video_frame = CreateTestYuvHardwareVideoFrame(PIXEL_FORMAT_NV12, 2,
GL_TEXTURE_RECTANGLE_ARB);
resources = updater->CreateExternalResourcesFromVideoFrame(video_frame);
EXPECT_EQ(VideoFrameResourceType::YUV, resources.type);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment