chunking_handler.h

// Copyright 2017 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_CHUNKING_CHUNKING_HANDLER_
#define PACKAGER_MEDIA_CHUNKING_CHUNKING_HANDLER_
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
 
#include <packager/chunking_params.h>
#include <packager/media/base/media_handler.h>
#include <packager/media/base/media_sample.h>
#include <packager/media/base/stream_info.h>
#include <packager/media/base/timestamp_util.h>
#include <packager/status.h>
 
namespace shaka {
namespace media {
 
class ChunkingHandler : public MediaHandler {
 public:
  explicit ChunkingHandler(const ChunkingParams& chunking_params);
  ~ChunkingHandler() override = default;
 
 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;
 
  Status OnStreamInfo(std::shared_ptr<const StreamInfo> info);
  Status OnCueEvent(std::shared_ptr<const CueEvent> event);
  Status OnMediaSample(std::shared_ptr<const MediaSample> sample);
 
  Status EndSegmentIfStarted();
  Status EndSubsegmentIfStarted() const;
 
  bool IsSubsegmentEnabled() {
    return subsegment_duration_ > 0 &&
           subsegment_duration_ != segment_duration_;
  }
 
  const ChunkingParams chunking_params_;
 
  // Segment and subsegment duration in stream's time scale.
  int64_t segment_duration_ = 0;
  int64_t subsegment_duration_ = 0;
 
  // Segment number that keeps monotically increasing.
  // Set to start_segment_number in constructor.
  int64_t segment_number_ = 1;
 
  // 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::optional<int64_t> segment_start_time_;
  std::optional<int64_t> subsegment_start_time_;
  int64_t max_segment_time_ = 0;
  int32_t time_scale_ = 0;
 
  // The offset is applied to sample timestamps so a full segment is generated
  // after cue points.
  int64_t cue_offset_ = 0;
 
  // Unwraps 33-bit PTS/DTS timestamps to 64-bit monotonically increasing
  // values, handling wrap-around at 2^33. This ensures SegmentInfo timestamps
  // are always increasing even when input timestamps wrap around.
  PtsUnwrapper pts_unwrapper_;
};
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_CHUNKING_CHUNKING_HANDLER_