1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "ClearKeyCDM.h"
#include "ClearKeyUtils.h"
using namespace cdm;
ClearKeyCDM::ClearKeyCDM(Host_10* aHost) {
mHost = aHost;
mSessionManager = new ClearKeySessionManager(mHost);
}
void ClearKeyCDM::Initialize(bool aAllowDistinctiveIdentifier,
bool aAllowPersistentState,
bool aUseHardwareSecureCodecs) {
mSessionManager->Init(aAllowDistinctiveIdentifier, aAllowPersistentState);
// We call mHost->OnInitialized() in the session manager once it has
// initialized.
}
void ClearKeyCDM::GetStatusForPolicy(uint32_t aPromiseId,
const Policy& aPolicy) {
// MediaKeys::GetStatusForPolicy checks the keysystem and
// reject the promise with NS_ERROR_DOM_NOT_SUPPORTED_ERR without calling CDM.
// This function should never be called and is not supported.
assert(false);
}
void ClearKeyCDM::SetServerCertificate(uint32_t aPromiseId,
const uint8_t* aServerCertificateData,
uint32_t aServerCertificateDataSize) {
mSessionManager->SetServerCertificate(aPromiseId, aServerCertificateData,
aServerCertificateDataSize);
}
void ClearKeyCDM::CreateSessionAndGenerateRequest(uint32_t aPromiseId,
SessionType aSessionType,
InitDataType aInitDataType,
const uint8_t* aInitData,
uint32_t aInitDataSize) {
mSessionManager->CreateSession(aPromiseId, aInitDataType, aInitData,
aInitDataSize, aSessionType);
}
void ClearKeyCDM::LoadSession(uint32_t aPromiseId, SessionType aSessionType,
const char* aSessionId, uint32_t aSessionIdSize) {
mSessionManager->LoadSession(aPromiseId, aSessionId, aSessionIdSize);
}
void ClearKeyCDM::UpdateSession(uint32_t aPromiseId, const char* aSessionId,
uint32_t aSessionIdSize,
const uint8_t* aResponse,
uint32_t aResponseSize) {
mSessionManager->UpdateSession(aPromiseId, aSessionId, aSessionIdSize,
aResponse, aResponseSize);
}
void ClearKeyCDM::CloseSession(uint32_t aPromiseId, const char* aSessionId,
uint32_t aSessionIdSize) {
mSessionManager->CloseSession(aPromiseId, aSessionId, aSessionIdSize);
}
void ClearKeyCDM::RemoveSession(uint32_t aPromiseId, const char* aSessionId,
uint32_t aSessionIdSize) {
mSessionManager->RemoveSession(aPromiseId, aSessionId, aSessionIdSize);
}
void ClearKeyCDM::TimerExpired(void* aContext) {
// Clearkey is not interested in timers, so this method has not been
// implemented.
assert(false);
}
Status ClearKeyCDM::Decrypt(const InputBuffer_2& aEncryptedBuffer,
DecryptedBlock* aDecryptedBuffer) {
return mSessionManager->Decrypt(aEncryptedBuffer, aDecryptedBuffer);
}
Status ClearKeyCDM::InitializeAudioDecoder(
const AudioDecoderConfig_2& aAudioDecoderConfig) {
// Audio decoding is not supported by Clearkey because Widevine doesn't
// support it and Clearkey's raison d'etre is to provide test coverage
// for paths that Widevine will exercise in the wild.
return Status::kDecodeError;
}
Status ClearKeyCDM::InitializeVideoDecoder(
const VideoDecoderConfig_2& aVideoDecoderConfig) {
#ifdef ENABLE_WMF
mVideoDecoder = new VideoDecoder(mHost);
return mVideoDecoder->InitDecode(aVideoDecoderConfig);
#else
return Status::kDecodeError;
#endif
}
void ClearKeyCDM::DeinitializeDecoder(StreamType aDecoderType) {
#ifdef ENABLE_WMF
if (aDecoderType == StreamType::kStreamTypeVideo) {
mVideoDecoder->DecodingComplete();
mVideoDecoder = nullptr;
}
#endif
}
void ClearKeyCDM::ResetDecoder(StreamType aDecoderType) {
#ifdef ENABLE_WMF
if (aDecoderType == StreamType::kStreamTypeVideo) {
mVideoDecoder->Reset();
}
#endif
}
Status ClearKeyCDM::DecryptAndDecodeFrame(const InputBuffer_2& aEncryptedBuffer,
VideoFrame* aVideoFrame) {
#ifdef ENABLE_WMF
return mVideoDecoder->Decode(aEncryptedBuffer, aVideoFrame);
#else
return Status::kDecodeError;
#endif
}
Status ClearKeyCDM::DecryptAndDecodeSamples(
const InputBuffer_2& aEncryptedBuffer, AudioFrames* aAudioFrame) {
// Audio decoding is not supported by Clearkey because Widevine doesn't
// support it and Clearkey's raison d'etre is to provide test coverage
// for paths that Widevine will exercise in the wild.
return Status::kDecodeError;
}
void ClearKeyCDM::OnPlatformChallengeResponse(
const PlatformChallengeResponse& aResponse) {
// This function should never be called and is not supported.
assert(false);
}
void ClearKeyCDM::OnQueryOutputProtectionStatus(
QueryResult aResult, uint32_t aLinkMask, uint32_t aOutputProtectionMask) {
// This function should never be called and is not supported.
assert(false);
}
void ClearKeyCDM::OnStorageId(uint32_t aVersion, const uint8_t* aStorageId,
uint32_t aStorageIdSize) {
// This function should never be called and is not supported.
assert(false);
}
void ClearKeyCDM::Destroy() {
mSessionManager->DecryptingComplete();
#ifdef ENABLE_WMF
// If we have called 'DeinitializeDecoder' mVideoDecoder will be null.
if (mVideoDecoder) {
mVideoDecoder->DecodingComplete();
}
#endif
delete this;
}
|
