Add power monitoring to the Cast VideoToolbox encoder.

media/cast/sender/h264_vt_encoder.cc

 // 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/cast/sender/h264_vt_encoder.h"
 
 #include <string>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/power_monitor/power_monitor.h"
 #include "base/synchronization/lock.h"
 #include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
 #include "media/cast/sender/video_frame_factory.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
@@ skipping 288 matching lines @@
 H264VideoToolboxEncoder::H264VideoToolboxEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const VideoSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb)
     : cast_environment_(cast_environment),
       videotoolbox_glue_(VideoToolboxGlue::Get()),
       video_config_(video_config),
       status_change_cb_(status_change_cb),
       last_frame_id_(kStartFrameId),
       encode_next_frame_as_keyframe_(false),
+      power_suspended_(false),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!status_change_cb_.is_null());
 
   OperationalStatus operational_status =
       H264VideoToolboxEncoder::IsSupported(video_config)
           ? STATUS_INITIALIZED
           : STATUS_UNSUPPORTED_CODEC;
   cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(status_change_cb_, operational_status));
 
   if (operational_status == STATUS_INITIALIZED) {
+    // Create the shared video frame factory. It persists for the combined
+    // lifetime of the encoder and all video frame factory proxies created by
+    // |CreateVideoFrameFactory| that reference it.
     video_frame_factory_ =
         scoped_refptr<VideoFrameFactoryImpl>(new VideoFrameFactoryImpl(
             weak_factory_.GetWeakPtr(), cast_environment_));
+
+    // Register for power state changes.
+    auto power_monitor = base::PowerMonitor::Get();
+    if (power_monitor) {
+      power_monitor->AddObserver(this);
+      VLOG(1) << "Registered for power state changes.";
+    } else {
+      DLOG(WARNING) << "No power monitor. Process suspension will invalidate "
+                       "the encoder.";
+    }
   }
 }
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
   DestroyCompressionSession();
+
+  // If video_frame_factory_ is not null, the encoder registered for power state
+  // changes in the ctor and it must now unregister.
+  if (video_frame_factory_) {
+    auto power_monitor = base::PowerMonitor::Get();
+    if (power_monitor)
+      power_monitor->RemoveObserver(this);
+  }
 }
 
 void H264VideoToolboxEncoder::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  // Ignore reset requests while power suspended.
+  if (power_suspended_)
+    return;
+
   // Notify that we're resetting the encoder.
   cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(status_change_cb_, STATUS_CODEC_REINIT_PENDING));
 
   // Destroy the current session, if any.
   DestroyCompressionSession();
 
   // On OS X, allow the hardware encoder. Don't require it, it does not support
   // all configurations (some of which are used for testing).
@@ skipping 258 matching lines @@
   if (!compression_session_)
     return;
 
   OSStatus status = videotoolbox_glue_->VTCompressionSessionCompleteFrames(
       compression_session_, CoreMediaGlue::CMTime{0, 0, 0, 0});
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCompleteFrames failed: " << status;
   }
 }
 
+void H264VideoToolboxEncoder::OnSuspend() {
+  VLOG(1)
+      << "OnSuspend: Emitting all frames and destroying compression session.";
+  EmitFrames();
+  DestroyCompressionSession();
+  power_suspended_ = true;
+}
+
+void H264VideoToolboxEncoder::OnResume() {
+  power_suspended_ = false;
+
+  // Reset the compression session only if the frame size is not zero (which
+  // will obviously fail). It is possible for the frame size to be zero if no
+  // frame was submitted for encoding or requested from the video frame factory
+  // before suspension.
+  if (!frame_size_.IsEmpty()) {
+    VLOG(1) << "OnResume: Resetting compression session.";
+    ResetCompressionSession();
+  }
+}
+
 bool H264VideoToolboxEncoder::SetSessionProperty(CFStringRef key,
                                                  int32_t value) {
   base::ScopedCFTypeRef<CFNumberRef> cfvalue(
       CFNumberCreate(nullptr, kCFNumberSInt32Type, &value));
   return videotoolbox_glue_->VTSessionSetProperty(compression_session_, key,
                                                   cfvalue) == noErr;
 }
 
 bool H264VideoToolboxEncoder::SetSessionProperty(CFStringRef key, bool value) {
   CFBooleanRef cfvalue = (value) ? kCFBooleanTrue : kCFBooleanFalse;
@@ skipping 69 matching lines @@
     CopySampleBufferToAnnexBBuffer(sbuf, &encoded_frame->data, keyframe);
 
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media