cdm_adapter.h revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
6#define MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
7
8#include <string>
9#include <vector>
10
11#include "base/basictypes.h"
12#include "base/compiler_specific.h"
13#include "build/build_config.h"
14#include "media/cdm/ppapi/api/content_decryption_module.h"
15#include "media/cdm/ppapi/cdm_helpers.h"
16#include "media/cdm/ppapi/cdm_wrapper.h"
17#include "media/cdm/ppapi/linked_ptr.h"
18#include "ppapi/c/pp_stdint.h"
19#include "ppapi/c/private/pp_content_decryptor.h"
20#include "ppapi/cpp/completion_callback.h"
21#include "ppapi/cpp/private/content_decryptor_private.h"
22#include "ppapi/cpp/var.h"
23#include "ppapi/cpp/var_array_buffer.h"
24#include "ppapi/utility/completion_callback_factory.h"
25
26#if defined(OS_CHROMEOS)
27#include "ppapi/cpp/private/output_protection_private.h"
28#include "ppapi/cpp/private/platform_verification.h"
29#endif
30
31namespace media {
32
33// GetCdmHostFunc implementation.
34void* GetCdmHost(int host_interface_version, void* user_data);
35
36// An adapter class for abstracting away PPAPI interaction and threading for a
37// Content Decryption Module (CDM).
38class CdmAdapter : public pp::Instance,
39                   public pp::ContentDecryptor_Private,
40                   public cdm::Host_1,
41                   public cdm::Host_2,
42                   public cdm::Host_4 {
43 public:
44  CdmAdapter(PP_Instance instance, pp::Module* module);
45  virtual ~CdmAdapter();
46
47  // pp::Instance implementation.
48  virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
49    return true;
50  }
51
52  // PPP_ContentDecryptor_Private implementation.
53  // Note: Results of calls to these methods must be reported through the
54  // PPB_ContentDecryptor_Private interface.
55  virtual void Initialize(const std::string& key_system) OVERRIDE;
56  virtual void CreateSession(uint32_t session_id,
57                             const std::string& content_type,
58                             pp::VarArrayBuffer init_data) OVERRIDE;
59  virtual void LoadSession(uint32_t session_id,
60                           const std::string& web_session_id) OVERRIDE;
61  virtual void UpdateSession(uint32_t session_id,
62                             pp::VarArrayBuffer response) OVERRIDE;
63  virtual void ReleaseSession(uint32_t session_id) OVERRIDE;
64  virtual void Decrypt(
65      pp::Buffer_Dev encrypted_buffer,
66      const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
67  virtual void InitializeAudioDecoder(
68      const PP_AudioDecoderConfig& decoder_config,
69      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
70  virtual void InitializeVideoDecoder(
71      const PP_VideoDecoderConfig& decoder_config,
72      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
73  virtual void DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
74                                   uint32_t request_id) OVERRIDE;
75  virtual void ResetDecoder(PP_DecryptorStreamType decoder_type,
76                            uint32_t request_id) OVERRIDE;
77  virtual void DecryptAndDecode(
78      PP_DecryptorStreamType decoder_type,
79      pp::Buffer_Dev encrypted_buffer,
80      const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
81
82  // cdm::Host implementation.
83  virtual cdm::Buffer* Allocate(uint32_t capacity) OVERRIDE;
84  virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;
85  virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
86  virtual void SendKeyMessage(
87      const char* session_id, uint32_t session_id_length,
88      const char* message, uint32_t message_length,
89      const char* default_url, uint32_t default_url_length) OVERRIDE;
90  virtual void SendKeyError(const char* session_id,
91                            uint32_t session_id_length,
92                            cdm::MediaKeyError error_code,
93                            uint32_t system_code) OVERRIDE;
94  virtual void GetPrivateData(int32_t* instance,
95                              GetPrivateInterface* get_interface) OVERRIDE;
96
97  // cdm::Host_2 implementation.
98  virtual void SendPlatformChallenge(
99      const char* service_id, uint32_t service_id_length,
100      const char* challenge, uint32_t challenge_length) OVERRIDE;
101  virtual void EnableOutputProtection(
102      uint32_t desired_protection_mask) OVERRIDE;
103  virtual void QueryOutputProtectionStatus() OVERRIDE;
104  virtual void OnDeferredInitializationDone(
105      cdm::StreamType stream_type,
106      cdm::Status decoder_status) OVERRIDE;
107
108  // cdm::Host_4 implementation.
109  virtual void OnSessionCreated(uint32_t session_id,
110                                const char* web_session_id,
111                                uint32_t web_session_id_length) OVERRIDE;
112  virtual void OnSessionMessage(uint32_t session_id,
113                                const char* message,
114                                uint32_t message_length,
115                                const char* destination_url,
116                                uint32_t destination_url_length) OVERRIDE;
117  virtual void OnSessionReady(uint32_t session_id) OVERRIDE;
118  virtual void OnSessionClosed(uint32_t session_id) OVERRIDE;
119  virtual void OnSessionError(uint32_t session_id,
120                              cdm::MediaKeyError error_code,
121                              uint32_t system_code) OVERRIDE;
122  virtual cdm::FileIO* CreateFileIO(cdm::FileIOClient* client) OVERRIDE;
123
124 private:
125  typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
126  typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
127  typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;
128
129  bool CreateCdmInstance(const std::string& key_system);
130
131  // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
132  // <code>callback_factory_</code> to ensure that calls into
133  // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
134  void SendSessionCreatedInternal(int32_t result,
135                                  uint32_t session_id,
136                                  const std::string& web_session_id);
137  void SendSessionMessageInternal(int32_t result,
138                                  uint32_t session_id,
139                                  const std::vector<uint8>& message,
140                                  const std::string& default_url);
141  void SendSessionReadyInternal(int32_t result, uint32_t session_id);
142  void SendSessionClosedInternal(int32_t result, uint32_t session_id);
143  void SendSessionErrorInternal(int32_t result,
144                                uint32_t session_id,
145                                cdm::MediaKeyError error_code,
146                                uint32_t system_code);
147
148  void DeliverBlock(int32_t result,
149                    const cdm::Status& status,
150                    const LinkedDecryptedBlock& decrypted_block,
151                    const PP_DecryptTrackingInfo& tracking_info);
152  void DecoderInitializeDone(int32_t result,
153                             PP_DecryptorStreamType decoder_type,
154                             uint32_t request_id,
155                             bool success);
156  void DecoderDeinitializeDone(int32_t result,
157                               PP_DecryptorStreamType decoder_type,
158                               uint32_t request_id);
159  void DecoderResetDone(int32_t result,
160                        PP_DecryptorStreamType decoder_type,
161                        uint32_t request_id);
162  void DeliverFrame(int32_t result,
163                    const cdm::Status& status,
164                    const LinkedVideoFrame& video_frame,
165                    const PP_DecryptTrackingInfo& tracking_info);
166  void DeliverSamples(int32_t result,
167                      const cdm::Status& status,
168                      const LinkedAudioFrames& audio_frames,
169                      const PP_DecryptTrackingInfo& tracking_info);
170
171  // Helper for SetTimer().
172  void TimerExpired(int32_t result, void* context);
173
174  bool IsValidVideoFrame(const LinkedVideoFrame& video_frame);
175
176#if !defined(NDEBUG)
177  // Logs the given message to the JavaScript console associated with the
178  // CDM adapter instance. The name of the CDM adapter issuing the log message
179  // will be automatically prepended to the message.
180  void LogToConsole(const pp::Var& value);
181#endif  // !defined(NDEBUG)
182
183#if defined(OS_CHROMEOS)
184  void SendPlatformChallengeDone(int32_t result);
185  void EnableProtectionDone(int32_t result);
186  void QueryOutputProtectionStatusDone(int32_t result);
187
188  pp::OutputProtection_Private output_protection_;
189  pp::PlatformVerification platform_verification_;
190
191  // Since PPAPI doesn't provide handlers for CompletionCallbacks with more than
192  // one output we need to manage our own.  These values are only read by
193  // SendPlatformChallengeDone().
194  pp::Var signed_data_output_;
195  pp::Var signed_data_signature_output_;
196  pp::Var platform_key_certificate_output_;
197  bool challenge_in_progress_;
198
199  // Same as above, these are only read by QueryOutputProtectionStatusDone().
200  uint32_t output_link_mask_;
201  uint32_t output_protection_mask_;
202  bool query_output_protection_in_progress_;
203#endif
204
205  PpbBufferAllocator allocator_;
206  pp::CompletionCallbackFactory<CdmAdapter> callback_factory_;
207  linked_ptr<CdmWrapper> cdm_;
208  std::string key_system_;
209
210  // If the CDM returned kDeferredInitialization during InitializeAudioDecoder()
211  // or InitializeVideoDecoder(), the (Audio|Video)DecoderConfig.request_id is
212  // saved for the future call to OnDeferredInitializationDone().
213  bool deferred_initialize_audio_decoder_;
214  uint32_t deferred_audio_decoder_config_id_;
215  bool deferred_initialize_video_decoder_;
216  uint32_t deferred_video_decoder_config_id_;
217
218  DISALLOW_COPY_AND_ASSIGN(CdmAdapter);
219};
220
221}  // namespace media
222
223#endif  // MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
224