Ts2Packet.h

Go to the documentation of this file.

/*****************************************************************
|
|   MPEG2 Transport Stream - Packet
|
|   $Id: Ts2Packet.h 196 2012-01-05 14:18:55Z 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) 2009-2012 Intertrust. All rights reserved. 
|
****************************************************************/

#ifndef _TS2_PACKET_H_
#define _TS2_PACKET_H_

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

/*----------------------------------------------------------------------
|   constants
+---------------------------------------------------------------------*/
/* pids */
#define TS2_NULL_PACKET_PID 0x1FFF
#define TS2_INVALID_PID     0xFFFF

/* frequency/PCR */
#define TS2_SYSTEM_CLOCK_FREQUENCY 27000000.0 /* 27 MHz */
#define TS2_INVALID_PCR_IN_SECS    -1.0
#define TS2_MAX_PCR_IN_SECS        95443.717696703708 /* ((2**33-1)*300+(2**9-1)) / 27000000.0 */

/* packet size */
#define TS2_PACKET_SIZE         188
#define TS2_PACKET_HEADER_SIZE  4
#define TS2_PACKET_PAYLOAD_SIZE (TS2_PACKET_SIZE - TS2_PACKET_HEADER_SIZE)

#define TS2_PACKET_SYNC_BYTE 0x47

#define TS2_PACKET_AF_CLOCK_REFERENCE_DATA_SIZE 6
#define TS2_PACKET_AF_EXTENSION_SEAMLESS_SIZE 5

#define TS2_STUFFING_BYTE 0xFF

/* flags */
#define TS2_PACKET_TRANSPORT_ERROR_INDICATOR_FLAG_MASK     0x04
#define TS2_PACKET_PAYLOAD_UNIT_START_INDICATOR_FLAG_MASK  0x02
#define TS2_PACKET_TRANSPORT_PRIORITY_FLAG_MASK            0x01

/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/
typedef struct {
    ATX_UInt8           length;
    ATX_UInt8           flags;
    ATX_UInt16          ltw;
    ATX_UInt32          piecewise;
    ATX_UInt8           seamless_splice[TS2_PACKET_AF_EXTENSION_SEAMLESS_SIZE];
} TS2_AdaptationField_Extension;

typedef struct {
    ATX_UInt8                      length;
    ATX_UInt8                      flags;
    ATX_UInt8                      pcr_data[TS2_PACKET_AF_CLOCK_REFERENCE_DATA_SIZE];
    ATX_UInt8                      opcr_data[TS2_PACKET_AF_CLOCK_REFERENCE_DATA_SIZE];
    ATX_UInt8                      splice_countdown;
    ATX_UInt8                      transport_private_data_length;
    ATX_Byte*                      transport_private_data;
    TS2_AdaptationField_Extension* extension;
} TS2_AdaptationField;

typedef enum {
    TS2_NO_SCRAMBLING           = 0x00,
    TS2_DEFAULT_CK_SCRAMBLING   = 0x01,
    TS2_EVEN_CK_SCRAMBLING      = 0x02,
    TS2_ODD_CK_SCRAMBLING       = 0x03
} TS2_ScramblingControl;

typedef enum {
    TS2_AF_CONTROL_NULL_PACKET      = 0x00,
    TS2_AF_CONTROL_PAYLOAD_ONLY     = 0x01,
    TS2_AF_CONTROL_AF_ONLY          = 0x02,
    TS2_AF_CONTROL_AF_AND_PAYLOAD   = 0x03
} TS2_AfControl;

typedef struct {
    ATX_UInt8               flags;
    ATX_UInt16              pid;
    TS2_ScramblingControl   scrambling_control;
    TS2_AfControl           af_control;
    ATX_UInt8               continuity_counter;
    TS2_AdaptationField*    adaptation_field;
    ATX_Byte                payload[TS2_PACKET_SIZE-TS2_PACKET_HEADER_SIZE];
    ATX_Size                payload_size;
} TS2_Packet;

typedef struct TS2_PacketDispatcher TS2_PacketDispatcher;

typedef struct {
    void*      instance;
    ATX_Result (*HandlePacket)(void*                 handler_instance,
                               TS2_PacketDispatcher* dispatcher,
                               TS2_Packet*           packet);
} TS2_PacketHandler;

typedef struct TS2_PacketPump TS2_PacketPump;

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*----------------------------------------------------------------------
|   TS2_AdaptationField functions and macros
+---------------------------------------------------------------------*/
ATX_Float
TS2_AdaptationField_PcrInSecs(TS2_AdaptationField* self);

#define TS2_AF_Flags_DiscontinuityIndicator(flags)   ((flags) & 0x80)
#define TS2_AF_Flags_RandomAccessIndicator(flags)    ((flags) & 0x40)
#define TS2_AF_Flags_EsPriorityIndicator(flags)      ((flags) & 0x20)
#define TS2_AF_Flags_PcrFlag(flags)                  ((flags) & 0x10)
#define TS2_AF_Flags_OpcrFlag(flags)                 ((flags) & 0x08)
#define TS2_AF_Flags_SplicingPointFlag(flags)        ((flags) & 0x04)
#define TS2_AF_Flags_TransportPrivateDataFlag(flags) ((flags) & 0x02)
#define TS2_AF_Flags_ExtensionFlag(flags)            ((flags) & 0x01)

#define TS2_AF_Extension_Flags_LtwFlag(flags)            ((flags) & 0x80)
#define TS2_AF_Extension_Flags_PiecewiseRateFlag(flags)  ((flags) & 0x40)
#define TS2_AF_Extension_Flags_SeamlessSpliceFlag(flags) ((flags) & 0x20)

/*----------------------------------------------------------------------
|   TS2_Packet functions and macros
+---------------------------------------------------------------------*/
ATX_Result 
TS2_Packet_InitFromInputStream(ATX_InputStream* stream, 
                               TS2_Packet*      packet);
    
ATX_Result 
TS2_Packet_InitFromBuffer(const ATX_Byte* buffer,
                          TS2_Packet*     packet);
    
ATX_Result 
TS2_Packet_SerializeToBuffer(TS2_Packet* packet,
                             ATX_Byte*   buffer);

void 
TS2_Packet_Destruct(TS2_Packet* packet);

void 
TS2_FormatPacketHeader(ATX_Byte*             buffer, /* TS2_PACKET_HEADER_SIZE */
                       ATX_UInt32            transport_error_indicator,
                       ATX_UInt32            payload_unit_start_indicator,
                       ATX_UInt32            transport_priority,
                       ATX_UInt16            pid,
                       TS2_ScramblingControl scrambling_control,
                       TS2_AfControl         af_control,
                       ATX_UInt32            continuity_counter);
                            

#define TS2_Packet_HasAdaptationField(packet) ((packet)->af_control & 0x02)
#define TS2_Packet_HasPayload(packet)         ((packet)->af_control & 0x01)
#define TS2_Packet_HasPcr(packet) (                         \
    TS2_Packet_HasAdaptationField(packet) &&                \
    packet->adaptation_field != NULL      &&                \
    TS2_AF_Flags_PcrFlag(packet->adaptation_field->flags)   \
)
    
#define TS2_Packet_Flags_TransportError(pflags)    (((pflags) & 0x04) >> 2)
#define TS2_Packet_Flags_PayloadUnitStart(pflags)  (((pflags) & 0x02) >> 1)
#define TS2_Packet_Flags_TransportPriority(pflags) (((pflags) & 0x01)     )

/*----------------------------------------------------------------------
|   TS2_PacketDispatcher functions
+---------------------------------------------------------------------*/
ATX_Result 
TS2_PacketDispatcher_Create(TS2_PacketDispatcher** dispatcher);

TS2_EXPORT ATX_Result
TS2_PacketDispatcher_SetHandler(TS2_PacketDispatcher* self,
                                ATX_UInt16            pid,
                                TS2_PacketHandler     handler);

TS2_EXPORT ATX_Result
TS2_PacketDispatcher_ResetHandler(TS2_PacketDispatcher* self,
                                  ATX_UInt16            pid);

ATX_Result
TS2_PacketDispatcher_SetDefaultHandler(TS2_PacketDispatcher* self,
                                       TS2_PacketHandler     handler);

ATX_Result
TS2_PacketDispatcher_ResetDefaultHandler(TS2_PacketDispatcher* self);

ATX_Result
TS2_PacketDispatcher_Dispatch(TS2_PacketDispatcher* self,
                              TS2_Packet*           packet);

ATX_UInt16
TS2_PacketDispatcher_GetNextAvailablePid(TS2_PacketDispatcher* self);

ATX_Boolean
TS2_PacketDispatcher_IsPidUsed(TS2_PacketDispatcher* self, ATX_UInt16 pid);

void 
TS2_PacketDispatcher_Destroy(TS2_PacketDispatcher* self);    

/*----------------------------------------------------------------------
|   TS2_Packet functions
+---------------------------------------------------------------------*/
TS2_EXPORT ATX_Result 
TS2_PacketPump_Create(ATX_InputStream*      stream, 
                      TS2_PacketDispatcher* dispatcher, /* takes ownership. If NULL, will create one */
                      TS2_PacketPump**      pump);

TS2_EXPORT TS2_PacketDispatcher* 
TS2_PacketPump_GetDispatcher(TS2_PacketPump* self);

TS2_EXPORT ATX_Result 
TS2_PacketPump_Pump(TS2_PacketPump* self);

TS2_EXPORT ATX_Result
TS2_PacketPump_ResetStream(TS2_PacketPump*  self,
                           ATX_InputStream* stream);

TS2_EXPORT void 
TS2_PacketPump_Destroy(TS2_PacketPump* self);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* _TS2_PACKET_H_ */