chunking_handler.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_CHUNKING_CHUNKING_HANDLER_
#define PACKAGER_MEDIA_CHUNKING_CHUNKING_HANDLER_

#include <atomic>

#include "packager/media/base/media_handler.h"

namespace shaka {
namespace media {

struct ChunkingOptions {
  double segment_duration_in_seconds = 0;

  double subsegment_duration_in_seconds = 0;

  bool segment_sap_aligned = true;

  bool subsegment_sap_aligned = true;
};

class ChunkingHandler : public MediaHandler {
 public:
  explicit ChunkingHandler(const ChunkingOptions& chunking_options);
  ~ChunkingHandler() override;

 protected:
  Status InitializeInternal() override;
  Status Process(std::unique_ptr<StreamData> stream_data) override;
  Status OnFlushRequest(size_t input_stream_index) override;

 private:
  friend class ChunkingHandlerTest;

  ChunkingHandler(const ChunkingHandler&) = delete;
  ChunkingHandler& operator=(const ChunkingHandler&) = delete;

  // Processes media sample and apply chunking if needed.
  Status ProcessMediaSample(const MediaSample* sample);

  // Dispatch cached non main stream samples before |timestamp_threshold|.
  Status DispatchNonMainSamples(int64_t timestamp_threshold);

  // The (sub)segments are aligned and dispatched together.
  Status DispatchSegmentInfoForAllStreams();
  Status DispatchSubsegmentInfoForAllStreams();

  const ChunkingOptions chunking_options_;

  // The inputs are expected to come from the same thread.
  std::atomic<int64_t> thread_id_;

  // The video stream is the main stream; if there is only one stream, it is the
  // main stream. The chunking is based on the main stream.
  const size_t kInvalidStreamIndex = static_cast<size_t>(-1);
  size_t main_stream_index_ = kInvalidStreamIndex;
  // Segment and subsegment duration in main stream's time scale.
  int64_t segment_duration_ = 0;
  int64_t subsegment_duration_ = 0;

  // The streams are expected to be synchronized. Cache non main (video) stream
  // samples so we can determine whether the next segment should include these
  // samples. The samples will be dispatched after seeing the next main stream
  // sample.
  std::deque<std::unique_ptr<StreamData>> non_main_samples_;

  // Current segment index, useful to determine where to do chunking.
  int64_t current_segment_index_ = -1;
  // Current subsegment index, useful to determine where to do chunking.
  int64_t current_subsegment_index_ = -1;

  std::vector<std::shared_ptr<SegmentInfo>> segment_info_;
  std::vector<std::shared_ptr<SegmentInfo>> subsegment_info_;
  std::vector<uint32_t> time_scales_;
  // The end timestamp of the last dispatched sample.
  std::vector<int64_t> last_sample_end_timestamps_;
};

}  // namespace media
}  // namespace shaka

#endif  // PACKAGER_MEDIA_CHUNKING_CHUNKING_HANDLER_