media_capabilities.h

Go to the documentation of this file.

// Copyright 2019 Google LLC
//
// 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
//
//     https://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.

#ifndef SHAKA_EMBEDDED_MEDIA_MEDIA_CAPABILITIES_H_
#define SHAKA_EMBEDDED_MEDIA_MEDIA_CAPABILITIES_H_

#include <string>
#include <vector>

#include "../eme/configuration.h"
#include "../macros.h"

namespace shaka {
namespace media {


enum class MediaDecodingType : uint8_t {
  File,

  MediaSource,
};

enum class HdrMetadataType : uint8_t {
  Unspecified,
  SmpteSt2086,
  SmpteSt2094_10,
  SmpteSt2094_40,
};

enum class ColorGamut : uint8_t {
  Unspecified,

  SRGB,

  P3,

  REC2020,
};

enum class TransferFunction : uint8_t {
  Unspecified,

  SRGB,

  PQ,

  HLG,
};

struct SHAKA_EXPORT VideoConfiguration final {
  SHAKA_DECLARE_STRUCT_SPECIAL_METHODS(VideoConfiguration);

  std::string content_type;

  uint32_t width;

  uint32_t height;

  uint64_t bitrate;

  double framerate;

  bool has_alpha_channel;

  HdrMetadataType hdr_metadata_type;

  ColorGamut color_gamut;

  TransferFunction transfer_function;
};

struct SHAKA_EXPORT AudioConfiguration final {
  SHAKA_DECLARE_STRUCT_SPECIAL_METHODS(AudioConfiguration);

  std::string content_type;

  uint16_t channels;

  uint64_t bitrate;

  uint32_t samplerate;

  bool spatial_rendering;
};

struct SHAKA_EXPORT KeySystemTrackConfiguration final {
  SHAKA_DECLARE_STRUCT_SPECIAL_METHODS(KeySystemTrackConfiguration);

  std::string robustness;
};

struct SHAKA_EXPORT MediaCapabilitiesKeySystemConfiguration final {
  SHAKA_DECLARE_STRUCT_SPECIAL_METHODS(MediaCapabilitiesKeySystemConfiguration);

  std::string key_system;

  eme::MediaKeyInitDataType init_data_type;

  eme::MediaKeysRequirement distinctive_identifier;

  eme::MediaKeysRequirement persistent_state;

  std::vector<eme::MediaKeySessionType> session_types;

  KeySystemTrackConfiguration audio;

  KeySystemTrackConfiguration video;
};

struct SHAKA_EXPORT MediaDecodingConfiguration final {
  SHAKA_DECLARE_STRUCT_SPECIAL_METHODS(MediaDecodingConfiguration);

  MediaDecodingType type;

  VideoConfiguration video;

  AudioConfiguration audio;

  MediaCapabilitiesKeySystemConfiguration key_system_configuration;
};

struct SHAKA_EXPORT MediaCapabilitiesInfo final {
  SHAKA_DECLARE_STRUCT_SPECIAL_METHODS(MediaCapabilitiesInfo);

  bool supported;

  bool smooth;

  bool power_efficient;


  MediaCapabilitiesInfo operator&(const MediaCapabilitiesInfo& other) const {
    MediaCapabilitiesInfo ret;
    ret.supported = supported & other.supported;
    ret.smooth = supported & other.smooth;
    ret.power_efficient = supported & other.power_efficient;
    return ret;
  }
};


}  // namespace media
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEDIA_MEDIA_CAPABILITIES_H_