text_sample.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_BASE_TEXT_SAMPLE_H_
#define PACKAGER_MEDIA_BASE_TEXT_SAMPLE_H_
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include "packager/base/optional.h"
 
namespace shaka {
namespace media {
 
enum class TextUnitType {
  kPixels,
  kLines,
  kPercent,
};
 
enum class WritingDirection {
  kHorizontal,
  kVerticalGrowingLeft,
  kVerticalGrowingRight,
};
 
enum class TextAlignment {
  kStart,
  kCenter,
  kEnd,
  kLeft,
  kRight,
};
 
struct TextNumber {
  TextNumber(float value, TextUnitType type) : value(value), type(type) {}
 
  float value;
  TextUnitType type;
};
 
struct TextSettings {
  base::Optional<TextNumber> line;
  base::Optional<TextNumber> position;
  base::Optional<TextNumber> width;
  base::Optional<TextNumber> height;
 
  std::string region;
 
  WritingDirection writing_direction = WritingDirection::kHorizontal;
  TextAlignment text_alignment = TextAlignment::kCenter;
};
 
struct TextFragmentStyle {
  base::Optional<bool> underline;
  base::Optional<bool> bold;
  base::Optional<bool> italic;
};
 
struct TextFragment {
  TextFragment() {}
  TextFragment(const TextFragmentStyle& style,
               const std::vector<TextFragment>& sub_fragments)
      : style(style), sub_fragments(sub_fragments) {}
  TextFragment(const TextFragmentStyle& style, const char* body)
      : style(style), body(body) {}
  TextFragment(const TextFragmentStyle& style, const std::string& body)
      : style(style), body(body) {}
  TextFragment(const TextFragmentStyle& style,
               const std::vector<uint8_t>& image)
      : style(style), image(image) {}
  TextFragment(const TextFragmentStyle& style, bool newline)
      : style(style), newline(newline) {}
 
  TextFragmentStyle style;
 
  std::vector<TextFragment> sub_fragments;
  std::string body;
  std::vector<uint8_t> image;
  bool newline = false;
 
  bool is_empty() const;
};
 
class TextSample {
 public:
  TextSample(const std::string& id,
             int64_t start_time,
             int64_t end_time,
             const TextSettings& settings,
             const TextFragment& body);
 
  const std::string& id() const { return id_; }
  int64_t start_time() const { return start_time_; }
  int64_t duration() const { return duration_; }
  const TextSettings& settings() const { return settings_; }
  const TextFragment& body() const { return body_; }
  int64_t EndTime() const;
 
  int32_t sub_stream_index() const { return sub_stream_index_; }
  void set_sub_stream_index(int32_t idx) { sub_stream_index_ = idx; }
 
 private:
  // Allow the compiler generated copy constructor and assignment operator
  // intentionally. Since the text data is typically small, the performance
  // impact is minimal.
 
  const std::string id_;
  const int64_t start_time_ = 0;
  const int64_t duration_ = 0;
  const TextSettings settings_;
  const TextFragment body_;
  int32_t sub_stream_index_ = -1;
};
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_BASE_TEXT_SAMPLE_H_