dvb_image.h

// Copyright 2020 Google LLC. 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_DVB_DVB_IMAGE_H_
#define PACKAGER_MEDIA_DVB_DVB_IMAGE_H_
 
#include <memory>
#include <type_traits>
 
namespace shaka {
namespace media {
 
struct RgbaColor {
  uint8_t r;
  uint8_t g;
  uint8_t b;
  uint8_t a;
 
  bool operator==(const RgbaColor& other) const {
    return r == other.r && g == other.g && b == other.b && a == other.a;
  }
  bool operator!=(const RgbaColor& other) const { return !(*this == other); }
};
// To avoid copying, we pass an RgbaColor array as a uint8_t* pointer to libpng
// for RGBA.
static_assert(std::is_pod<RgbaColor>::value, "RgbaColor must be POD");
static_assert(sizeof(RgbaColor) == 4, "RgbaColor not packed correctly");
 
enum class BitDepth : uint8_t {
  k2Bit,
  k4Bit,
  k8Bit,
};
 
class DvbImageColorSpace {
 public:
  DvbImageColorSpace();
  ~DvbImageColorSpace();
 
  DvbImageColorSpace(const DvbImageColorSpace&) = delete;
  DvbImageColorSpace& operator=(const DvbImageColorSpace&) = delete;
 
  RgbaColor GetColor(BitDepth bit_depth, uint8_t entry_id) const;
 
  void SetColor(BitDepth bit_depth, uint8_t entry_id, RgbaColor color);
  void Set2To4BitDepthMap(const uint8_t* map);
  void Set2To8BitDepthMap(const uint8_t* map);
  void Set4To8BitDepthMap(const uint8_t* map);
 
 private:
  RgbaColor GetColorRaw(BitDepth bit_depth, uint8_t entry_id) const;
 
  // These hold the colors for each entry ID.  Each value is initialized to the
  // special value kNoColor meaning there isn't a value present.
  RgbaColor color_map_2_[4];
  RgbaColor color_map_4_[16];
  RgbaColor color_map_8_[256];
  // See ETSI EN 300 743 Sections 10.4, 10.5, 10.6 for defaults.
  uint8_t bit_depth_2_to_4_[4] = {0x0, 0x7, 0x8, 0xf};
  uint8_t bit_depth_2_to_8_[4] = {0x0, 0x77, 0x88, 0xff};
  uint8_t bit_depth_4_to_8_[16] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55,
                                   0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
                                   0xcc, 0xdd, 0xee, 0xff};
};
 
class DvbImageBuilder {
 public:
  DvbImageBuilder(const DvbImageColorSpace* color_space,
                  const RgbaColor& default_color,
                  uint16_t max_width,
                  uint16_t max_height);
  ~DvbImageBuilder();
 
  DvbImageBuilder(const DvbImageBuilder&) = delete;
  DvbImageBuilder& operator=(const DvbImageBuilder&) = delete;
 
  uint16_t max_width() const { return max_width_; }
  uint16_t max_height() const { return max_height_; }
 
  bool AddPixel(BitDepth bit_depth, uint8_t byte_code, bool is_top_rows);
  void NewRow(bool is_top_rows);
  void MirrorToBottomRows();
 
  bool GetPixels(const RgbaColor** pixels,
                 uint16_t* width,
                 uint16_t* height) const;
 
 private:
  struct Position {
    uint16_t x, y;
  };
 
  const std::unique_ptr<RgbaColor[]> pixels_;
  const DvbImageColorSpace* const color_space_;
  Position top_pos_, bottom_pos_;
  const uint16_t max_width_;
  const uint16_t max_height_;
  uint16_t width_;
};
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_DVB_DVB_IMAGE_H_