demuxer.h

// Copyright 2014 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_DEMUXER_H_
#define PACKAGER_MEDIA_BASE_DEMUXER_H_

#include <deque>
#include <memory>
#include <vector>

#include "packager/base/compiler_specific.h"
#include "packager/media/base/container_names.h"
#include "packager/media/origin/origin_handler.h"
#include "packager/status.h"

namespace shaka {

class File;

namespace media {

class Decryptor;
class KeySource;
class MediaParser;
class MediaSample;
class StreamInfo;

class Demuxer : public OriginHandler {
 public:
  explicit Demuxer(const std::string& file_name);
  ~Demuxer();

  void SetKeySource(std::unique_ptr<KeySource> key_source);

  Status Run() override;

  void Cancel() override;

  MediaContainerName container_name() { return container_name_; }

  Status SetHandler(const std::string& stream_label,
                    std::shared_ptr<MediaHandler> handler);

  void SetLanguageOverride(const std::string& stream_label,
                           const std::string& language_override);

  void set_dump_stream_info(bool dump_stream_info) {
    dump_stream_info_ = dump_stream_info;
  }

 protected:
  Status InitializeInternal() override { return Status::OK; }
  Status Process(std::unique_ptr<StreamData> stream_data) override {
    return Status(error::INTERNAL_ERROR,
                  "Demuxer should not be the downstream handler.");
  }
  bool ValidateOutputStreamIndex(size_t stream_index) const override {
    // We don't know if the stream is valid or not when setting up the graph.
    // Will validate the stream index later when stream info is available.
    return true;
  }

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

  struct QueuedSample {
    QueuedSample(uint32_t track_id, std::shared_ptr<MediaSample> sample);
    ~QueuedSample();

    uint32_t track_id;
    std::shared_ptr<MediaSample> sample;
  };

  // Initialize the parser. This method primes the demuxer by parsing portions
  // of the media file to extract stream information.
  // @return OK on success.
  Status InitializeParser();

  // Parser init event.
  void ParserInitEvent(const std::vector<std::shared_ptr<StreamInfo>>& streams);
  // Parser new sample event handler. Queues the samples if init event has not
  // been received, otherwise calls PushSample() to push the sample to
  // corresponding stream.
  bool NewSampleEvent(uint32_t track_id,
                      const std::shared_ptr<MediaSample>& sample);
  // Helper function to push the sample to corresponding stream.
  bool PushSample(uint32_t track_id,
                  const std::shared_ptr<MediaSample>& sample);

  // Read from the source and send it to the parser.
  Status Parse();

  std::string file_name_;
  File* media_file_ = nullptr;
  // A stream is considered ready after receiving the stream info.
  bool all_streams_ready_ = false;
  // Queued samples received in NewSampleEvent() before ParserInitEvent().
  std::deque<QueuedSample> queued_samples_;
  std::unique_ptr<MediaParser> parser_;
  // TrackId -> StreamIndex map.
  std::map<uint32_t, size_t> track_id_to_stream_index_map_;
  // The list of stream indexes in the above map (in the same order as the input
  // stream info vector).
  std::vector<size_t> stream_indexes_;
  // StreamIndex -> language_override map.
  std::map<size_t, std::string> language_overrides_;
  MediaContainerName container_name_ = CONTAINER_UNKNOWN;
  std::unique_ptr<uint8_t[]> buffer_;
  std::unique_ptr<KeySource> key_source_;
  bool cancelled_ = false;
  // Whether to dump stream info when it is received.
  bool dump_stream_info_ = false;
  Status init_event_status_;
};

}  // namespace media
}  // namespace shaka

#endif  // PACKAGER_MEDIA_BASE_DEMUXER_H_