es_data_source.h

Go to the documentation of this file.

// Copyright (c) 2016 Samsung Electronics. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef NACL_PLAYER_ES_DATA_SOURCE_H_
#define NACL_PLAYER_ES_DATA_SOURCE_H_

#include <functional>
#include <memory>
#include <vector>

#include "nacl_player/common.h"
#include "nacl_player/error_codes.h"
#include "nacl_player/media_common.h"
#include "nacl_player/media_codecs.h"
#include "nacl_player/media_data_source.h"


namespace Samsung {
namespace NaClPlayer {

class ElementaryStreamListener;

class ElementaryStream {
 public:
  ElementaryStream(const ElementaryStream& other);
  ElementaryStream& operator=(const ElementaryStream& other);

  virtual ~ElementaryStream();

  virtual ElementaryStreamType GetStreamType() const = 0;

  int32_t InitializeDone(const std::function<void(int32_t)>& callback);

  int32_t InitializeDone();

  int32_t InitializeDone(
      StreamInitializationMode mode,
      const std::function<void(int32_t)>& callback);

  int32_t InitializeDone(StreamInitializationMode mode);

  int32_t AppendPacket(
      const ESPacket& packet,
      const std::function<void(int32_t)>& callback);

  int32_t AppendPacket(const ESPacket& packet);

  int32_t AppendEncryptedPacket(
      const ESPacket& packet,
      const ESPacketEncryptionInfo& encryption_info,
      const std::function<void(int32_t)>& callback);

  int32_t AppendEncryptedPacket(
      const ESPacket& packet,
      const ESPacketEncryptionInfo& encryption_info);

  int32_t AppendTrustZonePacket(
      const ESPacket& packet,
      const TrustZoneReference& handle,
      const std::function<void(int32_t)>& callback);

  int32_t AppendTrustZonePacket(
      const ESPacket& packet,
      const TrustZoneReference& handle);

  int32_t Flush(const std::function<void(int32_t)>& callback);

  int32_t Flush();

  int32_t SetDRMInitData(
      const std::string& type,
      uint32_t init_data_size,
      const void* init_data,
      const std::function<void(int32_t)>& callback);

  int32_t SetDRMInitData(
      const std::string& type,
      uint32_t init_data_size,
      const void* init_data);

 protected:
  ElementaryStream();

  class Impl;
  virtual Impl* impl() = 0;
};

class AudioElementaryStream : public ElementaryStream {
 public:
  AudioElementaryStream();
  AudioElementaryStream(const AudioElementaryStream& other);
  AudioElementaryStream& operator=(const AudioElementaryStream& other);

  virtual ~AudioElementaryStream();

  virtual ElementaryStreamType GetStreamType() const;

  AudioCodec_Type GetAudioCodecType() const;

  void SetAudioCodecType(AudioCodec_Type audio_codec);

  AudioCodec_Profile GetAudioCodecProfile() const;

  void SetAudioCodecProfile(AudioCodec_Profile profile);

  SampleFormat GetSampleFormat() const;

  void SetSampleFormat(SampleFormat sample_format);

  ChannelLayout GetChannelLayout() const;

  void SetChannelLayout(ChannelLayout channel_layout);

  int32_t GetBitsPerChannel() const;

  void SetBitsPerChannel(int32_t bits_per_channel);

  int32_t GetSamplesPerSecond() const;

  void SetSamplesPerSecond(int32_t samples_per_second);

  void SetCodecExtraData(
      uint32_t extra_data_size,
      const void* extra_data);

 protected:
  ElementaryStream::Impl* impl();

 private:
  class Impl;

  friend class ESDataSource;

  explicit AudioElementaryStream(std::unique_ptr<Impl> impl);

  std::unique_ptr<Impl> pimpl_;
};

class VideoElementaryStream : public ElementaryStream {
 public:
  VideoElementaryStream();
  VideoElementaryStream(const VideoElementaryStream& other);
  VideoElementaryStream& operator=(const VideoElementaryStream& other);

  virtual ~VideoElementaryStream();

  virtual ElementaryStreamType GetStreamType() const;

  VideoCodec_Type GetVideoCodecType() const;

  void SetVideoCodecType(VideoCodec_Type video_codec);

  VideoCodec_Profile GetVideoCodecProfile() const;

  void SetVideoCodecProfile(VideoCodec_Profile video_codec);

  VideoFrame_Format GetVideoFrameFormat() const;

  void SetVideoFrameFormat(VideoFrame_Format frame_format);

  Size GetVideoFrameSize() const;

  void SetVideoFrameSize(const Size& size);

  Rational GetFrameRate() const;

  void SetFrameRate(const Rational& r);

  void SetCodecExtraData(
      uint32_t extra_data_size,
      const void* extra_data);

 protected:
  ElementaryStream::Impl* impl();

 private:
  class Impl;

  friend class ESDataSource;

  explicit VideoElementaryStream(std::unique_ptr<Impl> impl);

  std::unique_ptr<Impl> pimpl_;
};

template <typename T>
struct ElementaryStreamTraits {
    static constexpr ElementaryStreamType kType =
        ElementaryStreamType_Unknown;
};

template <>
struct ElementaryStreamTraits<VideoElementaryStream> {
    static constexpr ElementaryStreamType kType =
        ElementaryStreamType_Video;
};

template <>
struct ElementaryStreamTraits<AudioElementaryStream> {
    static constexpr ElementaryStreamType kType =
        ElementaryStreamType_Audio;
};

class ESDataSource : public MediaDataSource {
 public:
  ESDataSource();
  ESDataSource(const ESDataSource& other);
  ESDataSource& operator=(const ESDataSource& other);

  virtual ~ESDataSource();

  template<typename T>
      int32_t AddStream(
          const std::function<void(int32_t, const T&)>& callback,
          ElementaryStreamListener* listener);

  template<typename T>
  int32_t AddStream(
      const std::function<void(int32_t, const T&)>& callback,
      std::shared_ptr<ElementaryStreamListener> listener);

  template<typename T>
  int32_t AddStream(T& stream,
      ElementaryStreamListener* listener = nullptr);

  template<typename T>
  int32_t AddStream(T& stream,
      std::shared_ptr<ElementaryStreamListener> listener);


  int32_t SetDuration(
      TimeDelta duration,
      const std::function<void(int32_t)>& callback);

  int32_t SetDuration(TimeDelta duration);

  int32_t SetEndOfStream(
      const std::function<void(int32_t)>& callback);

  int32_t SetEndOfStream();

 protected:
  MediaDataSource::Impl* impl() const;

 private:
  template<typename T>
  static void OnStreamAdded(
      const std::function<void(int32_t, const T&)>& callback,
      int32_t result, const ElementaryStream& stream);

  int32_t AddStream(
      ElementaryStreamType stream_type,
      ElementaryStreamListener* listener,
      const std::function<void(int32_t, const ElementaryStream&)>& callback);

  int32_t AddStream(ElementaryStreamType stream_type, ElementaryStream& stream,
      ElementaryStreamListener* listener);

  int32_t AddStream(
      ElementaryStreamType stream_type,
      std::shared_ptr<ElementaryStreamListener> listener,
      const std::function<void(int32_t, const ElementaryStream&)>& callback);

  int32_t AddStream(ElementaryStreamType stream_type, ElementaryStream& stream,
      std::shared_ptr<ElementaryStreamListener> listener);

  class Impl;
  std::unique_ptr<Impl> pimpl_;
};

template<typename T>
void ESDataSource::OnStreamAdded(
    const std::function<void(int32_t, const T&)>& callback,
    int32_t result, const ElementaryStream& stream) {
  callback(result, static_cast<const T&>(stream));
}

template<typename T>
inline int32_t ESDataSource::AddStream(
    const std::function<void(int32_t, const T&)>& callback,
    std::shared_ptr<ElementaryStreamListener> listener) {
  typedef ElementaryStreamTraits<T> Traits;
  static_assert(Traits::kType != ElementaryStreamType_Unknown,
      "Invalid stream type.");
  return AddStream(Traits::kType, listener,
      [callback](int32_t result, const ElementaryStream& stream) {
        ESDataSource::OnStreamAdded(callback, result, stream);});
}

template<typename T>
inline int32_t ESDataSource::AddStream(
    const std::function<void(int32_t, const T&)>& callback,
    ElementaryStreamListener* listener) {
  typedef ElementaryStreamTraits<T> Traits;
  static_assert(Traits::kType != ElementaryStreamType_Unknown,
        "Invalid stream type.");
  return AddStream(Traits::kType, listener,
      [callback](int32_t result, const ElementaryStream& stream) {
        ESDataSource::OnStreamAdded(callback, result, stream);});
}

template<typename T>
inline int32_t ESDataSource::AddStream(T& stream,
    std::shared_ptr<ElementaryStreamListener> listener) {
  typedef ElementaryStreamTraits<T> Traits;
  static_assert(Traits::kType != ElementaryStreamType_Unknown,
      "Invalid stream type.");
  return AddStream(Traits::kType, stream, listener);
}

template<typename T>
inline int32_t ESDataSource::AddStream(T& stream,
    ElementaryStreamListener* listener) {
  typedef ElementaryStreamTraits<T> Traits;
  static_assert(Traits::kType != ElementaryStreamType_Unknown,
      "Invalid stream type.");
  return AddStream(Traits::kType, stream, listener);
}

}  // namespace NaClPlayer
}  // namespace Samsung

#endif  // NACL_PLAYER_ES_DATA_SOURCE_H_