frames.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_FRAMES_H_
#define SHAKA_EMBEDDED_MEDIA_FRAMES_H_

#include <iostream>
#include <memory>
#include <vector>

#include "../eme/configuration.h"
#include "../eme/implementation.h"
#include "../macros.h"
#include "../variant.h"
#include "stream_info.h"

namespace shaka {
namespace media {

enum class MediaStatus : uint8_t {
  Success,

  FatalError,

  KeyNotFound,
};

enum class PixelFormat : uint8_t {
  Unknown,

  YUV420P,

  NV12,

  RGB24,


  VideoToolbox,

  //{
  AppFormat1 = 128,
  AppFormat2 = 129,
  AppFormat3 = 130,
  AppFormat4 = 131,
  //}
};

SHAKA_EXPORT std::ostream& operator<<(std::ostream& os, PixelFormat format);

enum class SampleFormat : uint8_t {
  Unknown,

  PackedU8,
  PackedS16,
  PackedS32,
  PackedS64,
  PackedFloat,
  PackedDouble,

  PlanarU8,
  PlanarS16,
  PlanarS32,
  PlanarS64,
  PlanarFloat,
  PlanarDouble,

  //{
  AppFormat1 = 128,
  AppFormat2 = 129,
  AppFormat3 = 130,
  AppFormat4 = 131,
  //}
};

SHAKA_EXPORT std::ostream& operator<<(std::ostream& os, SampleFormat format);

inline std::ostream& operator<<(std::ostream& os,
                                variant<PixelFormat, SampleFormat> format) {
  if (holds_alternative<PixelFormat>(format))
    return os << get<PixelFormat>(format);
  else
    return os << get<SampleFormat>(format);
}

SHAKA_EXPORT bool IsPlanarFormat(variant<PixelFormat, SampleFormat> format);

SHAKA_EXPORT size_t GetPlaneCount(variant<PixelFormat, SampleFormat> format,
                                  size_t channels);


class SHAKA_EXPORT BaseFrame {
 public:
  BaseFrame(std::shared_ptr<const StreamInfo> stream_info, double pts,
            double dts, double duration, bool is_key_frame);
  virtual ~BaseFrame();

  SHAKA_NON_COPYABLE_OR_MOVABLE_TYPE(BaseFrame);

  const std::shared_ptr<const StreamInfo> stream_info;

  const double pts;

  const double dts;

  const double duration;

  const bool is_key_frame;

  virtual size_t EstimateSize() const;

 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};

class SHAKA_EXPORT EncodedFrame : public BaseFrame {
 public:
  EncodedFrame(std::shared_ptr<const StreamInfo> stream, double pts, double dts,
               double duration, bool is_key_frame, const uint8_t* data,
               size_t data_size, double timestamp_offset,
               std::shared_ptr<eme::FrameEncryptionInfo> encryption_info);
  ~EncodedFrame() override;

  const uint8_t* const data;

  const size_t data_size;

  const double timestamp_offset;

  const std::shared_ptr<eme::FrameEncryptionInfo> encryption_info;


  virtual MediaStatus Decrypt(const eme::Implementation* implementation,
                              uint8_t* dest) const;


  size_t EstimateSize() const override;

 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};

class SHAKA_EXPORT DecodedFrame : public BaseFrame {
 public:
  DecodedFrame(std::shared_ptr<const StreamInfo> stream_info, double pts,
               double dts, double duration,
               variant<PixelFormat, SampleFormat> format, size_t sample_count,
               const std::vector<const uint8_t*>& data,
               const std::vector<size_t>& linesize);
  ~DecodedFrame() override;

  const size_t sample_count;


  const std::vector<const uint8_t*> data;

  const std::vector<size_t> linesize;

  const variant<PixelFormat, SampleFormat> format;


  size_t EstimateSize() const override;

 private:
  class Impl;
  std::unique_ptr<Impl> impl_;
};

}  // namespace media
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEDIA_FRAMES_H_