Ts2Streams.h

Go to the documentation of this file.

/*****************************************************************
|
|   MPEG2 Transport Stream - Streams
|
|   $Id: Ts2Streams.h 363 2018-07-23 08:41:38Z jebaseelir $
|   Original author:  Julien Boeuf
|
|   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) 2010-2014 by Intertrust. All rights reserved. 
|
****************************************************************/

#ifndef _TS2_STREAMS_H_
#define _TS2_STREAMS_H_

/*----------------------------------------------------------------------
|   includes
+---------------------------------------------------------------------*/
#include "Atomix.h"
#include "Ts2Packet.h"
#include "Ts2Protection.h"
#include "Ts2Marlin.h"
#include "Ts2Config.h"

/*----------------------------------------------------------------------
|   constants
+---------------------------------------------------------------------*/
#define TS2_INFINITE_PACKET_COUNT                   -1
#define TS2_DEFAULT_MAX_CAT_PACKET_COUNT_FROM_KSM   100
#define TS2_DEFAULT_PROGRAM_NUMBER                  1

/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/
typedef struct TS2_StreamInfo     TS2_StreamInfo;

typedef enum {
    TS2_UNKNOWN_CA,
    TS2_NO_CA,
    TS2_MARLIN_CA,
    /* To ensure backward compatibility */
    TS2_MARLIN_BBTS_CA = TS2_MARLIN_CA
} TS2_CaSystem;

typedef enum {
    TS2_DOVI_SINGLE_PID,
    TS2_DOVI_DUAL_PID
} TS2_DoviSignaling;

typedef struct {
    ATX_UInt16  pid;
    ATX_Byte    version_major;
    ATX_Byte    version_minor;
    ATX_Byte    profile;
    ATX_Byte    level;
    ATX_Boolean rpu_present;
    ATX_Boolean el_present;
    ATX_Boolean bl_present;
} TS2_DoviSignalingInfo;

typedef struct {
    ATX_Boolean           sdr_compatible;
    TS2_DoviSignaling     signaling_type;
    TS2_DoviSignalingInfo primary;
    TS2_DoviSignalingInfo secondary;    /* only use with dual pid signaling */
} TS2_DoviStreamInfo;

typedef struct {
    void* instance;
    void  (*HandleInfo)(void*                       instance,
                        const TS2_MarlinRightsInfo* info);
} TS2_MarlinRightsInfoHandler;

typedef struct TS2_BbtsParser TS2_BbtsParser;

typedef enum {
    TS2_BP_GOT_CONTENTID  = (1<<0),
    TS2_BP_GOT_RIGHTSINFO = (1<<1)
} TS2_BbtsParser_Status;

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
    
/*----------------------------------------------------------------------
|   TS2_StreamInfo_Create
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result
TS2_StreamInfo_Create(ATX_InputStream* stream,
                      ATX_Int32        max_packet_count,
                      TS2_StreamInfo** info);



/*----------------------------------------------------------------------
|   TS2_StreamInfo_CreateEx
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result
TS2_StreamInfo_CreateEx(ATX_InputStream* stream,
                        ATX_Int32        max_packet_count,
                        ATX_UInt32       max_cat_packet_count_from_ksm,
                        ATX_UInt32       user_program_number,
                        TS2_StreamInfo** info
                        );


TS2_EXPORT ATX_Result
TS2_StreamInfo_UpdatePMT(TS2_StreamInfo* self, 
                         const ATX_Byte* pmt_table, 
                         ATX_Size        pmt_len,
                         /* returns */
                         ATX_UInt16*     ksmt_pid);

TS2_EXPORT ATX_Result
TS2_StreamInfo_UpdateCAT(TS2_StreamInfo* self, 
                         const ATX_Byte* cat_table, 
                         ATX_Size        cat_len,
                         /* returns */
                         ATX_UInt16*     mrt_pid);

TS2_EXPORT ATX_Result
TS2_StreamInfo_UpdateKSMT(TS2_StreamInfo* self,
                          const ATX_Byte* ksm_table, 
                          ATX_Size        ksm_len);


TS2_EXPORT ATX_Result
TS2_StreamInfo_UpdateMRT(TS2_StreamInfo* self,
                         const ATX_Byte* mr_table, 
                         ATX_Size        mr_len);

TS2_EXPORT TS2_KSMT*
TS2_StreamInfo_GetKSMT(TS2_StreamInfo* self);

TS2_EXPORT TS2_PAT*
TS2_StreamInfo_GetPAT(TS2_StreamInfo* self);

TS2_EXPORT TS2_PMT*
TS2_StreamInfo_GetPMT(TS2_StreamInfo* self);

TS2_EXPORT TS2_CaSystem
TS2_StreamInfo_GetCaSystem(const TS2_StreamInfo* self);

TS2_EXPORT TS2_TrafficProtectionSystem
TS2_StreamInfo_GetTrafficProtectionSystem(const TS2_StreamInfo* self, ATX_UInt32* kdf_type);

TS2_EXPORT const char*
TS2_StreamInfo_GetContentIdBase(const TS2_StreamInfo* self);

TS2_EXPORT const char*
TS2_StreamInfo_GetContentId(const TS2_StreamInfo* self);

TS2_EXPORT const char*
TS2_StreamInfo_GetRightsIssuerUrl(const TS2_StreamInfo* self);

TS2_EXPORT const char* 
TS2_StreamInfo_GetSilentRightsUrl(const TS2_StreamInfo* self);

TS2_EXPORT const char* 
TS2_StreamInfo_GetPreviewRightsUrl(const TS2_StreamInfo* self);

TS2_EXPORT ATX_List*
TS2_StreamInfo_GetElementaryStreams(const TS2_StreamInfo* self);

TS2_EXPORT const TS2_DoviStreamInfo*
TS2_StreamInfo_GetDoviStreamInfo(const TS2_StreamInfo* self);

TS2_EXPORT void
TS2_StreamInfo_Destroy(TS2_StreamInfo* self);

/*----------------------------------------------------------------------
|   TS2_DecryptingStream
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result 
TS2_DecryptingStream_Create(ATX_InputStream*             protected_stream,
                            TS2_CryptoInterface          crypto,
                            TS2_MarlinRightsInfoHandler* marlin_handler,
                            ATX_InputStream**            decrypting_stream);

/*----------------------------------------------------------------------
|   TS2_AdaptiveAwareEncryptingStream
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result
TS2_AdaptiveAwareEncryptingStream_Create(ATX_InputStream*            cleartext_stream,
                                         const char*                 content_id,
                                         const ATX_Byte*             content_key,
                                         const ATX_Byte*             common_iv,
                                         TS2_TrafficProtectionSystem protection,
                                         ATX_UInt32                  crypto_period,
                                         const ATX_Byte*             traffic_seed,
                                         ATX_Size                    seed_size,
                                         ATX_UInt32                  first_segment_index,
                                         TS2_RotationPoints*         rotation_points,
                                         ATX_UInt16                  ksm_pid,
                                         const char*                 rights_issuer_url,
                                         const char*                 silent_rights_url,
                                         const char*                 preview_rights_url,
                                         const ATX_Byte*             access_criteria,
                                         ATX_Size                    access_criteria_size,
                                         ATX_InputStream**           encrypting_stream);

/*----------------------------------------------------------------------
|   TS2_EncryptingStream
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result
TS2_EncryptingStream_Create(ATX_InputStream*            cleartext_stream,
                            const char*                 content_id,
                            const ATX_Byte*             content_key,
                            const ATX_Byte*             common_iv,
                            TS2_TrafficProtectionSystem protection,
                            ATX_UInt32                  crypto_period, 
                            const char*                 rights_issuer_url,
                            const char*                 silent_rights_url,
                            const char*                 preview_rights_url,
                            ATX_Boolean                 skip_payload_unit_start,
                            ATX_Boolean                 single_key_layer,
                            const ATX_Byte*             access_criteria,
                            ATX_Size                    access_criteria_size,
                            ATX_InputStream**           encrypting_stream);

/*----------------------------------------------------------------------
|   common TS2_Stream methods
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result
TS2_Stream_ResetSourceStream(ATX_InputStream* self,
                             ATX_InputStream* source);

TS2_EXPORT ATX_Result
TS2_Stream_ResetDrm(ATX_InputStream* self,
                    const char*      content_id,
                    const ATX_Byte*  content_key);

TS2_EXPORT ATX_Result
TS2_Stream_ResetDrmEx(ATX_InputStream* self,
                      const char*      content_id,
                      const ATX_Byte*  content_key,
                      const ATX_Byte*  access_criteria,
                      ATX_Size         access_criteria_size);

                            
/*----------------------------------------------------------------------
|   TS2_BbtsParser
+---------------------------------------------------------------------*/
ATX_Result
TS2_BbtsParser_Create(TS2_BbtsParser** parser);

void
TS2_BbtsParser_Destroy(TS2_BbtsParser* self);

ATX_Result
TS2_BbtsParser_Update(TS2_BbtsParser* self, 
                      ATX_Byte* buffer, ATX_Size length, 
                      /* returns */
                      TS2_BbtsParser_Status *status);

ATX_Result
TS2_BbtsParser_GetInfo(TS2_BbtsParser* self, TS2_StreamInfo** info);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* _TS2_STREAMS_H_ */