cdm_adapter.h revision 8bcbed890bc3ce4d7a057a8f32cab53fa534672e 
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:
43  CdmAdapter(PP_Instance instance, pp::Module* module);
44  virtual ~CdmAdapter();
45
46  // pp::Instance implementation.
47  virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
48    return true;
49  }
50
51  // PPP_ContentDecryptor_Private implementation.
52  // Note: Results of calls to these methods must be reported through the
53  // PPB_ContentDecryptor_Private interface.
54  // TODO(jrummell): |can_challenge_platform| should be removed.
55  virtual void Initialize(const std::string& key_system,
56                          bool can_challenge_platform) OVERRIDE;
57  virtual void GenerateKeyRequest(const std::string& type,
58                                  pp::VarArrayBuffer init_data) OVERRIDE;
59  virtual void AddKey(const std::string& session_id,
60                      pp::VarArrayBuffer key,
61                      pp::VarArrayBuffer init_data) OVERRIDE;
62  virtual void CancelKeyRequest(const std::string& session_id) OVERRIDE;
63  virtual void Decrypt(
64      pp::Buffer_Dev encrypted_buffer,
65      const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
66  virtual void InitializeAudioDecoder(
67      const PP_AudioDecoderConfig& decoder_config,
68      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
69  virtual void InitializeVideoDecoder(
70      const PP_VideoDecoderConfig& decoder_config,
71      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
72  virtual void DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
73                                   uint32_t request_id) OVERRIDE;
74  virtual void ResetDecoder(PP_DecryptorStreamType decoder_type,
75                            uint32_t request_id) OVERRIDE;
76  virtual void DecryptAndDecode(
77      PP_DecryptorStreamType decoder_type,
78      pp::Buffer_Dev encrypted_buffer,
79      const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
80
81  // cdm::Host implementation.
82  virtual cdm::Buffer* Allocate(int32_t capacity) OVERRIDE;
83  virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;
84  virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
85  virtual void SendKeyMessage(
86      const char* session_id, int32_t session_id_length,
87      const char* message, int32_t message_length,
88      const char* default_url, int32_t default_url_length) OVERRIDE;
89  virtual void SendKeyError(const char* session_id,
90                            int32_t session_id_length,
91                            cdm::MediaKeyError error_code,
92                            uint32_t system_code) OVERRIDE;
93  virtual void GetPrivateData(int32_t* instance,
94                              GetPrivateInterface* get_interface) OVERRIDE;
95
96  // cdm::Host_2 implementation.
97  virtual void SendPlatformChallenge(
98      const char* service_id, int32_t service_id_length,
99      const char* challenge, int32_t challenge_length) OVERRIDE;
100  virtual void EnableOutputProtection(
101      uint32_t desired_protection_mask) OVERRIDE;
102  virtual void QueryOutputProtectionStatus() OVERRIDE;
103
104 private:
105  struct SessionInfo {
106    SessionInfo(const std::string& key_system_in,
107                const std::string& session_id_in)
108        : key_system(key_system_in),
109          session_id(session_id_in) {}
110    const std::string key_system;
111    const std::string session_id;
112  };
113
114  typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
115  typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
116  typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;
117
118  bool CreateCdmInstance(const std::string& key_system);
119
120  void SendUnknownKeyError(const std::string& key_system,
121                           const std::string& session_id);
122
123  void SendKeyAdded(const std::string& key_system,
124                    const std::string& session_id);
125
126  // TODO(jrummell): Drop the |key_system| parameter.
127  void SendKeyErrorInternal(const std::string& key_system,
128                            const std::string& session_id,
129                            cdm::MediaKeyError error_code,
130                            uint32_t system_code);
131
132  // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
133  // <code>callback_factory_</code> to ensure that calls into
134  // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
135  void KeyAdded(int32_t result, const SessionInfo& session_info);
136  void KeyMessage(int32_t result,
137                  const SessionInfo& session_info,
138                  const std::vector<uint8>& message,
139                  const std::string& default_url);
140  void KeyError(int32_t result,
141                const SessionInfo& session_info,
142                cdm::MediaKeyError error_code,
143                uint32_t system_code);
144  void DeliverBlock(int32_t result,
145                    const cdm::Status& status,
146                    const LinkedDecryptedBlock& decrypted_block,
147                    const PP_DecryptTrackingInfo& tracking_info);
148  void DecoderInitializeDone(int32_t result,
149                             PP_DecryptorStreamType decoder_type,
150                             uint32_t request_id,
151                             bool success);
152  void DecoderDeinitializeDone(int32_t result,
153                               PP_DecryptorStreamType decoder_type,
154                               uint32_t request_id);
155  void DecoderResetDone(int32_t result,
156                        PP_DecryptorStreamType decoder_type,
157                        uint32_t request_id);
158  void DeliverFrame(int32_t result,
159                    const cdm::Status& status,
160                    const LinkedVideoFrame& video_frame,
161                    const PP_DecryptTrackingInfo& tracking_info);
162  void DeliverSamples(int32_t result,
163                      const cdm::Status& status,
164                      const LinkedAudioFrames& audio_frames,
165                      const PP_DecryptTrackingInfo& tracking_info);
166
167  // Helper for SetTimer().
168  void TimerExpired(int32_t result, void* context);
169
170  bool IsValidVideoFrame(const LinkedVideoFrame& video_frame);
171
172
173#if defined(OS_CHROMEOS)
174  void SendPlatformChallengeDone(int32_t result);
175  void EnableProtectionDone(int32_t result);
176  void QueryOutputProtectionStatusDone(int32_t result);
177
178  pp::OutputProtection_Private output_protection_;
179  pp::PlatformVerification platform_verification_;
180
181  // Since PPAPI doesn't provide handlers for CompletionCallbacks with more than
182  // one output we need to manage our own.  These values are only read by
183  // SendPlatformChallengeDone().
184  pp::Var signed_data_output_;
185  pp::Var signed_data_signature_output_;
186  pp::Var platform_key_certificate_output_;
187  bool challenge_in_progress_;
188
189  // Same as above, these are only read by QueryOutputProtectionStatusDone().
190  uint32_t output_link_mask_;
191  uint32_t output_protection_mask_;
192  bool query_output_protection_in_progress_;
193#endif
194
195  PpbBufferAllocator allocator_;
196  pp::CompletionCallbackFactory<CdmAdapter> callback_factory_;
197  linked_ptr<CdmWrapper> cdm_;
198  std::string key_system_;
199
200  DISALLOW_COPY_AND_ASSIGN(CdmAdapter);
201};
202
203}  // namespace media
204
205#endif  // MEDIA_CDM_PPAPI_CDM_ADAPTER_H_
206