612 lines
19 KiB
Plaintext
Executable File
612 lines
19 KiB
Plaintext
Executable File
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <components/system.h>
|
|
#include <os/os.h>
|
|
#include <os/mem.h>
|
|
#include <os/str.h>
|
|
|
|
#include "agora_rtc.h"
|
|
#include "agora_config.h"
|
|
|
|
|
|
#define TAG "agora_rtc"
|
|
#define LOGI(...) BK_LOGE(TAG, ##__VA_ARGS__)
|
|
#define LOGE(...) BK_LOGE(TAG, ##__VA_ARGS__)
|
|
#define LOGW(...) BK_LOGE(TAG, ##__VA_ARGS__)
|
|
#define LOGD(...) BK_LOGE(TAG, ##__VA_ARGS__)
|
|
|
|
|
|
static agora_rtc_t agora_rtc = {0};
|
|
|
|
static agora_rtc_t *__get_rtc_instance(void)
|
|
{
|
|
return &agora_rtc;
|
|
}
|
|
|
|
static void __send_message_2_user(agora_rtc_t *rtc, agora_rtc_msg_t *msg)
|
|
{
|
|
if (rtc->user_message_callback) {
|
|
rtc->user_message_callback(msg);
|
|
}
|
|
}
|
|
|
|
static void __rtc_started(agora_rtc_t *rtc)
|
|
{
|
|
rtc->state = AGORA_RTC_STATE_WORKING;
|
|
}
|
|
|
|
static bool __is_rtc_started(agora_rtc_t *rtc)
|
|
{
|
|
if (rtc->state == AGORA_RTC_STATE_WORKING)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
static bool __get_rtc_status(agora_rtc_t *rtc)
|
|
{
|
|
return rtc->state;
|
|
}
|
|
|
|
static void __rtc_stopped(agora_rtc_t *rtc)
|
|
{
|
|
rtc->state = AGORA_RTC_STATE_IDLE;
|
|
}
|
|
|
|
static void __deep_copy_items_destroy(agora_rtc_t *rtc);
|
|
|
|
static void __key_frame_req_msg(agora_rtc_t *rtc)
|
|
{
|
|
agora_rtc_msg_t msg;
|
|
msg.code = AGORA_RTC_MSG_KEY_FRAME_REQUEST;
|
|
__send_message_2_user(rtc, &msg);
|
|
}
|
|
|
|
static void __change_encode_bitrate_req_msg(agora_rtc_t *rtc, uint32_t target_bps)
|
|
{
|
|
agora_rtc_msg_t msg;
|
|
msg.code = AGORA_RTC_MSG_BWE_TARGET_BITRATE_UPDATE;
|
|
msg.data.bwe.target_bitrate = target_bps;
|
|
__send_message_2_user(rtc, &msg);
|
|
}
|
|
|
|
static void __register_message_router(agora_rtc_t *rtc, agora_rtc_msg_notify_cb message_callback)
|
|
{
|
|
rtc->user_message_callback = message_callback;
|
|
}
|
|
|
|
static void __on_join_channel_success(connection_id_t conn_id, uint32_t uid, int elapsed_ms)
|
|
{
|
|
LOGD("conn_id: %d, uid: %d, elapsed_ms: %d \n", conn_id, uid, elapsed_ms);
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
rtc->b_channel_joined = true;
|
|
agora_rtc_msg_t msg = { .code = AGORA_RTC_MSG_JOIN_CHANNEL_SUCCESS };
|
|
__send_message_2_user(rtc, &msg);
|
|
if(uid!=1){
|
|
agora_rtc_mute_remote_audio(conn_id,uid,false);
|
|
}
|
|
__rtc_started(rtc);
|
|
}
|
|
|
|
static void __error_msg(agora_rtc_t *rtc, agora_rtc_msg_e err)
|
|
{
|
|
agora_rtc_msg_t msg;
|
|
msg.code = err;
|
|
__send_message_2_user(rtc, &msg);
|
|
}
|
|
|
|
static void __on_error(connection_id_t conn_id, int code, const char *msg)
|
|
{
|
|
LOGD("conn_id: %d, code: %d\nmsg: %s \n", conn_id, code, msg ? msg : "null");
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
switch (code) {
|
|
case ERR_SEND_VIDEO_OVER_BANDWIDTH_LIMIT:
|
|
break;
|
|
case ERR_INVALID_APP_ID:
|
|
__error_msg(rtc, AGORA_RTC_MSG_INVALID_APP_ID);
|
|
break;
|
|
case ERR_INVALID_CHANNEL_NAME:
|
|
__error_msg(rtc, AGORA_RTC_MSG_INVALID_CHANNEL_NAME);
|
|
break;
|
|
case ERR_INVALID_TOKEN:
|
|
__error_msg(rtc, AGORA_RTC_MSG_INVALID_TOKEN);
|
|
break;
|
|
case ERR_TOKEN_EXPIRED:
|
|
__error_msg(rtc, AGORA_RTC_MSG_TOKEN_EXPIRED);
|
|
break;
|
|
default:
|
|
LOGI("Unknown Error Code: %d \n", code);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void __on_user_joined(connection_id_t conn_id, uint32_t uid, int elapsed_ms)
|
|
{
|
|
LOGD("conn_id: %d, uid: %d, elapsed_ms: %d \n", conn_id, uid, elapsed_ms);
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
rtc->b_user_joined = true;
|
|
agora_rtc_msg_t msg = {
|
|
.code = AGORA_RTC_MSG_USER_JOINED,
|
|
.data.uid = uid
|
|
};
|
|
__send_message_2_user(rtc, &msg);
|
|
}
|
|
|
|
static void __on_user_offline(connection_id_t conn_id, uint32_t uid, int reason)
|
|
{
|
|
LOGD("conn_id: %d, uid: %d, reason: %d \n", conn_id, uid, reason);
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
rtc->b_user_joined = false;
|
|
agora_rtc_msg_t msg = {
|
|
.code = AGORA_RTC_MSG_USER_OFFLINE,
|
|
.data.uid = uid
|
|
};
|
|
__send_message_2_user(rtc, &msg);
|
|
}
|
|
|
|
static void __on_key_frame_gen_req(connection_id_t conn_id, uint32_t uid, video_stream_type_e stream_type)
|
|
{
|
|
LOGD("conn_id: %d, uid: %d, video stream type: %d \n", conn_id, uid, stream_type);
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
__key_frame_req_msg(rtc);
|
|
}
|
|
|
|
static void __on_audio_data(connection_id_t conn_id, uint32_t uid, uint16_t sent_ts,
|
|
const void *data_ptr, size_t data_len, const audio_frame_info_t *info_ptr)
|
|
{
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (!__is_rtc_started(rtc) || !rtc->b_channel_joined || !rtc->b_user_joined) {
|
|
LOGD( "Wrong rtc state, rtc_started: %s, channel_joined: %s, user_joined: %s \n",
|
|
__is_rtc_started(rtc) ? "true" : "false", rtc->b_channel_joined ? "true" : "false", rtc->b_user_joined ? "true" : "false");
|
|
return;
|
|
}
|
|
//LOGD("ch=%s, uid=%d sent_ts=%u codec=%u, data_ptr=%p, data_len=%d",
|
|
// rtc->agora_rtc_option.p_channel_name, (int)uid, sent_ts, info_ptr->data_type, data_ptr, (int)data_len);
|
|
//LOGE("R L:%d ts:%d %2X %2X %2X %2X %2X %2X %2X %2X \r\n",data_len,sent_ts,data_ptr[20],data_ptr[40],data_ptr[60],data_ptr[70],data_ptr[80],data_ptr[100],data_ptr[120],data_ptr[150]);
|
|
if (rtc->audio_rx_data_handle) {
|
|
rtc->audio_rx_data_handle((unsigned char *)data_ptr, data_len, info_ptr);
|
|
} else {
|
|
LOGD("aud_rx_data_handle is NULL \n");
|
|
}
|
|
}
|
|
|
|
static void __on_video_data(connection_id_t conn_id, uint32_t uid, uint16_t sent_ts, const void *data_ptr, size_t data_len,
|
|
const video_frame_info_t *info_ptr)
|
|
{
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (!__is_rtc_started(rtc) || !rtc->b_channel_joined || !rtc->b_user_joined) {
|
|
LOGI("Wrong rtc state, rtc_started: %s, channel_joined: %s, user_joined: %s \n",
|
|
__is_rtc_started(rtc) ? "true" : "false", rtc->b_channel_joined ? "true" : "false", rtc->b_user_joined ? "true" : "false");
|
|
return;
|
|
}
|
|
LOGD("ch=%s, uid=%d sent_ts=%u codec=%u, data_ptr=%p, data_len=%d",
|
|
rtc->agora_rtc_option.p_channel_name, (int)uid, sent_ts, info_ptr->data_type, data_ptr, (int)data_len);
|
|
|
|
if (rtc->video_rx_data_handle) {
|
|
rtc->video_rx_data_handle(data_ptr, data_len, info_ptr);
|
|
} else {
|
|
LOGD("aud_rx_data_handle is NULL \n");
|
|
}
|
|
}
|
|
|
|
static void __on_user_mute_audio(connection_id_t conn_id, uint32_t uid, bool muted)
|
|
{
|
|
LOGI("[conn-%u] audio: uid=%u muted=%d\n", conn_id, uid, muted);
|
|
}
|
|
|
|
static void __on_user_mute_video(connection_id_t conn_id, uint32_t uid, bool muted)
|
|
{
|
|
LOGI("[conn-%u] video: uid=%u muted=%d\n", conn_id, uid, muted);
|
|
}
|
|
|
|
static void __on_target_bitrate_changed(connection_id_t conn_id, uint32_t target_bps)
|
|
{
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (!__is_rtc_started(rtc)) {
|
|
LOGI("pipeline not started. Skip bitrate changed process \n");
|
|
return;
|
|
}
|
|
LOGD("conn_id: %d, target bitrate will change from %d to %d \n" ,
|
|
conn_id, rtc->target_bitrate, target_bps);
|
|
|
|
rtc->target_bitrate = target_bps;
|
|
__change_encode_bitrate_req_msg(rtc, target_bps);
|
|
}
|
|
|
|
static void __on_connection_lost(connection_id_t conn_id)
|
|
{
|
|
LOGD("conn_id: %d \n", conn_id);
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (!rtc->agora_rtc_option.p_channel_name) {
|
|
LOGI( "Invalid arguments, rtc->agora_rtc_option.p_channel_name: %p \n", rtc->agora_rtc_option.p_channel_name);
|
|
return;
|
|
}
|
|
LOGI("The connection of the channel: %s is lost \n", rtc->agora_rtc_option.p_channel_name);
|
|
rtc->b_channel_joined = false;
|
|
|
|
agora_rtc_msg_t msg = {
|
|
.code = AGORA_RTC_MSG_CONNECTION_LOST
|
|
};
|
|
__send_message_2_user(rtc, &msg);
|
|
}
|
|
|
|
static void __on_rejoin_channel_success(connection_id_t conn_id, uint32_t uid, int elapsed_ms)
|
|
{
|
|
LOGD("conn_id: %d \n", conn_id);
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (!rtc->agora_rtc_option.p_channel_name) {
|
|
LOGI("Invalid arguments, rtc->channel_name: %p \n", rtc->agora_rtc_option.p_channel_name);
|
|
return;
|
|
}
|
|
LOGI("The uid(%d) rejoins to the channel: %s \n", uid, rtc->agora_rtc_option.p_channel_name);
|
|
|
|
rtc->b_channel_joined = true;
|
|
}
|
|
|
|
static void __register_agora_rtc_event_handler(agora_rtc_t *rtc)
|
|
{
|
|
rtc->agora_rtc_event_handler.on_join_channel_success = __on_join_channel_success;
|
|
rtc->agora_rtc_event_handler.on_error = __on_error;
|
|
rtc->agora_rtc_event_handler.on_user_joined = __on_user_joined;
|
|
rtc->agora_rtc_event_handler.on_user_offline = __on_user_offline;
|
|
rtc->agora_rtc_event_handler.on_key_frame_gen_req = __on_key_frame_gen_req;
|
|
rtc->agora_rtc_event_handler.on_audio_data = __on_audio_data;
|
|
rtc->agora_rtc_event_handler.on_video_data = __on_video_data;
|
|
rtc->agora_rtc_event_handler.on_target_bitrate_changed = __on_target_bitrate_changed;
|
|
rtc->agora_rtc_event_handler.on_connection_lost = __on_connection_lost;
|
|
rtc->agora_rtc_event_handler.on_rejoin_channel_success = __on_rejoin_channel_success;
|
|
rtc->agora_rtc_event_handler.on_user_mute_audio = __on_user_mute_audio;
|
|
rtc->agora_rtc_event_handler.on_user_mute_video = __on_user_mute_video;
|
|
}
|
|
|
|
static void __deep_copy_items_destroy(agora_rtc_t *rtc)
|
|
{
|
|
if (rtc->agora_rtc_option.p_channel_name != NULL) {
|
|
os_free((void *)rtc->agora_rtc_option.p_channel_name);
|
|
rtc->agora_rtc_option.p_channel_name = NULL;
|
|
}
|
|
|
|
if (rtc->agora_rtc_option.p_token != NULL) {
|
|
os_free((void *)rtc->agora_rtc_option.p_token);
|
|
rtc->agora_rtc_option.p_token = NULL;
|
|
}
|
|
}
|
|
|
|
static int32_t __agora_init(agora_rtc_config_t *p_config)
|
|
{
|
|
int rval;
|
|
uint32_t bwe_min_bps = BANDWIDTH_ESTIMATE_MIN_BITRATE;
|
|
uint32_t bwe_max_bps = BANDWIDTH_ESTIMATE_MAX_BITRATE;
|
|
uint32_t bwe_start_bps = BANDWIDTH_ESTIMATE_START_BITRATE;
|
|
rtc_service_option_t service_opt = { 0 };
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
rtc->state = AGORA_RTC_STATE_NULL;
|
|
rtc->audio_rx_data_handle = NULL;
|
|
rtc->conn_id = (connection_id_t)0;
|
|
rtc->user_message_callback = NULL;
|
|
rtc->b_user_joined = false;
|
|
rtc->b_channel_joined = false;
|
|
rtc->agora_rtc_event_handler.on_audio_data = NULL;
|
|
rtc->agora_rtc_event_handler.on_connection_lost = NULL;
|
|
rtc->agora_rtc_event_handler.on_error = NULL;
|
|
rtc->agora_rtc_event_handler.on_join_channel_success = NULL;
|
|
#ifdef CONFIG_RTCM
|
|
rtc->agora_rtc_event_handler.on_media_ctrl_receive = NULL;
|
|
#endif
|
|
rtc->agora_rtc_event_handler.on_mixed_audio_data = NULL;
|
|
rtc->agora_rtc_event_handler.on_rejoin_channel_success = NULL;
|
|
rtc->agora_rtc_event_handler.on_token_privilege_will_expire = NULL;
|
|
rtc->agora_rtc_event_handler.on_user_joined = NULL;
|
|
rtc->agora_rtc_event_handler.on_user_mute_audio = NULL;
|
|
rtc->agora_rtc_event_handler.on_user_mute_video = NULL;
|
|
rtc->agora_rtc_event_handler.on_video_data = NULL;
|
|
rtc->agora_rtc_event_handler.on_target_bitrate_changed = NULL;
|
|
rtc->agora_rtc_event_handler.on_key_frame_gen_req = NULL;
|
|
rtc->agora_rtc_event_handler.on_user_offline = NULL;
|
|
rtc->target_bitrate = 0;
|
|
rtc->audio_rx_data_handle = NULL;
|
|
rtc->video_rx_data_handle = NULL;
|
|
|
|
rtc->agora_rtc_config.license[0] = '\0';
|
|
rtc->agora_rtc_config.enable_bwe_param = true;
|
|
rtc->agora_rtc_config.bwe_param_max_bps = bwe_max_bps;
|
|
rtc->agora_rtc_config.log_disable = true;
|
|
rtc->agora_rtc_config.area_code = AREA_CODE_GLOB;
|
|
|
|
rtc->agora_rtc_config.p_appid = (char *)psram_malloc(os_strlen(p_config->p_appid) + 1);
|
|
if (rtc->agora_rtc_config.p_appid == NULL) {
|
|
LOGE("malloc app_id fail, size: %d \n", (os_strlen(p_config->p_appid) + 1));
|
|
goto agora_init_error;
|
|
}
|
|
os_strcpy((char *)rtc->agora_rtc_config.p_appid, p_config->p_appid);
|
|
LOGI("Agora RTC SDK app_id: %s \n", rtc->agora_rtc_config.p_appid);
|
|
|
|
os_memcpy(rtc->agora_rtc_config.license, p_config->license, 32);
|
|
LOGI("Agora RTC SDK license: ");
|
|
for (int n = 0; n < 32; n++) {
|
|
os_printf( "%c", rtc->agora_rtc_config.license[n]);
|
|
}
|
|
os_printf("\n");
|
|
|
|
rtc->agora_rtc_config.enable_bwe_param = p_config->enable_bwe_param;
|
|
rtc->agora_rtc_config.bwe_param_max_bps = p_config->bwe_param_max_bps;
|
|
rtc->agora_rtc_config.log_disable = p_config->log_disable;
|
|
rtc->agora_rtc_config.area_code = p_config->area_code;
|
|
|
|
if (rtc->agora_rtc_config.enable_bwe_param) {
|
|
bwe_max_bps = p_config->bwe_param_max_bps;
|
|
} else {
|
|
rtc->agora_rtc_config.bwe_param_max_bps = bwe_max_bps;
|
|
}
|
|
|
|
// step1. agora sdk version.
|
|
LOGI("Agora RTC SDK v%s \n", agora_rtc_get_version());
|
|
//step4. register event handler
|
|
__register_agora_rtc_event_handler(rtc);
|
|
|
|
//step6. agora rtc init.
|
|
service_opt.area_code = p_config->area_code;
|
|
service_opt.log_cfg.log_disable = p_config->log_disable;
|
|
service_opt.log_cfg.log_path = DEFAULT_SDK_LOG_PATH;
|
|
service_opt.log_cfg.log_level = RTC_LOG_WARNING;
|
|
os_memcpy(service_opt.license_value, p_config->license, 33);
|
|
|
|
rval = agora_rtc_init(rtc->agora_rtc_config.p_appid, &rtc->agora_rtc_event_handler, &service_opt);
|
|
if (rval < 0) {
|
|
LOGI("agora rtc init failed, rval=%d error=%s\n", rval, agora_rtc_err_2_str(rval));
|
|
goto agora_init_error;
|
|
}
|
|
|
|
LOGI("BWE[%u,%u,%u]\n", bwe_min_bps, bwe_max_bps, bwe_start_bps);
|
|
rval = agora_rtc_set_bwe_param(CONNECTION_ID_ALL, bwe_min_bps, bwe_max_bps, bwe_start_bps);
|
|
if (rval < 0) {
|
|
LOGI("set BWE failed \n");
|
|
} else {
|
|
LOGI("agora_rtc_set_bwe_param ok \n");
|
|
}
|
|
|
|
return BK_OK;
|
|
|
|
agora_init_error:
|
|
if (rtc->agora_rtc_config.p_appid != NULL) {
|
|
os_free((void *)rtc->agora_rtc_config.p_appid);
|
|
rtc->agora_rtc_config.p_appid = NULL;
|
|
}
|
|
|
|
return BK_FAIL;
|
|
}
|
|
|
|
bk_err_t bk_agora_rtc_create(agora_rtc_config_t *p_config, agora_rtc_msg_notify_cb message_callback)
|
|
{
|
|
if (0 != __agora_init(p_config)) {
|
|
LOGE("__agora_init fail.\n");
|
|
return BK_FAIL;
|
|
} else {
|
|
LOGI("__agora_init ok.\n");
|
|
}
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (rtc) {
|
|
__register_message_router(rtc, message_callback);
|
|
} else {
|
|
return BK_FAIL;
|
|
}
|
|
LOGI("rtc create successfully.\n");
|
|
return BK_OK;
|
|
}
|
|
|
|
bk_err_t bk_agora_rtc_destroy(void)
|
|
{
|
|
int rval = agora_rtc_fini();
|
|
if (rval != 0) {
|
|
LOGI("agora_rtc_fini fail: %d, %s \n", rval, agora_rtc_err_2_str(rval));
|
|
}
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
rtc->state = AGORA_RTC_STATE_IDLE;
|
|
|
|
LOGI("rtc destroy successfully.\n");
|
|
return BK_OK;
|
|
}
|
|
|
|
bk_err_t bk_agora_rtc_start(agora_rtc_option_t *option)
|
|
{
|
|
int rval = 0;
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
if (!rtc)
|
|
return BK_FAIL;
|
|
|
|
/*copy channel name */
|
|
if (rtc->agora_rtc_option.p_channel_name) {
|
|
os_free((void *)rtc->agora_rtc_option.p_channel_name);
|
|
rtc->agora_rtc_option.p_channel_name = NULL;
|
|
}
|
|
rtc->agora_rtc_option.p_channel_name = (char *)os_malloc(os_strlen(option->p_channel_name) + 1);
|
|
if (rtc->agora_rtc_option.p_channel_name == NULL) {
|
|
LOGE("malloc channel_name fail, size: %d \n", (os_strlen(option->p_channel_name) + 1));
|
|
goto agora_rtc_start_fail;
|
|
}
|
|
os_strcpy((void *)rtc->agora_rtc_option.p_channel_name, option->p_channel_name);
|
|
LOGI("Agora RTC SDK channel_name: %s \n", rtc->agora_rtc_option.p_channel_name);
|
|
|
|
/*copy token */
|
|
if (option->p_token) {
|
|
if (rtc->agora_rtc_option.p_token) {
|
|
os_free((void *)rtc->agora_rtc_option.p_token);
|
|
rtc->agora_rtc_option.p_token = NULL;
|
|
}
|
|
rtc->agora_rtc_option.p_token = (char *)os_malloc(os_strlen(option->p_token) + 1);
|
|
if (rtc->agora_rtc_option.p_token == NULL) {
|
|
LOGE("malloc token fail, size: %d \n", (os_strlen(option->p_token) + 1));
|
|
goto agora_rtc_start_fail;
|
|
}
|
|
os_strcpy((void *)rtc->agora_rtc_option.p_token, option->p_token);
|
|
} else {
|
|
rtc->agora_rtc_option.p_token = NULL;
|
|
}
|
|
LOGI("Agora RTC SDK token: %s \n", rtc->agora_rtc_option.p_token);
|
|
|
|
rtc->agora_rtc_option.uid = option->uid;
|
|
#if defined (CONFIG_ENABLE_APP_DATA_BACK)
|
|
rtc->agora_rtc_option.auto_subscribe_audio = 0;//option->auto_subscribe_audio;
|
|
rtc->agora_rtc_option.auto_subscribe_video = 1;//option->auto_subscribe_video;
|
|
#else
|
|
rtc->agora_rtc_option.auto_subscribe_audio = option->auto_subscribe_audio;
|
|
rtc->agora_rtc_option.auto_subscribe_video = option->auto_subscribe_video;
|
|
#endif
|
|
rtc->agora_rtc_option.audio_config.audio_data_type = AUDIO_DATA_TYPE_PCMA;//AUDIO_DATA_TYPE_PCMA
|
|
rtc->agora_rtc_option.audio_config.pcm_sample_rate = option->audio_config.pcm_sample_rate;
|
|
rtc->agora_rtc_option.audio_config.pcm_channel_num = option->audio_config.pcm_channel_num;
|
|
|
|
rtc_channel_options_t channel_options = { 0 };
|
|
|
|
channel_options.auto_subscribe_audio = rtc->agora_rtc_option.auto_subscribe_audio;
|
|
channel_options.auto_subscribe_video = rtc->agora_rtc_option.auto_subscribe_video;
|
|
//channel_options.audio_codec_opt.audio_codec_type = option->audio_config.audio_data_type;
|
|
channel_options.audio_codec_opt.audio_codec_type = AUDIO_CODEC_DISABLED; // AUDIO_CODEC_TYPE_G711A AUDIO_CODEC_DISABLED
|
|
channel_options.audio_codec_opt.pcm_sample_rate = option->audio_config.pcm_sample_rate;
|
|
channel_options.audio_codec_opt.pcm_channel_num = option->audio_config.pcm_channel_num;
|
|
channel_options.audio_codec_opt.pcm_duration = 20;
|
|
|
|
LOGI("auto_subscribe_audio: %d, auto_subscribe_video: %d \n",
|
|
channel_options.auto_subscribe_audio ? 1 : 0, channel_options.auto_subscribe_video ? 1 : 0);
|
|
|
|
// step8. join channel
|
|
rval = agora_rtc_create_connection(&(rtc->conn_id));
|
|
if (0 != rval) {
|
|
LOGI("agora_rtc_create_connection failure: %d, %s \n", rval, agora_rtc_err_2_str(rval));
|
|
goto agora_rtc_start_fail;
|
|
}
|
|
|
|
rval = agora_rtc_join_channel(rtc->conn_id, rtc->agora_rtc_option.p_channel_name, rtc->agora_rtc_option.uid, rtc->agora_rtc_option.p_token, &channel_options);
|
|
if (rval < 0) {
|
|
LOGI("join channel %s failed, rval=%d error=%s \n",
|
|
rtc->agora_rtc_option.p_channel_name ? rtc->agora_rtc_option.p_channel_name : "", rval, agora_rtc_err_2_str(rval));
|
|
goto agora_rtc_start_fail;
|
|
}
|
|
|
|
LOGI("Joining channel %s ... \n", rtc->agora_rtc_option.p_channel_name);
|
|
return BK_OK;
|
|
|
|
agora_rtc_start_fail:
|
|
__deep_copy_items_destroy(rtc);
|
|
return BK_FAIL;
|
|
}
|
|
|
|
bk_err_t bk_agora_rtc_stop(void)
|
|
{
|
|
int rval = 0;
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
if (!rtc)
|
|
return BK_FAIL;
|
|
|
|
__rtc_stopped(rtc);
|
|
|
|
/* maybe lost connect. but API has covered this case */
|
|
rval = agora_rtc_leave_channel(rtc->conn_id);
|
|
if (rval < 0) {
|
|
LOGI("agora_rtc_leave_channel fail, rval=%d error=%s \n", rval, agora_rtc_err_2_str(rval));
|
|
return BK_FAIL;
|
|
}
|
|
|
|
rval = agora_rtc_destroy_connection(rtc->conn_id);
|
|
if (rval < 0) {
|
|
LOGI("agora_rtc_destroy_connection fail, rval=%d error=%s \n", rval, agora_rtc_err_2_str(rval));
|
|
return BK_FAIL;
|
|
}
|
|
|
|
if (rtc->agora_rtc_config.p_appid != NULL) {
|
|
os_free((void *)rtc->agora_rtc_config.p_appid);
|
|
rtc->agora_rtc_config.p_appid = NULL;
|
|
}
|
|
|
|
__deep_copy_items_destroy(rtc);
|
|
|
|
return BK_OK;
|
|
}
|
|
|
|
int bk_agora_rtc_video_data_send(const uint8_t *data_ptr, size_t data_len, const video_frame_info_t *info_ptr)
|
|
{
|
|
int rval = 0;
|
|
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
if (!rtc)
|
|
return BK_FAIL;
|
|
|
|
// API: send audio data
|
|
video_frame_info_t info = { 0 };
|
|
info.data_type = info_ptr->data_type;
|
|
info.frame_rate = info_ptr->frame_rate;
|
|
info.frame_type = info_ptr->frame_type;
|
|
info.stream_type = info_ptr->stream_type;
|
|
info.rotation = VIDEO_ORIENTATION_90;
|
|
|
|
rval = agora_rtc_send_video_data(rtc->conn_id, data_ptr, data_len, &info);
|
|
if (rval < 0) {
|
|
LOGI("send video data failed, rval=%d data_type=%d len=%d frame_type=%d \n",
|
|
rval, info.data_type, (int)data_len, info.frame_type);
|
|
} else {
|
|
//LOGI( "send video data successfully. len=%d", (int)data_len);
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
int bk_agora_rtc_audio_data_send(uint8_t *data_ptr, size_t data_len, audio_frame_info_t *info_ptr)
|
|
{
|
|
// API: send audio data
|
|
audio_frame_info_t info = { 0 };
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
if (!rtc)
|
|
return BK_FAIL;
|
|
|
|
info.data_type = info_ptr->data_type;
|
|
|
|
int rval = agora_rtc_send_audio_data(rtc->conn_id, data_ptr, data_len, &info);
|
|
if (rval < 0) {
|
|
LOGE("Failed to send audio data, reason: %s\n", agora_rtc_err_2_str(rval));
|
|
return BK_FAIL;
|
|
}
|
|
|
|
return BK_OK;
|
|
}
|
|
|
|
bk_err_t bk_aggora_rtc_register_audio_rx_handle(agora_rtc_audio_rx_data_handle audio_rx_handle)
|
|
{
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
if (!rtc)
|
|
return BK_FAIL;
|
|
|
|
rtc->audio_rx_data_handle = audio_rx_handle;
|
|
|
|
return BK_OK;
|
|
}
|
|
|
|
bk_err_t bk_aggora_rtc_register_video_rx_handle(agora_rtc_video_rx_data_handle video_rx_handle)
|
|
{
|
|
agora_rtc_t *rtc = __get_rtc_instance();
|
|
|
|
if (!rtc)
|
|
return BK_FAIL;
|
|
|
|
rtc->video_rx_data_handle = video_rx_handle;
|
|
|
|
return BK_OK;
|
|
}
|
|
|