static session_desc_t *find_sdp_for_program (const char *cm,
const char *loc,
char *errmsg,
uint32_t errlen,
uint64_t prog)
{
char buffer[1024];
http_client_t *http_client;
http_resp_t *http_resp;
sdp_decode_info_t *sdp_info;
session_desc_t *sdp, *ptr, *sdp_ret;
int translated;
int ret, ix;
snprintf(buffer, sizeof(buffer), "http://%s/%s", cm, loc);
http_resp = NULL;
http_client = http_init_connection(buffer);
if (http_client == NULL) {
snprintf(errmsg, errlen, "Cannot create http client with %s\n",
cm);
return NULL;
}
ret = http_get(http_client, NULL, &http_resp);
sdp_ret = NULL;
if (ret > 0) {
sdp_info = set_sdp_decode_from_memory(http_resp->body);
if ((sdp_decode(sdp_info, &sdp, &translated) == 0) &&
(translated > 0)) {
for (ix = 0; ix < translated && sdp_ret == NULL; ix++) {
if (sdp->session_id == prog) {
sdp_ret = sdp;
sdp = sdp->next;
sdp_ret->next = NULL;
} else {
ptr = sdp->next;
sdp->next = NULL;
sdp_free_session_desc(sdp);
sdp = ptr;
}
}
sdp_decode_info_free(sdp_info);
if (sdp != NULL) sdp_free_session_desc(sdp);
}
}
http_resp_free(http_resp);
http_free_connection(http_client);
return sdp_ret;
}
static int create_media_for_http (CPlayerSession *psptr,
const char *name,
char *errmsg,
uint32_t errlen,
control_callback_vft_t *cc_vft)
{
http_client_t *http_client;
int ret;
http_resp_t *http_resp;
http_resp = NULL;
http_client = http_init_connection(name);
if (http_client == NULL) {
snprintf(errmsg, errlen, "Can't create http client");
return -1;
}
ret = http_get(http_client, NULL, &http_resp);
if (ret > 0) {
sdp_decode_info_t *sdp_info;
int have_audio_driver = do_we_have_audio();
sdp_info = set_sdp_decode_from_memory(http_resp->body);
ret = create_from_sdp(psptr,
name,
errmsg,
errlen,
sdp_info,
have_audio_driver,
cc_vft);
} else {
ret = -1;
snprintf(errmsg, errlen, "HTTP error %d, %s", http_resp->ret_code,
http_resp->resp_phrase);
}
http_resp_free(http_resp);
http_free_connection(http_client);
return (ret);
}
int main (int argc, char **argv)
{
rtsp_client_t *rtsp_client;
int ret;
rtsp_command_t cmd;
rtsp_decode_t *decode;
session_desc_t *sdp;
media_desc_t *media;
sdp_decode_info_t *sdpdecode;
rtsp_session_t *session;
int dummy;
rtsp_set_error_func(local_error_msg);
rtsp_set_loglevel(LOG_DEBUG);
memset(&cmd, 0, sizeof(rtsp_command_t));
argv++;
rtsp_client = rtsp_create_client(*argv, &ret, NULL, 0);
if (rtsp_client == NULL) {
printf("No client created - error %d\n", ret);
return (1);
}
if (rtsp_send_describe(rtsp_client, &cmd, &decode) != RTSP_RESPONSE_GOOD) {
printf("Describe response not good\n");
free_decode_response(decode);
free_rtsp_client(rtsp_client);
return(1);
}
sdpdecode = set_sdp_decode_from_memory(decode->body);
if (sdpdecode == NULL) {
printf("Couldn't get sdp decode\n");
free_decode_response(decode);
free_rtsp_client(rtsp_client);
return(1);
}
if (sdp_decode(sdpdecode, &sdp, &dummy) != 0) {
printf("Couldn't decode sdp\n");
free_decode_response(decode);
free_rtsp_client(rtsp_client);
return (1);
}
free(sdpdecode);
if (decode->content_base == NULL) {
convert_relative_urls_to_absolute (sdp, *argv);
} else {
convert_relative_urls_to_absolute(sdp, decode->content_base);
}
free_decode_response(decode);
decode = NULL;
#if 1
cmd.transport = "RTP/AVP;unicast;client_port=4588-4589";
#else
cmd.transport = "RTP/AVP/TCP;interleaved=0-1";
#endif
media = sdp->media;
dummy = rtsp_send_setup(rtsp_client,
media->control_string,
&cmd,
&session,
&decode, 0);
if (dummy != RTSP_RESPONSE_GOOD) {
printf("Response to setup is %d\n", dummy);
sdp_free_session_desc(sdp);
free_decode_response(decode);
free_rtsp_client(rtsp_client);
return (1);
}
free_decode_response(decode);
cmd.range = "npt=0.0-30.0";
cmd.transport = NULL;
if (sdp->control_string != NULL)
dummy = rtsp_send_aggregate_play(rtsp_client, sdp->control_string, &cmd, &decode);
else
dummy = rtsp_send_play(session, &cmd, &decode);
if (dummy != RTSP_RESPONSE_GOOD) {
printf("response to play is %d\n", dummy);
} else {
sleep(10);
}
free_decode_response(decode);
cmd.transport = NULL;
if (sdp->control_string != NULL)
dummy = rtsp_send_aggregate_teardown(rtsp_client, sdp->control_string, &cmd, &decode);
else
dummy = rtsp_send_teardown(session, NULL, &decode);
printf("Teardown response %d\n", dummy);
sdp_free_session_desc(sdp);
free_decode_response(decode);
free_rtsp_client(rtsp_client);
return (0);
}
/*
* create_streaming - create a session for streaming. Create an
* RTSP session with the server, get the SDP information from it.
*/
int CPlayerSession::create_streaming_ondemand (const char *url,
char *errmsg,
uint32_t errlen,
int use_tcp)
{
rtsp_command_t cmd;
rtsp_decode_t *decode;
sdp_decode_info_t *sdpdecode;
int dummy;
int err;
// streaming has seek capability (at least on demand)
session_set_seekable(1);
player_debug_message("Creating streaming %s", url);
memset(&cmd, 0, sizeof(rtsp_command_t));
/*
* create RTSP session
*/
if (use_tcp != 0) {
m_rtsp_client = rtsp_create_client_for_rtp_tcp(url, &err);
} else {
m_rtsp_client = rtsp_create_client(url, &err);
}
if (m_rtsp_client == NULL) {
snprintf(errmsg, errlen, "Failed to create RTSP client");
player_error_message("Failed to create rtsp client - error %d", err);
return (err);
}
m_rtp_over_rtsp = use_tcp;
cmd.accept = "application/sdp";
/*
* Send the RTSP describe. This should return SDP information about
* the session.
*/
int rtsp_resp;
rtsp_resp = rtsp_send_describe(m_rtsp_client, &cmd, &decode);
if (rtsp_resp != RTSP_RESPONSE_GOOD) {
int retval;
if (decode != NULL) {
retval = (((decode->retcode[0] - '0') * 100) +
((decode->retcode[1] - '0') * 10) +
(decode->retcode[2] - '0'));
snprintf(errmsg, errlen, "RTSP describe error %d %s", retval,
decode->retresp != NULL ? decode->retresp : "");
free_decode_response(decode);
} else {
retval = -1;
snprintf(errmsg, errlen, "RTSP return invalid %d", rtsp_resp);
}
player_error_message("Describe response not good\n");
return (retval);
}
sdpdecode = set_sdp_decode_from_memory(decode->body);
if (sdpdecode == NULL) {
snprintf(errmsg, errlen, "Memory failure");
player_error_message("Couldn't get sdp decode\n");
free_decode_response(decode);
return (-1);
}
/*
* Decode the SDP information into structures we can use.
*/
err = sdp_decode(sdpdecode, &m_sdp_info, &dummy);
free(sdpdecode);
if (err != 0) {
snprintf(errmsg, errlen, "Couldn't decode session description %s",
decode->body);
player_error_message("Couldn't decode sdp %s", decode->body);
free_decode_response(decode);
return (-1);
}
if (dummy != 1) {
snprintf(errmsg, errlen, "Incorrect number of sessions in sdp decode %d",
dummy);
player_error_message("%s", errmsg);
free_decode_response(decode);
return (-1);
}
/*
* Make sure we can use the urls in the sdp info
*/
if (decode->content_location != NULL) {
// Note - we may have problems if the content location is not absolute.
m_content_base = strdup(decode->content_location);
} else if (decode->content_base != NULL) {
m_content_base = strdup(decode->content_base);
} else {
int urllen = strlen(url);
if (url[urllen] != '/') {
char *temp;
temp = (char *)malloc(urllen + 2);
strcpy(temp, url);
strcat(temp, "/");
m_content_base = temp;
} else {
m_content_base = strdup(url);
}
}
convert_relative_urls_to_absolute(m_sdp_info,
m_content_base);
if (m_sdp_info->control_string != NULL) {
player_debug_message("setting control url to %s", m_sdp_info->control_string);
set_session_control_url(m_sdp_info->control_string);
}
free_decode_response(decode);
m_streaming = 1;
m_streaming_ondemand = (get_range_from_sdp(m_sdp_info) != NULL);
return (0);
}
int check_name_for_network (const char *name,
int &isOnDemand,
int &isRtpOverRtsp)
{
sdp_decode_info_t *sdp_info;
session_desc_t *sdp;
int translated;
http_resp_t *http_resp;
int do_sdp = 0;
http_resp = NULL;
isOnDemand = 0;
isRtpOverRtsp = 0;
sdp_info = NULL;
if (strncmp(name, "mpeg2t://", strlen("mpeg2t://")) == 0) {
return 1;
}
if (strncmp(name, "iptv://", strlen("iptv://")) == 0) {
// more later to handle the on demand/streaming case
return 1;
}
if (strncmp(name, "rtsp://", strlen("rtsp://")) == 0) {
isOnDemand = 1;
isRtpOverRtsp = config.get_config_value(CONFIG_USE_RTP_OVER_RTSP);
return 1;
}
// handle http, .sdp case
if (strncmp(name, "http://", strlen("http://")) == 0) {
http_client_t *http_client;
int ret;
http_client = http_init_connection(name);
if (http_client == NULL) {
return -1;
}
ret = http_get(http_client, NULL, &http_resp);
if (ret > 0) {
sdp_decode_info_t *sdp_info;
sdp_info = set_sdp_decode_from_memory(http_resp->body);
do_sdp = 1;
http_free_connection(http_client);
} else return -1;
do_sdp = 1;
} else {
const char *suffix = strrchr(name, '.');
if (suffix == NULL) {
return -1;
}
if (strcasecmp(suffix, ".sdp") == 0) {
sdp_info = set_sdp_decode_from_filename(name);
do_sdp = 1;
} else
return 0;
}
if (do_sdp != 0) {
if ((sdp_decode(sdp_info, &sdp, &translated) != 0) ||
translated != 1) {
sdp_decode_info_free(sdp_info);
return (-1);
}
if (sdp->control_string != NULL) {
isOnDemand = 1;
isRtpOverRtsp = config.get_config_value(CONFIG_USE_RTP_OVER_RTSP);
}
sdp_free_session_desc(sdp);
if (http_resp != NULL)
http_resp_free(http_resp);
sdp_decode_info_free(sdp_info);
return 1;
}
return 0;
}
