Hu Chunming / Project_VideoStructure

#ifndef __SFX__SfxMediaStd__MODULE__
#define __SFX__SfxMediaStd__MODULE__
#ifdef __cplusplus
extern "C"
{
#endif
#include <SfxStd.h>
	
#define SFX_MTU_UDP_DEFAULT_SIZE              1500  //1442
#define SFX_MTU_DEFAULT_SIZE                  1500
#define SFX_MTU_UDP_PAYLOAD_SIZE              1420
#define SFX_MEDIA_KEEPALIVE_TIMEOUT           ( 1000 * 3 )
#define SFX_KEEPALIVE_TIMEOUT                 ( 1000 * 30 )
#define SFX_MEDIA_VIDEO_DEFAULT_SIZE          ( 1024 * 800 )
#define SFX_MEDIA_AUDIO_DEFAULT_SIZE          ( 1024 * 16 )
#define SFX_MP3_FRAME_LENGTH                  ( 1152 )
#define SFX_AAC_FRAME_LENGTH                  ( 1024 )
#define SFX_DECODE_CONFIG_MAX_SIZE            0x000000FF    // 256

#define SFX_GBX_ID_SIZE                       0x00000018
#define SFX_GBX_UN_SIZE                       0x00000080 

typedef enum SfxCodecRlt
{
	SFX_RLT_CACHE_INSUFFICIENT = -2,
	SFX_RLT_PCM_BUF_INSUFFICIENT = -3,
	SFX_RLT_LOST_SYNC_BYTE = -4
}SfxCodecRlt;


typedef enum SfxCodecType            // CODEC���Ͷ���,����λָ��ΪӲ����
{
	SFX_CODEC_TYPE_UNKNOW = 0x00,
	SFX_CODEC_TYPE_H263 = 0x01,
	SFX_CODEC_TYPE_H264 = 0x02,
	SFX_CODEC_TYPE_H265 = 0x03,
	SFX_CODEC_TYPE_JPEG = 0x04,
	SFX_CODEC_TYPE_MP3 = 0x06,
	SFX_CODEC_TYPE_AAC = 0x07,
    SFX_CODEC_TYPE_G711A = 0x08,
    SFX_CODEC_TYPE_G711U = 0x09,
    SFX_CODEC_TYPE_PS = 0x0A,
	//SFX_CODEC_TYPE_RGB24 = 0x08,
	//SFX_CODEC_TYPE_NV12 = 0x09,
	//SFX_CODEC_TYPE_YUV420

	SFX_CODEC_TYPE_MPEG1 = 0x100,
	SFX_CODEC_TYPE_MPEG2,
	SFX_CODEC_TYPE_MPEG4,
	SFX_CODEC_TYPE_WMV3,
	SFX_CODEC_TYPE_VC1,
	SFX_CODEC_TYPE_VP8,
	SFX_CODEC_TYPE_VP9,
	SFX_CODEC_TYPE_MJPEG,
	SFX_CODEC_TYPE_AV1
}SfxCodecType;


typedef enum SfxVideoFormat
{
    SFX_VIDEO_FORMAT_UNKNOW = 0x00,
    SFX_VIDEO_FORMAT_C3RGBU8,        // rgb 8bit unsigned char
    SFX_VIDEO_FORMAT_C4RGBAU8,       // rgba 8bit unsigned char
    SFX_VIDEO_FORMAT_YUV420U8,       // yyyyuv 8bit unsigned char
    SFX_VIDEO_FORMAT_NV12U8,         // yyyyuv 8bit unsigned char
    SFX_VIDEO_FORMAT_C4RGBAU102,     // rgba 10bit 
    SFX_VIDEO_FORMAT_NV12F32,        // yyyyuv 32bit float
    SFX_VIDEO_FORMAT_C3BGRU8,        // bbbgggrr rgb 8bit unsigned char
    SFX_VIDEO_FORMAT_C3BGRU8P,       // bbbgggrr rgb 8bit unsigned char
    SFX_VIDEO_FORMAT_C3BGRF32P,      // bbbgggrr rgb 32bit float
	SFX_VIDEO_FORMAT_C3RGBF32,       // rgb 32bit float
}SfxVideoFormat;


typedef enum SfxAcceleratorType
{
    SFX_ACCEL_TYPE_UNKNOW = 0x00,
    SFX_ACCEL_TYPE_SW,
    SFX_ACCEL_TYPE_D3D9,
    SFX_ACCEL_TYPE_D3D11,
    SFX_ACCEL_TYPE_DXVA2,
    SFX_ACCEL_TYPE_INTEL,
    SFX_ACCEL_TYPE_NVIDIA,
    SFX_ACCEL_TYPE_IPP,
}SfxAcceleratorType;


typedef enum SfxFrameType            // ֡����
{
    SFX_FRAME_TYPE_UNKNOW = 0,       // δ֪֡����
    SFX_FRAME_TYPE_CONFIG,
    SFX_FRAME_TYPE_AUDIO,            // ��Ƶ֡���ݣ��磺AAC���ݻ�PCM���ݣ�
    SFX_FRAME_TYPE_VIDEO,            // ��Ƶ֡���ݣ��磺H264���ݻ�YUV���ݣ�
	SFX_FRAME_TYPE_MUXER,
    SFX_FRAME_TYPE_FLV_TAG,          // ��׼FLV tag���ݣ�onmetadataҲ��ͨ�������ͷ��ͣ�
	SFX_FRAME_TYPE_KEY,              // 
    SFX_FRAME_TYPE_EVENTS,           // ������������չʹ��
	SFX_FRAME_TYPE_HDR,              // ���ͷ�����������mp4�ļ��е�moov��flvͷ��
	SFX_FRAME_TYPE_END,              // ���ͷ�����������mp4�ļ��е�moov��flvͷ��
	SFX_FRAME_TYPE_USERDEF           // �dz���֡���ݣ���mp4�������flvͷ���������
}SfxFrameType;


typedef enum SfxMuxerFrameType
{
	SFX_MUXER_FRAME_TYPE_UNKNOW = 0,
	SFX_MUXER_FRAME_TYPE_HDR,
	SFX_MUXER_FRAME_TYPE_KEY_FRAME,
	SFX_MUXER_FRAME_TYPE_FRAME,
	SFX_MUXER_FRAME_TYPE_FRAME_END,
	SFX_MUXER_FRAME_TYPE_END,
	SFX_MUXER_FRAME_TYPE_USERDEF
}SfxMuxerFrameType;


typedef enum SfxStreamOpt            // ���������Ͷ���
{
    SFX_STREAM_OPT_UNKNOW = 0,
    SFX_STREAM_OPT_PULL,             // PULL����
    SFX_STREAM_OPT_PUSH              // PUSH����
}SfxStreamOpt;


typedef enum SfxTransportMode
{
	SFX_TRANSPORT_MODE_UNKNOW = 0,
	SFX_TRANSPORT_MODE_TCP,
	SFX_TRANSPORT_MODE_UDP
}SfxTransportMode;

/*
typedef enum SfxStreamTrackType
{
	SFX_STREAM_TRACK_TYPE_UNKNOW = 0,
	SFX_STREAM_TRACK_TYPE_AUDIO,
	SFX_STREAM_TRACK_TYPE_VIDEO
}SfxStreamTrackType;
*/

typedef enum SfxPacketType
{
	SFX_PACKET_TYPE_UNKNOW = 0,
	SFX_PACKET_TYPE_RTMP = 1,
	SFX_PACKET_TYPE_HTTP = 2,
#define SFX_PACKET_TYPE_RTSP  SFX_PACKET_TYPE_HTTP
#define SFX_PACKET_TYPE_GBX   SFX_PACKET_TYPE_HTTP
	SFX_PACKET_TYPE_RTP = 3,
	SFX_PACKET_TYPE_RTCP = 4,
	SFX_PACKET_TYPE_SFX = 6
}SfxPacketType;


typedef enum SfxFileType
{
	SFX_FILE_TYPE_UNKNOW = 0,
	SFX_FILE_TYPE_FLV,
	SFX_FILE_TYPE_MP4,
	SFX_FILE_TYPE_FMP4,
	SFX_FILE_TYPE_TS,
	SFX_FILE_TYPE_EX_FLV,
    SFX_FILE_TYPE_RAW,
	SFX_FILE_TYPE_SFX,
	SFX_FILE_TYPE_ISFX
}SfxFileType;


typedef struct SfxMediaFileInfo
{
    SfxFileType type;
    sfx_u64 duration;
    sfx_u64 fileSize;
}SfxMediaFileInfo;


typedef enum SfxTimestampMode
{
	SFX_TIMESTAMP_MODE_UNKNOW,
	SFX_TIMESTAMP_MODE_INCREASE,
	SFX_TIMESTAMP_MODE_INCREMENT
}SfxTimestampMode;


typedef enum SfxDevCtlType
{
	SFX_DEV_CTL_TYPE_UNKNOW = 0,
	SFX_DEV_CTL_TYPE_KEEPALIVE,
	SFX_DEV_CTL_TYPE_ENABLE,
	SFX_DEV_CTL_TYPE_AUTO_ENABLE,
	SFX_DEV_CTL_TYPE_STREAM,
	SFX_DEV_CTL_TYPE_PTZ_VERTICAL,
	SFX_DEV_CTL_TYPE_PTZ_HORIZON,
	SFX_DEV_CTL_TYPE_PTZ_ZOOM,
	SFX_DEV_CTL_TYPE_IMAGE_BS,             // base set: contrast sharpness brightness colorSaturation
	SFX_DEV_CTL_TYPE_IMAGE_BC,             // backlight compensation
	SFX_DEV_CTL_TYPE_IMAGE_WDR,            // wide dynamic range
	SFX_DEV_CTL_TYPE_IMAGE_FOCUS,          // focus
	SFX_DEV_CTL_TYPE_IMAGE_FOCUS_ADJUST,
	SFX_DEV_CTL_TYPE_GET_CONFIG,
	SFX_DEV_CTL_TYPE_TEST
	/*
	SFX_DEV_CTL_TYPE_KEEPALIVE,
	SFX_DEV_CTL_TYPE_STREAM,
	SFX_DEV_CTL_TYPE_SW,                      // software control    on/off/reboot
	SFX_DEV_CTL_TYPE_HW,                      // hardware control    on/off/reboot
	SFX_DEV_CTL_TYPE_PTZ_X,
	SFX_DEV_CTL_TYPE_PTZ_Y,
	SFX_DEV_CTL_TYPE_PTZ_ZOOM
	*/
}SfxDevCtlType;

typedef enum SfxDeviceType
{
	SFX_DEVICE_TYPE_UNKNOW = 0,
	SFX_DEVICE_TYPE_RTSP = 0x01,
	SFX_DEVICE_TYPE_GBX = 0x02,           // gb28181
	SFX_DEVICE_TYPE_UDG = 0x03,
	SFX_DEVICE_TYPE_VG = 0x06,            // virtual group
	SFX_DEVICE_TYPE_INVALID = 0x07
}SfxSDCDeviceType;

typedef enum SfxHardwareType
{
	SFX_HARDWARE_TYPE_UNKNOW = 0,
	SFX_HARDWARE_TYPE_AUDIO,
	SFX_HARDWARE_TYPE_VIDEO
}SfxHardwareType;

typedef enum SfxHardwareIOType
{
	SFX_HARDWARE_IO_TYPE_UNKNOW = 0,
	SFX_HARDWARE_IO_TYPE_CAPTURE,
	SFX_HARDWARE_IO_TYPE_RENDER
}SfxHardwareIOType;


typedef struct SfxHWDevice
{
	sfx_u32 devId;
	SfxHardwareType type;
	sfx_8 devName[SFX_DEFAULT_URL_SIZE];
	const struct SfxHWDevice * next;
}SfxHWDevice;


typedef enum SfxProtocolType
{
    SFX_PROTO_TYPE_UNKNOW = 0,
    SFX_PROTO_TYPE_HTTP,
    SFX_PROTO_TYPE_RTMP,
    SFX_PROTO_TYPE_RTC,
    SFX_PROTO_TYPE_RTSP,
    SFX_PROTO_TYPE_GBX
}SfxProtocolType;


typedef struct SfxUserPtr
{
    sfx_u16 type;
    sfx_u16 reserved1;
    sfx_void * handler;
    sfx_void * userPtr;
    sfx_void * reserved2;
}SfxUserPtr;


typedef struct SfxAddrConfig
{
    sfx_u32 ip;
    sfx_u16 port;
}SfxAddrConfig;

/**************************************************
* �ӿڣ�SfxElementaryStreamCallback
* ���ܣ����ݻص��ӿ�
* ������const sfx_void * userPtr �û��Զ�������
*      SfxFrameType type ��������
*      const sfx_u8 * buf �����׵�ַ
*      sfx_u32 segLen ��������ʵ�ʳ���
*      sfx_u32 len ��֡����ʵ�ʳ���
*      sfx_u32 timestamp ��֡ʱ���
* ���أ��ɹ����� SFX_RLT_OK��ʧ�ܷ��� SFX_RLT_ERROR��
* ��ע�����ӿ��ڲ��ɽ�������/��ʱ��������0 == lenʱ��
*      bufָ��������͵�������Ϣ�ṹ�壬������Ƶ����˵��
*      bufָ��SfxAudioConfig��������Ƶ����˵��bufָ��
*      SfxVideoConfig�� segLen��ָ��ǰ�ṹ��Ĵ�С��
* ���ߣ�Inpilen@foxmail.com
**************************************************/
typedef sfx_32 ( sfx_stdcall * SfxElementaryStreamCallback )( 
															 const sfx_void * userPtr,
															 SfxFrameType type,
															 const sfx_u8 * buf, 
															 sfx_u32 segLen, 
															 sfx_u32 len, 
															 sfx_u32 timestamp 
															 );


/**************************************************
* �ӿڣ�SfxRawStreamCallback
* ���ܣ����ݻص��ӿ�
* ������const sfx_void * userPtr �û��Զ�������
*      SfxFrameType type ��������
*      const sfx_u8 * buf �����׵�ַ
*      sfx_u32 segLen ��������ʵ�ʳ���
*      sfx_u32 len ��֡����ʵ�ʳ���
* ���أ��ɹ����� SFX_RLT_OK��ʧ�ܷ��� SFX_RLT_ERROR��
* ��ע�����ӿ��ڲ��ɽ�������/��ʱ��������0 == lenʱ��
*      bufָ��������͵�������Ϣ�ṹ�壬������Ƶ����˵��
*      bufָ��SfxAudioConfig��������Ƶ����˵��bufָ��
*      SfxVideoConfig�� segLen��ָ��ǰ�ṹ��Ĵ�С��
* ���ߣ�Inpilen@foxmail.com
**************************************************/
typedef sfx_32 ( sfx_stdcall * SfxRawStreamCallback )( 
													  const sfx_void * userPtr,
													  SfxFrameType type,
													  const sfx_u8 * buf, 
													  sfx_u32 segLen, 
													  sfx_u32 len 
													  );

#define SfxFrameStreamCallback SfxRawStreamCallback


/**************************************************
* �ӿڣ�SfxMuxerStreamCallback
* ���ܣ����ݻص��ӿ�
* ������const sfx_void * userPtr �û��Զ�������
*       SfxMuxerStreamCallback type ��������
*       const sfx_u8 * buf �����׵�ַ
*       sfx_u32 segLen ��������ʵ�ʳ���
*       sfx_u32 len ��֡����ʵ�ʳ���
* ���أ��ɹ����� SFX_RLT_OK��ʧ�ܷ��� SFX_RLT_ERROR��
* ��ע�����ӿ��ڲ��ɽ�������/��ʱ��������0 == lenʱ��
*       bufָ��������͵�������Ϣ�ṹ�塣
* ���ߣ�Inpilen@foxmail.com
**************************************************/
typedef sfx_32 ( sfx_stdcall * SfxMuxerStreamCallback )( 
													    const sfx_void * userPtr,
													    SfxMuxerFrameType type,
													    const sfx_u8 * buf, 
													    sfx_u32 segLen, 
													    sfx_u32 len 
													    );

typedef struct SfxAudioConfig        
{
	sfx_u16 channel;                 // ��Ƶͨ����
	sfx_u16 sampleBits;              // ��Ƶ����λ��
	sfx_u32 sampleRate;              // ��Ƶ������
	SfxCodecType codec;              // �����������
}SfxAudioConfig;


typedef struct SfxVideoConfig        
{
	sfx_uih ui;
	sfx_u32 fps;
	sfx_u8 flags;                     // 0: enable parser stream
	sfx_u8 fastdecode:1;              // enable fast decode mode
	sfx_f32 minQP;                    // ����ʱ��С�������������ڴ򿪱�����ʱ��䣩
	sfx_f32 maxQP;                    // ����ʱ����������������ڴ򿪱�����ʱ��䣩
	sfx_32 gopSize;                  // ��Ƶ��GOP��С�����ڴ򿪱�����ʱ��䣩
	sfx_32 width;                    // ͼ�����ֵ
	sfx_32 height;                   // ͼ��߶�ֵ
    sfx_u32 kbps;
    SfxVideoFormat fmt;
	SfxCodecType codec;              // �����������
}SfxVideoConfig;


typedef struct SfxVPConfig
{
	sfx_u32 accelId;
    sfx_32 inWidth;
    sfx_32 inHeight;
	sfx_32 inStride;
    sfx_32 outWidth;
    sfx_32 outHeight;
	sfx_32 outStride;
    SfxVideoFormat inFmt;
    SfxVideoFormat outFmt;
    SfxAcceleratorType type;
}SfxVPConfig;


typedef struct SfxMediaConfig
{
	SfxAudioConfig a;
	SfxVideoConfig v;
}SfxMediaConfig;


typedef struct SfxCodecConfig
{
	sfx_u32 accelId;
	SfxMediaConfig cfg;
	SfxFrameType type;               // ��ǰ��������Ƶ/��Ƶ
    SfxLogHandler logHdr;            // ��־����ӿ�
	const sfx_void * userPtr;        // �û�����
    SfxAcceleratorType accel;
	const sfx_void * reserved;       // ��ʹ��DXVA2Ӳ�����ٷ�������ֵ������ΪD3D�豸���
    SfxRawStreamCallback rscb;       // ���ݻص��ӿ�
}SfxCodecConfig;


typedef struct SfxTranscoderConfig
{
    union 
    {
    	SfxAudioConfig a;
	    SfxVideoConfig v;
    }src;
    union 
    {
    	SfxAudioConfig a;
	    SfxVideoConfig v;
    }dst;
    SfxFrameType type;
    SfxLogHandler logHdr;            // ��־����ӿ�
	SfxAcceleratorType accel;
    const sfx_void * userPtr;
    SfxRawStreamCallback rscb;
}SfxTranscoderConfig;

#define SFX_RTP_STABLE_FLAG              0x00000001

typedef struct SfxRtpParserFlags
{
	sfx_u32 jitter:16;               // ������ʱ������λms
	sfx_u32 stable:1;                // �ȶ�ģʽ:�̷߳��� ���ȶ�ģʽ:�����߳�
	sfx_u32 reserved:15;             // ����
}SfxRtpParserFlags;


typedef union SfxMediaFlags
{
	struct 
	{
        sfx_bool nat;
        sfx_bool passive;
		sfx_bool pwdIsMd5;
		SfxRtpParserFlags rtp;
		SfxTransportMode mode;
		sfx_8 host[SFX_DEFAULT_MIN_SIZE];  // �����ձ���IP��ַ
	}rtp;
	struct 
	{
		sfx_u32 flags;                    // 0b: out flv tag hdr 1b: out flv tag preSize field  2b: record client 
	}rtmp;
}SfxMediaFlags;


typedef struct SfxMediaStreamConfig
{
	sfx_u8 sva;
	sfx_8 * pwd;
	sfx_8 * user;
	sfx_u16 audioDrop;                // ��Ƶ����󻺴����������������Ƶ����
	sfx_u16 videoDrop;                // ��Ƶ����󻺴����������������Ƶ����
	sfx_u16 signalDrop;               // �������󻺴����������������Ƶ����
	sfx_32 reconnect;                 // -1: infinite reconnect.  0: disable reconnect. otherwise, reconnect time.
	sfx_u32 keepalive;                // 
	sfx_u32 contimeout;               // connect timeout��unit:ms��. 0: block mode.   otherwise: non-block mode. 
	SfxMediaFlags flags;
	sfx_bool asyncExit;               // module close interface mode. default block mode. WARNING: not recommend use asyncExit mode. ^_^

	//SfxAudioConfig audio;             // ��Ƶ��������ã�����RTMP��˵����������ΪPUSH�ҹ�������Ϊ��FLV tagʱ�����
	//SfxVideoConfig video;             // ��Ƶ��������ã�����RTMP��˵����������ΪPUSH�ҹ�������Ϊ��FLV tagʱ�����
    SfxLogHandler logHdr;             // ��־����ӿ�
	SfxElementaryStreamCallback escb; // ԭʼ������ӿ�
    const sfx_void * userPtr;         // �û��Զ������ݣ���Ҫ����ͬ����֧�ֶ�Ự����
	const SfxBufsHdr * bufsHdr;   
}SfxMediaStreamConfig;


typedef union SfxMuxerFlags
{
	struct 
	{
		sfx_u32 flvHOF:1;              // flv file header
		sfx_u32 flvEOF:1;              // flv last frame
		sfx_u32 forceAVC:1;            // I frame before output AVC structure
        sfx_u32 notFixTime:1;
		sfx_u32 reserved:28;
        sfx_u32 cacheFrames;
	}flv;
	struct 
	{
		sfx_u32 segment;             // 0: not split  otherwise��gop count
	}ts;
	struct
	{
		//sfx_u32 segment;
		sfx_u16 videoFrame;
	}mp4;
}SfxMuxerFlags;


typedef struct SfxDeocdeConfig
{
	sfx_u16 acfgLen;
	sfx_u16 vcfgLen;
	sfx_u8 acfg[SFX_DECODE_CONFIG_MAX_SIZE];
	sfx_u8 vcfg[SFX_DECODE_CONFIG_MAX_SIZE];
}SfxDeocdeConfig;

typedef struct SfxMuxerConfig
{
	sfx_u8 hasAV;                           // 0:v 1:a
	sfx_bool avc;
	SfxDeocdeConfig dcfg;
	SfxAudioConfig audio;
	SfxVideoConfig video;
	SfxMuxerFlags flags;
	const sfx_void * userPtr;
	SfxMuxerStreamCallback mscb;
}SfxMuxerConfig;

#pragma pack(1)
typedef struct SfxStreamStatistics
{
	volatile sfx_u32 used;                   // ģ��ʹ�ü���
	volatile sfx_u32 alive;                  // ���߼���
	volatile sfx_u64 recvs;                  // �����ֽ���
	volatile sfx_u64 sends;                  // �����ֽ���
	volatile sfx_u64 losts;                  // ��������
	volatile sfx_u64 reconnect;              // �ͻ������Ӽ���(�ͻ���ģʽ/�����ģʽ)
	volatile sfx_u64 keepalive;              // ���һ�����ݽ���ʱ��
	volatile sfx_u64 conTime;                // ��������ʱ��
	volatile sfx_u64 runTime;                // ��������ʱ��
	sfx_bool cleanStatistics;                // ��ȡ���Ƿ������ͳ����Ϣ
}SfxStreamStatistics;

#pragma pack()

sfx_void sfxBytesToString( sfx_u64 bytes, sfx_8 * str, sfx_u32 strSize );

typedef sfx_void ( * SFX_LOST_CALLBACK )( const sfx_void * userPtr, sfx_u16 channel, sfx_u16 * lost, sfx_u16 lostSize ); 

static SfxFileType sfxGetFileFormat( const sfx_8 * fmt )
{
    SfxFileType type = SFX_FILE_TYPE_UNKNOW;

    if ( 0 == sfx_memicmp( "fmp4", fmt, strlen( fmt ) + 1 ) )
    {
        type = SFX_FILE_TYPE_FMP4;
    }
    else if ( 0 == sfx_memicmp( "mp4", fmt, strlen( fmt ) + 1 ) )
    {
        type = SFX_FILE_TYPE_MP4;
    }
    else if ( 0 == sfx_memicmp( "flv", fmt, strlen( fmt ) + 1 ) )
    {
        type = SFX_FILE_TYPE_FLV;
    }
    else if ( 0 == sfx_memicmp( "ts", fmt, strlen( fmt ) + 1 ) )
    {
        type = SFX_FILE_TYPE_TS;
    }
    else if ( 0 == sfx_memicmp( "raw", fmt, strlen( fmt ) + 1 ) )
    {
        type = SFX_FILE_TYPE_RAW;
    }


    return type;
}


static const sfx_8 * sfxGetFileType( SfxFileType type )
{
    const sfx_8 * fmt = "";

    switch ( type )
    {
        case SFX_FILE_TYPE_FMP4:
            fmt = "fmp4";
            break;

        case SFX_FILE_TYPE_MP4:
            fmt = "mp4";
            break;

        case SFX_FILE_TYPE_FLV:
            fmt = "flv";
            break;

        case SFX_FILE_TYPE_TS:
            fmt = "ts";
            break;

        case SFX_FILE_TYPE_RAW:
            fmt = "raw";
            break;
    }

    return fmt;
}

static const sfx_8 * sfxGetCodecName( SfxCodecType type )
{
    const sfx_8 * name = "UNKNOW";

    switch( type )
    {
        case SFX_CODEC_TYPE_H263:
            name = "H263";
            break;

        case SFX_CODEC_TYPE_H264:
            name = "H264";
            break;

        case SFX_CODEC_TYPE_H265:
            name = "H265";
            break;

        case SFX_CODEC_TYPE_JPEG:
            name = "JPEG";
            break;
            
        case SFX_CODEC_TYPE_MP3:
            name = "MP3";
            break;

        case SFX_CODEC_TYPE_AAC:
            name = "AAC";
            break;
            
        case SFX_CODEC_TYPE_G711A:
            name = "G711A";
            break;
            
        case SFX_CODEC_TYPE_G711U:
            name = "G711U";
            break;
            
        case SFX_CODEC_TYPE_PS:
            name = "PS";
            break;
    }

    return name;
}


#pragma pack(1)
typedef struct SfxRtpHdr
{
	sfx_u8 cc:4;
	sfx_u8 ext:1;
	sfx_u8 pad:1;
	sfx_u8 ver:2;

	sfx_u8 type:7;
	sfx_u8 marker:1;
	
	sfx_u16 seqNum;
	sfx_u32 timestamp;
	sfx_u32 ssrc;
	sfx_u32 * csrc;
}SfxRtpHdr;
#pragma pack()


typedef enum SfxPltEventType
{
    SFX_PLT_EVT_TYPE_UNKNOW = 0,
    SFX_PLT_EVT_TYPE_REGISTER,
    SFX_PLT_EVT_TYPE_KEEPALIVE,
    SFX_PLT_EVT_TYPE_CONFIG,
	SFX_RLT_EVT_TYPE_IMPORTANT
}SfxPltEventType;


sfx_32 sfx_setupPortRule( sfx_u16 minPort, sfx_u16 maxPort, SfxTransportMode mode );
sfx_u32 sfx_allocPort( sfx_u32 count, SfxTransportMode mode );
sfx_void sfx_freePort( sfx_u16 port, SfxTransportMode mode );

#ifdef __cplusplus
}
#endif
#endif