1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "media/base/video_frame.h" 6 7 #include "base/bind.h" 8 #include "base/callback_helpers.h" 9 #include "base/format_macros.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/strings/stringprintf.h" 12 #include "media/base/buffers.h" 13 #include "media/base/yuv_convert.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 16 namespace media { 17 18 using base::MD5DigestToBase16; 19 20 // Helper function that initializes a YV12 frame with white and black scan 21 // lines based on the |white_to_black| parameter. If 0, then the entire 22 // frame will be black, if 1 then the entire frame will be white. 23 void InitializeYV12Frame(VideoFrame* frame, double white_to_black) { 24 EXPECT_EQ(VideoFrame::YV12, frame->format()); 25 int first_black_row = static_cast<int>(frame->coded_size().height() * 26 white_to_black); 27 uint8* y_plane = frame->data(VideoFrame::kYPlane); 28 for (int row = 0; row < frame->coded_size().height(); ++row) { 29 int color = (row < first_black_row) ? 0xFF : 0x00; 30 memset(y_plane, color, frame->stride(VideoFrame::kYPlane)); 31 y_plane += frame->stride(VideoFrame::kYPlane); 32 } 33 uint8* u_plane = frame->data(VideoFrame::kUPlane); 34 uint8* v_plane = frame->data(VideoFrame::kVPlane); 35 for (int row = 0; row < frame->coded_size().height(); row += 2) { 36 memset(u_plane, 0x80, frame->stride(VideoFrame::kUPlane)); 37 memset(v_plane, 0x80, frame->stride(VideoFrame::kVPlane)); 38 u_plane += frame->stride(VideoFrame::kUPlane); 39 v_plane += frame->stride(VideoFrame::kVPlane); 40 } 41 } 42 43 // Given a |yv12_frame| this method converts the YV12 frame to RGBA and 44 // makes sure that all the pixels of the RBG frame equal |expect_rgb_color|. 45 void ExpectFrameColor(media::VideoFrame* yv12_frame, uint32 expect_rgb_color) { 46 ASSERT_EQ(VideoFrame::YV12, yv12_frame->format()); 47 ASSERT_EQ(yv12_frame->stride(VideoFrame::kUPlane), 48 yv12_frame->stride(VideoFrame::kVPlane)); 49 50 scoped_refptr<media::VideoFrame> rgb_frame; 51 rgb_frame = media::VideoFrame::CreateFrame(VideoFrame::RGB32, 52 yv12_frame->coded_size(), 53 yv12_frame->visible_rect(), 54 yv12_frame->natural_size(), 55 yv12_frame->GetTimestamp()); 56 57 ASSERT_EQ(yv12_frame->coded_size().width(), 58 rgb_frame->coded_size().width()); 59 ASSERT_EQ(yv12_frame->coded_size().height(), 60 rgb_frame->coded_size().height()); 61 62 media::ConvertYUVToRGB32(yv12_frame->data(VideoFrame::kYPlane), 63 yv12_frame->data(VideoFrame::kUPlane), 64 yv12_frame->data(VideoFrame::kVPlane), 65 rgb_frame->data(VideoFrame::kRGBPlane), 66 rgb_frame->coded_size().width(), 67 rgb_frame->coded_size().height(), 68 yv12_frame->stride(VideoFrame::kYPlane), 69 yv12_frame->stride(VideoFrame::kUPlane), 70 rgb_frame->stride(VideoFrame::kRGBPlane), 71 media::YV12); 72 73 for (int row = 0; row < rgb_frame->coded_size().height(); ++row) { 74 uint32* rgb_row_data = reinterpret_cast<uint32*>( 75 rgb_frame->data(VideoFrame::kRGBPlane) + 76 (rgb_frame->stride(VideoFrame::kRGBPlane) * row)); 77 for (int col = 0; col < rgb_frame->coded_size().width(); ++col) { 78 SCOPED_TRACE( 79 base::StringPrintf("Checking (%d, %d)", row, col)); 80 EXPECT_EQ(expect_rgb_color, rgb_row_data[col]); 81 } 82 } 83 } 84 85 // Fill each plane to its reported extents and verify accessors report non 86 // zero values. Additionally, for the first plane verify the rows and 87 // row_bytes values are correct. 88 void ExpectFrameExtents(VideoFrame::Format format, int planes, 89 int bytes_per_pixel, const char* expected_hash) { 90 const unsigned char kFillByte = 0x80; 91 const int kWidth = 61; 92 const int kHeight = 31; 93 const base::TimeDelta kTimestamp = base::TimeDelta::FromMicroseconds(1337); 94 95 gfx::Size size(kWidth, kHeight); 96 scoped_refptr<VideoFrame> frame = VideoFrame::CreateFrame( 97 format, size, gfx::Rect(size), size, kTimestamp); 98 ASSERT_TRUE(frame.get()); 99 100 for(int plane = 0; plane < planes; plane++) { 101 SCOPED_TRACE(base::StringPrintf("Checking plane %d", plane)); 102 EXPECT_TRUE(frame->data(plane)); 103 EXPECT_TRUE(frame->stride(plane)); 104 EXPECT_TRUE(frame->rows(plane)); 105 EXPECT_TRUE(frame->row_bytes(plane)); 106 107 if (plane == 0) { 108 EXPECT_EQ(frame->rows(plane), kHeight); 109 EXPECT_EQ(frame->row_bytes(plane), kWidth * bytes_per_pixel); 110 } 111 112 memset(frame->data(plane), kFillByte, 113 frame->stride(plane) * frame->rows(plane)); 114 } 115 116 base::MD5Context context; 117 base::MD5Init(&context); 118 frame->HashFrameForTesting(&context); 119 base::MD5Digest digest; 120 base::MD5Final(&digest, &context); 121 EXPECT_EQ(MD5DigestToBase16(digest), expected_hash); 122 } 123 124 TEST(VideoFrame, CreateFrame) { 125 const int kWidth = 64; 126 const int kHeight = 48; 127 const base::TimeDelta kTimestamp = base::TimeDelta::FromMicroseconds(1337); 128 129 // Create a YV12 Video Frame. 130 gfx::Size size(kWidth, kHeight); 131 scoped_refptr<media::VideoFrame> frame = 132 VideoFrame::CreateFrame(media::VideoFrame::YV12, size, gfx::Rect(size), 133 size, kTimestamp); 134 ASSERT_TRUE(frame.get()); 135 136 // Test VideoFrame implementation. 137 EXPECT_EQ(media::VideoFrame::YV12, frame->format()); 138 { 139 SCOPED_TRACE(""); 140 InitializeYV12Frame(frame.get(), 0.0f); 141 ExpectFrameColor(frame.get(), 0xFF000000); 142 } 143 base::MD5Digest digest; 144 base::MD5Context context; 145 base::MD5Init(&context); 146 frame->HashFrameForTesting(&context); 147 base::MD5Final(&digest, &context); 148 EXPECT_EQ(MD5DigestToBase16(digest), "9065c841d9fca49186ef8b4ef547e79b"); 149 { 150 SCOPED_TRACE(""); 151 InitializeYV12Frame(frame.get(), 1.0f); 152 ExpectFrameColor(frame.get(), 0xFFFFFFFF); 153 } 154 base::MD5Init(&context); 155 frame->HashFrameForTesting(&context); 156 base::MD5Final(&digest, &context); 157 EXPECT_EQ(MD5DigestToBase16(digest), "911991d51438ad2e1a40ed5f6fc7c796"); 158 159 // Test an empty frame. 160 frame = VideoFrame::CreateEmptyFrame(); 161 EXPECT_TRUE(frame->IsEndOfStream()); 162 } 163 164 TEST(VideoFrame, CreateBlackFrame) { 165 const int kWidth = 2; 166 const int kHeight = 2; 167 const uint8 kExpectedYRow[] = { 0, 0 }; 168 const uint8 kExpectedUVRow[] = { 128 }; 169 170 scoped_refptr<media::VideoFrame> frame = 171 VideoFrame::CreateBlackFrame(gfx::Size(kWidth, kHeight)); 172 ASSERT_TRUE(frame.get()); 173 174 // Test basic properties. 175 EXPECT_EQ(0, frame->GetTimestamp().InMicroseconds()); 176 EXPECT_FALSE(frame->IsEndOfStream()); 177 178 // Test |frame| properties. 179 EXPECT_EQ(VideoFrame::YV12, frame->format()); 180 EXPECT_EQ(kWidth, frame->coded_size().width()); 181 EXPECT_EQ(kHeight, frame->coded_size().height()); 182 183 // Test frames themselves. 184 uint8* y_plane = frame->data(VideoFrame::kYPlane); 185 for (int y = 0; y < frame->coded_size().height(); ++y) { 186 EXPECT_EQ(0, memcmp(kExpectedYRow, y_plane, arraysize(kExpectedYRow))); 187 y_plane += frame->stride(VideoFrame::kYPlane); 188 } 189 190 uint8* u_plane = frame->data(VideoFrame::kUPlane); 191 uint8* v_plane = frame->data(VideoFrame::kVPlane); 192 for (int y = 0; y < frame->coded_size().height() / 2; ++y) { 193 EXPECT_EQ(0, memcmp(kExpectedUVRow, u_plane, arraysize(kExpectedUVRow))); 194 EXPECT_EQ(0, memcmp(kExpectedUVRow, v_plane, arraysize(kExpectedUVRow))); 195 u_plane += frame->stride(VideoFrame::kUPlane); 196 v_plane += frame->stride(VideoFrame::kVPlane); 197 } 198 } 199 200 // Ensure each frame is properly sized and allocated. Will trigger OOB reads 201 // and writes as well as incorrect frame hashes otherwise. 202 TEST(VideoFrame, CheckFrameExtents) { 203 // Each call consists of a VideoFrame::Format, # of planes, bytes per pixel, 204 // and the expected hash of all planes if filled with kFillByte (defined in 205 // ExpectFrameExtents). 206 ExpectFrameExtents( 207 VideoFrame::RGB32, 1, 4, "de6d3d567e282f6a38d478f04fc81fb0"); 208 ExpectFrameExtents( 209 VideoFrame::YV12, 3, 1, "71113bdfd4c0de6cf62f48fb74f7a0b1"); 210 ExpectFrameExtents( 211 VideoFrame::YV16, 3, 1, "9bb99ac3ff350644ebff4d28dc01b461"); 212 } 213 214 static void TextureCallback(uint32* called_sync_point, uint32 sync_point) { 215 *called_sync_point = sync_point; 216 } 217 218 // Verify the TextureNoLongerNeededCallback is called when VideoFrame is 219 // destroyed with the original sync point. 220 TEST(VideoFrame, TextureNoLongerNeededCallbackIsCalled) { 221 uint32 sync_point = 7; 222 uint32 called_sync_point = 0; 223 224 { 225 scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture( 226 new VideoFrame::MailboxHolder( 227 gpu::Mailbox(), 228 sync_point, 229 base::Bind(&TextureCallback, &called_sync_point)), 230 5, // texture_target 231 gfx::Size(10, 10), // coded_size 232 gfx::Rect(10, 10), // visible_rect 233 gfx::Size(10, 10), // natural_size 234 base::TimeDelta(), // timestamp 235 base::Callback<void(const SkBitmap&)>(), // read_pixels_cb 236 base::Closure()); // no_longer_needed_cb 237 238 EXPECT_EQ(0u, called_sync_point); 239 } 240 EXPECT_EQ(sync_point, called_sync_point); 241 } 242 243 // Verify the TextureNoLongerNeededCallback is called when VideoFrame is 244 // destroyed with the new sync point, when the mailbox is taken by a caller. 245 TEST(VideoFrame, TextureNoLongerNeededCallbackAfterTakingAndReleasingMailbox) { 246 uint32 called_sync_point = 0; 247 248 gpu::Mailbox mailbox; 249 mailbox.name[0] = 50; 250 uint32 sync_point = 7; 251 uint32 target = 9; 252 253 { 254 scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture( 255 new VideoFrame::MailboxHolder( 256 mailbox, 257 sync_point, 258 base::Bind(&TextureCallback, &called_sync_point)), 259 target, 260 gfx::Size(10, 10), // coded_size 261 gfx::Rect(10, 10), // visible_rect 262 gfx::Size(10, 10), // natural_size 263 base::TimeDelta(), // timestamp 264 base::Callback<void(const SkBitmap&)>(), // read_pixels_cb 265 base::Closure()); // no_longer_needed_cb 266 267 { 268 scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder = 269 frame->texture_mailbox(); 270 271 EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]); 272 EXPECT_EQ(sync_point, mailbox_holder->sync_point()); 273 EXPECT_EQ(target, frame->texture_target()); 274 275 // Misuse the callback. 276 sync_point = 12; 277 mailbox_holder->Return(sync_point); 278 EXPECT_EQ(0u, called_sync_point); 279 280 // Finish using the mailbox_holder and drop our reference. 281 sync_point = 10; 282 mailbox_holder->Return(sync_point); 283 } 284 EXPECT_EQ(0u, called_sync_point); 285 } 286 EXPECT_EQ(sync_point, called_sync_point); 287 } 288 289 // If a caller has taken ownership of the texture mailbox, it should 290 // not be released when the VideoFrame is destroyed, but should when 291 // the TextureNoLongerNeededCallback is called. 292 TEST(VideoFrame, 293 TextureNoLongerNeededCallbackAfterTakingMailboxWithDestroyedFrame) { 294 uint32 called_sync_point = 0; 295 296 gpu::Mailbox mailbox; 297 mailbox.name[0] = 50; 298 uint32 sync_point = 7; 299 uint32 target = 9; 300 301 { 302 scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder; 303 304 { 305 scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture( 306 new VideoFrame::MailboxHolder( 307 mailbox, 308 sync_point, 309 base::Bind(&TextureCallback, &called_sync_point)), 310 target, 311 gfx::Size(10, 10), // coded_size 312 gfx::Rect(10, 10), // visible_rect 313 gfx::Size(10, 10), // natural_size 314 base::TimeDelta(), // timestamp 315 base::Callback<void(const SkBitmap&)>(), // read_pixels_cb 316 base::Closure()); // no_longer_needed_cb 317 318 mailbox_holder = frame->texture_mailbox(); 319 320 EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]); 321 EXPECT_EQ(sync_point, mailbox_holder->sync_point()); 322 EXPECT_EQ(target, frame->texture_target()); 323 324 // Keep a ref on the mailbox_holder after the VideoFrame is dropped. 325 } 326 EXPECT_EQ(0u, called_sync_point); 327 328 // Misuse the callback. 329 sync_point = 12; 330 mailbox_holder->Return(sync_point); 331 EXPECT_EQ(0u, called_sync_point); 332 333 // Finish using the mailbox_holder and drop our ref. 334 sync_point = 10; 335 mailbox_holder->Return(sync_point); 336 } 337 EXPECT_EQ(sync_point, called_sync_point); 338 } 339 340 // If a caller has taken ownership of the texture mailbox, but does 341 // not call the callback, it should still happen with the original 342 // sync point. 343 TEST(VideoFrame, 344 TextureNoLongerNeededCallbackWhenNotCallingAndFrameDestroyed) { 345 uint32 called_sync_point = 0; 346 347 gpu::Mailbox mailbox; 348 mailbox.name[0] = 50; 349 uint32 sync_point = 7; 350 uint32 target = 9; 351 352 { 353 scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder; 354 355 { 356 scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture( 357 new VideoFrame::MailboxHolder( 358 mailbox, 359 sync_point, 360 base::Bind(&TextureCallback, &called_sync_point)), 361 target, 362 gfx::Size(10, 10), // coded_size 363 gfx::Rect(10, 10), // visible_rect 364 gfx::Size(10, 10), // natural_size 365 base::TimeDelta(), // timestamp 366 base::Callback<void(const SkBitmap&)>(), // read_pixels_cb 367 base::Closure()); // no_longer_needed_cb 368 369 mailbox_holder = frame->texture_mailbox(); 370 371 EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]); 372 EXPECT_EQ(sync_point, mailbox_holder->sync_point()); 373 EXPECT_EQ(target, frame->texture_target()); 374 375 // Destroy the video frame. 376 } 377 EXPECT_EQ(0u, called_sync_point); 378 379 // Drop the reference on the mailbox without using it at all. 380 } 381 EXPECT_EQ(sync_point, called_sync_point); 382 } 383 384 // If a caller has taken ownership of the texture mailbox, but does 385 // not call the callback, it should still happen with the original 386 // sync point. 387 TEST(VideoFrame, 388 TextureNoLongerNeededCallbackAfterTakingMailboxAndNotCalling) { 389 uint32 called_sync_point = 0; 390 391 gpu::Mailbox mailbox; 392 mailbox.name[0] = 50; 393 uint32 sync_point = 7; 394 uint32 target = 9; 395 396 { 397 scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTexture( 398 new VideoFrame::MailboxHolder( 399 mailbox, 400 sync_point, 401 base::Bind(&TextureCallback, &called_sync_point)), 402 target, 403 gfx::Size(10, 10), // coded_size 404 gfx::Rect(10, 10), // visible_rect 405 gfx::Size(10, 10), // natural_size 406 base::TimeDelta(), // timestamp 407 base::Callback<void(const SkBitmap&)>(), // read_pixels_cb 408 base::Closure()); // no_longer_needed_cb 409 410 scoped_refptr<VideoFrame::MailboxHolder> mailbox_holder = 411 frame->texture_mailbox(); 412 413 EXPECT_EQ(mailbox.name[0], mailbox_holder->mailbox().name[0]); 414 EXPECT_EQ(sync_point, mailbox_holder->sync_point()); 415 EXPECT_EQ(target, frame->texture_target()); 416 417 EXPECT_EQ(0u, called_sync_point); 418 419 // Don't use the mailbox at all and drop our ref on it. 420 } 421 // The VideoFrame is destroyed, it should call the callback. 422 EXPECT_EQ(sync_point, called_sync_point); 423 } 424 425 } // namespace media 426
