media_player.h

Go to the documentation of this file.

// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SHAKA_EMBEDDED_MEDIA_MEDIA_PLAYER_H_
#define SHAKA_EMBEDDED_MEDIA_MEDIA_PLAYER_H_

#include <iostream>
#include <memory>
#include <string>
#include <vector>

#include "../eme/implementation.h"
#include "../macros.h"
#include "../utils.h"
#include "media_capabilities.h"
#include "media_track.h"
#include "streams.h"
#include "text_track.h"

namespace shaka {
namespace media {

enum class VideoReadyState : int8_t {
  NotAttached = -1,

  HaveNothing = 0,

  HaveMetadata = 1,

  HaveCurrentData = 2,

  HaveFutureData = 3,

  HaveEnoughData = 4,
};

std::string to_string(VideoReadyState state);
inline std::ostream& operator<<(std::ostream& os, VideoReadyState state) {
  return os << to_string(state);
}

enum class VideoPlaybackState : uint8_t {
  Detached,

  Initializing,

  Paused,

  Seeking,

  Buffering,

  WaitingForKey,

  Playing,

  Ended,

  Errored,
};

std::string to_string(VideoPlaybackState state);
inline std::ostream& operator<<(std::ostream& os, VideoPlaybackState state) {
  return os << to_string(state);
}

struct SHAKA_EXPORT VideoPlaybackQuality {
  uint32_t total_video_frames;

  uint32_t dropped_video_frames;

  uint32_t corrupted_video_frames;
};


class SHAKA_EXPORT MediaPlayer {
 public:
  class SHAKA_EXPORT Client {
   public:
    SHAKA_DECLARE_INTERFACE_METHODS(Client);

    virtual void OnAddAudioTrack(std::shared_ptr<MediaTrack> track);

    virtual void OnRemoveAudioTrack(std::shared_ptr<MediaTrack> track);

    virtual void OnAddVideoTrack(std::shared_ptr<MediaTrack> track);

    virtual void OnRemoveVideoTrack(std::shared_ptr<MediaTrack> track);

    virtual void OnAddTextTrack(std::shared_ptr<TextTrack> track);

    virtual void OnRemoveTextTrack(std::shared_ptr<TextTrack> track);


    virtual void OnReadyStateChanged(VideoReadyState old_state,
                                     VideoReadyState new_state);

    virtual void OnPlaybackStateChanged(VideoPlaybackState old_state,
                                        VideoPlaybackState new_state);

    virtual void OnPlaybackRateChanged(double old_rate, double new_rate);

    virtual void OnError(const std::string& error);

    virtual void OnAttachMse();

    virtual void OnAttachSource();

    virtual void OnDetach();


    virtual void OnPlay();

    virtual void OnSeeking();

    virtual void OnWaitingForKey();


    virtual void OnUserEvent(const std::string& name, void* user_data);
  };

  class SHAKA_EXPORT ClientList final : public Client {
   public:
    ClientList();
    ~ClientList() override;

    void AddClient(Client* client);
    void RemoveClient(Client* client);

    void OnAddAudioTrack(std::shared_ptr<MediaTrack> track) override;
    void OnRemoveAudioTrack(std::shared_ptr<MediaTrack> track) override;
    void OnAddVideoTrack(std::shared_ptr<MediaTrack> track) override;
    void OnRemoveVideoTrack(std::shared_ptr<MediaTrack> track) override;
    void OnAddTextTrack(std::shared_ptr<TextTrack> track) override;
    void OnRemoveTextTrack(std::shared_ptr<TextTrack> track) override;
    void OnReadyStateChanged(VideoReadyState old_state,
                             VideoReadyState new_state) override;
    void OnPlaybackStateChanged(VideoPlaybackState old_state,
                                VideoPlaybackState new_state) override;
    void OnPlaybackRateChanged(double old_rate, double new_rate) override;
    void OnError(const std::string& error) override;
    void OnAttachMse() override;
    void OnAttachSource() override;
    void OnDetach() override;
    void OnPlay() override;
    void OnSeeking() override;
    void OnWaitingForKey() override;

    void OnUserEvent(const std::string& name, void* user_data) override;

   private:
    class Impl;
    std::unique_ptr<Impl> impl_;
  };

  SHAKA_DECLARE_INTERFACE_METHODS(MediaPlayer);

  static void SetMediaPlayerForSupportChecks(const MediaPlayer* player);

  static const MediaPlayer* GetMediaPlayerForSupportChecks();


  virtual MediaCapabilitiesInfo DecodingInfo(
      const MediaDecodingConfiguration& config) const = 0;

  virtual VideoPlaybackQuality VideoPlaybackQuality() const = 0;

  virtual void AddClient(Client* client) const = 0;

  virtual void RemoveClient(Client* client) const = 0;

  virtual std::vector<BufferedRange> GetBuffered() const = 0;

  virtual VideoReadyState ReadyState() const = 0;

  virtual VideoPlaybackState PlaybackState() const = 0;

  virtual std::vector<std::shared_ptr<MediaTrack>> AudioTracks() = 0;

  virtual std::vector<std::shared_ptr<const MediaTrack>> AudioTracks()
      const = 0;

  virtual std::vector<std::shared_ptr<MediaTrack>> VideoTracks() = 0;

  virtual std::vector<std::shared_ptr<const MediaTrack>> VideoTracks()
      const = 0;

  virtual std::vector<std::shared_ptr<TextTrack>> TextTracks() = 0;

  virtual std::vector<std::shared_ptr<const TextTrack>> TextTracks() const = 0;

  virtual std::shared_ptr<TextTrack> AddTextTrack(
      TextTrackKind kind, const std::string& label,
      const std::string& language) = 0;


  virtual bool SetVideoFillMode(VideoFillMode mode) = 0;

  virtual uint32_t Width() const = 0;

  virtual uint32_t Height() const = 0;

  virtual double Volume() const = 0;

  virtual void SetVolume(double volume) = 0;

  virtual bool Muted() const = 0;

  virtual void SetMuted(bool muted) = 0;


  virtual void Play() = 0;

  virtual void Pause() = 0;

  virtual double CurrentTime() const = 0;

  virtual void SetCurrentTime(double time) = 0;

  virtual double Duration() const = 0;

  virtual void SetDuration(double duration) = 0;

  virtual double PlaybackRate() const = 0;

  virtual void SetPlaybackRate(double rate) = 0;


  virtual bool AttachSource(const std::string& src) = 0;

  virtual bool AttachMse() = 0;

  virtual bool AddMseBuffer(const std::string& mime, bool is_video,
                            const ElementaryStream* stream) = 0;

  virtual void LoadedMetaData(double duration) = 0;

  virtual void MseEndOfStream() = 0;

  virtual bool SetEmeImplementation(const std::string& key_system,
                                    eme::Implementation* implementation) = 0;

  virtual void Detach() = 0;
};

}  // namespace media
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEDIA_MEDIA_PLAYER_H_