// Copyright 2020 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <errno.h>
|
#include <stdbool.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
#include <ctype.h>
|
#include <inttypes.h>
|
|
#include <glib.h>
|
|
#include <pthread.h>
|
|
#include "json-c/json.h"
|
#include "mediaserver.h"
|
#include "dbserver.h"
|
|
#include "mediaserver_proxy.h"
|
#include "dbus_connection.h"
|
#include "libipcpro_log_control.h"
|
|
extern int ipc_pro_log_ctl;
|
|
#define MEDIA_DBUSSEND(path, interface, member, id, argout) \
|
dbus_mutex_lock(); \
|
try { \
|
DBus::Connection conn = get_dbus_conn(); \
|
auto proxy_ = std::make_shared<MediaControl>(conn, path, interface); \
|
if (proxy_) \
|
argout = proxy_->SetParam(member, id); \
|
} catch (DBus::Error err) { \
|
ipc_pro_log_ctl && printf("DBus::Error - %s\n", err.what()); \
|
} \
|
dbus_mutex_unlock();
|
|
#define MEDIA_DBUSSEND_PARAM(path, interface, member, id, param, argout) \
|
dbus_mutex_lock(); \
|
try { \
|
DBus::Connection conn = get_dbus_conn(); \
|
auto proxy_ = std::make_shared<MediaControl>(conn, path, interface); \
|
if (proxy_) \
|
argout = proxy_->SetParam(member, id, param); \
|
} catch (DBus::Error err) { \
|
ipc_pro_log_ctl && printf("DBus::Error - %s\n", err.what()); \
|
} \
|
dbus_mutex_unlock();
|
|
/*
|
bitrate set in setBitRate
|
*/
|
static struct KeyTable g_encoder_table[] = {
|
{ "iGOP", "SetGOP", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
// { "iMaxRate", "SetMaxRate", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iStreamSmooth", "SetStreamSmooth", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "sFrameRate", "SetFrameRate", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sResolution", "SetResolution", PARAM_TYPE_STRING, ACTION_TYPE_RESET_PIPE},
|
{ "sRCQuality", "SetRCQuality", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sOutputDataType", "SetOutputDataType", PARAM_TYPE_STRING, ACTION_TYPE_RESET_PIPE},
|
{ "sRCMode", "SetRCMode", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sH264Profile", "SetH264Profile", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sSmart", "SetSmart", PARAM_TYPE_STRING, ACTION_TYPE_RESET_PIPE},
|
{ "sSVC", "SetSVC", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sVideoType", "SetVideoType", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sGrayScaleMode", "SetFullRange", PARAM_TYPE_STRING, ACTION_TYPE_RESET_PIPE},
|
};
|
|
static struct KeyTable g_advanced_encoder_table[] = {
|
{ NULL, "SSetQp", PARAM_TYPE_ARRAY, ACTION_TYPE_SET},
|
{ NULL, "SSetSplit", PARAM_TYPE_ARRAY, ACTION_TYPE_SET},
|
};
|
|
static struct KeyTable g_audio_table[] = {
|
{ "iSampleRate", "SetSampleRate", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iVolume", "SetVolume", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iBitRate", "SetBitRate", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "sInput", "SetInput", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sEncodeType", "SetEncodeType", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sANS", "SetANS", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
};
|
|
static struct KeyTable g_camera_table[] = {
|
{ NULL, "StartCamera", PARAM_TYPE_NONE, ACTION_TYPE_RESET_PIPE},
|
{ NULL, "StopCamera", PARAM_TYPE_NONE, ACTION_TYPE_RESET_PIPE},
|
};
|
|
static struct KeyTable g_feature_table[] = {
|
{ NULL, "TakePicture", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ NULL, "StartRecord", PARAM_TYPE_NONE, ACTION_TYPE_SET},
|
{ NULL, "StopRecord", PARAM_TYPE_NONE, ACTION_TYPE_SET},
|
{ NULL, "SetOsd", PARAM_TYPE_ARRAY_DICT, ACTION_TYPE_SET},
|
{ NULL, "SetROI", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ NULL, "SetRegionInvade", PARAM_TYPE_ARRAY, ACTION_TYPE_SET},
|
{ NULL, "SetMoveDetect", PARAM_TYPE_ARRAY, ACTION_TYPE_SET},
|
{ NULL, "SetFaceDetectEn", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ NULL, "SetDrawFaceEn", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ NULL, "SetFaceCaptureEn", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ NULL, "SetFaceRegEn", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
};
|
|
static struct KeyTable g_face_config_table[] = {
|
{ "iPromptVolume", "SetPromptVolume", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iLiveDetectThreshold", "SetLiveDetectThreshold", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iFaceDetectionThreshold", "SetFaceDetectionThreshold", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iFaceRecognitionThreshold", "SetFaceRecognitionThreshold", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iFaceMinPixel", "SetFaceMinPixel", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iLeftCornerX", "SetLeftCornerX", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iLeftCornerY", "SetLeftCornerY", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iDetectWidth", "SetDetectWidth", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "iDetectHeight", "SetDetectHeight", PARAM_TYPE_INT, ACTION_TYPE_SET},
|
{ "sLiveDetect", "SetLiveDetectEn", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sLiveDetectBeginTime", "SetLiveDetectBeginTime", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
{ "sLiveDetectEndTime", "SetLiveDetectEndTime", PARAM_TYPE_STRING, ACTION_TYPE_SET},
|
};
|
|
static int mediaserver_cmd(const char *path, const char *interface,
|
const char *cmd, int id)
|
{
|
int ret;
|
MEDIA_DBUSSEND(path, interface, cmd, id, ret);
|
return ret;
|
}
|
|
static int mediaserver_cmd_int(const char *path, const char *interface,
|
const char *cmd, int id, int param)
|
{
|
int ret;
|
MEDIA_DBUSSEND_PARAM(path, interface, cmd, id, param, ret);
|
return ret;
|
}
|
|
static int mediaserver_cmd_array(const char *path, const char *interface,
|
const char *cmd, int id, void *param, int size)
|
{
|
int ret;
|
int32_t *values = (int32_t *)param;
|
std::vector<int32_t> params;
|
for (int i = 0; i < size; i++)
|
params.push_back(values[i]);
|
MEDIA_DBUSSEND_PARAM(path, interface, cmd, id, params, ret);
|
return ret;
|
}
|
|
static int mediaserver_cmd_string(const char *path, const char *interface,
|
const char *cmd, int id, const char *param)
|
{
|
int ret;
|
std::string params = param;
|
MEDIA_DBUSSEND_PARAM(path, interface, cmd, id, params, ret);
|
return ret;
|
}
|
|
static int mediaserver_cmd_array_dict(const char *path, const char *interface,
|
const char *cmd, int id, const char *param)
|
{
|
int ret;
|
std::map<std::string, std::string> params;
|
json_object *new_obj = json_tokener_parse(param);
|
json_object_object_foreach(new_obj, key, val) {
|
const char * value_str = json_object_get_string(val);
|
params.emplace(key, value_str);
|
}
|
json_object_put(new_obj);
|
MEDIA_DBUSSEND_PARAM(path, interface, cmd, id, params, ret);
|
return ret;
|
}
|
|
static int find_method_index(struct KeyTable *table,int table_size,
|
const char* key) {
|
for (int index = 0; index < table_size; index++) {
|
if (!strcmp(key, table[index].name))
|
return index;
|
}
|
return -1;
|
}
|
|
static int find_need_reset_index(struct KeyTable *table, int table_size,
|
const char* key) {
|
for (int index = 0; index < table_size; index++) {
|
if (!strcmp(key, table[index].name) &&
|
table[index].action_type == ACTION_TYPE_RESET_PIPE) {
|
return index;
|
}
|
}
|
return -1;
|
}
|
|
static int do_mediaserver_cmd(const char * path, const char * interface,
|
const char * method, int type,
|
int id, const char* value_str) {
|
int ret = 0;
|
if (type == PARAM_TYPE_STRING) {
|
ret = mediaserver_cmd_string(path, interface, method, id, value_str);
|
} else if (type == PARAM_TYPE_INT) {
|
int value = atoi(value_str);
|
ret = mediaserver_cmd_int(path, interface, method, id, value);
|
} else if (type == PARAM_TYPE_NONE) {
|
ret = mediaserver_cmd(path, interface, method, id);
|
} else if (type == PARAM_TYPE_ARRAY_DICT) {
|
ret = mediaserver_cmd_array_dict(path, interface, method, id, value_str);
|
}
|
return ret;
|
}
|
|
static int do_mediaserver_set(const char * path, const char * interface,
|
struct KeyTable *table, int table_size,
|
int id, const char *data) {
|
int ret = 0;
|
json_object *new_obj = json_tokener_parse(data);
|
json_object_object_foreach(new_obj, find_key, find_val) {
|
const char * value_str = json_object_get_string(find_val);
|
int index = find_need_reset_index(table, table_size, find_key);
|
if (index >= 0) {
|
const char * method = table[index].method;
|
int type = table[index].param_type;
|
ret = do_mediaserver_cmd(path, interface, method, type, id, value_str);
|
json_object_put(new_obj);
|
return ret;
|
}
|
}
|
json_object_object_foreach(new_obj, key, val) {
|
const char * value_str = json_object_get_string(val);
|
int index = find_method_index(table, table_size, key);
|
if (index >= 0) {
|
const char * method = table[index].method;
|
int type = table[index].param_type;
|
ret = do_mediaserver_cmd(path, interface, method, type, id, value_str);
|
}
|
}
|
json_object_put(new_obj);
|
return ret;
|
}
|
|
static int mediaserver_video_set(int id, const char *data) {
|
int ret = 0;
|
int table_size = sizeof(g_encoder_table) / sizeof(struct KeyTable);
|
ret = do_mediaserver_set(MEDIASERVER_ENCODER_PATH,
|
MEDIASERVER_ENCODER_INTERFACE,
|
g_encoder_table, table_size, id, data);
|
return ret;
|
}
|
|
static int mediaserver_audio_set(int id, const char *data) {
|
int ret = 0;
|
int table_size = sizeof(g_audio_table) / sizeof(struct KeyTable);
|
ret = do_mediaserver_set(MEDIASERVER_AUDIO_PATH,
|
MEDIASERVER_AUDIO_INTERFACE,
|
g_audio_table, table_size, id, data);
|
return ret;
|
}
|
|
static int mediaserver_osd_set(int id, const char *data) {
|
int ret = 0;
|
ret = mediaserver_cmd_array_dict(MEDIASERVER_FEATURE_PATH,
|
MEDIASERVER_FEATURE_INTERFACE,
|
"SetOsd", id, data);
|
return ret;
|
}
|
|
static int mediaserver_roi_set(int id, const char *data) {
|
int ret = 0;
|
ret = mediaserver_cmd_string(MEDIASERVER_FEATURE_PATH,
|
MEDIASERVER_FEATURE_INTERFACE,
|
"SetRoi", id, data);
|
return ret;
|
}
|
|
static int mediaserver_move_detect_set(int id, const char *data) {
|
int ret = 0;
|
ret = mediaserver_cmd_array_dict(MEDIASERVER_FEATURE_PATH,
|
MEDIASERVER_FEATURE_INTERFACE,
|
"SetMoveDetect", id, data);
|
return ret;
|
}
|
|
static int mediaserver_region_invade_set(int id, const char *data) {
|
int ret = 0;
|
ret = mediaserver_cmd_array_dict(MEDIASERVER_FEATURE_PATH,
|
MEDIASERVER_FEATURE_INTERFACE,
|
"SetRegionInvade", id, data);
|
return ret;
|
}
|
|
static int mediaserver_face_config_set(int id, const char *data) {
|
int ret = 0;
|
int table_size = sizeof(g_face_config_table) / sizeof(struct KeyTable);
|
ret = do_mediaserver_set(MEDIASERVER_FACE_RECOGNIZE_PATH,
|
MEDIASERVER_FACE_RECOGNIZE_INTERFACE,
|
g_face_config_table, table_size, id, data);
|
return ret;
|
}
|
|
int mediaserver_set(char *table, int id, const char *data) {
|
int ret = 0;
|
|
if (!strcmp(table, TABLE_VIDEO)) {
|
ret = mediaserver_video_set(id, data);
|
}else if (!strcmp(table, TABLE_AUDIO)) {
|
ret = mediaserver_audio_set(id, data);
|
} else if (!strcmp(table, TABLE_OSD)) {
|
ret = mediaserver_osd_set(id, data);
|
} else if (!strcmp(table, TABLE_ROI)) {
|
ret = mediaserver_roi_set(id, data);
|
} else if (!strcmp(table, TABLE_MOVE_DETECTION)) {
|
ret = mediaserver_move_detect_set(id, data);
|
} else if (!strcmp(table, TABLE_REGIONAL_INVASION)) {
|
ret = mediaserver_region_invade_set(id, data);
|
} else if (!strcmp(table, TABLE_FACE_CONFIG)) {
|
mediaserver_face_config_set(id, data);
|
}
|
|
return ret;
|
}
|
|
int mediaserver_bitrate_set(int id, const char *json) {
|
int ret = 0;
|
ret = mediaserver_cmd_string(MEDIASERVER_ENCODER_PATH,
|
MEDIASERVER_ENCODER_INTERFACE,
|
"SetBitRate", id, json);
|
return ret;
|
}
|
|
int mediaserver_advanced_enc_set(int id, int table_id, void* param, int size) {
|
int ret = 0;
|
ret =mediaserver_cmd_array(MEDIASERVER_ADVANCED_ENCODER_PATH,
|
MEDIASERVER_ADVANCED_ENCODER_INTERFACE,
|
g_advanced_encoder_table[table_id].method,
|
id, param, size);
|
return ret;
|
}
|
|
int mediaserver_take_photo(int id, int count) {
|
int ret = 0;
|
ret = mediaserver_cmd_int(MEDIASERVER_FEATURE_PATH, MEDIASERVER_FEATURE_INTERFACE,
|
"TakePicture", id, count);
|
return ret;
|
}
|
|
int mediaserver_start_record(int id) {
|
int ret = 0;
|
ret = mediaserver_cmd(MEDIASERVER_FEATURE_PATH, MEDIASERVER_FEATURE_INTERFACE,
|
"StartRecord", id);
|
return ret;
|
}
|
|
int mediaserver_stop_record(int id) {
|
int ret = 0;
|
ret = mediaserver_cmd(MEDIASERVER_FEATURE_PATH, MEDIASERVER_FEATURE_INTERFACE,
|
"StopRecord", id);
|
return ret;
|
}
|
|
int mediaserver_get_record_status(int id) {
|
int ret = 0;
|
ret = mediaserver_cmd(MEDIASERVER_FEATURE_PATH, MEDIASERVER_FEATURE_INTERFACE,
|
"GetRecordStatus", id);
|
return ret;
|
}
|
|
int mediaserver_feature_id_int(char * method, int id, int enable) {
|
int ret = 0;
|
ret = mediaserver_cmd_int(MEDIASERVER_FEATURE_PATH, MEDIASERVER_FEATURE_INTERFACE,
|
method, id, enable);
|
return ret;
|
}
|
|
int mediaserver_sync_schedules() {
|
int ret = 0;
|
ret = mediaserver_cmd(MEDIASERVER_FEATURE_PATH, MEDIASERVER_FEATURE_INTERFACE,
|
"SyncSchedules", 0);
|
return ret;
|
}
|
|
int mediaserver_set_face_image(int id, const char *path) {
|
int ret = 0;
|
ret = mediaserver_cmd_string(MEDIASERVER_FACE_RECOGNIZE_PATH,
|
MEDIASERVER_FACE_RECOGNIZE_INTERFACE,
|
"SetImageToRegn", id, path);
|
return ret;
|
}
|
|
int mediaserver_delete_face(int id, int face_id) {
|
int ret = 0;
|
ret = mediaserver_cmd_int(MEDIASERVER_FACE_RECOGNIZE_PATH,
|
MEDIASERVER_FACE_RECOGNIZE_INTERFACE,
|
"DeleteFaceInfo", id, face_id);
|
return ret;
|
}
|
|
int mediaserver_clear_face_db() {
|
int ret = 0;
|
ret = mediaserver_cmd_int(MEDIASERVER_FACE_RECOGNIZE_PATH,
|
MEDIASERVER_FACE_RECOGNIZE_INTERFACE,
|
"ClearFaceDB", 0, 0);
|
return ret;
|
}
|
|
void mediaserver_stop_flow() {
|
mediaserver_cmd(MEDIASERVER_ENCODER_PATH,
|
MEDIASERVER_ENCODER_INTERFACE,
|
"StopFlow", 0);
|
}
|
|
void mediaserver_restart_flow() {
|
mediaserver_cmd(MEDIASERVER_ENCODER_PATH,
|
MEDIASERVER_ENCODER_INTERFACE,
|
"RestartFlow", 0);
|
}
|
