muxer_listener.h

// Copyright 2014 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
//
// Event handler for events fired by Muxer.
 
#ifndef PACKAGER_MEDIA_EVENT_MUXER_LISTENER_H_
#define PACKAGER_MEDIA_EVENT_MUXER_LISTENER_H_
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include <packager/macros/classes.h>
#include <packager/macros/compiler.h>
#include <packager/media/base/fourccs.h>
#include <packager/media/base/range.h>
 
namespace shaka {
namespace media {
 
struct MuxerOptions;
struct ProtectionSystemSpecificInfo;
class StreamInfo;
 
class MuxerListener {
 public:
  enum ContainerType {
    kContainerUnknown = 0,
    kContainerMp4,
    kContainerMpeg2ts,
    kContainerWebM,
    kContainerText,
    kContainerPackedAudio,
  };
 
  struct MediaRanges {
    std::optional<Range> init_range;
    std::optional<Range> index_range;
    std::vector<Range> subsegment_ranges;
  };
 
  virtual ~MuxerListener() = default;
 
  virtual void OnEncryptionInfoReady(
      bool is_initial_encryption_info,
      FourCC protection_scheme,
      const std::vector<uint8_t>& key_id,
      const std::vector<uint8_t>& iv,
      const std::vector<ProtectionSystemSpecificInfo>& key_system_info) = 0;
 
  virtual void OnEncryptionStart() = 0;
 
  virtual void OnMediaStart(const MuxerOptions& muxer_options,
                            const StreamInfo& stream_info,
                            int32_t time_scale,
                            ContainerType container_type) = 0;
 
  virtual void OnAvailabilityOffsetReady() {}
 
  virtual void OnSampleDurationReady(int32_t sample_duration) = 0;
 
  virtual void OnSegmentDurationReady() {}
 
  virtual void OnMediaEnd(const MediaRanges& media_ranges,
                          float duration_seconds) = 0;
 
  virtual void OnNewSegment(const std::string& segment_name,
                            int64_t start_time,
                            int64_t duration,
                            uint64_t segment_file_size,
                            int64_t segment_number) = 0;
 
  virtual void OnCompletedSegment(int64_t duration,
                                  uint64_t segment_file_size) {
    UNUSED(duration);
    UNUSED(segment_file_size);
  }
 
  virtual void OnKeyFrame(int64_t timestamp,
                          uint64_t start_byte_offset,
                          uint64_t size) = 0;
 
  virtual void OnCueEvent(int64_t timestamp, const std::string& cue_data) = 0;
 
 protected:
  MuxerListener() = default;
};
 
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_EVENT_MUXER_LISTENER_H_