crypto_params.h

// Copyright 2017 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

#ifndef PACKAGER_MEDIA_PUBLIC_CRYPTO_PARAMS_H_
#define PACKAGER_MEDIA_PUBLIC_CRYPTO_PARAMS_H_

#include <functional>
#include <map>
#include <string>
#include <vector>

namespace shaka {

enum class KeyProvider {
  kNone = 0,
  kWidevine = 1,
  kPlayReady = 2,
  kRawKey = 3,
};

struct WidevineSigner {
  std::string signer_name;

  enum class SigningKeyType {
    kNone,
    kAes,
    kRsa,
  };
  SigningKeyType signing_key_type = SigningKeyType::kNone;
  struct {
    std::vector<uint8_t> key;
    std::vector<uint8_t> iv;
  } aes;
  struct {
    std::string key;
  } rsa;
};

struct WidevineEncryptionParams {
  std::string key_server_url;
  std::vector<uint8_t> content_id;
  std::string policy;
  WidevineSigner signer;
  std::vector<uint8_t> group_id;
  bool enable_entitlement_license;
};

struct PlayReadyEncryptionParams {
  std::string key_server_url;
  std::string program_identifier;
  std::string ca_file;
  std::string client_cert_file;
  std::string client_cert_private_key_file;
  std::string client_cert_private_key_password;
};

struct RawKeyParams {
  std::vector<uint8_t> iv;
  std::vector<uint8_t> pssh;

  using StreamLabel = std::string;
  struct KeyInfo {
    std::vector<uint8_t> key_id;
    std::vector<uint8_t> key;
  };
  std::map<StreamLabel, KeyInfo> key_map;
};

struct EncryptionParams {
  KeyProvider key_provider = KeyProvider::kNone;
  // Only one of the three fields is valid.
  WidevineEncryptionParams widevine;
  PlayReadyEncryptionParams playready;
  RawKeyParams raw_key;

  enum class ProtectionSystem {
    kCommonSystem,
    kFairPlay,
    kPlayReady,
    kWidevine,
  };
  std::vector<ProtectionSystem> protection_systems;

  double clear_lead_in_seconds = 0;
  static constexpr uint32_t kProtectionSchemeCenc = 0x63656E63;
  static constexpr uint32_t kProtectionSchemeCbc1 = 0x63626331;
  static constexpr uint32_t kProtectionSchemeCens = 0x63656E73;
  static constexpr uint32_t kProtectionSchemeCbcs = 0x63626373;
  uint32_t protection_scheme = kProtectionSchemeCenc;
  static constexpr double kNoKeyRotation = 0;
  double crypto_period_duration_in_seconds = kNoKeyRotation;
  bool vp9_subsample_encryption = true;

  struct EncryptedStreamAttributes {
    enum StreamType {
      kUnknown,
      kVideo,
      kAudio,
    };

    StreamType stream_type = kUnknown;
    union OneOf {
      OneOf() {}

      struct {
        int width = 0;
        int height = 0;
        float frame_rate = 0;
        int bit_depth = 0;
      } video;

      struct {
        int number_of_channels = 0;
      } audio;
    } oneof;
  };
  std::function<std::string(const EncryptedStreamAttributes& stream_attributes)>
      stream_label_func;
};

struct WidevineDecryptionParams {
  std::string key_server_url;
  WidevineSigner signer;
};

struct DecryptionParams {
  KeyProvider key_provider = KeyProvider::kNone;
  // Only one of the two fields is valid.
  WidevineDecryptionParams widevine;
  RawKeyParams raw_key;
};

}  // namespace shaka

#endif  // PACKAGER_MEDIA_PUBLIC_CRYPTO_PARAMS_H_