es_data_source_samsung.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 PPAPI_CPP_SAMSUNG_ES_DATA_SOURCE_SAMSUNG_H_
#define PPAPI_CPP_SAMSUNG_ES_DATA_SOURCE_SAMSUNG_H_

#include <string>

#include "ppapi/c/samsung/ppb_media_data_source_samsung.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/cpp/resource.h"
#include "ppapi/cpp/samsung/media_data_source_samsung.h"

namespace pp {

class ElementaryStreamListener_Samsung;
class InstanceHandle;

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

  virtual ~ElementaryStream_Samsung();

  virtual PP_ElementaryStream_Type_Samsung GetStreamType() const = 0;

  int32_t InitializeDone(
      const CompletionCallback& callback);

  int32_t InitializeDone(PP_StreamInitializationMode mode,
                         const CompletionCallback& callback);

  int32_t AppendPacket(
      const PP_ESPacket& packet,
      const CompletionCallback& callback);

  int32_t AppendEncryptedPacket(
      const PP_ESPacket& packet,
      const PP_ESPacketEncryptionInfo& encryption_info,
      const CompletionCallback& callback);

  int32_t AppendTrustZonePacket(const PP_ESPacket& packet,
                                const PP_TrustZoneReference& handle,
                                const CompletionCallback& callback);

  int32_t Flush(
      const CompletionCallback& callback);

  int32_t SetDRMInitData(
      uint32_t type_size,
      const void* type,
      uint32_t init_data_size,
      const void* init_data,
      const CompletionCallback& callback);


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

 protected:
  ElementaryStream_Samsung();
  explicit ElementaryStream_Samsung(PP_Resource resource);
  explicit ElementaryStream_Samsung(const Resource& resource);
  explicit ElementaryStream_Samsung(PassRef, PP_Resource resource);
};

class AudioElementaryStream_Samsung : public ElementaryStream_Samsung {
 public:
  AudioElementaryStream_Samsung();
  explicit AudioElementaryStream_Samsung(PP_Resource resource);
  explicit AudioElementaryStream_Samsung(PassRef, PP_Resource resource);
  AudioElementaryStream_Samsung(const AudioElementaryStream_Samsung& other);
  AudioElementaryStream_Samsung& operator=(
      const AudioElementaryStream_Samsung& other);

  virtual ~AudioElementaryStream_Samsung();

  virtual PP_ElementaryStream_Type_Samsung GetStreamType() const;

  PP_AudioCodec_Type_Samsung GetAudioCodecType() const;

  void SetAudioCodecType(PP_AudioCodec_Type_Samsung audio_codec);

  PP_AudioCodec_Profile_Samsung GetAudioCodecProfile() const;

  void SetAudioCodecProfile(PP_AudioCodec_Profile_Samsung profile);

  PP_SampleFormat_Samsung GetSampleFormat() const;

  void SetSampleFormat(PP_SampleFormat_Samsung sample_format);

  PP_ChannelLayout_Samsung GetChannelLayout() const;

  void SetChannelLayout(PP_ChannelLayout_Samsung 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);
};

class VideoElementaryStream_Samsung : public ElementaryStream_Samsung {
 public:
  VideoElementaryStream_Samsung();
  explicit VideoElementaryStream_Samsung(PP_Resource resource);
  explicit VideoElementaryStream_Samsung(PassRef, PP_Resource resource);
  VideoElementaryStream_Samsung(const VideoElementaryStream_Samsung& other);
  VideoElementaryStream_Samsung& operator=(
      const VideoElementaryStream_Samsung& other);

  virtual ~VideoElementaryStream_Samsung();

  virtual PP_ElementaryStream_Type_Samsung GetStreamType() const;

  PP_VideoCodec_Type_Samsung GetVideoCodecType() const;

  void SetVideoCodecType(PP_VideoCodec_Type_Samsung video_codec);

  PP_VideoCodec_Profile_Samsung GetVideoCodecProfile() const;

  void SetVideoCodecProfile(PP_VideoCodec_Profile_Samsung video_codec);

  PP_VideoFrame_Format_Samsung GetVideoFrameFormat() const;

  void SetVideoFrameFormat(PP_VideoFrame_Format_Samsung frame_format);

  PP_Size GetVideoFrameSize() const;

  void SetVideoFrameSize(const PP_Size& size);

  void GetFrameRate(uint32_t* numerator, uint32_t* denominator) const;

  void SetFrameRate(uint32_t numerator, uint32_t denominator);

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

class ESDataSource_Samsung : public MediaDataSource_Samsung {
 public:
  explicit ESDataSource_Samsung(const InstanceHandle& instance);

  ESDataSource_Samsung(const ESDataSource_Samsung& other);

  explicit ESDataSource_Samsung(PP_Resource resource);
  ESDataSource_Samsung(PassRef, PP_Resource resource);

  ESDataSource_Samsung& operator=(const ESDataSource_Samsung& other);

  virtual ~ESDataSource_Samsung();

  template<typename T>
  int32_t AddStream(const CompletionCallbackWithOutput<T>& callback,
      ElementaryStreamListener_Samsung* listener = NULL);

  int32_t SetDuration(
      PP_TimeDelta duration,
      const CompletionCallback& callback);

  int32_t SetEndOfStream(
      const CompletionCallback& callback);

 private:
  int32_t AddStream(
          PP_ElementaryStream_Type_Samsung stream_type,
          PP_Resource* stream,
          ElementaryStreamListener_Samsung* listener,
          const CompletionCallback& callback);
};

template <typename T>
struct ElementaryStreamTraits_Samsung {
    static const PP_ElementaryStream_Type_Samsung kType =
            PP_ELEMENTARYSTREAM_TYPE_SAMSUNG_UNKNOWN;
};

template <>
struct ElementaryStreamTraits_Samsung<VideoElementaryStream_Samsung> {
    static const PP_ElementaryStream_Type_Samsung kType =
            PP_ELEMENTARYSTREAM_TYPE_SAMSUNG_VIDEO;
};

template <>
struct ElementaryStreamTraits_Samsung<AudioElementaryStream_Samsung> {
    static const PP_ElementaryStream_Type_Samsung kType =
            PP_ELEMENTARYSTREAM_TYPE_SAMSUNG_AUDIO;
};

#if __cplusplus >= 201103L
#define PP_MEDIA_PLAYER_SAMSUNG_STATIC_ASSERT(expr, msg) \
    static_assert(expr, msg)
#else
#if __GNUC__ >= 4
#define UNUSED_TYPEDEF __attribute__((__unused__))
#else
#define UNUSED_TYPEDEF
#endif
#define PP_MEDIA_PLAYER_SAMSUNG_STATIC_ASSERT(expr, msg)             \
  do {                                                               \
    typedef int static_assert_check[(expr) ? 1 : -1] UNUSED_TYPEDEF; \
  } while (0)
#endif

template<typename T>
inline int32_t ESDataSource_Samsung::AddStream(
    const CompletionCallbackWithOutput<T>& callback,
    ElementaryStreamListener_Samsung* listener) {
  typedef ElementaryStreamTraits_Samsung<T> Traits;
  PP_MEDIA_PLAYER_SAMSUNG_STATIC_ASSERT(
      Traits::kType != PP_ELEMENTARYSTREAM_TYPE_SAMSUNG_UNKNOWN,
      "Bad stream type!");
  return AddStream(Traits::kType, callback.output(), listener, callback);
}

}  // namespace pp

#endif  // PPAPI_CPP_SAMSUNG_ES_DATA_SOURCE_SAMSUNG_H_