streams.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_STREAMS_H_
#define SHAKA_EMBEDDED_MEDIA_STREAMS_H_

#include <memory>
#include <type_traits>
#include <vector>

#include "../macros.h"
#include "frames.h"

namespace shaka {
namespace media {

enum class FrameLocation : uint8_t {
  KeyFrameBefore,
  Near,
  After,
};


struct SHAKA_EXPORT BufferedRange {
  BufferedRange() = default;
  BufferedRange(double start, double end) : start(start), end(end) {}

  bool operator==(const BufferedRange& other) const {
    return start == other.start && end == other.end;
  }
  bool operator!=(const BufferedRange& other) const {
    return !(*this == other);
  }

  double start;
  double end;
};
static_assert(std::is_pod<BufferedRange>::value, "BufferedRange should be POD");


class SHAKA_EXPORT StreamBase {
 public:
  static constexpr const double kMaxGapSize = 0.15;


  explicit StreamBase(bool order_by_dts);
  ~StreamBase();

  SHAKA_NON_COPYABLE_OR_MOVABLE_TYPE(StreamBase);

  size_t CountFramesBetween(double start, double end) const;

  std::vector<BufferedRange> GetBufferedRanges() const;

  size_t EstimateSize() const;


  void Remove(double start, double end);

  void Clear();


  void DebugPrint(bool all_frames) const;

 protected:
  std::shared_ptr<BaseFrame> GetFrameInternal(double time,
                                              FrameLocation kind) const;

  void AddFrameInternal(std::shared_ptr<BaseFrame> frame);

 private:
  void AssertRangesSorted() const;

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


template <typename T, bool OrderByDts>
class SHAKA_EXPORT Stream : public StreamBase {
 public:
  Stream() : StreamBase(OrderByDts) {}

  void AddFrame(std::shared_ptr<T> frame) {
    AddFrameInternal(frame);
  }

  std::shared_ptr<T> GetFrame(
      double time, FrameLocation kind = FrameLocation::After) const {
    auto ret = GetFrameInternal(time, kind);
    return std::shared_ptr<T>(ret, static_cast<T*>(ret.get()));
  }
};


using ElementaryStream = Stream<EncodedFrame, true>;
using DecodedStream = Stream<DecodedFrame, false>;

}  // namespace media
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEDIA_STREAMS_H_