#include <stdio.h>
|
#include <stdlib.h>
|
#include <assert.h>
|
#include <errno.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
#include <signal.h>
|
#include <sys/wait.h>
|
#include <time.h>
|
#include <sys/vfs.h>
|
#include <stdint.h>
|
#include <sys/stat.h>
|
#include <signal.h>
|
#include <sys/types.h>
|
#include <dirent.h>
|
|
#include "libavcodec/avcodec.h"
|
#include "libavdevice/avdevice.h"
|
#include "libavformat/avformat.h"
|
#include "libavfilter/avfilter.h"
|
#include "libavutil/avutil.h"
|
#include "libswscale/swscale.h"
|
#include "libavutil/pixdesc.h"
|
|
#include "probe/probe.h"
|
#include "av_demux/av_demux.h"
|
#include "proto_comm.h"
|
#include "proto_dbg.h"
|
|
static AVDevs *gAVDevs = NULL;
|
|
static int data_cmp(char *s1, char *s2, char *dlim);
|
|
/*signal process interrupt handler*/
|
static void handler(int sig)
|
{
|
sync();
|
}
|
|
void av_timer_handler(union sigval para)
|
{
|
gAVDevs->slice_stat = FALSE;
|
}
|
|
/*parse the location to get the right direction*/
|
static int get_dir_with_key(char *dir_path, char *name, char *key, char *buf, int length) {
|
DIR *pDir;
|
char *ptr;
|
char temp = 0;
|
char found = FALSE;
|
struct dirent * entry;
|
char parse_buf[MAX_BUF_SIZE] = { 0x00 };
|
|
pDir = opendir(dir_path);
|
if (
|
pDir == NULL) {
|
SOAP_DBGERR("the path(%s) can not be opened!\n", dir_path);
|
|
return -1;
|
}
|
|
while((entry = readdir(pDir)) != NULL) {
|
|
if (entry->d_type & DT_DIR) {
|
|
if ((strcmp(entry->d_name, ".") != 0) && (strcmp(entry->d_name, "..") != 0)) {
|
|
ptr = strstr(entry->d_name, NAME_BRIDGE);
|
|
if ((ptr != NULL) && (strcmp(ptr + 1, name) == 0)) {
|
|
if (data_cmp(entry->d_name, key, NAME_MID) <= 0) {
|
|
found = TRUE;
|
if (temp == 0) {
|
memcpy(parse_buf, entry->d_name, sizeof(parse_buf));
|
|
temp = 1;
|
|
} else {
|
|
if (data_cmp(parse_buf, entry->d_name, NAME_MID) < 0) {
|
memset(parse_buf, 0x00, sizeof(parse_buf));
|
memcpy(parse_buf, entry->d_name, sizeof(parse_buf));
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
closedir(pDir);
|
|
if (found == TRUE) {
|
memcpy(buf, dir_path, length - 1);
|
memcpy(buf + strlen(buf), "/", length - strlen(buf) - 1);
|
memcpy(buf + strlen(buf), parse_buf, length - strlen(buf) - 1);
|
} else {
|
buf[0] = 0;
|
}
|
|
return found;
|
}
|
|
int playback_get_key(playback_key set, char *buf, int length) {
|
int ret;
|
char parse_buf[MAX_BUF_SIZE] = { 0x00 };
|
char buf_temp[MAX_BUF_SIZE] = { 0x00 };
|
|
if ((set.name == NULL) || (set.date == NULL) || (set.time == NULL)) {
|
SOAP_DBGERR("invalid playbeck key set parameters!\n");
|
|
return 0;
|
}
|
|
ret = get_dir_with_key(VIDEO_PUT_DIR, set.name, set.date, parse_buf, sizeof(parse_buf));
|
if (ret > 0) {
|
ret = get_file_with_key(parse_buf, set.time, buf_temp, sizeof(buf_temp), 0);
|
if (ret > 0) {
|
memcpy(buf, buf_temp, length);
|
}
|
}
|
|
return ret;
|
}
|
|
static int get_dir_oldest(char *dir_path, char *buf, int length) {
|
DIR *pDir;
|
char temp = 0;
|
int found = FALSE;
|
struct dirent * entry;
|
char parse_buf[MAX_BUF_SIZE] = { 0x00 };
|
|
pDir = opendir(dir_path);
|
if (
|
pDir == NULL) {
|
SOAP_DBGERR("the path(%s) can not be opened!\n", dir_path);
|
|
return -1;
|
}
|
|
while((entry = readdir(pDir)) != NULL) {
|
|
if (entry->d_type & DT_DIR) {
|
|
if ((strcmp(entry->d_name, ".") != 0) && (strcmp(entry->d_name, "..") != 0)) {
|
|
found = TRUE;
|
if (temp == 0) {
|
memcpy(parse_buf, entry->d_name, sizeof(parse_buf));
|
|
temp = 1;
|
|
} else {
|
|
if (data_cmp(parse_buf, entry->d_name, NAME_MID) > 0) {
|
memset(parse_buf, 0x00, sizeof(parse_buf));
|
memcpy(parse_buf, entry->d_name, sizeof(parse_buf));
|
}
|
}
|
}
|
}
|
}
|
|
closedir(pDir);
|
|
if (found == TRUE) {
|
memcpy(buf, dir_path, length);
|
memcpy(buf + strlen(buf), "/", length - strlen(buf) - 1);
|
memcpy(buf + strlen(buf), parse_buf, length - strlen(buf) - 1);
|
|
return 0;
|
}
|
|
buf[0] = 0x00;
|
|
return -1;
|
}
|
|
/*parse the location to get the right file.
|
* flag - include the key itself or not
|
*/
|
static int get_file_with_key(char *dir_path, char *key, char *buf, int length, int flag) {
|
DIR *pDir;
|
char temp = 0;
|
char found = FALSE;
|
char found_flag = FALSE;
|
struct dirent * entry;
|
char parse_buf[MAX_BUF_SIZE] = { 0x00 };
|
|
pDir = opendir(dir_path);
|
if (pDir == NULL) {
|
SOAP_DBGERR("the path(%s) can not be opened!\n", dir_path);
|
|
return -1;
|
}
|
|
while((entry = readdir(pDir)) != NULL) {
|
|
if (entry->d_type & DT_REG) {
|
|
if ((key != NULL) && (data_cmp(key, entry->d_name, NAME_MID) >= 0)) {
|
|
if ((flag == 1) && (data_cmp(key, entry->d_name, NAME_MID) > 0)) {
|
found = TRUE;
|
} else if (flag == 0) {
|
found = TRUE;
|
}
|
} else if (key == NULL) {
|
found = TRUE;
|
}
|
|
if (found == TRUE) {
|
|
found_flag = TRUE;
|
|
if (temp == 0) {
|
memcpy(parse_buf, entry->d_name, sizeof(parse_buf));
|
|
temp = 1;
|
|
} else {
|
|
if (data_cmp(parse_buf, entry->d_name, NAME_MID) < 0) {
|
memset(parse_buf, 0x00, sizeof(parse_buf));
|
memcpy(parse_buf, entry->d_name, sizeof(parse_buf));
|
}
|
}
|
|
found = FALSE;
|
}
|
}
|
}
|
|
closedir(pDir);
|
|
if (found_flag == TRUE) {
|
memcpy(buf, dir_path, length - 1);
|
memcpy(buf + strlen(buf), "/", length - strlen(buf) - 1);
|
memcpy(buf + strlen(buf), parse_buf, length - strlen(buf) - 1);
|
} else {
|
buf[0] = 0;
|
}
|
|
return found_flag;
|
}
|
|
/*compare the string between s1 and s2*/
|
static int data_cmp(char *s1, char *s2, char *dlim)
|
{
|
int data1;
|
int data2;
|
char *ptr1;
|
char *ptr2;
|
|
data1 = atoi(s1);
|
data2 = atoi(s2);
|
if (data1 > data2)
|
return 1;
|
|
if (data1 < data2)
|
return -1;
|
|
ptr1 = strstr(s1, dlim);
|
ptr2 = strstr(s2, dlim);
|
data1 = atoi(ptr1 + 1);
|
data2 = atoi(ptr2 + 1);
|
if (data1 > data2)
|
return 1;
|
|
if (data1 < data2)
|
return -1;
|
|
ptr1 = strstr(ptr1 + 1, dlim);
|
ptr2 = strstr(ptr2 + 1, dlim);
|
data1 = atoi(ptr1 + 1);
|
data2 = atoi(ptr2 + 1);
|
if (data1 > data2)
|
return 1;
|
|
if (data1 < data2)
|
return -1;
|
|
return 0;
|
}
|
|
/*av stream capture task*/
|
static void *task_av_capture(void *arg)
|
{
|
struct timespec time_exp;
|
|
time_exp.tv_sec = WT_TIME;
|
time_exp.tv_nsec = 0;
|
//int data = *(int *)arg;
|
|
pthread_detach(pthread_self());
|
|
while(1) {
|
sem_timedwait(&(gAVDevs->sem_cap), &time_exp);
|
|
while(gAVDevs->run_stat == TRUE) {
|
|
av_start_cap(gAVDevs);
|
|
gAVDevs->slice_stat = TRUE;
|
|
}
|
|
if (gAVDevs->dev_stat == DISABLE) {
|
|
gAVDevs->proc_stat = DISABLE;
|
|
}
|
}
|
|
return 0;
|
}
|
|
/*monitor the disk usage*/
|
static void *task_disk_mon(void *arg)
|
{
|
int ret;
|
uint64_t blocksize;
|
uint64_t totalsize;
|
uint64_t availableDisk;
|
struct statfs diskInfo;
|
char buf[MAX_BUF_SIZE] = { 0x00 };
|
char buf_cmd[MAX_BUF_SIZE] = { 0x00 };
|
|
pthread_detach(pthread_self());
|
|
while(1) {
|
statfs(VIDEO_PUT_DIR, &diskInfo);
|
|
blocksize = diskInfo.f_bsize;
|
totalsize = blocksize * diskInfo.f_blocks;
|
availableDisk = diskInfo.f_bavail * blocksize;
|
|
while ((availableDisk * 1.0 / totalsize) < DISK_FREE_THRES) {
|
ret = get_dir_oldest(VIDEO_PUT_DIR, buf, sizeof(buf));
|
if (ret == 0) {
|
memcpy(buf_cmd, "rm -rf ", sizeof(buf_cmd));
|
snprintf(buf_cmd + strlen(buf_cmd), sizeof(buf_cmd) - strlen(buf_cmd) - 1, "rm -rf %s", buf);
|
system(buf_cmd);
|
sleep(WT_TIME);
|
|
statfs(VIDEO_PUT_DIR, &diskInfo);
|
|
blocksize = diskInfo.f_bsize;
|
totalsize = blocksize * diskInfo.f_blocks;
|
availableDisk = diskInfo.f_bavail * blocksize;
|
|
memset(buf, 0x00, sizeof(buf));
|
memset(buf_cmd, 0x00, sizeof(buf_cmd));
|
} else {
|
|
break;
|
}
|
}
|
|
sleep(WT_MAX_TIME);
|
}
|
|
return NULL;
|
}
|
|
/*initialize the stream data channel*/
|
int proto_AVInit(void) {
|
|
int ret;
|
int flag;
|
pthread_t tid;
|
struct stat stat_buf;
|
|
if (stat(VIDEO_CONF_DATA, &stat_buf) != 0) {
|
SOAP_DBGERR("The video configuration(%s) is not existed! Please put it firstly!\n", VIDEO_CONF_DATA);
|
|
return -1;
|
}
|
|
ret = chmod(VIDEO_CONF_DATA, 0777);
|
if (ret < 0) {
|
SOAP_DBGERR("parse the configuration error: %s\n", strerror(errno));
|
|
return -1;
|
}
|
|
ret = DiscoverDevice(cb_av_probe);
|
if (ret <= 0) {
|
return -1;
|
}
|
|
ret = pthread_create(&tid, NULL, task_av_capture, &flag);
|
if (ret) {
|
return -1;
|
}
|
|
ret = pthread_create(&tid, NULL, task_disk_mon, &flag);
|
if (ret) {
|
return -1;
|
}
|
|
return 0;
|
}
|
|
void proto_AVStart(AVDevs *DevData) {
|
|
DevData->slice_stat = TRUE;
|
|
DevData->run_stat = TRUE;
|
|
sem_post(&(DevData->sem_cap));
|
|
}
|
|
static int av_start_cap(AVDevs *DevData) {
|
int ret;
|
pid_t pid;
|
char data_buf[MAX_BUF_SIZE] = { 0x00 };
|
char temp_buf[MAX_BUF_SIZE] = { 0x00 };
|
char data_buf_temp[MAX_BUF_SIZE] = { 0x00 };
|
char buf[MAX_BUF_SIZE] = { 0x00 };
|
|
signal(SIGINT, handler);
|
|
pid = fork();
|
if (pid < 0) {
|
SOAP_DBGERR("AV start failure: fork failed!\n");
|
|
return -1;
|
|
}
|
|
if (pid > 0) {
|
|
timer_start(gAVDevs->timer_id, gAVDevs->timer_sec);
|
|
while((gAVDevs->run_stat == TRUE) && (gAVDevs->slice_stat == TRUE)) {
|
sleep(1);
|
}
|
timer_stop(gAVDevs->timer_id);
|
|
kill(pid, SIGINT);
|
|
wait(NULL);
|
|
sync();
|
|
if ((gAVDevs->work_mode == PAUSE) && (gAVDevs->pause_enable == FALSE)) {
|
|
gAVDevs->pause_enable = TRUE;
|
|
} else if ((gAVDevs->work_mode == PAUSE) && (gAVDevs->pause_enable == TRUE)) {
|
|
system_date_get(data_buf_temp, sizeof(data_buf_temp));
|
|
ret = get_dir_with_key(VIDEO_PUT_DIR, gAVDevs->ip, data_buf_temp, data_buf, sizeof(data_buf));
|
if (ret > 0) {
|
|
memcpy(temp_buf, data_buf, sizeof(temp_buf) - 1);
|
memset(data_buf, 0x00, sizeof(data_buf));
|
get_file_with_key(temp_buf, NULL, data_buf, sizeof(data_buf), 0);
|
|
memset(data_buf_temp, 0x00, sizeof(data_buf_temp));
|
get_file_with_key(temp_buf, data_buf, data_buf_temp, sizeof(data_buf_temp), 1);
|
|
snprintf(buf, sizeof(buf) - 1, "%s", VIDEO_CONF_DATA);
|
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf) - 1, "%s %s", data_buf_temp, data_buf);
|
system(buf);
|
}
|
|
gAVDevs->work_mode = NORMAL;
|
|
gAVDevs->pause_enable = FALSE;
|
}
|
|
} else {
|
|
ret = video_file_create(data_buf, sizeof(data_buf));
|
if (ret < 0) {
|
return 0;
|
}
|
|
ret = execl(FFMPEG_BIN_DIR, "ffmpeg", "-f", "rtsp", "-rtsp_transport", "tcp", "-i", gAVDevs->uri_data, "-vcodec", "copy", "-y", data_buf, (char *)NULL);
|
if (ret < 0) {
|
SOAP_DBGERR("ffmpeg stuffs are not available: %s\n", strerror(errno));
|
SOAP_DBGERR("please check and confirm it had already been installed correctly!\n");
|
}
|
|
}
|
|
return 0;
|
}
|
|
void proto_AVStop(AVDevs *DevData, enum wr_mode mode) {
|
|
DevData->run_stat = FALSE;
|
|
DevData->work_mode = mode;
|
}
|
|
static int video_file_create(char *data_buf, int length) {
|
|
int ret;
|
int len;
|
struct stat stat_buf;
|
char buf[MAX_BUF_SIZE] = { 0x00 };
|
|
struct tm tloc;
|
time_t now;
|
time(&now);
|
localtime_r(&now, &tloc);
|
|
if (stat(VIDEO_PUT_DIR, &stat_buf) != 0) {
|
memcpy(buf, "mkdir -p ", sizeof(buf));
|
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf) - 1, "%s", VIDEO_PUT_DIR);
|
system(buf);
|
}
|
|
memset(buf, 0x00, sizeof(buf));
|
len = MAX_BUF_SIZE - 1;
|
snprintf(buf, len, "%s", VIDEO_PUT_DIR);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "/%d-", tloc.tm_year + 1900);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "%d-", tloc.tm_mon + 1);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "%d", tloc.tm_mday);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "_%s", gAVDevs->ip);
|
|
if (stat(buf, &stat_buf) != 0) {
|
|
ret = mkdir(buf, 0777);
|
if (ret < 0) {
|
SOAP_DBGERR("the video put dir create failure: %s\n", strerror(errno));
|
|
return -1;
|
}
|
}
|
|
time(&now);
|
localtime_r(&now, &tloc);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "/%d-", tloc.tm_hour);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "%d-", tloc.tm_min);
|
len = (MAX_BUF_SIZE - 1) >= strlen(buf) ? MAX_BUF_SIZE - 1 - strlen(buf) : 0;
|
snprintf(buf + strlen(buf), len, "%d.mp4", tloc.tm_sec);
|
|
memcpy(data_buf, buf, length);
|
|
return 0;
|
}
|
|
static void system_date_get(char *buf, int len)
|
{
|
struct tm tloc;
|
time_t now;
|
time(&now);
|
localtime_r(&now, &tloc);
|
|
sprintf(buf, "%d", tloc.tm_year + 1900);
|
sprintf(buf + strlen(buf), "-%d", tloc.tm_mon + 1);
|
sprintf(buf + strlen(buf), "-%d", tloc.tm_mday);
|
|
return;
|
}
|
|
static void cb_av_probe(char *DeviceXAddr)
|
{
|
int ret;
|
int len;
|
char *pos_s, *pos_e;
|
|
if (gAVDevs == NULL) {
|
|
gAVDevs = malloc(sizeof(AVDevs));
|
|
SOAP_ASSERT(gAVDevs != NULL);
|
|
memset(gAVDevs, 0x00, sizeof(AVDevs));
|
|
pos_s = strstr(DeviceXAddr, ADDR_PREFIX);
|
pos_e = strstr(DeviceXAddr + strlen(ADDR_PREFIX), ADDR_LAST);
|
len = pos_e - DeviceXAddr - strlen(ADDR_PREFIX);
|
memcpy(gAVDevs->ip, DeviceXAddr + strlen(ADDR_PREFIX), len);
|
|
gAVDevs->timer_sec = VIDEO_DURATION;
|
|
gAVDevs->dev_stat = ENABLE;
|
gAVDevs->run_stat = FALSE;
|
|
ret = sem_init(&(gAVDevs->sem_cap), 0, 0);
|
SOAP_ASSERT(ret == 0);
|
|
timer_init(&(gAVDevs->timer_id), av_timer_handler);
|
}
|
|
/*Get the device capabilities*/
|
proto_GetCapabilities(DeviceXAddr, &(gAVDevs->capa), USERNAME, PASSWORD);
|
|
/*Parse the stream configurations*/
|
proto_GetProfiles(gAVDevs->capa.MediaXAddr, &(gAVDevs->profiles), USERNAME, PASSWORD);
|
|
proto_GetStreamUri(gAVDevs->capa.MediaXAddr, gAVDevs->profiles->token, gAVDevs->uri, sizeof(gAVDevs->uri), USERNAME, PASSWORD);
|
|
bridge_uri(gAVDevs->uri, USERNAME, PASSWORD, gAVDevs->uri_data, sizeof(gAVDevs->uri_data));
|
|
}
|
|
AVDevs *proto_AVGethandle(void)
|
{
|
return gAVDevs;
|
}
|
|
void proto_AVClose(void)
|
{
|
if (gAVDevs != NULL) {
|
|
if (gAVDevs->dev_stat == ENABLE) {
|
proto_AVStop(gAVDevs, NORMAL);
|
}
|
|
gAVDevs->dev_stat = DISABLE;
|
|
while(gAVDevs->proc_stat != DISABLE) {
|
sleep(2);
|
}
|
|
sem_destroy(&(gAVDevs->sem_cap));
|
|
timer_destroy(gAVDevs->timer_id);
|
|
free(gAVDevs->profiles);
|
|
free(gAVDevs);
|
|
gAVDevs = NULL;
|
}
|
}
|
|
/*get the video and audio packet*/
|
void get_stream(AVDevs *DevData)
|
{
|
unsigned int i;
|
int ret;
|
int video_st_index = -1;
|
int audio_st_index = -1;
|
AVFormatContext *ifmt_ctx = NULL;
|
AVPacket pkt;
|
AVStream *st = NULL;
|
char errbuf[64];
|
|
/*Open the input file for reading*/
|
if ((ret = avformat_open_input(&ifmt_ctx, DevData->uri_data, 0, NULL)) < 0) {
|
SOAP_DBGERR("Could not open input file '%s' (error '%s')\n", DevData->uri_data, av_make_error_string(errbuf, sizeof(errbuf), ret));
|
|
goto EXIT;
|
}
|
|
/*Get information on the input file (number of streams etc.))*/
|
if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
|
SOAP_DBGERR("Could not open find stream info (error '%s')\n", av_make_error_string(errbuf, sizeof(errbuf), ret));
|
|
goto EXIT;
|
}
|
|
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
|
av_dump_format(ifmt_ctx, i, DevData->uri_data, 0);
|
}
|
|
/*find video stream index*/
|
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
|
|
st = ifmt_ctx->streams[i];
|
|
switch(st->codec->codec_type) {
|
|
case AVMEDIA_TYPE_AUDIO:
|
audio_st_index = i;
|
|
break;
|
|
case AVMEDIA_TYPE_VIDEO:
|
video_st_index = i;
|
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
if (-1 == video_st_index) {
|
SOAP_DBGERR("No H.264 video stream in the input file\n");
|
|
goto EXIT;
|
}
|
|
/*initialize packet*/
|
av_init_packet(&pkt);
|
pkt.data = NULL;
|
pkt.size = 0;
|
|
while (1) {
|
do {
|
|
ret = av_read_frame(ifmt_ctx, &pkt);
|
|
} while (ret == AVERROR(EAGAIN));
|
|
if (ret < 0) {
|
SOAP_DBGERR("Could not read frame (error '%s')\n", av_make_error_string(errbuf, sizeof(errbuf), ret));
|
|
break;
|
}
|
|
/*video frame*/
|
if (pkt.stream_index == video_st_index) {
|
|
SOAP_DBGERR("Video Packet size = %d\n", pkt.size);
|
|
} else if(pkt.stream_index == audio_st_index) {
|
/*audio frame*/
|
SOAP_DBGERR("Audio Packet size = %d\n", pkt.size);
|
|
} else {
|
|
SOAP_DBGERR("Unknow Packet size = %d\n", pkt.size);
|
|
}
|
|
av_packet_unref(&pkt);
|
}
|
|
EXIT:
|
|
if (NULL != ifmt_ctx) {
|
|
avformat_close_input(&ifmt_ctx);
|
|
ifmt_ctx = NULL;
|
}
|
|
return ;
|
}
|
|
/*Get the device service stream address*/
|
int proto_GetStreamUri(const char *MediaXAddr, char *ProfileToken, char *uri, unsigned int sizeuri, const char *username, const char *passwd)
|
{
|
|
int result = 0;
|
struct soap *soap = NULL;
|
struct tt__StreamSetup ttStreamSetup;
|
struct tt__Transport ttTransport;
|
struct _trt__GetStreamUri req;
|
struct _trt__GetStreamUriResponse rep;
|
|
SOAP_ASSERT(NULL != MediaXAddr);
|
SOAP_ASSERT(NULL != uri);
|
|
memset(uri, 0x00, sizeuri);
|
|
SOAP_ASSERT(NULL != (soap = proto_soap_new(SOAP_SOCK_TIMEOUT)));
|
|
memset(&req, 0x00, sizeof(req));
|
memset(&rep, 0x00, sizeof(rep));
|
memset(&ttStreamSetup, 0x00, sizeof(ttStreamSetup));
|
memset(&ttTransport, 0x00, sizeof(ttTransport));
|
|
ttStreamSetup.Stream = tt__StreamType__RTP_Unicast;
|
ttStreamSetup.Transport = &ttTransport;
|
ttStreamSetup.Transport->Protocol = tt__TransportProtocol__RTSP;
|
ttStreamSetup.Transport->Tunnel = NULL;
|
req.StreamSetup = &ttStreamSetup;
|
req.ProfileToken = ProfileToken;
|
|
proto_SetAuthInfo(soap, username, passwd);
|
result = soap_call___trt__GetStreamUri(soap, MediaXAddr, NULL, &req, &rep);
|
SOAP_CHECK_ERROR(result, soap, "GetServices");
|
|
dump_trt__GetStreamUriResponse(&rep);
|
|
result = -1;
|
if (NULL != rep.MediaUri) {
|
if (NULL != rep.MediaUri->Uri) {
|
if (sizeuri > strlen(rep.MediaUri->Uri)) {
|
|
strcpy(uri, rep.MediaUri->Uri);
|
|
result = 0;
|
} else {
|
SOAP_DBGERR("Not enough cache!\n");
|
}
|
}
|
}
|
|
EXIT:
|
|
if (NULL != soap) {
|
proto_soap_delete(soap);
|
}
|
|
return result;
|
|
}
|
|
|
