106 lines
3.3 KiB
C++
106 lines
3.3 KiB
C++
// 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::HdcpCapability current_hdcp_level);
|
|
|
|
private:
|
|
void Init(const ConstraintList& constraints);
|
|
|
|
VideoResolutionConstraint* GetConstraintForRes(uint32_t res);
|
|
|
|
static CryptoSession::HdcpCapability ProtobufHdcpToOemCryptoHdcp(
|
|
const OutputProtection::HDCP& input);
|
|
|
|
bool can_decrypt_;
|
|
|
|
CryptoSession::HdcpCapability default_hdcp_level_;
|
|
ConstraintList constraints_;
|
|
};
|
|
|
|
typedef std::map<wvcdm::KeyId,
|
|
wvcdm::MaxResEngine::KeyStatus*>::const_iterator KeyIterator;
|
|
|
|
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_
|