MediaCommon.h

Go to the documentation of this file.

/*
 * If not stated otherwise in this file or this component's LICENSE file the
 * following copyright and licenses apply:
 *
 * Copyright 2022 Sky UK
 *
 * 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
 *
 * http://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 FIREBOLT_RIALTO_MEDIA_COMMON_H_
#define FIREBOLT_RIALTO_MEDIA_COMMON_H_
 
#include <limits>
#include <optional>
#include <stddef.h>
#include <stdint.h>
#include <utility>
#include <vector>
 
namespace firebolt::rialto
{
constexpr int32_t kInvalidSessionId{-1};
 
constexpr uint32_t kInvalidAudioChannels{0};
 
constexpr uint32_t kInvalidAudioSampleRate{0};
 
constexpr int32_t kUndefinedSize{0};
 
constexpr uint32_t kInvalidLimitBuffering{std::numeric_limits<uint32_t>::max()};
 
constexpr uint64_t kUndefinedPosition{std::numeric_limits<uint64_t>::max()};
 
enum class MediaSourceType
{
    UNKNOWN,
    AUDIO,
    VIDEO,
    SUBTITLE
};
 
enum class SourceConfigType
{
    UNKNOWN,
    AUDIO,
    VIDEO,
    VIDEO_DOLBY_VISION,
    SUBTITLE
};
 
enum class AudioEaseType
{
    LINEAR = 0,
    INCUBIC,
    OUTCUBIC
};
 
enum class MediaType
{
    UNKNOWN, 
    MSE      
};
 
enum class MediaSourceStatus
{
    OK,                   
    EOS,                  
    ERROR,                
    CODEC_CHANGED,        
    NO_AVAILABLE_SAMPLES, 
    NO_SPACE_FOR_SAMPLES  
};
 
enum class NetworkState
{
    UNKNOWN,            
    IDLE,               
    BUFFERING,          
    BUFFERING_PROGRESS, 
    BUFFERED,           
    STALLED,            
    FORMAT_ERROR,       
    NETWORK_ERROR,      
    DECODE_ERROR        
};
 
enum class PlaybackState
{
    UNKNOWN,       
    IDLE,          
    PLAYING,       
    PAUSED,        
    SEEKING,       
    SEEK_DONE,     
    STOPPED,       
    END_OF_STREAM, 
    FAILURE        
};
 
enum class Format
{
    S8,
    U8,
    S16LE,
    S16BE,
    U16LE,
    U16BE,
    S24_32LE,
    S24_32BE,
    U24_32LE,
    U24_32BE,
    S32LE,
    S32BE,
    U32LE,
    U32BE,
    S24LE,
    S24BE,
    U24LE,
    U24BE,
    S20LE,
    S20BE,
    U20LE,
    U20BE,
    S18LE,
    S18BE,
    U18LE,
    U18BE,
    F32LE,
    F32BE,
    F64LE,
    F64BE
};
 
enum class Layout
{
    INTERLEAVED,
    NON_INTERLEAVED
};
 
struct AudioConfig
{
    uint32_t numberOfChannels = kInvalidAudioChannels; 
    uint32_t sampleRate = kInvalidAudioSampleRate;     
    std::vector<uint8_t> codecSpecificConfig;       
    std::optional<Format> format;                   
    std::optional<Layout> layout;                   
    std::optional<uint64_t> channelMask;            
    std::vector<std::vector<uint8_t>> streamHeader; 
    std::optional<bool>
        framed; 
};
 
enum class AddSegmentStatus
{
    OK,       
    NO_SPACE, 
    ERROR     
};
 
struct SubSamplePair
{
    size_t numClearBytes;     
    size_t numEncryptedBytes; 
};
 
struct VideoRequirements
{
    uint32_t maxWidth;  
    uint32_t maxHeight; 
};
 
struct MediaPlayerShmInfo
{
    uint32_t maxMetadataBytes; 
    uint32_t metadataOffset;   
    uint32_t mediaDataOffset;  
    uint32_t maxMediaBytes;    
};
 
struct QosInfo
{
    uint64_t processed; 
    uint64_t dropped;   
};
 
enum class MediaKeyErrorStatus
{
    OK,                        
    FAIL,                      
    BAD_SESSION_ID,            
    NOT_SUPPORTED,             
    INVALID_STATE,             
    INTERFACE_NOT_IMPLEMENTED, 
    BUFFER_TOO_SMALL,          
    OUTPUT_RESTRICTED          
};
 
enum class KeySessionType
{
    UNKNOWN,                   
    TEMPORARY,                 
    PERSISTENT_LICENCE,        
    PERSISTENT_RELEASE_MESSAGE 
};
 
enum class InitDataType
{
    UNKNOWN,  
    CENC,     
    KEY_IDS,  
    WEBM,     
    DRMHEADER 
};
 
enum class KeyStatus
{
    USABLE,
    EXPIRED,
    OUTPUT_RESTRICTED,
    PENDING,
    INTERNAL_ERROR,
    RELEASED
};
 
enum class SegmentAlignment
{
    UNDEFINED,
    NAL,
    AU
};
 
enum class StreamFormat
{
    UNDEFINED,
    RAW,
    AVC,
    BYTE_STREAM,
    HVC1,
    HEV1
};
 
typedef std::vector<std::pair<std::vector<unsigned char>, KeyStatus>> KeyStatusVector;
 
struct WebAudioShmInfo
{
    uint32_t offsetMain; 
    uint32_t lengthMain; 
    uint32_t offsetWrap; 
    uint32_t lengthWrap; 
};
 
struct WebAudioPcmConfig
{
    uint32_t rate;       
    uint32_t channels;   
    uint32_t sampleSize; 
    bool isBigEndian;    
    bool isSigned;       
    bool isFloat;        
};
 
union WebAudioConfig
{
    WebAudioPcmConfig pcm;
};
 
enum class WebAudioPlayerState
{
    UNKNOWN,       
    IDLE,          
    PLAYING,       
    PAUSED,        
    END_OF_STREAM, 
    FAILURE        
};
 
enum class CipherMode
{
    UNKNOWN,
    CENC, /* AES-CTR scheme */
    CBC1, /* AES-CBC scheme */
    CENS, /* AES-CTR subsample pattern encryption scheme */
    CBCS  /* AES-CBC subsample pattern encryption scheme */
};
 
struct Fraction
{
    int32_t numerator;   
    int32_t denominator; 
};
 
enum class CodecDataType
{
    BUFFER,
    STRING
};
 
struct CodecData
{
    std::vector<uint8_t> data{};               
    CodecDataType type{CodecDataType::BUFFER}; 
};
 
enum class PlaybackError
{
    UNKNOWN,
    DECRYPTION,       /* Player failed to decrypt a buffer and the frame has been dropped */
    OUTPUT_PROTECTION /* HDCP output protection failure */
};
 
enum class EaseType
{
    EASE_LINEAR,
    EASE_IN_CUBIC,
    EASE_OUT_CUBIC
};
 
struct PlaybackInfo
{
    int64_t currentPosition{-1}; 
    double volume{1.0};          
};
 
enum class LimitedDurationLicense
{
    NOT_SPECIFIED, 
    ENABLED,       
    DISABLED       
};
} // namespace firebolt::rialto
 
#endif // FIREBOLT_RIALTO_MEDIA_COMMON_H_