云存储模块

iv_cs_get_balance_info //获取本地套餐信息(非必须)
    |
iv_cs_init
    |
iv_cs_push_stream_start_cb // 收到回调，开始推流
    |
while(1) { iv_cs_push_stream }
    |
iv_cs_push_stream_stop_cb // 收到回调，停止推流
    |
iv_cs_exit

iv_cs_get_balance_info //获取本地套餐信息(非必须)
    |
iv_cs_init
    |
iv_cs_event_start/iv_cs_event_start_ext // 用户触发事件
    |
iv_cs_event_capture_picture_cb // SDK向用户请求获取事件截图
    |
iv_cs_push_stream_start_cb // 收到回调，开始推流
    |
while(1) { iv_cs_push_stream }
    |
iv_cs_event_stop/iv_cs_event_stop_ext  //用户停止事件
    ｜             
iv_cs_push_stream_stop_cb // 收到回调，停止推流
    |
iv_cs_event_picture_result_cb // 截图使用完毕，用户回收截图资源
    |
iv_cs_exit

int iv_cs_init(iv_cs_init_parm_s *pstInitParm);

int iv_cs_exit(void); 

int iv_cs_push_stream(iv_cm_stream_type_e eCsStreamType, void *pstCsPack); 

int16_t audio_data[1024]; // 单声道
int16_t audio_data[2048]; // 双声道

H264 I帧
00 00 00 01 67 (...) 00 00 00 01 68 (...) 00 00 00 01 65 (...)

H264 P帧
00 00 00 01 41 (...)

H265 I帧
00 00 00 01 40 (...) 00 00 00 01 42 (...) 00 00 00 01 44 (...) 00 00 00 01 2A (...)

H265 P帧
00 00 00 01 02 (...)

int iv_cs_event_directly_report(int32_t event_id, uint32_t event_time_s, uint8_t *pic_addr,
                                uint32_t pic_len)

int iv_cs_event_start(int32_t event_id);

int iv_cs_event_stop(int32_t event_id);

int iv_cs_event_start_ext(int32_t event_id, uint32_t event_start_time_s, uint32_t stream_start_time_s);

int iv_cs_event_stop_ext(int32_t event_id, uint32_t event_stop_time_s, uint32_t stream_stop_time_s);

int iv_cs_get_balance_info(iv_cs_balance_info_s *pstBalanceInfo, uint32_t timeout_s)

int iv_cs_set_ai_process(int32_t event_id, iv_cs_ai_type_e ai_type, void *args);

int iv_cs_get_ai_process(int32_t event_id, iv_cs_ai_type_e *ai_type, void *args);

int iv_cs_set_trans_time(uint32_t upload_timeout_ms, uint32_t reply_timeout_ms)

int (*iv_cs_push_stream_stop_cb)(void);

int (*iv_cs_push_stream_start_cb)(void);

int (*iv_cs_event_capture_picture_cb)(int32_t event_id, uint8_t **pic, int32_t *size);

int (*iv_cs_event_picture_result_cb)(uint8_t **pic, iv_err_code_e err_code);

int (*iv_cs_event_report_result_cb)(iv_cs_event_result_info *pst_result_info);

int (*iv_cs_notify_cb)(iv_cs_notify_msg_type_e notify_msg_type,
                       iv_cs_notify_msg_data *pst_notify_data);

typedef enum
{
    CS_TYPE_NONE      = 0,
    CS_TYPE_FULL_TIME = 1,
    CS_TYPE_EVENT     = 2,
} iv_cs_type_e;

typedef struct iv_cs_balance_s {
    int cs_switch;
    iv_cs_type_e cs_type;
} iv_cs_balance_info_s;

typedef enum
{
    CS_AI_TYPE_CLOSE       = (uint32_t)0,
    CS_AI_TYPE_FALL_DETECT = (uint32_t)(1 << 0),
} iv_cs_ai_type_e;

typedef enum cs_event_upload_options
{
    CS_EVENT_TS_REQ = 0,
    CS_EVENT_PIC_REQ = 1,
    CS_EVENT_TS_OR_PIC_REQ = 2,
} iv_cs_event_report_opt_e;

typedef enum
{
    IV_CS_UPLOAD_OK  = 0,
    IV_CS_UPLOAD_ERR = 1,
} iv_cs_upload_state_e;

typedef struct {
    uint64_t utc_sec_a;
    uint64_t utc_sec_b;
    uint64_t pts_ms_a;
    uint64_t pts_ms_b;
    uint32_t frame_seq_a;
    uint32_t frame_seq_b;
    uint32_t upload_size;
    uint32_t total_size;
    iv_cs_upload_state_e state;
} iv_cs_upload_slice_info_s;

typedef struct {
    iv_cs_upload_slice_info_s slice_info[MAX_UPLOAD_INFO_NUM];
    int32_t num;
} iv_cs_upload_info_s;

typedef enum cs_notify_type
{
    IV_CS_AV_UPLOAD_CONNECT_FAIL = 0,
    IV_CS_AV_UPLOAD_CONNECT_RECOVER = 1,
    IV_CS_AV_UPLOAD_STATE_MSG = 2,
    IV_CS_AV_UPLOAD_WATERMARK_LOW = 3,
    IV_CS_AV_UPLOAD_WATERMARK_WARN = 4,
    IV_CS_AV_UPLOAD_WATERMARK_HIGH = 5,
    IV_CS_COS_SERVICE_WRONG = 6,
    IV_CS_MSG_BUTT
} iv_cs_notify_msg_type_e;

typedef union {
    iv_cs_upload_info_s *av_result_info;
} iv_cs_notify_msg_data;

typedef struct {
    int32_t result_code;
    int32_t event_id;
    uint32_t start_time_s;
    uint32_t end_time_s;
} iv_cs_event_result_info;

typedef struct {
    size_t low_mark;
    size_t warn_mark;
    size_t high_mark;
    int8_t enable;
} iv_cs_congestion_ctrl_s;

typedef struct iv_cs_init_parm_s
{
    uint32_t u32MaxGopSize;
    iv_cs_congestion_ctrl_s congestion_cfg;
    iv_cm_av_data_info_s av_fmt;
    iv_cs_event_report_opt_e event_report_opt;
    int (*iv_cs_push_stream_start_cb)(void);
    int (*iv_cs_push_stream_stop_cb)(void);
    void (*iv_cs_ai_service_notify_cb)(unsigned int ai_server_type, unsigned long long utc_expire);
    int (*iv_cs_event_capture_picture_cb)(int32_t event_id, uint8_t **pic, int32_t *size);
    int (*iv_cs_event_picture_result_cb)(uint8_t **pic, int32_t err_code);
    int (*iv_cs_event_report_result_cb)(iv_cs_event_result_info *pst_result_info);
    int (*iv_cs_notify_cb)(iv_cs_notify_msg_type_e notify_msg_type,
                           iv_cs_notify_msg_data *pst_notify_data);
}iv_cs_init_parm_s;

// 云存推流
while (run_flag)
{
    // 调用者主动推流，由调用者保证推送音视频帧的顺序与间隔，否则可能造成音视频不同步
    if(compare_time_stamp(frame_count_audio, audio_time_base, frame_count_video, video_time_base) <= 0)
    {
        frame_count_audio += 1;
        get_aac_frame(audio_frame_buf, &audio_len);
        audio_pack.pu8Addr = audio_frame_buf;
        audio_pack.u32Len = audio_len;
        audio_pack.u64TimeStamp = (uint64_t)(frame_count_a * 1024 / 48.0);
        audio_pack.u32Seq = frame_count_a;
        iv_cs_push_stream(IV_CM_STREAM_TYPE_AUDIO, &audio_pack);
    }
    else
    {
        frame_count_video += 1;
        get_video_frame_h264(video_frame_buf, &video_len, &frame_type);
        video_pack.pu8Addr = video_frame_buf;
        video_pack.u32Len = video_len;
        video_pack.eFrameType = frame_type;
        video_pack.u64PTS = (uint64_t)(frame_count_v * 1000 / 25.0);
        video_pack.u32Seq = frame_count_v;
        iv_cs_push_stream(IV_CM_STREAM_TYPE_VIDEO, &video_pack);
    }
    sleep_ms(10);
}