/*
* pause_all_media - do a spin loop until the sync thread indicates it's
* paused.
*/
int CPlayerSession::pause_all_media (void)
{
int ret;
CPlayerMedia *p;
m_session_state = SESSION_PAUSED;
if (session_control_is_aggregate()) {
rtsp_command_t cmd;
rtsp_decode_t *decode;
memset(&cmd, 0, sizeof(rtsp_command_t));
if (rtsp_send_aggregate_pause(m_rtsp_client,
m_session_control_url,
&cmd,
&decode) != 0) {
player_debug_message("RTSP aggregate pause command failed");
free_decode_response(decode);
return (-1);
}
free_decode_response(decode);
}
p = m_my_media;
while (p != NULL) {
ret = p->do_pause();
if (ret != 0) return (ret);
p = p->get_next();
}
m_sync_pause_done = 0;
send_sync_thread_a_message(MSG_PAUSE_SESSION);
#ifndef NEED_SDL_VIDEO_IN_MAIN_THREAD
do {
#endif
SDL_Delay(100);
#ifndef NEED_SDL_VIDEO_IN_MAIN_THREAD
} while (m_sync_pause_done == 0);
#endif
m_paused = 1;
return (0);
}
/*
* free_rtsp_client()
* frees all memory associated with rtsp client information
*/
void free_rtsp_client (rtsp_client_t *rptr)
{
/*if (rptr->thread != NULL) {
rtsp_close_thread(rptr);
} else*/ {
rtsp_close_socket(rptr);
#ifdef _WINDOWS
WSACleanup();
#endif
}
CHECK_AND_FREE(rptr->orig_url);
CHECK_AND_FREE(rptr->url);
CHECK_AND_FREE(rptr->server_name);
CHECK_AND_FREE(rptr->cookie);
free_decode_response(rptr->decode_response);
rptr->decode_response = NULL;
free(rptr);
}
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);
}
CPlayerSession::~CPlayerSession ()
{
int hadthread = 0;
#ifndef NEED_SDL_VIDEO_IN_MAIN_THREAD
if (m_sync_thread) {
send_sync_thread_a_message(MSG_STOP_THREAD);
SDL_WaitThread(m_sync_thread, NULL);
m_sync_thread = NULL;
hadthread = 1;
}
#else
send_sync_thread_a_message(MSG_STOP_THREAD);
hadthread = 1;
#endif
if (m_streaming_media_set_up != 0 &&
session_control_is_aggregate()) {
rtsp_command_t cmd;
rtsp_decode_t *decode;
memset(&cmd, 0, sizeof(rtsp_command_t));
rtsp_send_aggregate_teardown(m_rtsp_client,
m_session_control_url,
&cmd,
&decode);
free_decode_response(decode);
}
if (m_rtsp_client) {
free_rtsp_client(m_rtsp_client);
m_rtsp_client = NULL;
}
while (m_my_media != NULL) {
CPlayerMedia *p;
p = m_my_media;
m_my_media = p->get_next();
delete p;
}
if (m_sdp_info) {
sdp_free_session_desc(m_sdp_info);
m_sdp_info = NULL;
}
if (m_sync_sem) {
SDL_DestroySemaphore(m_sync_sem);
m_sync_sem = NULL;
}
int quit_sdl = 1;
if (m_video_sync != NULL) {
// we need to know if we should quit SDL or not. If the control
// code has grabbed the persistence, we don't want to quit
if (m_video_sync->grabbed_video_persistence() != 0) {
quit_sdl = 0;
}
delete m_video_sync;
m_video_sync = NULL;
}
if (m_audio_sync != NULL) {
delete m_audio_sync;
m_audio_sync = NULL;
}
if (m_session_name) {
free((void *)m_session_name);
m_session_name = NULL;
}
if (m_content_base) {
free((void *) m_content_base);
m_content_base = NULL;
}
for (int ix = 0; ix < SESSION_DESC_COUNT; ix++) {
if (m_session_desc[ix] != NULL)
free((void *)m_session_desc[ix]);
m_session_desc[ix] = NULL;
}
if (m_media_close_callback != NULL) {
m_media_close_callback(m_media_close_callback_data);
}
while (m_unused_ports != NULL) {
CIpPort *first;
first = m_unused_ports;
m_unused_ports = first->get_next();
delete first;
}
if (hadthread != 0 && quit_sdl != 0) {
SDL_Quit();
}
}
/*
* play_all_media - get all media to play
*/
int CPlayerSession::play_all_media (int start_from_begin,
double start_time,
char *errmsg,
uint32_t errlen)
{
int ret;
CPlayerMedia *p;
if (m_set_end_time == 0) {
range_desc_t *range;
if (m_sdp_info && m_sdp_info->session_range.have_range != FALSE) {
range = &m_sdp_info->session_range;
} else {
range = NULL;
p = m_my_media;
while (range == NULL && p != NULL) {
media_desc_t *media;
media = p->get_sdp_media_desc();
if (media && media->media_range.have_range) {
range = &media->media_range;
}
p = p->get_next();
}
}
if (range != NULL) {
m_end_time = (uint64_t)(range->range_end * 1000.0);
m_set_end_time = 1;
}
}
p = m_my_media;
m_session_state = SESSION_BUFFERING;
if (m_paused == 1 && start_time == 0.0 && start_from_begin == FALSE) {
/*
* we were paused. Continue.
*/
m_play_start_time = m_current_time;
start_time = UINT64_TO_DOUBLE(m_current_time);
start_time /= 1000.0;
player_debug_message("Restarting at " U64 ", %g", m_current_time, start_time);
} else {
/*
* We might have been paused, but we're told to seek
*/
// Indicate what time we're starting at for sync task.
m_play_start_time = (uint64_t)(start_time * 1000.0);
}
m_paused = 0;
send_sync_thread_a_message(MSG_START_SESSION);
// If we're doing aggregate rtsp, send the play command...
if (session_control_is_aggregate() &&
m_dont_send_first_rtsp_play == 0) {
char buffer[80];
rtsp_command_t cmd;
rtsp_decode_t *decode;
memset(&cmd, 0, sizeof(rtsp_command_t));
if (m_set_end_time != 0) {
uint64_t stime = (uint64_t)(start_time * 1000.0);
sprintf(buffer, "npt="U64"."U64"-"U64"."U64,
stime / 1000, stime % 1000, m_end_time / 1000, m_end_time % 1000);
cmd.range = buffer;
}
if (rtsp_send_aggregate_play(m_rtsp_client,
m_session_control_url,
&cmd,
&decode) != 0) {
if (errmsg != NULL) {
snprintf(errmsg, errlen, "RTSP Aggregate Play Error %s-%s",
decode->retcode,
decode->retresp != NULL ? decode->retresp : "");
}
player_debug_message("RTSP aggregate play command failed");
free_decode_response(decode);
return (-1);
}
if (decode->rtp_info == NULL) {
player_error_message("No rtp info field");
} else {
player_debug_message("rtp info is \'%s\'", decode->rtp_info);
}
int ret = process_rtsp_rtpinfo(decode->rtp_info, this, NULL);
free_decode_response(decode);
if (ret < 0) {
if (errmsg != NULL) {
snprintf(errmsg, errlen, "RTSP aggregate RtpInfo response failure");
}
player_debug_message("rtsp aggregate rtpinfo failed");
return (-1);
}
}
m_dont_send_first_rtsp_play = 0;
while (p != NULL) {
ret = p->do_play(start_time, errmsg, errlen);
if (ret != 0) return (ret);
p = p->get_next();
}
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);
}
