WsbPlaylistProxy.h

Go to the documentation of this file.

/*****************************************************************
|
|   Wasabi - Playlist Proxy, C interface
|
|   $Id: WsbPlaylistProxy.h 13807 2018-02-09 10:12:46Z nbanda $
|   Original author: Edin Hodzic ([email protected])
|
|   This software is provided to you pursuant to your agreement 
|   with Intertrust Technologies Corporation ("Intertrust"). 
|   This software may be used only in accordance with the terms 
|   of the agreement.
|      
|   Copyright (c) 2011-2014 by Intertrust. All rights reserved. 
|
****************************************************************/
#ifndef _WSB_PLAYLIST_PROXY_H_
#define _WSB_PLAYLIST_PROXY_H_

/*----------------------------------------------------------------------
 |   includes
 +---------------------------------------------------------------------*/
#include "WsbResults.h"
#include "WsbTypes.h"

/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/


typedef struct WSB_PlaylistProxy WSB_PlaylistProxy;

typedef enum {

    WSB_PPMST_SINGLE_FILE,

    WSB_PPMST_HLS,

    WSB_PPMST_DASH

} WSB_PlaylistProxy_MediaSourceType;

typedef enum {
    WSB_PP_TRACK_ANY = 0,
    WSB_PP_TRACK_BY_ID,
    WSB_PP_TRACK_BY_INDEX
} WSB_PlaylistProxy_TrackSelector;

typedef struct {

    const char*  source_content_type;

    const char*  content_type;

    unsigned int duration_seconds;

    unsigned int bitrate_bps;

    const char* language;

    const char* audio_codecs;

    const char* video_codecs;

    const char* bbts_index_url;

    const char* master_playlist_appendix;

    WSB_PlaylistProxy_TrackSelector audio_track_selector;
    
    WSB_UInt32 audio_track;

    WSB_PlaylistProxy_TrackSelector video_track_selector;
    
    WSB_UInt32 video_track;
    
    const char* extra_content_access_http_headers;

    const char* extra_client_http_headers;

    const char* subtitle_name;

    const char* subtitle_lang;

    const char* subtitle_url;

} WSB_PlaylistProxy_MediaSourceParams;

typedef enum {
    WSB_PPLT_NONE,
    WSB_PPLT_MS3_SURL,
    WSB_PPLT_BB_TOKEN
} WSB_PlaylistProxy_LicenseType;

typedef enum {
    WSB_PPET_ERROR_NOTIFICATION = 0
} WSB_PlaylistProxy_EventType;

typedef struct {
    WSB_PlaylistProxy_EventType type;
} WSB_PlaylistProxy_Event;

typedef struct {
    WSB_PlaylistProxy_Event base;

    WSB_Result              result;

    const char*             error_string;
} WSB_PlaylistProxy_ErrorNotificationEvent;

typedef struct {
    void* instance;
    void (*handler)(void* instance, const WSB_PlaylistProxy_Event* event);
} WSB_PlaylistProxy_EventListener;

/*----------------------------------------------------------------------
|   functions
+---------------------------------------------------------------------*/

#if defined(__cplusplus)
extern "C" {
#endif

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_Create(WSB_PlaylistProxy** self);

#define WSB_PP_FLAG_ENCRYPTED_HLS     (1<<0)

#define WSB_PP_FLAG_AUTH_TOKEN_HEADER (1<<1)

#define WSB_PP_FLAG_SESSION_KEY (1<<2)

#define WSB_PP_FLAG_BLOCK_FOR_LICENSE_IMPLICIT (1<<3)

#define WSB_PP_FLAG_BLOCK_FOR_LICENSE_EXPLICIT (1<<4)

#define WSB_PP_FLAG_NO_SHORT_URLS (1<<5)
    
#define WSB_PP_FLAG_ALLOW_EXTERNAL_CLIENT (1<<6)
    
#define WSB_PP_FLAG_FAIRPLAY_ENCRYPTED_HLS (1<<7)
    
#define WSB_PP_FLAG_DEMUXED_HLS (1<<8)

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_CreateWithFlags(WSB_UInt32 flags, WSB_PlaylistProxy** self);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_CreateWithListener(WSB_UInt32 flags,
                                     const WSB_PlaylistProxy_EventListener listener,
                                     WSB_PlaylistProxy** self);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_Destroy(WSB_PlaylistProxy* self);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_Start(WSB_PlaylistProxy* self);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_UnblockForLicense(WSB_PlaylistProxy* self,
                                    WSB_PlaylistProxy_LicenseType type,
                                    const void* license_data,
                                    WSB_Size license_length);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_Stop(WSB_PlaylistProxy* self);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_GetAndClearLastError(WSB_PlaylistProxy* self);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_MakeUrl(
    WSB_PlaylistProxy*                         self,
    const char*                                media_source,
    WSB_PlaylistProxy_MediaSourceType          media_source_type,
    const WSB_PlaylistProxy_MediaSourceParams* media_source_params,
    const char**                               http_url);

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_GetAuthToken(WSB_PlaylistProxy* self,
                               char*              auth_token,
                               WSB_Size*          token_size);
typedef enum {
    WSB_PPSKF_CLEAR,
    WSB_PPSKF_SKB
} WSB_PlaylistProxySessionKeyFormat;

WSB_EXPORT WSB_Result
WSB_PlaylistProxy_GetSessionKey(WSB_PlaylistProxy*                self,
                                WSB_PlaylistProxySessionKeyFormat key_format,
                                WSB_Byte*                         key,
                                WSB_Size*                         key_size);

#if defined(__cplusplus)
}
#endif

#endif /* _WSB_PLAYLIST_PROXY_H_ */