utils.h

Go to the documentation of this file.

// Copyright 2017 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_UTILS_H_
#define SHAKA_EMBEDDED_UTILS_H_

#include <assert.h>

#include <iostream>
#include <limits>
#include <string>
#include <type_traits>

#include "macros.h"

namespace shaka {

enum class VideoFillMode : uint8_t {
  MaintainRatio,

  Stretch,

  Zoom,
};


template <typename T>
struct SHAKA_EXPORT ShakaRect {
  T x;
  T y;
  T w;
  T h;

  bool operator==(const ShakaRect& other) const {
    return x == other.x && y == other.y && w == other.w && h == other.h;
  }
  bool operator!=(const ShakaRect& other) const {
    return !(*this == other);
  }
};

template <typename T>
std::ostream& operator<<(std::ostream& os, const ShakaRect<T>& rect) {
  return os << "{x=" << rect.x << ",y=" << rect.y << ",w=" << rect.w << ",h="
            << rect.h << "}";
}

template <typename T>
struct SHAKA_EXPORT Rational final {
 private:
  template <typename U>
  using common = typename std::common_type<T, U>::type;
  template <typename U>
  using enable_if_num =
      typename std::enable_if<std::is_arithmetic<U>::value>::type;

  static T gcd(T a, T b) {
    // Calculate the gcd(a, b) using the euclidean algorithm.
    while (b != 0) {
      T temp = a % b;
      a = b;
      b = temp;
    }
    return a;
  }

  static void reduce(T* num, T* den) {
    T a = gcd(*num, *den);
    *num /= a;
    *den /= a;
  }

  Rational(T num1, T num2, T den1, T den2) {
    if (num1 == 0 || num2 == 0 || den1 == 0 || den2 == 0) {
      numerator = denominator = 0;
      return;
    }

    reduce(&num1, &den1);
    reduce(&num1, &den2);
    reduce(&num2, &den1);
    reduce(&num2, &den2);

    // Avoid errors later by just crashing on overflow.
    // TODO: Consider converting to float and rounding if this would overflow.
    assert(std::numeric_limits<T>::max() / num1 >= num2);
    assert(std::numeric_limits<T>::max() / den1 >= den2);

    // These should now be relatively prime since any common prime factor should
    // have been removed in the reductions above.
    numerator = num1 * num2;
    denominator = den1 * den2;
    assert(gcd(numerator, denominator) == 1);
  }

 public:
  Rational() = default;
  Rational(T num, T den) : Rational(num, 1, den, 1) {}

  T truncate() const {
    return numerator / denominator;
  }
  Rational<T> inverse() const {
    return {denominator, numerator};
  }

  operator bool() const {
    return numerator != 0 && denominator != 0;
  }
  operator double() const {
    return static_cast<double>(numerator) / denominator;
  }

  template <typename U>
  bool operator==(const Rational<U>& other) const {
    return numerator == other.numerator && denominator == other.denominator;
  }

  template <typename U>
  bool operator!=(const Rational<U>& other) const {
    return !(*this == other);
  }

  template <typename U>
  Rational<common<U>> operator*(const Rational<U>& other) const {
    return {numerator, other.numerator, denominator, other.denominator};
  }

  template <typename U, typename = enable_if_num<U>>
  Rational<common<U>> operator*(U other) const {
    return {numerator, other, denominator, 1};
  }

  template <typename U>
  Rational<common<U>> operator/(const Rational<U>& other) const {
    return {numerator, other.denominator, denominator, other.numerator};
  }

  template <typename U, typename = enable_if_num<U>>
  Rational<common<U>> operator/(U other) const {
    return {numerator, 1, denominator, other};
  }

  T numerator;
  T denominator;
};
static_assert(std::is_pod<Rational<int>>::value, "Rational should be POD");

template <typename T>
std::ostream& operator<<(std::ostream& os, const Rational<T>& bar) {
  return os << bar.numerator << "/" << bar.denominator;
}

// operator*(T, Rational<T>);
template <typename T, typename U, typename =
      typename std::enable_if<std::is_arithmetic<T>::value>::type>
Rational<typename std::common_type<T, U>::type> operator*(
    T a, const Rational<U>& b) {
  return Rational<T>{a, 1} * b;
}

// operator/(T, Rational<T>);
template <typename T, typename U, typename =
      typename std::enable_if<std::is_arithmetic<T>::value>::type>
Rational<typename std::common_type<T, U>::type> operator/(
    T a, const Rational<U>& b) {
  return b.inverse() * a;
}


SHAKA_EXPORT void FitVideoToRegion(ShakaRect<uint32_t> frame,
                                   ShakaRect<uint32_t> bounds,
                                   Rational<uint32_t> sample_aspect_ratio,
                                   VideoFillMode mode, ShakaRect<uint32_t>* src,
                                   ShakaRect<uint32_t>* dest);


inline std::string EscapeKeySystem(const std::string& key_system) {
  std::string ret = key_system;
  std::string::size_type pos = 0;
  while ((pos = ret.find('.', pos)) != std::string::npos) {
    ret.insert(pos, "\\");
    pos += 2;
  }
  return ret;
}

inline std::string LicenseServerConfig(const std::string& key_system) {
  return "drm.servers." + EscapeKeySystem(key_system);
}

inline std::string AdvancedDrmConfig(const std::string& key_system,
                                     const std::string& property) {
  return "drm.advanced." + EscapeKeySystem(key_system) + "." + property;
}

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_UTILS_H_