Initial source release: v2.0.8-0-679

Change-Id: Idf6316a8faf4b4fdc54265aad12084e5aa60707a

cdm/src/clock.cpp

@@ -0,0 +1,24 @@
+#include "clock.h"
+
+#include <cstddef>
+
+#include "cdm_host_clock.h"
+
+namespace wvcdm {
+
+IClock* HostClock::impl_ = NULL;
+
+IClock::~IClock() {
+  HostClock::impl_ = NULL;
+}
+
+int64_t Clock::GetCurrentTime() {
+  return HostClock::impl_ ?
+      HostClock::impl_->GetCurrentTimeInSeconds() : -1;
+}
+
+void HostClock::SetClockInterface(IClock* iclock) {
+  HostClock::impl_ = iclock;
+}
+
+} // namespace wvcdm

cdm/src/file_store.cpp

@@ -0,0 +1,146 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#include <string.h>
+#include <string>
+#include "cdm_host_file.h"
+
+namespace wvcdm {
+
+IFileFactory*  File::Impl::factory_ = NULL;
+
+// File::Impl() Section
+// The file handler for cert.bin, aka DeviceCertificate is all we're
+// setting up for now.
+
+bool File::Impl::Exists(const std::string& name) {
+  if (name == "cert.bin") {
+    std::vector<uint8_t> value;
+    if (host_->GetPlatformByteArray("DeviceCertificate", &value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool File::Impl::Open(const std::string& name) {
+  if (name == "cert.bin") {
+    fname_= name;
+    return true;
+  }
+  return false;
+}
+
+bool File::Impl::Close() {
+  fname_ = "";
+  return true;
+}
+
+bool File::Impl::Remove(const std::string& name) {
+  if (Exists(name)) {
+    std::vector<uint8_t> value(0);
+    if (host_->SetPlatformByteArray("DeviceCertificate", value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+size_t File::Impl::Read(char* buffer, size_t bytes) {
+ if (fname_ == "cert.bin") {
+    std::vector<uint8_t> value;
+    if (host_->GetPlatformByteArray("DeviceCertificate", &value)) {
+      memcpy(buffer, &value[0], bytes);
+      return bytes;
+    }
+  }
+  return 0;
+}
+
+size_t File::Impl::Write(const char* buffer, size_t bytes) {
+  if (fname_ == "cert.bin") {
+    std::vector<uint8_t> value;
+    value.resize(bytes);
+    memcpy(&value[0], buffer, bytes);
+    if (host_->PersistPlatformByteArray("DeviceCertificate", value)) {
+      return bytes;
+    }
+  }
+  return 0;
+}
+
+size_t File::Impl::FileSize(const std::string& name) {
+  if (name == "cert.bin") {
+    std::vector<uint8_t> value;
+    if (host_->GetPlatformByteArray("DeviceCertificate", &value)) {
+      return value.size();
+    }
+  }
+  return 0;
+}
+
+File::File() : impl_(File::Impl::factory_->NewFileImpl()) {}
+
+File::~File() {
+  Close();
+  delete impl_;
+}
+
+bool File::Open(const std::string& name, int flags) {
+  return impl_->Open(name);
+}
+
+void File::Close() {
+  impl_->Close();
+  return;
+}
+
+ssize_t File::Read(char* buffer, size_t bytes) {
+  return impl_->Read(buffer, bytes);
+}
+
+ssize_t File::Write(const char* buffer, size_t bytes) {
+  return impl_->Write(buffer, bytes);
+}
+
+bool File::Exists(const std::string& path) {
+  return impl_->Exists(path);
+}
+
+bool File::Remove(const std::string& path) {
+  return impl_->Remove(path);
+}
+
+bool File::Copy(const std::string& from, const std::string& to) {
+  // Required for linkage only - no current API implementation in the partner CDM is required.
+  return false;
+}
+
+bool File::List(const std::string& path, std::vector<std::string>* files) {
+  // Required for linkage only - no current API implementation in the partner CDM is required.
+  return false;
+}
+
+bool File::CreateDirectory(std::string path) {
+  // Required for linkage only - no current API implementation in the partner CDM is required.
+  return true;
+}
+
+bool File::IsDirectory(const std::string& path) {
+  // Required for linkage only - no current API implementation in the partner CDM is required.
+  return false;
+}
+
+bool File::IsRegularFile(const std::string& path) {
+ // Required for linkage only - no current API implementation in the partner CDM is required.
+  return false;
+}
+
+ssize_t File::FileSize(const std::string& path) {
+  size_t size = impl_->FileSize(path);
+  if (size > 0) {
+    return size;
+  }
+  return -1;
+}
+
+}  // namespace wvcdm

cdm/src/host_event_listener.cpp

@@ -0,0 +1,38 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#include "host_event_listener.h"
+
+#include "log.h"
+#include "wv_cdm_constants.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+void HostEventListener::OnEvent(const CdmSessionId& session_id,
+                                CdmEventType cdm_event) {
+  switch (cdm_event) {
+    case LICENSE_RENEWAL_NEEDED_EVENT: {
+      wvcdm::CdmKeyMessage cdm_message;
+      std::string server_url;
+      CdmResponseType result = cdm_engine_->GenerateRenewalRequest(
+          session_id, &cdm_message, &server_url);
+      if (result == wvcdm::KEY_MESSAGE) {
+        host_->SendKeyMessage(session_id.data(), session_id.length(),
+                              cdm_message.data(), cdm_message.length(),
+                              server_url.data(), server_url.length());
+      } else {
+        LOGD("Error on Generating a Renewal Request!");
+        host_->SendKeyError(session_id.data(), session_id.size(),
+                            cdm::kUnknownError, 0);
+      }
+      break;
+    }
+    case LICENSE_EXPIRED_EVENT: {
+      host_->SendKeyError(session_id.data(), session_id.size(),
+                          cdm::kUnknownError, 0);
+      break;
+    }
+  }
+}
+
+}  // namespace wvcdm

cdm/src/properties_common.cpp

@@ -0,0 +1,95 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#include "properties.h"
+
+#include <string>
+#include <sys/utsname.h>
+
+#include "log.h"
+
+namespace wvcdm {
+
+bool Properties::GetCompanyName(std::string* company_name) {
+  if (!company_name) {
+    LOGW("Properties::GetCompanyName: Invalid parameter");
+    return false;
+  }
+  *company_name = PLATFORM_COMPANY_NAME_WV;
+
+  return true;
+}
+
+bool Properties::GetModelName(std::string* model_name) {
+  if (!model_name) {
+    LOGW("Properties::GetModelName: Invalid parameter");
+    return false;
+  }
+  *model_name = PLATFORM_MODEL_NAME_WV;
+  return true;
+
+}
+
+bool Properties::GetArchitectureName(std::string* arch_name) {
+  if (!arch_name) {
+    LOGW("Properties::GetArchitectureName: Invalid parameter");
+    return false;
+  }
+  *arch_name = PLATFORM_ARCHITECTURE_NAME_WV;
+  return true;
+
+}
+
+bool Properties::GetDeviceName(std::string* device_name) {
+  if (!device_name) {
+    LOGW("Properties::GetDeviceName: Invalid parameter");
+    return false;
+  }
+  *device_name = PLATFORM_DEVICE_NAME_WV;
+  return true;
+
+}
+
+bool Properties::GetProductName(std::string* product_name) {
+  if (!product_name) {
+    LOGW("Properties::GetProductName: Invalid parameter");
+    return false;
+  }
+  *product_name = PLATFORM_PRODUCT_NAME_WV;
+  return true;
+
+}
+
+bool Properties::GetBuildInfo(std::string* build_info) {
+  if (!build_info) {
+    LOGW("Properties::GetBuildInfo: Invalid parameter");
+    return false;
+  }
+  *build_info = PLATFORM_BUILDINFO_WV;
+  return true;
+
+}
+
+bool Properties::GetDeviceFilesBasePath(CdmSecurityLevel security_level,
+                                        std::string* base_path) {
+  // no-op
+  return true;
+}
+
+bool Properties::GetFactoryKeyboxPath(std::string* keybox) {
+  if (!keybox) {
+    LOGW("Properties::GetFactoryKeyboxPath: Invalid parameter");
+    return false;
+  }
+  return true;
+}
+
+bool Properties::GetOEMCryptoPath(std::string* library_name) {
+  if (!library_name) {
+    LOGW("Properties::GetOEMCryptoPath: Invalid parameter");
+    return false;
+  }
+  *library_name = "out/Default/lib.target/liboemcrypto.so";
+  return true;
+}
+
+}  // namespace wvcdm

cdm/src/timer.cpp

@@ -0,0 +1,76 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Timer class - provides a simple timer implementation
+//
+#include "cdm_host_timer.h"
+#include "scoped_ptr.h"
+#include "timer.h"
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <time.h>
+#include <unistd.h>
+
+namespace wvcdm {
+
+ITimerFactory* Timer::Impl::factory_ = NULL;
+
+Timer::Impl::Impl(cdm::Host* const host)
+    : host_(host), handler_(NULL), delay_ms_(0),
+      state_(kIdle) {
+}
+
+void Timer::Impl::RegisterTimerFactory(ITimerFactory* factory) {
+  factory_ = factory;
+}
+
+void Timer::Impl::Start(TimerHandler* handler, uint32_t time_in_secs) {
+  handler_ = handler;
+  delay_ms_ = time_in_secs * 1000;
+  state_ = kRunning;
+  host_->SetTimer(delay_ms_, this);
+}
+
+void Timer::Impl::OnTimerEvent() {
+  if (kRunning == state_) {
+    handler_->OnTimerEvent();
+    host_->SetTimer(delay_ms_, this);
+  }
+}
+
+void Timer::Impl::Stop() {
+  state_ = kIdle;
+}
+
+Timer::Timer() : impl_(NULL) {}
+
+Timer::~Timer() {
+  if (impl_)
+    delete impl_;
+}
+
+bool Timer::Start(TimerHandler* handler, uint32_t time_in_secs) {
+  if (!handler || 0 == time_in_secs)
+    return false;
+  if (!impl_ && Impl::factory_)
+    impl_ = Impl::factory_->NewTimerImpl();
+  if(!impl_)
+    return false;
+
+  impl_->Start(handler, time_in_secs);
+  return IsRunning();
+}
+
+void Timer::Stop() {
+  if (impl_)
+    impl_->Stop();
+}
+
+bool Timer::IsRunning() {
+  if (!impl_)
+    return false;
+  return impl_->IsRunning();
+}
+
+} // namespace wvcdm

cdm/src/wv_content_decryption_module.cpp

@@ -0,0 +1,410 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#include "wv_content_decryption_module.h"
+
+#include <iostream>
+#include <string.h>
+
+#include "cdm_client_property_set.h"
+#include "content_decryption_module.h"
+
+#include "log.h"
+#include "OEMCryptoCENC.h"
+#include "properties.h"
+
+#include "wv_cdm_constants.h"
+#include "wv_cdm_types.h"
+#include "wv_cdm_version.h"
+
+void INITIALIZE_CDM_MODULE() {}
+
+void DeinitializeCdmModule() {}
+
+void* CreateCdmInstance(int cdm_interface_version, const char* key_system,
+                        int key_system_size, GetCdmHostFunc get_cdm_host_func,
+                        void* user_data) {
+  if (cdm_interface_version != cdm::kCdmInterfaceVersion) return NULL;
+
+  cdm::Host* host = static_cast<cdm::Host*>(
+      get_cdm_host_func(cdm::kHostInterfaceVersion, user_data));
+
+  if (!host) return NULL;
+
+  return static_cast<cdm::ContentDecryptionModule*>(
+      new wvcdm::WvContentDecryptionModule(host));
+}
+
+int GetCdmVersion() { return cdm::kCdmInterfaceVersion; }
+
+namespace {
+static const std::string kWvCdmVersionString(WV_CDM_VERSION);
+
+const int kCdmPolicyTimerDurationSeconds = 1;
+const int kCdmPolicyTimerCancel = 0;
+
+// The iso spec only uses the lower 8 bytes of the iv as
+// the counter.
+const uint32_t kCencIvSize = 8;
+const uint32_t kIvSize = 16;
+
+bool Ctr128Add(size_t block_count, uint8_t* counter) {
+  if (NULL == counter)
+    return false;
+  if (0 == block_count)
+    return true;
+  uint8_t carry = 0;
+  uint8_t n = kIvSize - 1;
+  while (n >= kCencIvSize) {
+    uint32_t temp = block_count & 0xff;
+    temp += counter[n];
+    temp += carry;
+    counter[n] = temp & 0xff;
+    carry = (temp & 0x100) ? 1 : 0;
+    block_count = block_count >> 8;
+    n--;
+    if (!block_count && !carry) {
+      break;
+    }
+  }
+  return true;
+}
+} // namespace
+
+namespace wvcdm {
+
+// An empty iv string signals that the frame is unencrypted.
+bool IsBufferEncrypted(const cdm::InputBuffer& input_buffer) {
+  return input_buffer.iv_size != 0;
+}
+
+// cdm::ContentDecryptionModule implementation.
+
+WvContentDecryptionModule::~WvContentDecryptionModule() {
+  DisablePolicyTimer();
+}
+
+cdm::Status WvContentDecryptionModule::GenerateKeyRequest(
+    const char* type, int type_size, const uint8_t* init_data,
+    int init_data_size) {
+  LOGI("Enter WvContentDecryptionModule::GenerateKeyRequest()");
+  CdmInitData init_data_internal(reinterpret_cast<const char*>(init_data),
+                                 init_data_size);
+  CdmKeyMessage key_request;
+  CdmSessionId session_id;
+
+  std::string security_level;
+  std::string privacy_mode;
+  kVectorBytes service_certificate;
+
+  host_->GetPlatformString("SecurityLevel", &security_level);
+  host_->GetPlatformString("PrivacyOn", &privacy_mode);
+  host_->GetPlatformByteArray("ServiceCertificate", &service_certificate);
+
+  property_set_.set_security_level(security_level);
+  property_set_.set_use_privacy_mode(privacy_mode == "True" ? 1 : 0 );
+  property_set_.set_service_certificate(service_certificate);
+
+  CdmResponseType result =
+    cdm_engine_.OpenSession("com.widevine.alpha", &property_set_, &session_id);
+
+  if (NEED_PROVISIONING == result) {
+    LOGI("Need to aquire a Device Certificate from the Provisioning Server");
+    return cdm::kNeedsDeviceCertificate;
+  }
+
+  if (NO_ERROR != result) return cdm::kSessionError;
+
+  if (!cdm_engine_.AttachEventListener(session_id, &host_event_listener_)) {
+    cdm_engine_.CloseSession(session_id);
+    return cdm::kSessionError;
+  }
+
+  CdmAppParameterMap app_parameters;  // empty
+  CdmKeySetId key_set_id;             // empty
+  std::string server_url;
+
+  result = cdm_engine_.GenerateKeyRequest(
+      session_id, key_set_id, init_data_internal, kLicenseTypeStreaming,
+      app_parameters, &key_request, &server_url);
+  if (KEY_MESSAGE != result) {
+    cdm_engine_.CloseSession(session_id);
+    return cdm::kSessionError;
+  }
+
+  host_->SendKeyMessage(session_id.data(), session_id.length(),
+                        key_request.data(), key_request.length(),
+                        server_url.data(), server_url.length());
+
+  return cdm::kSuccess;
+}
+
+cdm::Status WvContentDecryptionModule::AddKey(const char* session_id,
+                                              int session_id_size,
+                                              const uint8_t* key, int key_size,
+                                              const uint8_t* key_id,
+                                              int key_id_size) {
+  LOGI("Enter WvContentDecryptionModule::AddKey()\n");
+  CdmSessionId session_id_internal(session_id, session_id_size);
+  CdmKeyResponse key_data((const char*)key, key_size);
+  CdmKeySetId key_set_id;
+
+  CdmResponseType response = cdm_engine_.AddKey(session_id_internal,
+      key_data, &key_set_id);
+
+  if (response == KEY_ADDED) {
+    EnablePolicyTimer();
+    return cdm::kSuccess;
+  } else {
+    return cdm::kSessionError;
+  }
+
+}
+
+cdm::Status WvContentDecryptionModule::CancelKeyRequest(const char* session_id,
+                                                        int session_id_size) {
+  LOGI("Enter WvContentDecryptionModule::CancelKeyRequest()\n");
+  CdmSessionId session_id_internal(session_id, session_id_size);
+  return cdm_engine_.CancelKeyRequest(session_id_internal) == NO_ERROR
+             ? cdm::kSuccess
+             : cdm::kSessionError;
+}
+
+void WvContentDecryptionModule::TimerExpired(void* context) {
+  LOGI("Timer expired, send cdm_engine OnTimerEvent");
+  if (this != context) {
+    LOGD("Context should have been set, Timer Expired Error\n");
+    return;
+  }
+  OnTimerEvent();
+}
+
+cdm::Status WvContentDecryptionModule::Decrypt(
+    const cdm::InputBuffer& encrypted_buffer,
+    cdm::DecryptedBlock* decrypted_block) {
+  LOGI("=>Enter WvContentDecryptionModule::Decrypt()\n");
+  if (encrypted_buffer.iv_size != KEY_IV_SIZE)
+    return cdm::kDecryptError;
+  std::vector < uint8_t > iv(KEY_IV_SIZE);
+  memcpy(&iv[0], encrypted_buffer.iv, encrypted_buffer.iv_size);
+
+  KeyId key_id(reinterpret_cast<const char*>(encrypted_buffer.key_id),
+               encrypted_buffer.key_id_size);
+
+  CdmSessionId session_id;  // it's empty but cdm_engine will locate via key_id?
+
+  if (NULL == encrypted_buffer.subsamples
+        || encrypted_buffer.num_subsamples <= 0)
+      return cdm::kDecryptError;
+
+  CdmDecryptionParameters parameters(&key_id,
+                                     encrypted_buffer.data, 0, &iv, 0,
+                                     NULL);
+  parameters.is_secure = false;
+  return DoSubsampleDecrypt(session_id,
+                            parameters,
+                            iv,
+                            encrypted_buffer,
+                            decrypted_block);
+}
+
+cdm::Status WvContentDecryptionModule::InitializeAudioDecoder(
+    const cdm::AudioDecoderConfig& audio_decoder_config) {
+  LOGI("WvContentDecryptionModule::InitializeAudioDecoder() Not implemented\n");
+  return cdm::kDecodeError;
+}
+
+cdm::Status WvContentDecryptionModule::InitializeVideoDecoder(
+    const cdm::VideoDecoderConfig& video_decoder_config) {
+  LOGI("WvContentDecryptionModule::InitializeVideoDecoder() Not implemented\n");
+  return cdm::kDecodeError;
+}
+
+void WvContentDecryptionModule::DeinitializeDecoder(
+    cdm::StreamType decoder_type) {
+  LOGI("WvContentDecryptionModule::DeInitializeDecoder() Not implemented\n");
+}
+
+void WvContentDecryptionModule::ResetDecoder(cdm::StreamType decoder_type) {
+  LOGI("WvContentDecryptionModule::ResetDecoder() Not implemented\n");
+}
+
+cdm::Status WvContentDecryptionModule::DecryptAndDecodeFrame(
+    const cdm::InputBuffer& encrypted_buffer, cdm::VideoFrame* video_frame) {
+  LOGI("WvContentDecryptionModule::DecryptAndDecodeFrame() Not implemented\n");
+  return cdm::kDecodeError;
+}
+
+cdm::Status WvContentDecryptionModule::DecryptAndDecodeSamples(
+    const cdm::InputBuffer& encrypted_buffer, cdm::AudioFrames* audio_frames) {
+  LOGI(
+      "WvContentDecryptionModule::DecryptAndDecodeSamples() Not implemented\n");
+  return cdm::kDecodeError;
+}
+
+// This is the Level 1 API.  When the host application calls the CDM's
+// DecryptDecodeAndRenderFrame(), rather than the CDM's Decrypt(),
+// OEMCrypto_DecryptCTR() will be told to use direct rendering with no
+// cleartext in the return.
+cdm::Status WvContentDecryptionModule::DecryptDecodeAndRenderFrame(
+    const cdm::InputBuffer& encrypted_buffer) {
+  LOGI("WvContentDecryptionModule::DecryptDecodeAndRenderFrame()\n");
+
+  if (encrypted_buffer.iv_size != KEY_IV_SIZE) return cdm::kDecryptError;
+
+  std::vector<uint8_t> iv(KEY_IV_SIZE);
+  memcpy(&iv[0], encrypted_buffer.iv, encrypted_buffer.iv_size);
+  KeyId key_id(reinterpret_cast<const char*>(encrypted_buffer.key_id),
+               encrypted_buffer.key_id_size);
+  CdmSessionId session_id;  // it's empty but cdm_engine will locate via key_id.
+
+  if (NULL == encrypted_buffer.subsamples
+      || encrypted_buffer.num_subsamples <= 0)
+    return cdm::kDecryptError;
+
+  CdmDecryptionParameters parameters(&key_id, encrypted_buffer.data, 0, &iv, 0,
+                                     NULL);
+  return DoSubsampleDecrypt(session_id, parameters, iv, encrypted_buffer,
+                            NULL);
+}
+
+// This is the Level 1 API.  When the host application calls the CDM's
+// DecryptDecodeAndRenderSamples(), rather than the CDM's Decrypt(),
+// OEMCrypto_DecryptCTR() will be told to use direct rendering with no cleartext
+// in the return.
+cdm::Status WvContentDecryptionModule::DecryptDecodeAndRenderSamples(
+    const cdm::InputBuffer& encrypted_buffer) {
+  LOGI("WvContentDecryptionModule::DecryptDecodeAndRenderSamples()\n");
+
+  if (encrypted_buffer.iv_size != KEY_IV_SIZE) return cdm::kDecryptError;
+
+  std::vector<uint8_t> iv(KEY_IV_SIZE);
+  memcpy(&iv[0], encrypted_buffer.iv, encrypted_buffer.iv_size);
+  KeyId key_id(reinterpret_cast<const char*>(encrypted_buffer.key_id),
+               encrypted_buffer.key_id_size);
+  CdmSessionId session_id;  // it's empty but cdm_engine will locate via key_id.
+
+  if (NULL == encrypted_buffer.subsamples ||
+      encrypted_buffer.num_subsamples <= 0)
+    return cdm::kDecryptError;
+
+  CdmDecryptionParameters parameters(&key_id, encrypted_buffer.data, 0, &iv, 0,
+                                     NULL);
+  parameters.is_video = false;  // override the default true value for audio.
+  return DoSubsampleDecrypt(session_id, parameters, iv, encrypted_buffer,
+                            NULL);
+}
+
+void WvContentDecryptionModule::Destroy() { delete this; }
+
+// Provisioning related methods
+cdm::Status WvContentDecryptionModule::GetProvisioningRequest(
+    std::string* request, std::string* provisioning_server_url) {
+  if (cdm_engine_.GetProvisioningRequest(
+      static_cast<CdmProvisioningRequest*>(request),
+      provisioning_server_url) == NO_ERROR) {
+    return cdm::kSuccess;
+  }
+  return cdm::kSessionError;
+}
+
+cdm::Status WvContentDecryptionModule::HandleProvisioningResponse(
+    std::string& response) {
+  if (cdm_engine_.HandleProvisioningResponse(
+      static_cast<CdmProvisioningRequest&>(response)) == NO_ERROR) {
+    return cdm::kSuccess;
+  }
+  return cdm::kSessionError;
+}
+
+void WvContentDecryptionModule::EnablePolicyTimer() {
+  LOGI("WvContentDecryptionModule::EnablePolicyTimer()\n");
+  host_->SetTimer(kCdmPolicyTimerDurationSeconds * 1000, this);
+}
+
+void WvContentDecryptionModule::DisablePolicyTimer() {
+  LOGI("WvContentDecryptionModule::DisablePolicyTimer()\n");
+  host_->SetTimer(kCdmPolicyTimerCancel, NULL);
+}
+
+void WvContentDecryptionModule::OnTimerEvent() {
+
+  LOGI("WvContentDecryptionModule::OnTimerEvent()\n");
+  cdm_engine_.OnTimerEvent();
+}
+
+cdm::Status WvContentDecryptionModule::DoSubsampleDecrypt(
+    CdmSessionId& session_id,
+    CdmDecryptionParameters& parameters,
+    std::vector < uint8_t >& iv,
+    const cdm::InputBuffer& encrypted_buffer,
+    cdm::DecryptedBlock* decrypted_block) {
+
+  /* This routine assumes session_id and iv have already
+  been initialized by the caller and encrypted_buffer contains subsample
+  information. Also, parameters is expected to be pre-initialized with any
+  needed parameters not related to subsample parsing.
+  decrypted_block may be NULL. */
+  CdmResponseType status = NO_ERROR;
+  uint8_t* output_buffer = decrypted_block
+                               ? reinterpret_cast<uint8_t*>(
+                                     decrypted_block->DecryptedBuffer()->Data())
+                               : NULL;
+  size_t offset = 0;
+  size_t encrypted_offset = 0;
+  uint32_t block_ctr = 0;
+  const cdm::SubsampleEntry *subsamples = encrypted_buffer.subsamples;
+  bool first = true;
+
+  for (int i = 0; i < encrypted_buffer.num_subsamples; ++i) {
+    const cdm::SubsampleEntry& subsample = subsamples[i];
+
+    for (int is_encrypted = 0; is_encrypted < 2; ++is_encrypted) {
+      size_t bytes =
+          is_encrypted ? subsample.cipher_bytes : subsample.clear_bytes;
+      if (0 == bytes)
+        continue;
+      if (is_encrypted) {
+        uint32_t counter = encrypted_offset / kIvSize;
+        ::Ctr128Add(counter - block_ctr, &iv[0]);
+        block_ctr = counter;
+      }
+
+      parameters.encrypt_buffer = &encrypted_buffer.data[encrypted_buffer
+          .data_offset + offset];
+      if (output_buffer)
+        parameters.decrypt_buffer = &output_buffer[offset];
+
+      parameters.encrypt_length = bytes;
+      parameters.decrypt_buffer_length = encrypted_buffer.data_size - offset;
+      parameters.block_offset = encrypted_offset % kIvSize;
+
+      offset += bytes;
+      if (is_encrypted)
+        encrypted_offset += bytes;
+
+      parameters.is_encrypted = is_encrypted;
+      parameters.subsample_flags =
+          (true == first) ? OEMCrypto_FirstSubsample : 0;
+      parameters.subsample_flags |= (
+          offset == encrypted_buffer.data_size ? OEMCrypto_LastSubsample : 0);
+
+      first = false;
+
+      status = cdm_engine_.Decrypt(session_id, parameters);
+
+      switch (status) {
+        case wvcdm::NEED_KEY:
+          return cdm::kNoKey;
+          break;
+        case wvcdm::NO_ERROR:
+          break;
+        default:
+          return cdm::kDecryptError;
+          break;
+      }
+    }
+  }
+  return cdm::kSuccess;
+}
+
+}  // namespace wvcdm