AgoraMediaPlayerTypes.h

Go to the documentation of this file.

//
//  Agora Engine SDK
//
//  Created by Sting Feng in 2020-05.
//  Copyright (c) 2017 Agora.io. All rights reserved.
 
#pragma once  // NOLINT(build/header_guard)
 
#include <cstring>
#include <stdint.h>
 
#include "AgoraOptional.h"
 
#define KEY_PLAYER_REAL_TIME_STREAM_ANALYZE_DURATION    "analyze_duration"
 
#define KEY_PLAYER_ENABLE_AUDIO                  "enable_audio"
 
#define KEY_PLAYER_ENABLE_VIDEO                  "enable_video"
 
#define KEY_PLAYER_ENABLE_SEARCH_METADATA         "enable_search_metadata"
 
#define KEY_PLAYER_SEI_FILTER_TYPE         "set_sei_filter_type"
 
namespace agora {
 
namespace media {
 
namespace base {
static const uint8_t kMaxCharBufferLength = 50;
enum MEDIA_PLAYER_STATE {
  PLAYER_STATE_IDLE = 0,
  PLAYER_STATE_OPENING,
  PLAYER_STATE_OPEN_COMPLETED,
  PLAYER_STATE_PLAYING,
  PLAYER_STATE_PAUSED,
  PLAYER_STATE_PLAYBACK_COMPLETED,
  PLAYER_STATE_PLAYBACK_ALL_LOOPS_COMPLETED,
  PLAYER_STATE_STOPPED,
  PLAYER_STATE_PAUSING_INTERNAL = 50,
  PLAYER_STATE_STOPPING_INTERNAL,
  PLAYER_STATE_SEEKING_INTERNAL,
  PLAYER_STATE_GETTING_INTERNAL,
  PLAYER_STATE_NONE_INTERNAL,
  PLAYER_STATE_DO_NOTHING_INTERNAL,
  PLAYER_STATE_SET_TRACK_INTERNAL,
  PLAYER_STATE_FAILED = 100,
};
enum MEDIA_PLAYER_REASON {
  PLAYER_REASON_NONE = 0,
  PLAYER_REASON_INVALID_ARGUMENTS = -1,
  PLAYER_REASON_INTERNAL = -2,
  PLAYER_REASON_NO_RESOURCE = -3,
  PLAYER_REASON_INVALID_MEDIA_SOURCE = -4,
  PLAYER_REASON_UNKNOWN_STREAM_TYPE = -5,
  PLAYER_REASON_OBJ_NOT_INITIALIZED = -6,
  PLAYER_REASON_CODEC_NOT_SUPPORTED = -7,
  PLAYER_REASON_VIDEO_RENDER_FAILED = -8,
  PLAYER_REASON_INVALID_STATE = -9,
  PLAYER_REASON_URL_NOT_FOUND = -10,
  PLAYER_REASON_INVALID_CONNECTION_STATE = -11,
  PLAYER_REASON_SRC_BUFFER_UNDERFLOW = -12,
  PLAYER_REASON_INTERRUPTED = -13,
  PLAYER_REASON_NOT_SUPPORTED = -14,
  PLAYER_REASON_TOKEN_EXPIRED = -15,
  PLAYER_REASON_IP_EXPIRED = -16,
  PLAYER_REASON_UNKNOWN = -17,
};
 
enum MEDIA_STREAM_TYPE {
  STREAM_TYPE_UNKNOWN = 0,
  STREAM_TYPE_VIDEO = 1,
  STREAM_TYPE_AUDIO = 2,
  STREAM_TYPE_SUBTITLE = 3,
};
 
enum MEDIA_PLAYER_EVENT {
  PLAYER_EVENT_SEEK_BEGIN = 0,
  PLAYER_EVENT_SEEK_COMPLETE = 1,
  PLAYER_EVENT_SEEK_ERROR = 2,
  PLAYER_EVENT_AUDIO_TRACK_CHANGED = 5,
  PLAYER_EVENT_BUFFER_LOW = 6,
  PLAYER_EVENT_BUFFER_RECOVER = 7,
  PLAYER_EVENT_FREEZE_START = 8,
  PLAYER_EVENT_FREEZE_STOP = 9,
  PLAYER_EVENT_SWITCH_BEGIN = 10,
  PLAYER_EVENT_SWITCH_COMPLETE = 11,
  PLAYER_EVENT_SWITCH_ERROR = 12,
  PLAYER_EVENT_FIRST_DISPLAYED = 13,
  PLAYER_EVENT_REACH_CACHE_FILE_MAX_COUNT = 14,
  PLAYER_EVENT_REACH_CACHE_FILE_MAX_SIZE = 15,
  PLAYER_EVENT_TRY_OPEN_START = 16,
  PLAYER_EVENT_TRY_OPEN_SUCCEED = 17,
  PLAYER_EVENT_TRY_OPEN_FAILED = 18,
  PLAYER_EVENT_HTTP_REDIRECT = 19,
};
 
enum PLAYER_PRELOAD_EVENT  {
  PLAYER_PRELOAD_EVENT_BEGIN = 0,
  PLAYER_PRELOAD_EVENT_COMPLETE = 1,
  PLAYER_PRELOAD_EVENT_ERROR = 2,
};
 
struct PlayerStreamInfo {
  int streamIndex;
 
  MEDIA_STREAM_TYPE streamType;
 
  char codecName[kMaxCharBufferLength];
 
  char language[kMaxCharBufferLength];
 
  int videoFrameRate;
 
  int videoBitRate;
 
  int videoWidth;
 
  int videoHeight;
 
  int videoRotation;
 
  int audioSampleRate;
 
  int audioChannels;
 
  int audioBitsPerSample;
 
  int64_t duration;
 
  PlayerStreamInfo() : streamIndex(0),
                       streamType(STREAM_TYPE_UNKNOWN),
                       videoFrameRate(0),
                       videoBitRate(0),
                       videoWidth(0),
                       videoHeight(0),
                       videoRotation(0),
                       audioSampleRate(0),
                       audioChannels(0),
                       audioBitsPerSample(0),
                       duration(0) {
    memset(codecName, 0, sizeof(codecName));
    memset(language, 0, sizeof(language));
  }
};
 
struct SrcInfo {
  int bitrateInKbps;
 
  const char* name;
 
};
 
enum MEDIA_PLAYER_METADATA_TYPE {
  PLAYER_METADATA_TYPE_UNKNOWN = 0,
  PLAYER_METADATA_TYPE_SEI = 1,
};
 
struct CacheStatistics {
  int64_t fileSize;
  int64_t cacheSize;
  int64_t downloadSize;
};
 
struct PlayerPlaybackStats {
  int videoFps;
  int videoBitrateInKbps;
  int audioBitrateInKbps;
  int totalBitrateInKbps;
};
 
struct PlayerUpdatedInfo {
  const char* internalPlayerUuid;
  const char* deviceId;
  int videoHeight;
  int videoWidth;
  int audioSampleRate;
  int audioChannels;
  int audioBitsPerSample;
 
  PlayerUpdatedInfo()
      : internalPlayerUuid(NULL),
        deviceId(NULL),
        videoHeight(0),
        videoWidth(0),
        audioSampleRate(0),
        audioChannels(0),
        audioBitsPerSample(0) {}
};
 
class IMediaPlayerCustomDataProvider {
public:
    
    virtual int onReadData(unsigned char *buffer, int bufferSize) = 0;
    
    virtual int64_t onSeek(int64_t offset, int whence) = 0;
    
    virtual ~IMediaPlayerCustomDataProvider() {}
};
 
struct MediaSource {
  const char* url;
  const char* uri;
  int64_t startPos;
  bool autoPlay;
  bool enableCache;
  bool enableMultiAudioTrack;
  Optional<bool> isAgoraSource;
  Optional<bool> isLiveSource;
  IMediaPlayerCustomDataProvider* provider;
 
  MediaSource() : url(NULL), uri(NULL), startPos(0), autoPlay(true), enableCache(false),
                  enableMultiAudioTrack(false), provider(NULL){
  }
};
 
}  // namespace base
}  // namespace media
}  // namespace agora