plv-player-def.h

Go to the documentation of this file.

#pragma once
#include <stddef.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
 
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define PLAYERSDK_CALL __cdecl
#if defined(PLAYERSDK_EXPORT)
#define PLAYERSDK_API extern "C" __declspec(dllexport)
#else
#define PLAYERSDK_API extern "C" __declspec(dllimport)
#endif
#elif defined(__APPLE__)
#include <TargetConditionals.h>
#define PLAYERSDK_API __attribute__((visibility("default"))) extern "C"
#define PLAYERSDK_CALL
#elif defined(__ANDROID__) || defined(__linux__)
#define PLAYERSDK_API extern "C" __attribute__((visibility("default")))
#define PLAYERSDK_CALL
#else
#define PLAYERSDK_API extern "C"
#define PLAYERSDK_CALL
#endif
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
 
const int PLV_MAX_DEVICE_ID_LENGTH = 512;
 
const int PLV_MAX_NAME_LENGTH = 1024;
 
enum VIDEO_RATE_TYPE{
    VIDEO_RATE_AUTO = 0,
 
    VIDEO_RATE_LD,
    VIDEO_RATE_SD,
    VIDEO_RATE_HD,
 
    VIDEO_RATE_SOURCE,
};
 
enum LOG_FILTER_TYPE{
    LOG_FILTER_OFF = 0,
 
    LOG_FILTER_DEBUG,
    LOG_FILTER_INFO ,
    LOG_FILTER_WARN ,
    LOG_FILTER_ERROR,
    LOG_FILTER_FATAL,
};
 
enum SOFTWARE_RECORDING_NOTIFY_TYPE{
    SOFTWARE_RECORDING_NONE = 0,
    SOFTWARE_RECORDING_START,
    SOFTWARE_RECORDING_STOP,
};
 
enum DEVICE_CHANGED_TYPE {
    DEVICE_CHANGED_NONE = 0,
    HDMI_DEVICE_USE,
    HDMI_DEVICE_UNUSE,
};
 
enum VIDEO_OUTPUT_DEVICE{
    VIDEO_OUTPUT_NONE = 0,
 
    VIDEO_OUTPUT_GPU,
 
#ifdef _WIN32
    VIDEO_OUTPUT_DIRECT3D,
 
    VIDEO_OUTPUT_GDI,
#endif// end _WIN32
};
 
enum SDK_HTTP_REQUEST{
    FIRST_HTTP_REQUEST = 0,
    FIRST_HTTPS_REQUEST,
    ONLY_HTTP_REQUEST,
    ONLY_HTTPS_REQUEST,
};
 
enum SDK_ERROR_TYPE{
    E_NO_ERR = 0,
    E_NO_INIT,
    E_NO_FILE,
    E_NO_RATE,
    E_NO_SPACE ,
    E_NO_SUPPORT,
    E_VID_ERR,
    E_KEY_ERR,
    E_ZIP_ERR,
    E_M3U8_ERR,
    E_HTTP_ERR,
    E_PATH_ERR,
    E_PARAM_ERR,
    E_DELETE_ERR,
    E_INVOKE_ERR,
    E_NETWORK_ERR,
    E_ABORT_OPERATION,
    E_DOWNLOAD_ERR,
    E_DOWNLOADING,
    E_DELETE_VIDEO,
    E_MEDIA_UNINIT,
    E_MEDIA_UNLOAD,
    E_MEDIA_LOADING,
    E_TSFILESIZE,
    E_OUTFLOW, 
    E_OSDFONT_ERR,
    E_FILE_INCOMPLETE,
    E_OBJECT_NULL,
    E_NO_AUDIO_DEVICE,
    E_VIEWERID_EMPTY,
    E_MAC_NOT_ALLFILESACCESS,
    E_STILL_REQUEST,
    E_MIGRATE_ERR,
    E_CAFILE_ERR,
    E_MEDIA_UNLOADING,
 
    E_HTTP_MAX,
 
    E_CORE_MAX = 1000,
};
 
enum PLAYER_MEDIA_STATE {
    MEDIA_STATE_NONE = -1,
    MEDIA_STATE_LOADING = 0,
    MEDIA_STATE_LOADED,
    MEDIA_STATE_PLAY,
    MEDIA_STATE_PAUSE,
    MEDIA_STATE_BEGIN_CACHE,
    MEDIA_STATE_END_CACHE,
    MEDIA_STATE_BEGIN_SEEKING,
    MEDIA_STATE_END_SEEKING,
    MEDIA_STATE_FAIL,
    MEDIA_STATE_END,
};
enum PLAYER_MEDIA_PROPERTY {
    MEDIA_PROPERTY_NONE = -1,
    MEDIA_PROPERTY_DURATION = 0,
    MEDIA_PROPERTY_POSTION,
    MEDIA_PROPERTY_HWDEC,
    MEDIA_PROPERTY_VIDEO_CODEC,
    MEDIA_PROPERTY_VIDEO_BITRATE,
    MEDIA_PROPERTY_VIDEO_FPS,
    MEDIA_PROPERTY_VIDEO_WIDTH,
    MEDIA_PROPERTY_VIDEO_HEIGHT,
    MEDIA_PROPERTY_AUDIO_CODEC,
    MEDIA_PROPERTY_AUDIO_BITRATE,
    MEDIA_PROPERTY_CACHE_SPEED,
    MEDIA_PROPERTY_CACHE_PROGRESS, 
    MEDIA_PROPERTY_CACHE_TIME,
    MEDIA_PROPERTY_SUBTITLE_TEXT,  
    MEDIA_PROPERTY_SUBTITLE_START, 
    MEDIA_PROPERTY_SUBTITLE_STOP,  
};
enum PLAYER_MEDIA_FORMAT {
    MEDIA_FORMAT_INT64 = 0,
    MEDIA_FORMAT_DOUBLE,
    MEDIA_FORMAT_STRING,
};
 
enum OSD_DISPLAY_TYPE {
    OSD_DISPALY_ROLL = 0,
    OSD_DISPALY_BLINK,
};
 
enum LIVE_PLAYER_CHANNEL_STATE {
    CHANNEL_STATE_NONE = 0,
    CHANNEL_STATE_UNKNOWN = 1,
    CHANNEL_STATE_END = 2,
    CHANNEL_STATE_PAUSE = 3,
    CHANNEL_STATE_LIVE = 4,
};
 
enum LIVE_PLAYER_PLAY_MODE {
    PLAY_AUDIO_VIDEO = 0,
    PLAY_AUDIO_ONLY = 1,
};
 
struct PLVAccountInfo {
    PLVAccountInfo() :
        userId(0),
        secretKey(0),
        appId(0),
        appSecret(0),
        subAccount(false)
    {}
    const char* userId; 
    const char* secretKey;
    const char* appId;
    const char* appSecret;
    bool subAccount;
};
 
struct PLVOsdConfigInfo {
    PLVOsdConfigInfo() :
        text(0),
        textSize(55),
        textColor(0),
        borderSize(1),
        borderColor(0),
        animationEffect(OSD_DISPALY_ROLL),
        displayDuration(5),
        displayInterval(1),
        fadeDuration(3)
    {
    }
    const char* text;
    int textSize;
    const char* textColor;
    int borderSize;
    const char* borderColor;
    OSD_DISPLAY_TYPE animationEffect;
    int displayDuration;
    int displayInterval;
    int fadeDuration;
};
 
 
struct PLVLogoTextInfo {
    PLVLogoTextInfo() :
        text(0),
        textSize(16),
        textColor(0),
        borderSize(1),
        borderColor(0), 
        alignX(1),
        alignY(-1)
    {
    }
    const char* text;
    int textSize;
    const char* textColor;
    int borderSize;
    const char* borderColor;
    int alignX;
    int alignY;
};
 
enum VIDEO_REQUEST_TYPE {
    VIDEO_REQUEST_NONE = 0,
    VIDEO_REQUEST_VID,
    VIDEO_REQUEST_PAGE,
};
struct PLVVideoRequestParam {
    PLVVideoRequestParam():
        type(VIDEO_REQUEST_NONE),
        vids(NULL),
        page(1),
        pageSize(10)
    {
    }
    VIDEO_REQUEST_TYPE type;
    const char* vids;
    int page;
    int pageSize;
};
 
struct PLVVideoRequestInfo {
    PLVVideoRequestInfo() :
        encrypt(false),
        cateId(0),
        status(0),
        duration(0),
        ratesNum(0),
        sourceFilesize(0),
        vid(NULL),
        title(NULL),
        thumbnailURL(NULL),
        coverURL(NULL),
        rates(NULL)
    {
    }
    bool encrypt;
    int status;
    int cateId;
    int64_t sourceFilesize;
    double duration;
    struct Rate {
        int64_t filesize;
        int rate;
        int bitrate;
        int fps;
        int height;
        int width;
    };
    Rate* rates;
    int ratesNum;
    const char* vid;
    const char* title;
    const char* thumbnailURL;
    const char* coverURL;
};
 
struct PLVVideoRequestPageInfo {
    PLVVideoRequestPageInfo():
        type(VIDEO_REQUEST_NONE),
        totalPages(0),
        totalItems(0),
        pageNumber(0),
        pageSize(0)
    {}
    VIDEO_REQUEST_TYPE type;
    int totalPages;
    int totalItems;
    int pageNumber;
    int pageSize;
};
 
struct PLVVideoFrame {
    uint8_t* data[8];
    uint32_t linesize[8];
    uint64_t timestamp;
    uint32_t width;
    uint32_t height;
    uint32_t format;
};
 
struct PLVChannelLineInfo {
    const char **qualitys;
    int64_t qualityNum;
    PLVChannelLineInfo() : qualitys(nullptr), qualityNum(0) {}
};
 
struct PLVSubtitleConfigInfo {
    PLVSubtitleConfigInfo()
        : textFont("sans-serif"),
          textSize(38),
          textColor("#FFFFFFFF"),
          borderSize(2),
          borderColor("#FF000000"),
          backgroundColor("#00000000"),
          alignX(0),
          alignY(1),
          posY(100),
          scaleByWindow(true),
          visible(true)
    {
    }
    const char *textFont;        
    int textSize;                
    const char *textColor;       
    int borderSize;              
    const char *borderColor;     
    const char *backgroundColor; 
    int alignX;                  
    int alignY;                  
    int posY;                    
    bool scaleByWindow;          
    bool visible;                
};
 
struct PLVChannelInfo {
    char channelId[PLV_MAX_NAME_LENGTH];
    char name[PLV_MAX_NAME_LENGTH];
    PLVChannelLineInfo *lines;
    int64_t lineNum;
    bool isOnlyAudio;
    PLVChannelInfo() : channelId(""), name(""), lines(nullptr), lineNum(0), isOnlyAudio(false) {}
};
 
#ifdef __cplusplus
}
#endif