Fix the H.264 config detection code which lead to video playback errors.

content/common/gpu/media/dxva_video_decode_accelerator_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 16 matching lines @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "media/base/win/mf_initializer.h"
-#include "media/filters/h264_parser.h"
 #include "media/video/video_decode_accelerator.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_surface_egl.h"
 
 namespace {
 
@@ skipping 329 matching lines @@
 H264ConfigChangeDetector::~H264ConfigChangeDetector() {
 }
 
 bool H264ConfigChangeDetector::DetectConfig(const uint8_t* stream,
                                             unsigned int size) {
   std::vector<uint8_t> sps;
   std::vector<uint8_t> pps;
   media::H264NALU nalu;
   bool idr_seen = false;
 
-  media::H264Parser parser;
-  parser.SetStream(stream, size);
+  if (!parser_.get())
+    parser_.reset(new media::H264Parser);
+
+  parser_->SetStream(stream, size);
   config_changed_ = false;
 
   while (true) {
-    media::H264Parser::Result result = parser.AdvanceToNextNALU(&nalu);
+    media::H264Parser::Result result = parser_->AdvanceToNextNALU(&nalu);
 
     if (result == media::H264Parser::kEOStream)
       break;
 
     if (result == media::H264Parser::kUnsupportedStream) {
       DLOG(ERROR) << "Unsupported H.264 stream";
       return false;
     }
 
     if (result != media::H264Parser::kOk) {
       DLOG(ERROR) << "Failed to parse H.264 stream";
       return false;
     }
 
     switch (nalu.nal_unit_type) {
       case media::H264NALU::kSPS:
-        result = parser.ParseSPS(&last_sps_id_);
+        result = parser_->ParseSPS(&last_sps_id_);
         if (result == media::H264Parser::kUnsupportedStream) {
           DLOG(ERROR) << "Unsupported SPS";
           return false;
         }
 
         if (result != media::H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse SPS";
           return false;
         }
 
         sps.assign(nalu.data, nalu.data + nalu.size);
         break;
 
       case media::H264NALU::kPPS:
-        result = parser.ParsePPS(&last_pps_id_);
+        result = parser_->ParsePPS(&last_pps_id_);
         if (result == media::H264Parser::kUnsupportedStream) {
           DLOG(ERROR) << "Unsupported PPS";
           return false;
         }
         if (result != media::H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse PPS";
           return false;
         }
         pps.assign(nalu.data, nalu.data + nalu.size);
         break;
@@ skipping 490 matching lines @@
       "Send MFT_MESSAGE_NOTIFY_BEGIN_STREAMING notification failed",
       PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0),
       "Send MFT_MESSAGE_NOTIFY_START_OF_STREAM notification failed",
       PLATFORM_FAILURE, false);
 
   config_ = config;
 
+  config_change_detector_.reset(new H264ConfigChangeDetector);
+
   SetState(kNormal);
 
   StartDecoderThread();
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
   TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
 
   HRESULT hr = E_FAIL;
@@ skipping 878 matching lines @@
   output_picture_buffers_.clear();
   stale_output_picture_buffers_.clear();
   pending_output_samples_.clear();
   // We want to continue processing pending input after detecting a config
   // change.
   if (GetState() != kConfigChange)
     pending_input_buffers_.clear();
   decoder_.Release();
   pictures_requested_ = false;
 
+  config_change_detector_.reset();
+
   if (use_dx11_) {
     if (video_format_converter_mft_.get()) {
       video_format_converter_mft_->ProcessMessage(
           MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
       video_format_converter_mft_.Release();
     }
     d3d11_device_context_.Release();
     d3d11_device_.Release();
     d3d11_device_manager_.Release();
     d3d11_query_.Release();
@@ skipping 784 matching lines @@
     IMFSample* sample, bool* config_changed) {
   if (codec_ != media::kCodecH264)
     return S_FALSE;
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from input sample", hr);
 
   MediaBufferScopedPointer scoped_media_buffer(buffer.get());
 
-  if (!config_change_detector_.DetectConfig(
+  if (!config_change_detector_->DetectConfig(
           scoped_media_buffer.get(),
           scoped_media_buffer.current_length())) {
     RETURN_ON_HR_FAILURE(E_FAIL, "Failed to detect H.264 stream config",
         E_FAIL);
   }
-  *config_changed = config_change_detector_.config_changed();
+  *config_changed = config_change_detector_->config_changed();
   return S_OK;
 }
 
 void DXVAVideoDecodeAccelerator::ConfigChanged(
     const Config& config) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   SetState(kConfigChange);
   DismissStaleBuffers(true);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace content