media_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_BASE_MEDIA_HANDLER_H_
#define PACKAGER_MEDIA_BASE_MEDIA_HANDLER_H_

#include <map>
#include <memory>
#include <utility>

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

namespace shaka {
namespace media {

class MediaHandler {
 public:
  MediaHandler() = default;
  virtual ~MediaHandler() = default;

  Status SetHandler(int output_stream_index,
                    std::shared_ptr<MediaHandler> handler);

  Status AddHandler(std::shared_ptr<MediaHandler> handler) {
    return SetHandler(next_output_stream_index_, handler);
  }

 protected:
  enum class StreamDataType {
    kUnknown,
    kPeriodInfo,
    kStreamInfo,
    kEncryptionConfig,
    kMediaSample,
    kMediaEvent,
    kSegmentInfo,
  };

  // TODO(kqyang): Define these structures.
  struct PeriodInfo {};
  struct StreamInfo {};
  struct EncryptionConfig {};
  struct MediaSample {};
  struct MediaEvent {};
  struct SegmentInfo {};

  // TODO(kqyang): Should we use protobuf?
  struct StreamData {
    int stream_index;
    StreamDataType stream_data_type;

    std::unique_ptr<PeriodInfo> period_info;
    std::unique_ptr<StreamInfo> stream_info;
    std::unique_ptr<EncryptionConfig> encryption_config;
    std::unique_ptr<MediaSample> media_sample;
    std::unique_ptr<MediaEvent> media_event;
    std::unique_ptr<SegmentInfo> segment_info;
  };

  virtual Status Process(std::unique_ptr<StreamData> stream_data) = 0;

  virtual Status FlushStream(int input_stream_index);

  virtual bool ValidateOutputStreamIndex(int stream_index) const;

  Status Dispatch(std::unique_ptr<StreamData> stream_data);

  Status DispatchPeriodInfo(int stream_index,
                            std::unique_ptr<PeriodInfo> period_info) {
    std::unique_ptr<StreamData> stream_data(new StreamData);
    stream_data->stream_index = stream_index;
    stream_data->period_info = std::move(period_info);
    return Dispatch(std::move(stream_data));
  }

  Status DispatchStreamInfo(int stream_index,
                            std::unique_ptr<StreamInfo> stream_info) {
    std::unique_ptr<StreamData> stream_data(new StreamData);
    stream_data->stream_index = stream_index;
    stream_data->stream_info = std::move(stream_info);
    return Dispatch(std::move(stream_data));
  }

  Status DispatchEncryptionConfig(
      int stream_index,
      std::unique_ptr<EncryptionConfig> encryption_config) {
    std::unique_ptr<StreamData> stream_data(new StreamData);
    stream_data->stream_index = stream_index;
    stream_data->encryption_config = std::move(encryption_config);
    return Dispatch(std::move(stream_data));
  }

  Status DispatchMediaSample(int stream_index,
                             std::unique_ptr<MediaSample> media_sample) {
    std::unique_ptr<StreamData> stream_data(new StreamData);
    stream_data->stream_index = stream_index;
    stream_data->media_sample = std::move(media_sample);
    return Dispatch(std::move(stream_data));
  }

  Status DispatchMediaEvent(int stream_index,
                            std::unique_ptr<MediaEvent> media_event) {
    std::unique_ptr<StreamData> stream_data(new StreamData);
    stream_data->stream_index = stream_index;
    stream_data->media_event = std::move(media_event);
    return Dispatch(std::move(stream_data));
  }

  Status DispatchSegmentInfo(int stream_index,
                             std::unique_ptr<SegmentInfo> segment_info) {
    std::unique_ptr<StreamData> stream_data(new StreamData);
    stream_data->stream_index = stream_index;
    stream_data->segment_info = std::move(segment_info);
    return Dispatch(std::move(stream_data));
  }

  int num_input_streams() const { return num_input_streams_; }

 private:
  MediaHandler(const MediaHandler&) = delete;
  MediaHandler& operator=(const MediaHandler&) = delete;

  // Number of input streams.
  int num_input_streams_ = 0;
  // The next available output stream index, used by AddHandler.
  int next_output_stream_index_ = 0;
  // output stream index -> {output handler, output handler input stream index}
  // map.
  std::map<int, std::pair<std::shared_ptr<MediaHandler>, int>> output_handlers_;
};

}  // namespace media
}  // namespace shaka

#endif  // PACKAGER_MEDIA_BASE_MEDIA_HANDLER_H_