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 "content/common/gpu/media/dxva_video_decode_accelerator.h" 6 7 #if !defined(OS_WIN) 8 #error This file should only be built on Windows. 9 #endif // !defined(OS_WIN) 10 11 #include <ks.h> 12 #include <codecapi.h> 13 #include <mfapi.h> 14 #include <mferror.h> 15 #include <wmcodecdsp.h> 16 17 #include "base/bind.h" 18 #include "base/callback.h" 19 #include "base/command_line.h" 20 #include "base/debug/trace_event.h" 21 #include "base/logging.h" 22 #include "base/memory/scoped_handle.h" 23 #include "base/memory/scoped_ptr.h" 24 #include "base/memory/shared_memory.h" 25 #include "base/message_loop/message_loop.h" 26 #include "base/win/windows_version.h" 27 #include "media/video/video_decode_accelerator.h" 28 #include "ui/gl/gl_bindings.h" 29 #include "ui/gl/gl_surface_egl.h" 30 #include "ui/gl/gl_switches.h" 31 32 namespace content { 33 34 // We only request 5 picture buffers from the client which are used to hold the 35 // decoded samples. These buffers are then reused when the client tells us that 36 // it is done with the buffer. 37 static const int kNumPictureBuffers = 5; 38 39 #define RETURN_ON_FAILURE(result, log, ret) \ 40 do { \ 41 if (!(result)) { \ 42 DLOG(ERROR) << log; \ 43 return ret; \ 44 } \ 45 } while (0) 46 47 #define RETURN_ON_HR_FAILURE(result, log, ret) \ 48 RETURN_ON_FAILURE(SUCCEEDED(result), \ 49 log << ", HRESULT: 0x" << std::hex << result, \ 50 ret); 51 52 #define RETURN_AND_NOTIFY_ON_FAILURE(result, log, error_code, ret) \ 53 do { \ 54 if (!(result)) { \ 55 DVLOG(1) << log; \ 56 StopOnError(error_code); \ 57 return ret; \ 58 } \ 59 } while (0) 60 61 #define RETURN_AND_NOTIFY_ON_HR_FAILURE(result, log, error_code, ret) \ 62 RETURN_AND_NOTIFY_ON_FAILURE(SUCCEEDED(result), \ 63 log << ", HRESULT: 0x" << std::hex << result, \ 64 error_code, ret); 65 66 // Maximum number of iterations we allow before aborting the attempt to flush 67 // the batched queries to the driver and allow torn/corrupt frames to be 68 // rendered. 69 enum { kMaxIterationsForD3DFlush = 10 }; 70 71 static IMFSample* CreateEmptySample() { 72 base::win::ScopedComPtr<IMFSample> sample; 73 HRESULT hr = MFCreateSample(sample.Receive()); 74 RETURN_ON_HR_FAILURE(hr, "MFCreateSample failed", NULL); 75 return sample.Detach(); 76 } 77 78 // Creates a Media Foundation sample with one buffer of length |buffer_length| 79 // on a |align|-byte boundary. Alignment must be a perfect power of 2 or 0. 80 static IMFSample* CreateEmptySampleWithBuffer(int buffer_length, int align) { 81 CHECK_GT(buffer_length, 0); 82 83 base::win::ScopedComPtr<IMFSample> sample; 84 sample.Attach(CreateEmptySample()); 85 86 base::win::ScopedComPtr<IMFMediaBuffer> buffer; 87 HRESULT hr = E_FAIL; 88 if (align == 0) { 89 // Note that MFCreateMemoryBuffer is same as MFCreateAlignedMemoryBuffer 90 // with the align argument being 0. 91 hr = MFCreateMemoryBuffer(buffer_length, buffer.Receive()); 92 } else { 93 hr = MFCreateAlignedMemoryBuffer(buffer_length, 94 align - 1, 95 buffer.Receive()); 96 } 97 RETURN_ON_HR_FAILURE(hr, "Failed to create memory buffer for sample", NULL); 98 99 hr = sample->AddBuffer(buffer); 100 RETURN_ON_HR_FAILURE(hr, "Failed to add buffer to sample", NULL); 101 102 return sample.Detach(); 103 } 104 105 // Creates a Media Foundation sample with one buffer containing a copy of the 106 // given Annex B stream data. 107 // If duration and sample time are not known, provide 0. 108 // |min_size| specifies the minimum size of the buffer (might be required by 109 // the decoder for input). If no alignment is required, provide 0. 110 static IMFSample* CreateInputSample(const uint8* stream, int size, 111 int min_size, int alignment) { 112 CHECK(stream); 113 CHECK_GT(size, 0); 114 base::win::ScopedComPtr<IMFSample> sample; 115 sample.Attach(CreateEmptySampleWithBuffer(std::max(min_size, size), 116 alignment)); 117 RETURN_ON_FAILURE(sample, "Failed to create empty sample", NULL); 118 119 base::win::ScopedComPtr<IMFMediaBuffer> buffer; 120 HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive()); 121 RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample", NULL); 122 123 DWORD max_length = 0; 124 DWORD current_length = 0; 125 uint8* destination = NULL; 126 hr = buffer->Lock(&destination, &max_length, ¤t_length); 127 RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer", NULL); 128 129 CHECK_EQ(current_length, 0u); 130 CHECK_GE(static_cast<int>(max_length), size); 131 memcpy(destination, stream, size); 132 133 hr = buffer->Unlock(); 134 RETURN_ON_HR_FAILURE(hr, "Failed to unlock buffer", NULL); 135 136 hr = buffer->SetCurrentLength(size); 137 RETURN_ON_HR_FAILURE(hr, "Failed to set buffer length", NULL); 138 139 return sample.Detach(); 140 } 141 142 static IMFSample* CreateSampleFromInputBuffer( 143 const media::BitstreamBuffer& bitstream_buffer, 144 DWORD stream_size, 145 DWORD alignment) { 146 base::SharedMemory shm(bitstream_buffer.handle(), true); 147 RETURN_ON_FAILURE(shm.Map(bitstream_buffer.size()), 148 "Failed in base::SharedMemory::Map", NULL); 149 150 return CreateInputSample(reinterpret_cast<const uint8*>(shm.memory()), 151 bitstream_buffer.size(), 152 stream_size, 153 alignment); 154 } 155 156 // Maintains information about a DXVA picture buffer, i.e. whether it is 157 // available for rendering, the texture information, etc. 158 struct DXVAVideoDecodeAccelerator::DXVAPictureBuffer { 159 public: 160 static linked_ptr<DXVAPictureBuffer> Create( 161 const DXVAVideoDecodeAccelerator& decoder, 162 const media::PictureBuffer& buffer, 163 EGLConfig egl_config); 164 ~DXVAPictureBuffer(); 165 166 void ReusePictureBuffer(); 167 // Copies the output sample data to the picture buffer provided by the 168 // client. 169 // The dest_surface parameter contains the decoded bits. 170 bool CopyOutputSampleDataToPictureBuffer( 171 const DXVAVideoDecodeAccelerator& decoder, 172 IDirect3DSurface9* dest_surface); 173 174 bool available() const { 175 return available_; 176 } 177 178 void set_available(bool available) { 179 available_ = available; 180 } 181 182 int id() const { 183 return picture_buffer_.id(); 184 } 185 186 gfx::Size size() const { 187 return picture_buffer_.size(); 188 } 189 190 private: 191 explicit DXVAPictureBuffer(const media::PictureBuffer& buffer); 192 193 bool available_; 194 media::PictureBuffer picture_buffer_; 195 EGLSurface decoding_surface_; 196 base::win::ScopedComPtr<IDirect3DTexture9> decoding_texture_; 197 198 DISALLOW_COPY_AND_ASSIGN(DXVAPictureBuffer); 199 }; 200 201 // static 202 linked_ptr<DXVAVideoDecodeAccelerator::DXVAPictureBuffer> 203 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::Create( 204 const DXVAVideoDecodeAccelerator& decoder, 205 const media::PictureBuffer& buffer, 206 EGLConfig egl_config) { 207 linked_ptr<DXVAPictureBuffer> picture_buffer(new DXVAPictureBuffer(buffer)); 208 209 EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay(); 210 211 EGLint attrib_list[] = { 212 EGL_WIDTH, buffer.size().width(), 213 EGL_HEIGHT, buffer.size().height(), 214 EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB, 215 EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, 216 EGL_NONE 217 }; 218 219 picture_buffer->decoding_surface_ = eglCreatePbufferSurface( 220 egl_display, 221 egl_config, 222 attrib_list); 223 RETURN_ON_FAILURE(picture_buffer->decoding_surface_, 224 "Failed to create surface", 225 linked_ptr<DXVAPictureBuffer>(NULL)); 226 227 HANDLE share_handle = NULL; 228 EGLBoolean ret = eglQuerySurfacePointerANGLE( 229 egl_display, 230 picture_buffer->decoding_surface_, 231 EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE, 232 &share_handle); 233 234 RETURN_ON_FAILURE(share_handle && ret == EGL_TRUE, 235 "Failed to query ANGLE surface pointer", 236 linked_ptr<DXVAPictureBuffer>(NULL)); 237 238 HRESULT hr = decoder.device_->CreateTexture( 239 buffer.size().width(), 240 buffer.size().height(), 241 1, 242 D3DUSAGE_RENDERTARGET, 243 D3DFMT_X8R8G8B8, 244 D3DPOOL_DEFAULT, 245 picture_buffer->decoding_texture_.Receive(), 246 &share_handle); 247 248 RETURN_ON_HR_FAILURE(hr, "Failed to create texture", 249 linked_ptr<DXVAPictureBuffer>(NULL)); 250 return picture_buffer; 251 } 252 253 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::DXVAPictureBuffer( 254 const media::PictureBuffer& buffer) 255 : available_(true), 256 picture_buffer_(buffer), 257 decoding_surface_(NULL) { 258 } 259 260 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::~DXVAPictureBuffer() { 261 if (decoding_surface_) { 262 EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay(); 263 264 eglReleaseTexImage( 265 egl_display, 266 decoding_surface_, 267 EGL_BACK_BUFFER); 268 269 eglDestroySurface( 270 egl_display, 271 decoding_surface_); 272 decoding_surface_ = NULL; 273 } 274 } 275 276 void DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ReusePictureBuffer() { 277 DCHECK(decoding_surface_); 278 EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay(); 279 eglReleaseTexImage( 280 egl_display, 281 decoding_surface_, 282 EGL_BACK_BUFFER); 283 set_available(true); 284 } 285 286 bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer:: 287 CopyOutputSampleDataToPictureBuffer( 288 const DXVAVideoDecodeAccelerator& decoder, 289 IDirect3DSurface9* dest_surface) { 290 DCHECK(dest_surface); 291 292 D3DSURFACE_DESC surface_desc; 293 HRESULT hr = dest_surface->GetDesc(&surface_desc); 294 RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false); 295 296 D3DSURFACE_DESC texture_desc; 297 decoding_texture_->GetLevelDesc(0, &texture_desc); 298 299 if (texture_desc.Width != surface_desc.Width || 300 texture_desc.Height != surface_desc.Height) { 301 NOTREACHED() << "Decode surface of different dimension than texture"; 302 return false; 303 } 304 305 hr = decoder.d3d9_->CheckDeviceFormatConversion( 306 D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, surface_desc.Format, D3DFMT_X8R8G8B8); 307 RETURN_ON_HR_FAILURE(hr, "Device does not support format converision", false); 308 309 // This function currently executes in the context of IPC handlers in the 310 // GPU process which ensures that there is always an OpenGL context. 311 GLint current_texture = 0; 312 glGetIntegerv(GL_TEXTURE_BINDING_2D, ¤t_texture); 313 314 glBindTexture(GL_TEXTURE_2D, picture_buffer_.texture_id()); 315 316 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 317 318 base::win::ScopedComPtr<IDirect3DSurface9> d3d_surface; 319 hr = decoding_texture_->GetSurfaceLevel(0, d3d_surface.Receive()); 320 RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false); 321 322 hr = decoder.device_->StretchRect( 323 dest_surface, NULL, d3d_surface, NULL, D3DTEXF_NONE); 324 RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed", 325 false); 326 327 // Ideally, this should be done immediately before the draw call that uses 328 // the texture. Flush it once here though. 329 hr = decoder.query_->Issue(D3DISSUE_END); 330 RETURN_ON_HR_FAILURE(hr, "Failed to issue END", false); 331 332 // The DXVA decoder has its own device which it uses for decoding. ANGLE 333 // has its own device which we don't have access to. 334 // The above code attempts to copy the decoded picture into a surface 335 // which is owned by ANGLE. As there are multiple devices involved in 336 // this, the StretchRect call above is not synchronous. 337 // We attempt to flush the batched operations to ensure that the picture is 338 // copied to the surface owned by ANGLE. 339 // We need to do this in a loop and call flush multiple times. 340 // We have seen the GetData call for flushing the command buffer fail to 341 // return success occassionally on multi core machines, leading to an 342 // infinite loop. 343 // Workaround is to have an upper limit of 10 on the number of iterations to 344 // wait for the Flush to finish. 345 int iterations = 0; 346 while ((decoder.query_->GetData(NULL, 0, D3DGETDATA_FLUSH) == S_FALSE) && 347 ++iterations < kMaxIterationsForD3DFlush) { 348 Sleep(1); // Poor-man's Yield(). 349 } 350 EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay(); 351 eglBindTexImage( 352 egl_display, 353 decoding_surface_, 354 EGL_BACK_BUFFER); 355 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 356 glBindTexture(GL_TEXTURE_2D, current_texture); 357 return true; 358 } 359 360 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo( 361 int32 buffer_id, IMFSample* sample) 362 : input_buffer_id(buffer_id) { 363 output_sample.Attach(sample); 364 } 365 366 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {} 367 368 // static 369 bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() { 370 TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager"); 371 372 HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive()); 373 RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false); 374 375 D3DPRESENT_PARAMETERS present_params = {0}; 376 present_params.BackBufferWidth = 1; 377 present_params.BackBufferHeight = 1; 378 present_params.BackBufferFormat = D3DFMT_UNKNOWN; 379 present_params.BackBufferCount = 1; 380 present_params.SwapEffect = D3DSWAPEFFECT_DISCARD; 381 present_params.hDeviceWindow = ::GetShellWindow(); 382 present_params.Windowed = TRUE; 383 present_params.Flags = D3DPRESENTFLAG_VIDEO; 384 present_params.FullScreen_RefreshRateInHz = 0; 385 present_params.PresentationInterval = 0; 386 387 hr = d3d9_->CreateDeviceEx(D3DADAPTER_DEFAULT, 388 D3DDEVTYPE_HAL, 389 ::GetShellWindow(), 390 D3DCREATE_FPU_PRESERVE | 391 D3DCREATE_SOFTWARE_VERTEXPROCESSING | 392 D3DCREATE_DISABLE_PSGP_THREADING | 393 D3DCREATE_MULTITHREADED, 394 &present_params, 395 NULL, 396 device_.Receive()); 397 RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false); 398 399 hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_, 400 device_manager_.Receive()); 401 RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false); 402 403 hr = device_manager_->ResetDevice(device_, dev_manager_reset_token_); 404 RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false); 405 406 hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive()); 407 RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false); 408 // Ensure query_ API works (to avoid an infinite loop later in 409 // CopyOutputSampleDataToPictureBuffer). 410 hr = query_->Issue(D3DISSUE_END); 411 RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false); 412 return true; 413 } 414 415 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator( 416 media::VideoDecodeAccelerator::Client* client, 417 const base::Callback<bool(void)>& make_context_current) 418 : client_(client), 419 dev_manager_reset_token_(0), 420 egl_config_(NULL), 421 state_(kUninitialized), 422 pictures_requested_(false), 423 inputs_before_decode_(0), 424 make_context_current_(make_context_current) { 425 memset(&input_stream_info_, 0, sizeof(input_stream_info_)); 426 memset(&output_stream_info_, 0, sizeof(output_stream_info_)); 427 } 428 429 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() { 430 client_ = NULL; 431 } 432 433 bool DXVAVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile) { 434 DCHECK(CalledOnValidThread()); 435 436 // Not all versions of Windows 7 and later include Media Foundation DLLs. 437 // Instead of crashing while delay loading the DLL when calling MFStartup() 438 // below, probe whether we can successfully load the DLL now. 439 // 440 // See http://crbug.com/339678 for details. 441 HMODULE mfplat_dll = ::LoadLibrary(L"MFPlat.dll"); 442 RETURN_ON_FAILURE(mfplat_dll, "MFPlat.dll is required for decoding", false); 443 444 // TODO(ananta) 445 // H264PROFILE_HIGH video decoding is janky at times. Needs more 446 // investigation. 447 if (profile != media::H264PROFILE_BASELINE && 448 profile != media::H264PROFILE_MAIN && 449 profile != media::H264PROFILE_HIGH) { 450 RETURN_AND_NOTIFY_ON_FAILURE(false, 451 "Unsupported h264 profile", PLATFORM_FAILURE, false); 452 } 453 454 RETURN_AND_NOTIFY_ON_FAILURE( 455 gfx::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle, 456 "EGL_ANGLE_surface_d3d_texture_2d_share_handle unavailable", 457 PLATFORM_FAILURE, 458 false); 459 460 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kUninitialized), 461 "Initialize: invalid state: " << state_, ILLEGAL_STATE, false); 462 463 HRESULT hr = MFStartup(MF_VERSION, MFSTARTUP_FULL); 464 RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "MFStartup failed.", PLATFORM_FAILURE, 465 false); 466 467 RETURN_AND_NOTIFY_ON_FAILURE(CreateD3DDevManager(), 468 "Failed to initialize D3D device and manager", 469 PLATFORM_FAILURE, 470 false); 471 472 RETURN_AND_NOTIFY_ON_FAILURE(InitDecoder(profile), 473 "Failed to initialize decoder", PLATFORM_FAILURE, false); 474 475 RETURN_AND_NOTIFY_ON_FAILURE(GetStreamsInfoAndBufferReqs(), 476 "Failed to get input/output stream info.", PLATFORM_FAILURE, false); 477 478 RETURN_AND_NOTIFY_ON_FAILURE( 479 SendMFTMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0), 480 "Send MFT_MESSAGE_NOTIFY_BEGIN_STREAMING notification failed", 481 PLATFORM_FAILURE, false); 482 483 RETURN_AND_NOTIFY_ON_FAILURE( 484 SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0), 485 "Send MFT_MESSAGE_NOTIFY_START_OF_STREAM notification failed", 486 PLATFORM_FAILURE, false); 487 488 state_ = kNormal; 489 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 490 &DXVAVideoDecodeAccelerator::NotifyInitializeDone, 491 base::AsWeakPtr(this))); 492 return true; 493 } 494 495 void DXVAVideoDecodeAccelerator::Decode( 496 const media::BitstreamBuffer& bitstream_buffer) { 497 DCHECK(CalledOnValidThread()); 498 499 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kStopped || 500 state_ == kFlushing), 501 "Invalid state: " << state_, ILLEGAL_STATE,); 502 503 base::win::ScopedComPtr<IMFSample> sample; 504 sample.Attach(CreateSampleFromInputBuffer(bitstream_buffer, 505 input_stream_info_.cbSize, 506 input_stream_info_.cbAlignment)); 507 RETURN_AND_NOTIFY_ON_FAILURE(sample, "Failed to create input sample", 508 PLATFORM_FAILURE,); 509 510 RETURN_AND_NOTIFY_ON_HR_FAILURE(sample->SetSampleTime(bitstream_buffer.id()), 511 "Failed to associate input buffer id with sample", PLATFORM_FAILURE,); 512 513 DecodeInternal(sample); 514 } 515 516 void DXVAVideoDecodeAccelerator::AssignPictureBuffers( 517 const std::vector<media::PictureBuffer>& buffers) { 518 DCHECK(CalledOnValidThread()); 519 520 RETURN_AND_NOTIFY_ON_FAILURE((state_ != kUninitialized), 521 "Invalid state: " << state_, ILLEGAL_STATE,); 522 RETURN_AND_NOTIFY_ON_FAILURE((kNumPictureBuffers == buffers.size()), 523 "Failed to provide requested picture buffers. (Got " << buffers.size() << 524 ", requested " << kNumPictureBuffers << ")", INVALID_ARGUMENT,); 525 526 // Copy the picture buffers provided by the client to the available list, 527 // and mark these buffers as available for use. 528 for (size_t buffer_index = 0; buffer_index < buffers.size(); 529 ++buffer_index) { 530 linked_ptr<DXVAPictureBuffer> picture_buffer = 531 DXVAPictureBuffer::Create(*this, buffers[buffer_index], egl_config_); 532 RETURN_AND_NOTIFY_ON_FAILURE(picture_buffer.get(), 533 "Failed to allocate picture buffer", PLATFORM_FAILURE,); 534 535 bool inserted = output_picture_buffers_.insert(std::make_pair( 536 buffers[buffer_index].id(), picture_buffer)).second; 537 DCHECK(inserted); 538 } 539 ProcessPendingSamples(); 540 if (state_ == kFlushing && pending_output_samples_.empty()) 541 FlushInternal(); 542 } 543 544 void DXVAVideoDecodeAccelerator::ReusePictureBuffer( 545 int32 picture_buffer_id) { 546 DCHECK(CalledOnValidThread()); 547 548 RETURN_AND_NOTIFY_ON_FAILURE((state_ != kUninitialized), 549 "Invalid state: " << state_, ILLEGAL_STATE,); 550 551 if (output_picture_buffers_.empty()) 552 return; 553 554 OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id); 555 RETURN_AND_NOTIFY_ON_FAILURE(it != output_picture_buffers_.end(), 556 "Invalid picture id: " << picture_buffer_id, INVALID_ARGUMENT,); 557 558 it->second->ReusePictureBuffer(); 559 ProcessPendingSamples(); 560 561 if (state_ == kFlushing && pending_output_samples_.empty()) 562 FlushInternal(); 563 } 564 565 void DXVAVideoDecodeAccelerator::Flush() { 566 DCHECK(CalledOnValidThread()); 567 568 DVLOG(1) << "DXVAVideoDecodeAccelerator::Flush"; 569 570 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kStopped), 571 "Unexpected decoder state: " << state_, ILLEGAL_STATE,); 572 573 state_ = kFlushing; 574 575 RETURN_AND_NOTIFY_ON_FAILURE(SendMFTMessage(MFT_MESSAGE_COMMAND_DRAIN, 0), 576 "Failed to send drain message", PLATFORM_FAILURE,); 577 578 if (!pending_output_samples_.empty()) 579 return; 580 581 FlushInternal(); 582 } 583 584 void DXVAVideoDecodeAccelerator::Reset() { 585 DCHECK(CalledOnValidThread()); 586 587 DVLOG(1) << "DXVAVideoDecodeAccelerator::Reset"; 588 589 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kStopped), 590 "Reset: invalid state: " << state_, ILLEGAL_STATE,); 591 592 state_ = kResetting; 593 594 pending_output_samples_.clear(); 595 596 NotifyInputBuffersDropped(); 597 598 RETURN_AND_NOTIFY_ON_FAILURE(SendMFTMessage(MFT_MESSAGE_COMMAND_FLUSH, 0), 599 "Reset: Failed to send message.", PLATFORM_FAILURE,); 600 601 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 602 &DXVAVideoDecodeAccelerator::NotifyResetDone, base::AsWeakPtr(this))); 603 604 state_ = DXVAVideoDecodeAccelerator::kNormal; 605 } 606 607 void DXVAVideoDecodeAccelerator::Destroy() { 608 DCHECK(CalledOnValidThread()); 609 Invalidate(); 610 delete this; 611 } 612 613 bool DXVAVideoDecodeAccelerator::InitDecoder(media::VideoCodecProfile profile) { 614 if (profile < media::H264PROFILE_MIN || profile > media::H264PROFILE_MAX) 615 return false; 616 617 // We mimic the steps CoCreateInstance uses to instantiate the object. This 618 // was previously done because it failed inside the sandbox, and now is done 619 // as a more minimal approach to avoid other side-effects CCI might have (as 620 // we are still in a reduced sandbox). 621 HMODULE decoder_dll = ::LoadLibrary(L"msmpeg2vdec.dll"); 622 RETURN_ON_FAILURE(decoder_dll, 623 "msmpeg2vdec.dll required for decoding is not loaded", 624 false); 625 626 typedef HRESULT(WINAPI * GetClassObject)( 627 const CLSID & clsid, const IID & iid, void * *object); 628 629 GetClassObject get_class_object = reinterpret_cast<GetClassObject>( 630 GetProcAddress(decoder_dll, "DllGetClassObject")); 631 RETURN_ON_FAILURE( 632 get_class_object, "Failed to get DllGetClassObject pointer", false); 633 634 base::win::ScopedComPtr<IClassFactory> factory; 635 HRESULT hr = get_class_object(__uuidof(CMSH264DecoderMFT), 636 __uuidof(IClassFactory), 637 reinterpret_cast<void**>(factory.Receive())); 638 RETURN_ON_HR_FAILURE(hr, "DllGetClassObject for decoder failed", false); 639 640 hr = factory->CreateInstance(NULL, 641 __uuidof(IMFTransform), 642 reinterpret_cast<void**>(decoder_.Receive())); 643 RETURN_ON_HR_FAILURE(hr, "Failed to create decoder instance", false); 644 645 RETURN_ON_FAILURE(CheckDecoderDxvaSupport(), 646 "Failed to check decoder DXVA support", false); 647 648 hr = decoder_->ProcessMessage( 649 MFT_MESSAGE_SET_D3D_MANAGER, 650 reinterpret_cast<ULONG_PTR>(device_manager_.get())); 651 RETURN_ON_HR_FAILURE(hr, "Failed to pass D3D manager to decoder", false); 652 653 EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay(); 654 655 EGLint config_attribs[] = { 656 EGL_BUFFER_SIZE, 32, 657 EGL_RED_SIZE, 8, 658 EGL_GREEN_SIZE, 8, 659 EGL_BLUE_SIZE, 8, 660 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, 661 EGL_ALPHA_SIZE, 0, 662 EGL_NONE 663 }; 664 665 EGLint num_configs; 666 667 if (!eglChooseConfig( 668 egl_display, 669 config_attribs, 670 &egl_config_, 671 1, 672 &num_configs)) 673 return false; 674 675 return SetDecoderMediaTypes(); 676 } 677 678 bool DXVAVideoDecodeAccelerator::CheckDecoderDxvaSupport() { 679 base::win::ScopedComPtr<IMFAttributes> attributes; 680 HRESULT hr = decoder_->GetAttributes(attributes.Receive()); 681 RETURN_ON_HR_FAILURE(hr, "Failed to get decoder attributes", false); 682 683 UINT32 dxva = 0; 684 hr = attributes->GetUINT32(MF_SA_D3D_AWARE, &dxva); 685 RETURN_ON_HR_FAILURE(hr, "Failed to check if decoder supports DXVA", false); 686 687 hr = attributes->SetUINT32(CODECAPI_AVDecVideoAcceleration_H264, TRUE); 688 RETURN_ON_HR_FAILURE(hr, "Failed to enable DXVA H/W decoding", false); 689 return true; 690 } 691 692 bool DXVAVideoDecodeAccelerator::SetDecoderMediaTypes() { 693 RETURN_ON_FAILURE(SetDecoderInputMediaType(), 694 "Failed to set decoder input media type", false); 695 return SetDecoderOutputMediaType(MFVideoFormat_NV12); 696 } 697 698 bool DXVAVideoDecodeAccelerator::SetDecoderInputMediaType() { 699 base::win::ScopedComPtr<IMFMediaType> media_type; 700 HRESULT hr = MFCreateMediaType(media_type.Receive()); 701 RETURN_ON_HR_FAILURE(hr, "MFCreateMediaType failed", false); 702 703 hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video); 704 RETURN_ON_HR_FAILURE(hr, "Failed to set major input type", false); 705 706 hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264); 707 RETURN_ON_HR_FAILURE(hr, "Failed to set subtype", false); 708 709 // Not sure about this. msdn recommends setting this value on the input 710 // media type. 711 hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE, 712 MFVideoInterlace_MixedInterlaceOrProgressive); 713 RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false); 714 715 hr = decoder_->SetInputType(0, media_type, 0); // No flags 716 RETURN_ON_HR_FAILURE(hr, "Failed to set decoder input type", false); 717 return true; 718 } 719 720 bool DXVAVideoDecodeAccelerator::SetDecoderOutputMediaType( 721 const GUID& subtype) { 722 base::win::ScopedComPtr<IMFMediaType> out_media_type; 723 724 for (uint32 i = 0; 725 SUCCEEDED(decoder_->GetOutputAvailableType(0, i, 726 out_media_type.Receive())); 727 ++i) { 728 GUID out_subtype = {0}; 729 HRESULT hr = out_media_type->GetGUID(MF_MT_SUBTYPE, &out_subtype); 730 RETURN_ON_HR_FAILURE(hr, "Failed to get output major type", false); 731 732 if (out_subtype == subtype) { 733 hr = decoder_->SetOutputType(0, out_media_type, 0); // No flags 734 RETURN_ON_HR_FAILURE(hr, "Failed to set decoder output type", false); 735 return true; 736 } 737 out_media_type.Release(); 738 } 739 return false; 740 } 741 742 bool DXVAVideoDecodeAccelerator::SendMFTMessage(MFT_MESSAGE_TYPE msg, 743 int32 param) { 744 HRESULT hr = decoder_->ProcessMessage(msg, param); 745 return SUCCEEDED(hr); 746 } 747 748 // Gets the minimum buffer sizes for input and output samples. The MFT will not 749 // allocate buffer for input nor output, so we have to do it ourselves and make 750 // sure they're the correct size. We only provide decoding if DXVA is enabled. 751 bool DXVAVideoDecodeAccelerator::GetStreamsInfoAndBufferReqs() { 752 HRESULT hr = decoder_->GetInputStreamInfo(0, &input_stream_info_); 753 RETURN_ON_HR_FAILURE(hr, "Failed to get input stream info", false); 754 755 hr = decoder_->GetOutputStreamInfo(0, &output_stream_info_); 756 RETURN_ON_HR_FAILURE(hr, "Failed to get decoder output stream info", false); 757 758 DVLOG(1) << "Input stream info: "; 759 DVLOG(1) << "Max latency: " << input_stream_info_.hnsMaxLatency; 760 // There should be three flags, one for requiring a whole frame be in a 761 // single sample, one for requiring there be one buffer only in a single 762 // sample, and one that specifies a fixed sample size. (as in cbSize) 763 CHECK_EQ(input_stream_info_.dwFlags, 0x7u); 764 765 DVLOG(1) << "Min buffer size: " << input_stream_info_.cbSize; 766 DVLOG(1) << "Max lookahead: " << input_stream_info_.cbMaxLookahead; 767 DVLOG(1) << "Alignment: " << input_stream_info_.cbAlignment; 768 769 DVLOG(1) << "Output stream info: "; 770 // The flags here should be the same and mean the same thing, except when 771 // DXVA is enabled, there is an extra 0x100 flag meaning decoder will 772 // allocate its own sample. 773 DVLOG(1) << "Flags: " 774 << std::hex << std::showbase << output_stream_info_.dwFlags; 775 CHECK_EQ(output_stream_info_.dwFlags, 0x107u); 776 DVLOG(1) << "Min buffer size: " << output_stream_info_.cbSize; 777 DVLOG(1) << "Alignment: " << output_stream_info_.cbAlignment; 778 return true; 779 } 780 781 void DXVAVideoDecodeAccelerator::DoDecode() { 782 // This function is also called from FlushInternal in a loop which could 783 // result in the state transitioning to kStopped due to no decoded output. 784 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kFlushing || 785 state_ == kStopped), 786 "DoDecode: not in normal/flushing/stopped state", ILLEGAL_STATE,); 787 788 MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0}; 789 DWORD status = 0; 790 791 HRESULT hr = decoder_->ProcessOutput(0, // No flags 792 1, // # of out streams to pull from 793 &output_data_buffer, 794 &status); 795 IMFCollection* events = output_data_buffer.pEvents; 796 if (events != NULL) { 797 VLOG(1) << "Got events from ProcessOuput, but discarding"; 798 events->Release(); 799 } 800 if (FAILED(hr)) { 801 // A stream change needs further ProcessInput calls to get back decoder 802 // output which is why we need to set the state to stopped. 803 if (hr == MF_E_TRANSFORM_STREAM_CHANGE) { 804 if (!SetDecoderOutputMediaType(MFVideoFormat_NV12)) { 805 // Decoder didn't let us set NV12 output format. Not sure as to why 806 // this can happen. Give up in disgust. 807 NOTREACHED() << "Failed to set decoder output media type to NV12"; 808 state_ = kStopped; 809 } else { 810 DVLOG(1) << "Received output format change from the decoder." 811 " Recursively invoking DoDecode"; 812 DoDecode(); 813 } 814 return; 815 } else if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) { 816 // No more output from the decoder. Stop playback. 817 state_ = kStopped; 818 return; 819 } else { 820 NOTREACHED() << "Unhandled error in DoDecode()"; 821 return; 822 } 823 } 824 TRACE_EVENT_END_ETW("DXVAVideoDecodeAccelerator.Decoding", this, ""); 825 826 TRACE_COUNTER1("DXVA Decoding", "TotalPacketsBeforeDecode", 827 inputs_before_decode_); 828 829 inputs_before_decode_ = 0; 830 831 RETURN_AND_NOTIFY_ON_FAILURE(ProcessOutputSample(output_data_buffer.pSample), 832 "Failed to process output sample.", PLATFORM_FAILURE,); 833 } 834 835 bool DXVAVideoDecodeAccelerator::ProcessOutputSample(IMFSample* sample) { 836 RETURN_ON_FAILURE(sample, "Decode succeeded with NULL output sample", false); 837 838 base::win::ScopedComPtr<IMFMediaBuffer> output_buffer; 839 HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive()); 840 RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false); 841 842 base::win::ScopedComPtr<IDirect3DSurface9> surface; 843 hr = MFGetService(output_buffer, MR_BUFFER_SERVICE, 844 IID_PPV_ARGS(surface.Receive())); 845 RETURN_ON_HR_FAILURE(hr, "Failed to get D3D surface from output sample", 846 false); 847 848 LONGLONG input_buffer_id = 0; 849 RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id), 850 "Failed to get input buffer id associated with sample", 851 false); 852 853 pending_output_samples_.push_back( 854 PendingSampleInfo(input_buffer_id, sample)); 855 856 // If we have available picture buffers to copy the output data then use the 857 // first one and then flag it as not being available for use. 858 if (output_picture_buffers_.size()) { 859 ProcessPendingSamples(); 860 return true; 861 } 862 if (pictures_requested_) { 863 DVLOG(1) << "Waiting for picture slots from the client."; 864 return true; 865 } 866 867 // We only read the surface description, which contains its width/height when 868 // we need the picture buffers from the client. Once we have those, then they 869 // are reused. 870 D3DSURFACE_DESC surface_desc; 871 hr = surface->GetDesc(&surface_desc); 872 RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false); 873 874 // Go ahead and request picture buffers. 875 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 876 &DXVAVideoDecodeAccelerator::RequestPictureBuffers, 877 base::AsWeakPtr(this), surface_desc.Width, surface_desc.Height)); 878 879 pictures_requested_ = true; 880 return true; 881 } 882 883 void DXVAVideoDecodeAccelerator::ProcessPendingSamples() { 884 RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(), 885 "Failed to make context current", PLATFORM_FAILURE,); 886 887 OutputBuffers::iterator index; 888 889 for (index = output_picture_buffers_.begin(); 890 index != output_picture_buffers_.end() && 891 !pending_output_samples_.empty(); 892 ++index) { 893 if (index->second->available()) { 894 PendingSampleInfo sample_info = pending_output_samples_.front(); 895 896 base::win::ScopedComPtr<IMFMediaBuffer> output_buffer; 897 HRESULT hr = sample_info.output_sample->GetBufferByIndex( 898 0, output_buffer.Receive()); 899 RETURN_AND_NOTIFY_ON_HR_FAILURE( 900 hr, "Failed to get buffer from output sample", PLATFORM_FAILURE,); 901 902 base::win::ScopedComPtr<IDirect3DSurface9> surface; 903 hr = MFGetService(output_buffer, MR_BUFFER_SERVICE, 904 IID_PPV_ARGS(surface.Receive())); 905 RETURN_AND_NOTIFY_ON_HR_FAILURE( 906 hr, "Failed to get D3D surface from output sample", 907 PLATFORM_FAILURE,); 908 909 D3DSURFACE_DESC surface_desc; 910 hr = surface->GetDesc(&surface_desc); 911 RETURN_AND_NOTIFY_ON_HR_FAILURE( 912 hr, "Failed to get surface description", PLATFORM_FAILURE,); 913 914 if (surface_desc.Width != 915 static_cast<uint32>(index->second->size().width()) || 916 surface_desc.Height != 917 static_cast<uint32>(index->second->size().height())) { 918 HandleResolutionChanged(surface_desc.Width, surface_desc.Height); 919 return; 920 } 921 922 RETURN_AND_NOTIFY_ON_FAILURE( 923 index->second->CopyOutputSampleDataToPictureBuffer(*this, surface), 924 "Failed to copy output sample", 925 PLATFORM_FAILURE, ); 926 927 media::Picture output_picture(index->second->id(), 928 sample_info.input_buffer_id); 929 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 930 &DXVAVideoDecodeAccelerator::NotifyPictureReady, 931 base::AsWeakPtr(this), output_picture)); 932 933 index->second->set_available(false); 934 pending_output_samples_.pop_front(); 935 } 936 } 937 938 if (!pending_input_buffers_.empty() && pending_output_samples_.empty()) { 939 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 940 &DXVAVideoDecodeAccelerator::DecodePendingInputBuffers, 941 base::AsWeakPtr(this))); 942 } 943 } 944 945 void DXVAVideoDecodeAccelerator::StopOnError( 946 media::VideoDecodeAccelerator::Error error) { 947 DCHECK(CalledOnValidThread()); 948 949 if (client_) 950 client_->NotifyError(error); 951 client_ = NULL; 952 953 if (state_ != kUninitialized) { 954 Invalidate(); 955 } 956 } 957 958 void DXVAVideoDecodeAccelerator::Invalidate() { 959 if (state_ == kUninitialized) 960 return; 961 output_picture_buffers_.clear(); 962 pending_output_samples_.clear(); 963 pending_input_buffers_.clear(); 964 decoder_.Release(); 965 MFShutdown(); 966 state_ = kUninitialized; 967 } 968 969 void DXVAVideoDecodeAccelerator::NotifyInitializeDone() { 970 if (client_) 971 client_->NotifyInitializeDone(); 972 } 973 974 void DXVAVideoDecodeAccelerator::NotifyInputBufferRead(int input_buffer_id) { 975 if (client_) 976 client_->NotifyEndOfBitstreamBuffer(input_buffer_id); 977 } 978 979 void DXVAVideoDecodeAccelerator::NotifyFlushDone() { 980 if (client_) 981 client_->NotifyFlushDone(); 982 } 983 984 void DXVAVideoDecodeAccelerator::NotifyResetDone() { 985 if (client_) 986 client_->NotifyResetDone(); 987 } 988 989 void DXVAVideoDecodeAccelerator::RequestPictureBuffers(int width, int height) { 990 // This task could execute after the decoder has been torn down. 991 if (state_ != kUninitialized && client_) { 992 client_->ProvidePictureBuffers( 993 kNumPictureBuffers, 994 gfx::Size(width, height), 995 GL_TEXTURE_2D); 996 } 997 } 998 999 void DXVAVideoDecodeAccelerator::NotifyPictureReady( 1000 const media::Picture& picture) { 1001 // This task could execute after the decoder has been torn down. 1002 if (state_ != kUninitialized && client_) 1003 client_->PictureReady(picture); 1004 } 1005 1006 void DXVAVideoDecodeAccelerator::NotifyInputBuffersDropped() { 1007 if (!client_ || !pending_output_samples_.empty()) 1008 return; 1009 1010 for (PendingInputs::iterator it = pending_input_buffers_.begin(); 1011 it != pending_input_buffers_.end(); ++it) { 1012 LONGLONG input_buffer_id = 0; 1013 RETURN_ON_HR_FAILURE((*it)->GetSampleTime(&input_buffer_id), 1014 "Failed to get buffer id associated with sample",); 1015 client_->NotifyEndOfBitstreamBuffer(input_buffer_id); 1016 } 1017 pending_input_buffers_.clear(); 1018 } 1019 1020 void DXVAVideoDecodeAccelerator::DecodePendingInputBuffers() { 1021 RETURN_AND_NOTIFY_ON_FAILURE((state_ != kUninitialized), 1022 "Invalid state: " << state_, ILLEGAL_STATE,); 1023 1024 if (pending_input_buffers_.empty() || !pending_output_samples_.empty()) 1025 return; 1026 1027 PendingInputs pending_input_buffers_copy; 1028 std::swap(pending_input_buffers_, pending_input_buffers_copy); 1029 1030 for (PendingInputs::iterator it = pending_input_buffers_copy.begin(); 1031 it != pending_input_buffers_copy.end(); ++it) { 1032 DecodeInternal(*it); 1033 } 1034 } 1035 1036 void DXVAVideoDecodeAccelerator::FlushInternal() { 1037 // The DoDecode function sets the state to kStopped when the decoder returns 1038 // MF_E_TRANSFORM_NEED_MORE_INPUT. 1039 // The MFT decoder can buffer upto 30 frames worth of input before returning 1040 // an output frame. This loop here attempts to retrieve as many output frames 1041 // as possible from the buffered set. 1042 while (state_ != kStopped) { 1043 DoDecode(); 1044 if (!pending_output_samples_.empty()) 1045 return; 1046 } 1047 1048 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 1049 &DXVAVideoDecodeAccelerator::NotifyFlushDone, base::AsWeakPtr(this))); 1050 1051 state_ = kNormal; 1052 } 1053 1054 void DXVAVideoDecodeAccelerator::DecodeInternal( 1055 const base::win::ScopedComPtr<IMFSample>& sample) { 1056 DCHECK(CalledOnValidThread()); 1057 1058 if (state_ == kUninitialized) 1059 return; 1060 1061 if (!pending_output_samples_.empty() || !pending_input_buffers_.empty()) { 1062 pending_input_buffers_.push_back(sample); 1063 return; 1064 } 1065 1066 if (!inputs_before_decode_) { 1067 TRACE_EVENT_BEGIN_ETW("DXVAVideoDecodeAccelerator.Decoding", this, ""); 1068 } 1069 inputs_before_decode_++; 1070 1071 HRESULT hr = decoder_->ProcessInput(0, sample, 0); 1072 // As per msdn if the decoder returns MF_E_NOTACCEPTING then it means that it 1073 // has enough data to produce one or more output samples. In this case the 1074 // recommended options are to 1075 // 1. Generate new output by calling IMFTransform::ProcessOutput until it 1076 // returns MF_E_TRANSFORM_NEED_MORE_INPUT. 1077 // 2. Flush the input data 1078 // We implement the first option, i.e to retrieve the output sample and then 1079 // process the input again. Failure in either of these steps is treated as a 1080 // decoder failure. 1081 if (hr == MF_E_NOTACCEPTING) { 1082 DoDecode(); 1083 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kStopped || state_ == kNormal), 1084 "Failed to process output. Unexpected decoder state: " << state_, 1085 PLATFORM_FAILURE,); 1086 hr = decoder_->ProcessInput(0, sample, 0); 1087 // If we continue to get the MF_E_NOTACCEPTING error we do the following:- 1088 // 1. Add the input sample to the pending queue. 1089 // 2. If we don't have any output samples we post the 1090 // DecodePendingInputBuffers task to process the pending input samples. 1091 // If we have an output sample then the above task is posted when the 1092 // output samples are sent to the client. 1093 // This is because we only support 1 pending output sample at any 1094 // given time due to the limitation with the Microsoft media foundation 1095 // decoder where it recycles the output Decoder surfaces. 1096 if (hr == MF_E_NOTACCEPTING) { 1097 pending_input_buffers_.push_back(sample); 1098 if (pending_output_samples_.empty()) { 1099 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 1100 &DXVAVideoDecodeAccelerator::DecodePendingInputBuffers, 1101 base::AsWeakPtr(this))); 1102 } 1103 return; 1104 } 1105 } 1106 RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to process input sample", 1107 PLATFORM_FAILURE,); 1108 1109 DoDecode(); 1110 1111 RETURN_AND_NOTIFY_ON_FAILURE((state_ == kStopped || state_ == kNormal), 1112 "Failed to process output. Unexpected decoder state: " << state_, 1113 ILLEGAL_STATE,); 1114 1115 LONGLONG input_buffer_id = 0; 1116 RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id), 1117 "Failed to get input buffer id associated with sample",); 1118 // The Microsoft Media foundation decoder internally buffers up to 30 frames 1119 // before returning a decoded frame. We need to inform the client that this 1120 // input buffer is processed as it may stop sending us further input. 1121 // Note: This may break clients which expect every input buffer to be 1122 // associated with a decoded output buffer. 1123 // TODO(ananta) 1124 // Do some more investigation into whether it is possible to get the MFT 1125 // decoder to emit an output packet for every input packet. 1126 // http://code.google.com/p/chromium/issues/detail?id=108121 1127 // http://code.google.com/p/chromium/issues/detail?id=150925 1128 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 1129 &DXVAVideoDecodeAccelerator::NotifyInputBufferRead, 1130 base::AsWeakPtr(this), input_buffer_id)); 1131 } 1132 1133 void DXVAVideoDecodeAccelerator::HandleResolutionChanged(int width, 1134 int height) { 1135 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 1136 &DXVAVideoDecodeAccelerator::DismissStaleBuffers, 1137 base::AsWeakPtr(this), output_picture_buffers_)); 1138 1139 base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind( 1140 &DXVAVideoDecodeAccelerator::RequestPictureBuffers, 1141 base::AsWeakPtr(this), width, height)); 1142 1143 output_picture_buffers_.clear(); 1144 } 1145 1146 void DXVAVideoDecodeAccelerator::DismissStaleBuffers( 1147 const OutputBuffers& picture_buffers) { 1148 OutputBuffers::const_iterator index; 1149 1150 for (index = picture_buffers.begin(); 1151 index != picture_buffers.end(); 1152 ++index) { 1153 DVLOG(1) << "Dismissing picture id: " << index->second->id(); 1154 client_->DismissPictureBuffer(index->second->id()); 1155 } 1156 } 1157 1158 } // namespace content 1159
