src/starboard/shared/win32/decrypting_decoder.cc - cobalt - Git at Google

 // Copyright 2017 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "starboard/shared/win32/decrypting_decoder.h"

 #include <algorithm>
 #include <numeric>

 #include "starboard/byte_swap.h"
 #include "starboard/common/ref_counted.h"
 #include "starboard/log.h"
 #include "starboard/memory.h"
 #include "starboard/shared/win32/error_utils.h"
 #include "starboard/shared/win32/media_foundation_utils.h"

 namespace starboard {
 namespace shared {
 namespace win32 {

 namespace {

 ComPtr<IMFSample> CreateSample(const void* data,
                                int size,
                                int64_t win32_timestamp) {
   ComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = MFCreateMemoryBuffer(size, &buffer);
   CheckResult(hr);

   BYTE* buffer_ptr;
   hr = buffer->Lock(&buffer_ptr, 0, 0);
   CheckResult(hr);

   SbMemoryCopy(buffer_ptr, data, size);

   hr = buffer->Unlock();
   CheckResult(hr);

   hr = buffer->SetCurrentLength(size);
   CheckResult(hr);

   ComPtr<IMFSample> input;
   hr = MFCreateSample(&input);
   CheckResult(hr);

   hr = input->AddBuffer(buffer.Get());
   CheckResult(hr);

   // sample time is in 100 nanoseconds.
   input->SetSampleTime(win32_timestamp);
   return input;
 }

 void AttachDrmDataToSample(ComPtr<IMFSample> sample,
                            int sample_size,
                            const uint8_t* key_id,
                            int key_id_size,
                            const uint8_t* iv,
                            int iv_size,
                            const SbDrmSubSampleMapping* subsample_mapping,
                            int subsample_count) {
   if (iv_size == 16 && SbMemoryIsZero(iv + 8, 8)) {
     // For iv that is 16 bytes long but the the last 8 bytes is 0, we treat
     // it as an 8 bytes iv.
     iv_size = 8;
   }
   sample->SetBlob(MFSampleExtension_Encryption_SampleID,
                   reinterpret_cast<const UINT8*>(iv),
                   static_cast<UINT32>(iv_size));
   SB_DCHECK(key_id_size == sizeof(GUID));
   GUID guid = *reinterpret_cast<const GUID*>(key_id);

   guid.Data1 = SbByteSwapU32(guid.Data1);
   guid.Data2 = SbByteSwapU16(guid.Data2);
   guid.Data3 = SbByteSwapU16(guid.Data3);

   sample->SetGUID(MFSampleExtension_Content_KeyID, guid);

   SB_DCHECK(sizeof(DWORD) * 2 == sizeof(SbDrmSubSampleMapping));

   SbDrmSubSampleMapping default_subsample = {0, sample_size};
   if (subsample_count == 0) {
     subsample_mapping = &default_subsample;
     subsample_count = 1;
   }
   sample->SetBlob(
       MFSampleExtension_Encryption_SubSampleMappingSplit,
       reinterpret_cast<const UINT8*>(subsample_mapping),
       static_cast<UINT32>(subsample_count * sizeof(SbDrmSubSampleMapping)));
 }

 }  // namespace

 DecryptingDecoder::DecryptingDecoder(const std::string& type,
                                      CLSID clsid,
                                      SbDrmSystem drm_system)
     : type_(type), decoder_(clsid) {
   drm_system_ = static_cast<SbDrmSystemPlayready*>(drm_system);
 }

 DecryptingDecoder::~DecryptingDecoder() {
   Reset();
 }

 bool DecryptingDecoder::TryWriteInputBuffer(
     const scoped_refptr<InputBuffer>& input_buffer,
     int bytes_to_skip_in_sample) {
   SB_DCHECK(input_buffer);
   SB_DCHECK(bytes_to_skip_in_sample > 0);

   ComPtr<IMFSample> input_sample;

   const SbDrmSampleInfo* drm_info = input_buffer->drm_info();
   const uint8_t* key_id = NULL;
   int key_id_size = 0;
   bool encrypted = false;

   if (drm_info != NULL && drm_info->identifier_size == 16 &&
       (drm_info->initialization_vector_size == 8 ||
        drm_info->initialization_vector_size == 16)) {
     key_id = drm_info->identifier;
     key_id_size = drm_info->identifier_size;
     encrypted = true;
   }

   if (input_buffer == last_input_buffer_) {
     SB_DCHECK(last_input_sample_);
     input_sample = last_input_sample_;
   } else {
     if (input_buffer->size() < bytes_to_skip_in_sample) {
       SB_NOTREACHED();
       return false;
     }

     const void* data = input_buffer->data() + bytes_to_skip_in_sample;
     int size = input_buffer->size() - bytes_to_skip_in_sample;

     std::int64_t win32_timestamp = ConvertToWin32Time(input_buffer->pts());
     const uint8_t* iv = NULL;
     int iv_size = 0;
     const SbDrmSubSampleMapping* subsample_mapping = NULL;
     int subsample_count = 0;

     if (drm_info != NULL && drm_info->initialization_vector_size != 0) {
       if (bytes_to_skip_in_sample != 0) {
         if (drm_info->subsample_count != 0 && drm_info->subsample_count != 1) {
           return false;
         }
         if (drm_info->subsample_count == 1) {
           if (drm_info->subsample_mapping[0].clear_byte_count !=
               bytes_to_skip_in_sample) {
             return false;
           }
         }
       } else {
         subsample_mapping = drm_info->subsample_mapping;
         subsample_count = drm_info->subsample_count;
       }

       iv = drm_info->initialization_vector;
       iv_size = drm_info->initialization_vector_size;
     }

     // MFSampleExtension_CleanPoint is a key-frame for the video + audio. It is
     // not set here because the win32 system is smart enough to figure this out.
     // It will probably be totally ok to not set this at all. Resolution: If
     // there are problems with win32 video decoding, come back to this and see
     // if setting this will fix it. THis will be used if
     // SbMediaVideoSampleInfo::is_key_frame is true inside of the this function
     // (which will receive an InputBuffer).
     input_sample = CreateSample(data, size, win32_timestamp);

     if (encrypted) {
       AttachDrmDataToSample(input_sample, size, key_id, key_id_size, iv,
                             iv_size, subsample_mapping, subsample_count);
     }
     last_input_buffer_ = input_buffer;
     last_input_sample_ = input_sample;
   }

   if (encrypted) {
     if (!decryptor_) {
       if (decoder_.draining()) {
         return false;
       }
       if (!decoder_.drained()) {
         decoder_.Drain();
         return false;
       }
       decoder_.ResetFromDrained();
       scoped_refptr<SbDrmSystemPlayready::License> license =
           drm_system_->GetLicense(key_id, key_id_size);
       if (license && license->usable()) {
         decryptor_.reset(new MediaTransform(license->decryptor()));
         ActivateDecryptor();
       }
     }
     if (!decryptor_) {
       SB_NOTREACHED();
       return false;
     }
   }

   if (encrypted) {
     return decryptor_->TryWrite(input_sample);
   }
   return decoder_.TryWrite(input_sample);
 }

 bool DecryptingDecoder::ProcessAndRead(ComPtr<IMFSample>* output,
                                        ComPtr<IMFMediaType>* new_type) {
   bool did_something = false;

   *output = decoder_.TryRead(new_type);
   did_something = *output != NULL;

   if (decryptor_) {
     if (!pending_decryptor_output_) {
       ComPtr<IMFMediaType> ignored_type;
       pending_decryptor_output_ = decryptor_->TryRead(&ignored_type);
       did_something = pending_decryptor_output_ != NULL;
     }

     if (pending_decryptor_output_) {
       if (decoder_.TryWrite(pending_decryptor_output_)) {
         pending_decryptor_output_.Reset();
         did_something = true;
       }
     }

     if (decryptor_->drained() && !decoder_.draining() && !decoder_.drained()) {
       decoder_.Drain();
       did_something = true;
     }
   }

   return did_something;
 }

 void DecryptingDecoder::Drain() {
   if (decryptor_) {
     decryptor_->Drain();
   } else {
     decoder_.Drain();
   }
 }

 void DecryptingDecoder::ActivateDecryptor() {
   SB_DCHECK(decryptor_);

   ComPtr<IMFMediaType> decoder_output_type = decoder_.GetCurrentOutputType();
   decryptor_->SetInputType(decoder_.GetCurrentInputType());

   GUID original_sub_type;
   decoder_output_type->GetGUID(MF_MT_SUBTYPE, &original_sub_type);

   // Ensure that the decryptor and the decoder agrees on the protection of
   // samples transferred between them.
   ComPtr<IMFSampleProtection> decryption_sample_protection =
       decryptor_->GetSampleProtection();
   SB_DCHECK(decryption_sample_protection);

   DWORD decryption_protection_version;
   HRESULT hr = decryption_sample_protection->GetOutputProtectionVersion(
       &decryption_protection_version);
   CheckResult(hr);

   ComPtr<IMFSampleProtection> decoder_sample_protection =
       decoder_.GetSampleProtection();
   SB_DCHECK(decoder_sample_protection);

   DWORD decoder_protection_version;
   hr = decoder_sample_protection->GetInputProtectionVersion(
       &decoder_protection_version);
   CheckResult(hr);

   DWORD protection_version =
       std::min(decoder_protection_version, decryption_protection_version);
   if (protection_version < SAMPLE_PROTECTION_VERSION_RC4) {
     SB_NOTREACHED();
     return;
   }

   BYTE* cert_data = NULL;
   DWORD cert_data_size = 0;

   hr = decoder_sample_protection->GetProtectionCertificate(
       protection_version, &cert_data, &cert_data_size);
   CheckResult(hr);

   BYTE* crypt_seed = NULL;
   DWORD crypt_seed_size = 0;
   hr = decryption_sample_protection->InitOutputProtection(
       protection_version, 0, cert_data, cert_data_size, &crypt_seed,
       &crypt_seed_size);
   CheckResult(hr);

   hr = decoder_sample_protection->InitInputProtection(
       protection_version, 0, crypt_seed, crypt_seed_size);
   CheckResult(hr);

   CoTaskMemFree(cert_data);
   CoTaskMemFree(crypt_seed);

   // Ensure that the input type of the decoder is the output type of the
   // decryptor.
   ComPtr<IMFMediaType> decoder_input_type;
   std::vector<ComPtr<IMFMediaType>> decryptor_output_types =
       decryptor_->GetAvailableOutputTypes();
   SB_DCHECK(!decryptor_output_types.empty());

   decryptor_->SetOutputType(decryptor_output_types[0]);
   decoder_.SetInputType(decryptor_output_types[0]);

   std::vector<ComPtr<IMFMediaType>> decoder_output_types =
       decoder_.GetAvailableOutputTypes();
   for (auto output_type : decoder_output_types) {
     GUID sub_type;
     output_type->GetGUID(MF_MT_SUBTYPE, &sub_type);
     if (IsEqualGUID(sub_type, original_sub_type)) {
       decoder_.SetOutputType(output_type);
       return;
     }
   }
 }

 void DecryptingDecoder::Reset() {
   if (decryptor_) {
     decryptor_->Reset();
   }
   decoder_.Reset();

   last_input_buffer_ = nullptr;
   last_input_sample_ = nullptr;
 }

 }  // namespace win32
 }  // namespace shared
 }  // namespace starboard
	// Copyright 2017 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "starboard/shared/win32/decrypting_decoder.h"

	#include <algorithm>
	#include <numeric>

	#include "starboard/byte_swap.h"
	#include "starboard/common/ref_counted.h"
	#include "starboard/log.h"
	#include "starboard/memory.h"
	#include "starboard/shared/win32/error_utils.h"
	#include "starboard/shared/win32/media_foundation_utils.h"

	namespace starboard {
	namespace shared {
	namespace win32 {

	namespace {

	ComPtr<IMFSample> CreateSample(const void* data,
	int size,
	int64_t win32_timestamp) {
	ComPtr<IMFMediaBuffer> buffer;
	HRESULT hr = MFCreateMemoryBuffer(size, &buffer);
	CheckResult(hr);

	BYTE* buffer_ptr;
	hr = buffer->Lock(&buffer_ptr, 0, 0);
	CheckResult(hr);

	SbMemoryCopy(buffer_ptr, data, size);

	hr = buffer->Unlock();
	CheckResult(hr);

	hr = buffer->SetCurrentLength(size);
	CheckResult(hr);

	ComPtr<IMFSample> input;
	hr = MFCreateSample(&input);
	CheckResult(hr);

	hr = input->AddBuffer(buffer.Get());
	CheckResult(hr);

	// sample time is in 100 nanoseconds.
	input->SetSampleTime(win32_timestamp);
	return input;
	}

	void AttachDrmDataToSample(ComPtr<IMFSample> sample,
	int sample_size,
	const uint8_t* key_id,
	int key_id_size,
	const uint8_t* iv,
	int iv_size,
	const SbDrmSubSampleMapping* subsample_mapping,
	int subsample_count) {
	if (iv_size == 16 && SbMemoryIsZero(iv + 8, 8)) {
	// For iv that is 16 bytes long but the the last 8 bytes is 0, we treat
	// it as an 8 bytes iv.
	iv_size = 8;
	}
	sample->SetBlob(MFSampleExtension_Encryption_SampleID,
	reinterpret_cast<const UINT8*>(iv),
	static_cast<UINT32>(iv_size));
	SB_DCHECK(key_id_size == sizeof(GUID));
	GUID guid = reinterpret_cast<const GUID>(key_id);

	guid.Data1 = SbByteSwapU32(guid.Data1);
	guid.Data2 = SbByteSwapU16(guid.Data2);
	guid.Data3 = SbByteSwapU16(guid.Data3);

	sample->SetGUID(MFSampleExtension_Content_KeyID, guid);

	SB_DCHECK(sizeof(DWORD) * 2 == sizeof(SbDrmSubSampleMapping));

	SbDrmSubSampleMapping default_subsample = {0, sample_size};
	if (subsample_count == 0) {
	subsample_mapping = &default_subsample;
	subsample_count = 1;
	}
	sample->SetBlob(
	MFSampleExtension_Encryption_SubSampleMappingSplit,
	reinterpret_cast<const UINT8*>(subsample_mapping),
	static_cast<UINT32>(subsample_count * sizeof(SbDrmSubSampleMapping)));
	}

	} // namespace

	DecryptingDecoder::DecryptingDecoder(const std::string& type,
	CLSID clsid,
	SbDrmSystem drm_system)
	: type_(type), decoder_(clsid) {
	drm_system_ = static_cast<SbDrmSystemPlayready*>(drm_system);
	}

	DecryptingDecoder::~DecryptingDecoder() {
	Reset();
	}

	bool DecryptingDecoder::TryWriteInputBuffer(
	const scoped_refptr<InputBuffer>& input_buffer,
	int bytes_to_skip_in_sample) {
	SB_DCHECK(input_buffer);
	SB_DCHECK(bytes_to_skip_in_sample > 0);

	ComPtr<IMFSample> input_sample;

	const SbDrmSampleInfo* drm_info = input_buffer->drm_info();
	const uint8_t* key_id = NULL;
	int key_id_size = 0;
	bool encrypted = false;

	if (drm_info != NULL && drm_info->identifier_size == 16 &&
	(drm_info->initialization_vector_size == 8 \|\|
	drm_info->initialization_vector_size == 16)) {
	key_id = drm_info->identifier;
	key_id_size = drm_info->identifier_size;
	encrypted = true;
	}

	if (input_buffer == last_input_buffer_) {
	SB_DCHECK(last_input_sample_);
	input_sample = last_input_sample_;
	} else {
	if (input_buffer->size() < bytes_to_skip_in_sample) {
	SB_NOTREACHED();
	return false;
	}

	const void* data = input_buffer->data() + bytes_to_skip_in_sample;
	int size = input_buffer->size() - bytes_to_skip_in_sample;

	std::int64_t win32_timestamp = ConvertToWin32Time(input_buffer->pts());
	const uint8_t* iv = NULL;
	int iv_size = 0;
	const SbDrmSubSampleMapping* subsample_mapping = NULL;
	int subsample_count = 0;

	if (drm_info != NULL && drm_info->initialization_vector_size != 0) {
	if (bytes_to_skip_in_sample != 0) {
	if (drm_info->subsample_count != 0 && drm_info->subsample_count != 1) {
	return false;
	}
	if (drm_info->subsample_count == 1) {
	if (drm_info->subsample_mapping[0].clear_byte_count !=
	bytes_to_skip_in_sample) {
	return false;
	}
	}
	} else {
	subsample_mapping = drm_info->subsample_mapping;
	subsample_count = drm_info->subsample_count;
	}

	iv = drm_info->initialization_vector;
	iv_size = drm_info->initialization_vector_size;
	}

	// MFSampleExtension_CleanPoint is a key-frame for the video + audio. It is
	// not set here because the win32 system is smart enough to figure this out.
	// It will probably be totally ok to not set this at all. Resolution: If
	// there are problems with win32 video decoding, come back to this and see
	// if setting this will fix it. THis will be used if
	// SbMediaVideoSampleInfo::is_key_frame is true inside of the this function
	// (which will receive an InputBuffer).
	input_sample = CreateSample(data, size, win32_timestamp);

	if (encrypted) {
	AttachDrmDataToSample(input_sample, size, key_id, key_id_size, iv,
	iv_size, subsample_mapping, subsample_count);
	}
	last_input_buffer_ = input_buffer;
	last_input_sample_ = input_sample;
	}

	if (encrypted) {
	if (!decryptor_) {
	if (decoder_.draining()) {
	return false;
	}
	if (!decoder_.drained()) {
	decoder_.Drain();
	return false;
	}
	decoder_.ResetFromDrained();
	scoped_refptr<SbDrmSystemPlayready::License> license =
	drm_system_->GetLicense(key_id, key_id_size);
	if (license && license->usable()) {
	decryptor_.reset(new MediaTransform(license->decryptor()));
	ActivateDecryptor();
	}
	}
	if (!decryptor_) {
	SB_NOTREACHED();
	return false;
	}
	}

	if (encrypted) {
	return decryptor_->TryWrite(input_sample);
	}
	return decoder_.TryWrite(input_sample);
	}

	bool DecryptingDecoder::ProcessAndRead(ComPtr<IMFSample>* output,
	ComPtr<IMFMediaType>* new_type) {
	bool did_something = false;

	*output = decoder_.TryRead(new_type);
	did_something = *output != NULL;

	if (decryptor_) {
	if (!pending_decryptor_output_) {
	ComPtr<IMFMediaType> ignored_type;
	pending_decryptor_output_ = decryptor_->TryRead(&ignored_type);
	did_something = pending_decryptor_output_ != NULL;
	}

	if (pending_decryptor_output_) {
	if (decoder_.TryWrite(pending_decryptor_output_)) {
	pending_decryptor_output_.Reset();
	did_something = true;
	}
	}

	if (decryptor_->drained() && !decoder_.draining() && !decoder_.drained()) {
	decoder_.Drain();
	did_something = true;
	}
	}

	return did_something;
	}

	void DecryptingDecoder::Drain() {
	if (decryptor_) {
	decryptor_->Drain();
	} else {
	decoder_.Drain();
	}
	}

	void DecryptingDecoder::ActivateDecryptor() {
	SB_DCHECK(decryptor_);

	ComPtr<IMFMediaType> decoder_output_type = decoder_.GetCurrentOutputType();
	decryptor_->SetInputType(decoder_.GetCurrentInputType());

	GUID original_sub_type;
	decoder_output_type->GetGUID(MF_MT_SUBTYPE, &original_sub_type);

	// Ensure that the decryptor and the decoder agrees on the protection of
	// samples transferred between them.
	ComPtr<IMFSampleProtection> decryption_sample_protection =
	decryptor_->GetSampleProtection();
	SB_DCHECK(decryption_sample_protection);

	DWORD decryption_protection_version;
	HRESULT hr = decryption_sample_protection->GetOutputProtectionVersion(
	&decryption_protection_version);
	CheckResult(hr);

	ComPtr<IMFSampleProtection> decoder_sample_protection =
	decoder_.GetSampleProtection();
	SB_DCHECK(decoder_sample_protection);

	DWORD decoder_protection_version;
	hr = decoder_sample_protection->GetInputProtectionVersion(
	&decoder_protection_version);
	CheckResult(hr);

	DWORD protection_version =
	std::min(decoder_protection_version, decryption_protection_version);
	if (protection_version < SAMPLE_PROTECTION_VERSION_RC4) {
	SB_NOTREACHED();
	return;
	}

	BYTE* cert_data = NULL;
	DWORD cert_data_size = 0;

	hr = decoder_sample_protection->GetProtectionCertificate(
	protection_version, &cert_data, &cert_data_size);
	CheckResult(hr);

	BYTE* crypt_seed = NULL;
	DWORD crypt_seed_size = 0;
	hr = decryption_sample_protection->InitOutputProtection(
	protection_version, 0, cert_data, cert_data_size, &crypt_seed,
	&crypt_seed_size);
	CheckResult(hr);

	hr = decoder_sample_protection->InitInputProtection(
	protection_version, 0, crypt_seed, crypt_seed_size);
	CheckResult(hr);

	CoTaskMemFree(cert_data);
	CoTaskMemFree(crypt_seed);

	// Ensure that the input type of the decoder is the output type of the
	// decryptor.
	ComPtr<IMFMediaType> decoder_input_type;
	std::vector<ComPtr<IMFMediaType>> decryptor_output_types =
	decryptor_->GetAvailableOutputTypes();
	SB_DCHECK(!decryptor_output_types.empty());

	decryptor_->SetOutputType(decryptor_output_types[0]);
	decoder_.SetInputType(decryptor_output_types[0]);

	std::vector<ComPtr<IMFMediaType>> decoder_output_types =
	decoder_.GetAvailableOutputTypes();
	for (auto output_type : decoder_output_types) {
	GUID sub_type;
	output_type->GetGUID(MF_MT_SUBTYPE, &sub_type);
	if (IsEqualGUID(sub_type, original_sub_type)) {
	decoder_.SetOutputType(output_type);
	return;
	}
	}
	}

	void DecryptingDecoder::Reset() {
	if (decryptor_) {
	decryptor_->Reset();
	}
	decoder_.Reset();

	last_input_buffer_ = nullptr;
	last_input_sample_ = nullptr;
	}

	} // namespace win32
	} // namespace shared
	} // namespace starboard