Merge "Add Max-Res Decode Engine to CDM Core" into lmp-mr1-dev

libwvdrmengine/cdm/core/include/max_res_engine.h

@@ -0,0 +1,102 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_MAX_RES_ENGINE_H_
+#define WVCDM_CORE_MAX_RES_ENGINE_H_
+
+#include <map>
+
+#include "crypto_session.h"
+#include "license_protocol.pb.h"
+#include "lock.h"
+#include "scoped_ptr.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class Clock;
+class MaxResEngineTest;
+
+// Similar to the Policy Engine, this acts as an oracle that basically says
+// "Yes(true) you may still decrypt or no(false) you may not decrypt this data
+// anymore."
+class MaxResEngine {
+ public:
+  explicit MaxResEngine(CryptoSession* crypto_session);
+  virtual ~MaxResEngine();
+
+  // The value returned is computed during the last call to SetLicense/
+  // SetResolution/OnTimerEvent and may be out of sync depending on the amount
+  // of time elapsed. The current decryption status is not calculated when this
+  // function is called to avoid overhead in the decryption path.
+  virtual bool CanDecrypt(const KeyId& key_id);
+
+  // SetLicense is used in handling the initial license response. It stores
+  // an exact copy of the key constraints from the license.
+  virtual void SetLicense(const video_widevine_server::sdk::License& license);
+
+  // SetResolution is called when the current output resolution is updated by
+  // the decoder. The max-res engine will recalculate the current resolution
+  // constraints, (if any) which may affect the results for CanDecrypt().
+  virtual void SetResolution(uint32_t width, uint32_t height);
+
+  // OnTimerEvent is called when a timer fires. The max-res engine may check the
+  // current HDCP level using the crypto session, which may affect the results
+  // for CanDecrypt().
+  virtual void OnTimerEvent();
+
+ private:
+  typedef ::video_widevine_server::sdk::License::KeyContainer KeyContainer;
+  typedef ::video_widevine_server::sdk::License::KeyContainer::OutputProtection
+      OutputProtection;
+  typedef ::video_widevine_server::sdk::License::KeyContainer::
+      VideoResolutionConstraint VideoResolutionConstraint;
+  typedef ::google::protobuf::RepeatedPtrField<VideoResolutionConstraint>
+      ConstraintList;
+
+  class KeyStatus {
+   public:
+    explicit KeyStatus(const ConstraintList& constraints);
+    KeyStatus(const ConstraintList& constraints,
+              const OutputProtection::HDCP& default_hdcp_level);
+
+    bool can_decrypt() const { return can_decrypt_; }
+
+    void Update(uint32_t res,
+                CryptoSession::OemCryptoHdcpVersion current_hdcp_level);
+
+   private:
+    void Init(const ConstraintList& constraints);
+
+    VideoResolutionConstraint* GetConstraintForRes(uint32_t res);
+
+    static CryptoSession::OemCryptoHdcpVersion ProtobufHdcpToOemCryptoHdcp(
+        const OutputProtection::HDCP& input);
+
+    bool can_decrypt_;
+
+    scoped_ptr<CryptoSession::OemCryptoHdcpVersion> default_hdcp_level_;
+    ConstraintList constraints_;
+  };
+
+  void Init(CryptoSession* crypto_session, Clock* clock);
+
+  void DeleteAllKeys();
+
+  Lock status_lock_;
+  std::map<KeyId, KeyStatus*> keys_;
+  uint32_t current_resolution_;
+  int64_t next_check_time_;
+
+  scoped_ptr<Clock> clock_;
+  CryptoSession* crypto_session_;
+
+  // For testing
+  friend class MaxResEngineTest;
+  MaxResEngine(CryptoSession* crypto_session, Clock* clock);
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(MaxResEngine);
+};
+
+}  // wvcdm
+
+#endif  // WVCDM_CORE_MAX_RES_ENGINE_H_

libwvdrmengine/cdm/core/include/policy_engine.h

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "license_protocol.pb.h"
+#include "max_res_engine.h"
 #include "wv_cdm_types.h"
 
 namespace wvcdm {
@@ -13,13 +14,14 @@ namespace wvcdm {
 using video_widevine_server::sdk::LicenseIdentification;
 
 class Clock;
+class CryptoSession;
 class PolicyEngineTest;
 
 // This acts as an oracle that basically says "Yes(true) you may still decrypt
 // or no(false) you may not decrypt this data anymore."
 class PolicyEngine {
  public:
-  PolicyEngine();
+  explicit PolicyEngine(CryptoSession* crypto_session);
   virtual ~PolicyEngine();
 
   // The value returned should be taken as a hint rather than an absolute
@@ -27,7 +29,7 @@ class PolicyEngine {
   // UpdateLicense/OnTimerEvent/BeginDecryption and may be out of sync
   // depending on the amount of time elapsed. The current decryption
   // status is not calculated to avoid overhead in the decryption path.
-  virtual bool can_decrypt() { return can_decrypt_; }
+  virtual bool CanDecrypt(const KeyId& key_id);
 
   // OnTimerEvent is called when a timer fires. It notifies the Policy Engine
   // that the timer has fired and that it should check whether any events have
@@ -118,11 +120,12 @@ class PolicyEngine {
   int64_t next_renewal_time_;
   int64_t policy_max_duration_seconds_;
 
+  MaxResEngine max_res_engine_;
   Clock* clock_;
 
   // For testing
   friend class PolicyEngineTest;
-  PolicyEngine(Clock* clock);
+  PolicyEngine(CryptoSession* crypto_session, Clock* clock);
 
   CORE_DISALLOW_COPY_AND_ASSIGN(PolicyEngine);
 };