getUserMeida: report device starting states

media/capture/video/mac/video_capture_device_decklink_mac.mm

 // Copyright 2014 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 "media/capture/video/mac/video_capture_device_decklink_mac.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 80 matching lines @@
   // This is used to control the video capturing device input interface.
   ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_;
   // |decklink_| represents a physical device attached to the host.
   ScopedDeckLinkPtr<IDeckLink> decklink_;
 
   base::TimeTicks first_ref_time_;
 
   // Checks for Device (a.k.a. Audio) thread.
   base::ThreadChecker thread_checker_;
 
+  bool capture_;
+
   friend class scoped_refptr<DeckLinkCaptureDelegate>;
   friend class base::RefCountedThreadSafe<DeckLinkCaptureDelegate>;
 
   ~DeckLinkCaptureDelegate() override;
 
   DISALLOW_COPY_AND_ASSIGN(DeckLinkCaptureDelegate);
 };
 
 static float GetDisplayModeFrameRate(
     const ScopedDeckLinkPtr<IDeckLinkDisplayMode>& display_mode) {
   BMDTimeValue time_value, time_scale;
   float display_mode_frame_rate = 0.0f;
   if (display_mode->GetFrameRate(&time_value, &time_scale) == S_OK &&
       time_value > 0) {
     display_mode_frame_rate = static_cast<float>(time_scale) / time_value;
   }
   // Interlaced formats are going to be marked as double the frame rate,
   // which follows the general naming convention.
   if (display_mode->GetFieldDominance() == bmdLowerFieldFirst ||
       display_mode->GetFieldDominance() == bmdUpperFieldFirst) {
     display_mode_frame_rate *= 2.0f;
   }
   return display_mode_frame_rate;
 }
 
 DeckLinkCaptureDelegate::DeckLinkCaptureDelegate(
     const media::VideoCaptureDeviceDescriptor& device_descriptor,
     media::VideoCaptureDeviceDeckLinkMac* frame_receiver)
-    : device_descriptor_(device_descriptor), frame_receiver_(frame_receiver) {}
+    : device_descriptor_(device_descriptor),
+      frame_receiver_(frame_receiver),
+      capture_(false) {}
 
 DeckLinkCaptureDelegate::~DeckLinkCaptureDelegate() {
 }
 
 void DeckLinkCaptureDelegate::AllocateAndStart(
     const media::VideoCaptureParams& params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_refptr<IDeckLinkIterator> decklink_iter(
       CreateDeckLinkIteratorInstance());
   DLOG_IF(ERROR, !decklink_iter.get()) << "Error creating DeckLink iterator";
@@ skipping 62 matching lines @@
           chosen_display_mode->GetDisplayMode(), bmdFormat8BitYUV,
           bmdVideoInputFlagDefault) != S_OK) {
     SendErrorString(FROM_HERE, "Could not select the video format we like.");
     return;
   }
 
   decklink_input_local->SetCallback(this);
   if (decklink_input_local->StartStreams() != S_OK)
     SendErrorString(FROM_HERE, "Could not start capturing");
 
+  if (frame_receiver_)
+    frame_receiver_->ReportStarted();
+
+  capture_ = true;
+
   decklink_.swap(decklink_local);
   decklink_input_.swap(decklink_input_local);
 }
 
 void DeckLinkCaptureDelegate::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  capture_ = false;
   if (!decklink_input_.get())
     return;
   if (decklink_input_->StopStreams() != S_OK)
     SendLogString("Problem stopping capture.");
   decklink_input_->SetCallback(NULL);
   decklink_input_->DisableVideoInput();
   decklink_input_.Release();
   decklink_.Release();
   ResetVideoCaptureDeviceReference();
 }
 
 HRESULT DeckLinkCaptureDelegate::VideoInputFormatChanged(
     BMDVideoInputFormatChangedEvents notification_events,
     IDeckLinkDisplayMode* new_display_mode,
     BMDDetectedVideoInputFormatFlags detected_signal_flags) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return S_OK;
 }
 
 HRESULT DeckLinkCaptureDelegate::VideoInputFrameArrived(
     IDeckLinkVideoInputFrame* video_frame,
     IDeckLinkAudioInputPacket* /* audio_packet */) {
+  if (!capture_)
+    return S_OK;
+
   // Capture frames are manipulated as an IDeckLinkVideoFrame.
   uint8_t* video_data = NULL;
   video_frame->GetBytes(reinterpret_cast<void**>(&video_data));
 
   media::VideoPixelFormat pixel_format =
       media::PIXEL_FORMAT_UNKNOWN;
   switch (video_frame->GetPixelFormat()) {
     case bmdFormat8BitYUV:  // A.k.a. '2vuy';
       pixel_format = media::PIXEL_FORMAT_UYVY;
       break;
@@ skipping 237 matching lines @@
     client_->OnError(from_here, reason);
 }
 
 void VideoCaptureDeviceDeckLinkMac::SendLogString(const std::string& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   if (client_)
     client_->OnLog(message);
 }
 
+void VideoCaptureDeviceDeckLinkMac::ReportStarted() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::AutoLock lock(lock_);
+  if (client_)
+    client_->OnStarted();
+}
+
 void VideoCaptureDeviceDeckLinkMac::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_ = std::move(client);
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->AllocateAndStart(params);
 }
 
 void VideoCaptureDeviceDeckLinkMac::StopAndDeAllocate() {
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->StopAndDeAllocate();
 }
 
 }  // namespace media