129 lines
4.1 KiB
C++
129 lines
4.1 KiB
C++
// Copyright 2014 Google Inc. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
#include "media/base/encryption_key_source.h"
|
|
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "media/base/aes_encryptor.h"
|
|
#include "media/base/buffer_writer.h"
|
|
|
|
namespace {
|
|
const uint8 kWidevineSystemId[] = {0xed, 0xef, 0x8b, 0xa9, 0x79, 0xd6,
|
|
0x4a, 0xce, 0xa3, 0xc8, 0x27, 0xdc,
|
|
0xd5, 0x1d, 0x21, 0xed};
|
|
} // namespace
|
|
|
|
namespace media {
|
|
|
|
EncryptionKey::EncryptionKey() {}
|
|
EncryptionKey::~EncryptionKey() {}
|
|
|
|
EncryptionKeySource::~EncryptionKeySource() {}
|
|
|
|
Status EncryptionKeySource::GetKey(TrackType track_type, EncryptionKey* key) {
|
|
DCHECK(key);
|
|
DCHECK(encryption_key_);
|
|
*key = *encryption_key_;
|
|
return Status::OK;
|
|
}
|
|
|
|
Status EncryptionKeySource::GetCryptoPeriodKey(size_t crypto_period_index,
|
|
TrackType track_type,
|
|
EncryptionKey* key) {
|
|
NOTIMPLEMENTED();
|
|
return Status(error::UNIMPLEMENTED, "");
|
|
}
|
|
|
|
scoped_ptr<EncryptionKeySource> EncryptionKeySource::CreateFromHexStrings(
|
|
const std::string& key_id_hex,
|
|
const std::string& key_hex,
|
|
const std::string& pssh_data_hex,
|
|
const std::string& iv_hex) {
|
|
scoped_ptr<EncryptionKey> encryption_key(new EncryptionKey());
|
|
|
|
if (!base::HexStringToBytes(key_id_hex, &encryption_key->key_id)) {
|
|
LOG(ERROR) << "Cannot parse key_id_hex " << key_id_hex;
|
|
return scoped_ptr<EncryptionKeySource>();
|
|
}
|
|
|
|
if (!base::HexStringToBytes(key_hex, &encryption_key->key)) {
|
|
LOG(ERROR) << "Cannot parse key_hex " << key_hex;
|
|
return scoped_ptr<EncryptionKeySource>();
|
|
}
|
|
|
|
std::vector<uint8> pssh_data;
|
|
if (!base::HexStringToBytes(pssh_data_hex, &pssh_data)) {
|
|
LOG(ERROR) << "Cannot parse pssh_hex " << pssh_data_hex;
|
|
return scoped_ptr<EncryptionKeySource>();
|
|
}
|
|
|
|
if (!iv_hex.empty()) {
|
|
if (!base::HexStringToBytes(iv_hex, &encryption_key->iv)) {
|
|
LOG(ERROR) << "Cannot parse iv_hex " << iv_hex;
|
|
return scoped_ptr<EncryptionKeySource>();
|
|
}
|
|
}
|
|
|
|
encryption_key->pssh = PsshBoxFromPsshData(pssh_data);
|
|
return scoped_ptr<EncryptionKeySource>(
|
|
new EncryptionKeySource(encryption_key.Pass()));
|
|
}
|
|
|
|
EncryptionKeySource::TrackType EncryptionKeySource::GetTrackTypeFromString(
|
|
const std::string& track_type_string) {
|
|
if (track_type_string == "SD")
|
|
return TRACK_TYPE_SD;
|
|
if (track_type_string == "HD")
|
|
return TRACK_TYPE_HD;
|
|
if (track_type_string == "AUDIO")
|
|
return TRACK_TYPE_AUDIO;
|
|
LOG(WARNING) << "Unexpected track type: " << track_type_string;
|
|
return TRACK_TYPE_UNKNOWN;
|
|
}
|
|
|
|
std::string EncryptionKeySource::TrackTypeToString(TrackType track_type) {
|
|
switch (track_type) {
|
|
case TRACK_TYPE_SD:
|
|
return "SD";
|
|
case TRACK_TYPE_HD:
|
|
return "HD";
|
|
case TRACK_TYPE_AUDIO:
|
|
return "AUDIO";
|
|
default:
|
|
NOTIMPLEMENTED() << "Unknown track type: " << track_type;
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
std::vector<uint8> EncryptionKeySource::PsshBoxFromPsshData(
|
|
const std::vector<uint8>& pssh_data) {
|
|
const uint8 kPsshFourCC[] = {'p', 's', 's', 'h'};
|
|
const uint32 kVersionAndFlags = 0;
|
|
|
|
const uint32 pssh_data_size = pssh_data.size();
|
|
const uint32 total_size =
|
|
sizeof(total_size) + sizeof(kPsshFourCC) + sizeof(kVersionAndFlags) +
|
|
sizeof(kWidevineSystemId) + sizeof(pssh_data_size) + pssh_data_size;
|
|
|
|
BufferWriter writer;
|
|
writer.AppendInt(total_size);
|
|
writer.AppendArray(kPsshFourCC, sizeof(kPsshFourCC));
|
|
writer.AppendInt(kVersionAndFlags);
|
|
writer.AppendArray(kWidevineSystemId, sizeof(kWidevineSystemId));
|
|
writer.AppendInt(pssh_data_size);
|
|
writer.AppendVector(pssh_data);
|
|
return std::vector<uint8>(writer.Buffer(), writer.Buffer() + writer.Size());
|
|
}
|
|
|
|
EncryptionKeySource::EncryptionKeySource() {}
|
|
EncryptionKeySource::EncryptionKeySource(
|
|
scoped_ptr<EncryptionKey> encryption_key)
|
|
: encryption_key_(encryption_key.Pass()) {
|
|
DCHECK(encryption_key_);
|
|
}
|
|
|
|
} // namespace media
|