// Create.
MapilVoid GLTexture::Create( const MapilTChar* pFileName )
{
MapilChar name[ 1024 ];
ConvertToMultiByte( pFileName, -1, name, 1024 );
// Analyze file format.
FileFormatAnalyzer ffa;
ffa.Open( name );
ffa.Analyze();
MapilInt32 channel = 3;
if( ffa.GetFileFmt() == FILE_FORMAT_PNG ){
PNGFile pf;
pf.Open( name, FILE_OPEN_READ_MODE );
pf.Load();
m_TexSize.m_X = pf.GetWidth();
m_TexSize.m_Y = pf.GetHeight();
m_pData = new GLubyte[ pf.GetDataSize() ];
ZeroObject( m_pData, sizeof( GLubyte ) * pf.GetDataSize() );
pf.Copy( m_pData );
channel = pf.GetChannel();
pf.Close();
}
else if( ffa.GetFileFmt() == FILE_FORMAT_BMP ){
BMPFile bf;
bf.Open( name, FILE_OPEN_READ_MODE );
bf.Load( name );
m_TexSize.m_X = bf.GetWidth();
m_TexSize.m_Y = bf.GetHeight();
m_pData = new GLubyte[ m_TexSize.m_X * m_TexSize.m_Y * 4 ];
for( MapilInt32 i = 0; i < m_TexSize.m_Y; i++ ){
for( MapilInt32 j = 0; j < m_TexSize.m_X; j++ ){
ColorRGB < MapilUChar > col = bf.GetPixelColor( j, i );
MapilInt32 offset = i * m_TexSize.m_X;
m_pData[ j * 4 + offset * 4 ] = col.m_R;
m_pData[ j * 4 + offset * 4 + 1 ] = col.m_G;
m_pData[ j * 4 + offset * 4 + 2 ] = col.m_B;
m_pData[ j * 4 + offset * 4 + 3 ] = 255;
}
}
}
glGenTextures( 1, &m_TexName );
glBindTexture( GL_TEXTURE_2D, m_TexName );
glTexImage2D( GL_TEXTURE_2D,
0,
( channel == 4 ) ? GL_RGBA :GL_RGB,
m_TexSize.m_X,
m_TexSize.m_Y,
0,
( channel == 4 ) ? GL_RGBA :GL_RGB,
GL_UNSIGNED_BYTE,
m_pData );
}
void roadmap_fileselection_new (const char *title,
const char *filter,
const char *path,
const char *mode,
RoadMapFileCallback callback)
{
//TODO this stub - FIX
#ifndef __SYMBIAN32__
WCHAR filename[MAX_PATH] = {0};
WCHAR strFilter[MAX_PATH] = {0};
LPWSTR fltr = NULL;
LPWSTR title_unicode = ConvertToWideChar(title, CP_UTF8);
BOOL res;
OPENFILENAME ofn;
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFile = filename;
ofn.nMaxFile = sizeof(filename) / sizeof(filename[0]);
ofn.Flags = OFN_EXPLORER;
ofn.lpstrTitle = title_unicode;
if (filter != NULL) {
fltr = ConvertToWideChar(filter, CP_UTF8);
_snwprintf(strFilter, sizeof(strFilter)/sizeof(strFilter[0]),
TEXT("*.%s|*.%s\0"), fltr, fltr);
strFilter[wcslen(fltr)+2] = 0;
ofn.lpstrDefExt = fltr;
ofn.lpstrFilter = strFilter;
} else {
ofn.lpstrFilter = TEXT("*.*\0*.*\0");
}
if (strchr(mode, 'r') != NULL) {
ofn.Flags |= OFN_FILEMUSTEXIST;
res = GetOpenFileName(&ofn);
} else {
ofn.Flags |= OFN_OVERWRITEPROMPT;
res = GetSaveFileName(&ofn);
}
free((char*)ofn.lpstrTitle);
if (fltr) free(fltr);
if (res) {
char *name = ConvertToMultiByte(filename, CP_UTF8);
(*callback)(name, mode);
free(name);
}
#endif
}
const char *roadmap_path_user (void)
{
static char *RoadMapUser = NULL;
if (RoadMapUser == NULL) {
WCHAR path_unicode[MAX_PATH];
char *path;
char *tmp;
/* We don't have a user directory so we'll use the executable path */
GetModuleFileName(NULL, path_unicode,
sizeof(path_unicode)/sizeof(path_unicode[0]));
path = ConvertToMultiByte(path_unicode, CP_UTF8);
tmp = strrchr (path, '\\');
if (tmp != NULL) {
*tmp = '\0';
}
RoadMapUser = path;
}
return RoadMapUser;
}
int WINAPI _tWinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow
)
{
int argc;
TCHAR szMsg[RC_STRING_MAX_SIZE];
LPTSTR *argv;
LPTSTR lptCmdLine,lptDllName,lptFuncName,lptMsgBuffer;
LPSTR lpFuncName,lpaCmdLine;
LPWSTR lpwCmdLine;
HMODULE hDll;
DllWinMainW fnDllWinMainW;
DllWinMainA fnDllWinMainA;
HWND hWindow;
int i;
size_t nStrLen;
// Get command-line in argc-argv format
argv = CommandLineToArgv(GetCommandLine(),&argc);
// Skip all beginning arguments starting with a slash (/)
for (i = 1; i < argc; i++)
if (*argv[i] != _T('/')) break;
// If no dll was specified, there is nothing to do
if (i >= argc) {
if (argv) free(argv);
return 0;
}
lptDllName = argv[i++];
// The next argument, which specifies the name of the dll function,
// can either have a comma between it and the dll filename or a space.
// Using a comma here is the preferred method
if (i < argc)
lptFuncName = argv[i++];
else
lptFuncName = _T("");
// If no function name was specified, nothing needs to be done
if (!*lptFuncName) {
if (argv) free(argv);
return 0;
}
// The rest of the arguments will be passed to dll function
if (i < argc)
lptCmdLine = argv[i];
else
lptCmdLine = _T("");
// Everything is all setup, so load the dll now
hDll = LoadLibrary(lptDllName);
if (hDll) {
nStrLen = _tcslen(lptFuncName);
// Make a non-unicode version of the function name,
// since that is all GetProcAddress accepts
lpFuncName = DuplicateToMultiByte(lptFuncName,nStrLen + 2);
#ifdef UNICODE
lpFuncName[nStrLen] = 'W';
lpFuncName[nStrLen+1] = 0;
// Get address of unicode version of the dll function if it exists
fnDllWinMainW = (DllWinMainW)GetProcAddress(hDll,lpFuncName);
fnDllWinMainA = 0;
if (!fnDllWinMainW) {
// If no unicode function was found, get the address of the non-unicode function
lpFuncName[nStrLen] = 'A';
fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
if (!fnDllWinMainA) {
// If first non-unicode function was not found, get the address
// of the other non-unicode function
lpFuncName[nStrLen] = 0;
fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
}
}
#else
// Get address of non-unicode version of the dll function if it exists
fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
fnDllWinMainW = 0;
if (!fnDllWinMainA) {
// If first non-unicode function was not found, get the address
// of the other non-unicode function
lpFuncName[nStrLen] = 'A';
lpFuncName[nStrLen+1] = 0;
fnDllWinMainA = (DllWinMainA)GetProcAddress(hDll,lpFuncName);
if (!fnDllWinMainA) {
// If non-unicode function was not found, get the address of the unicode function
lpFuncName[nStrLen] = 'W';
fnDllWinMainW = (DllWinMainW)GetProcAddress(hDll,lpFuncName);
}
}
#endif
free(lpFuncName);
if (!RegisterBlankClass(hInstance, hPrevInstance))
{
return 0;
}
// Create a window so we can pass a window handle to
// the dll function; this is required
hWindow = CreateWindowEx(0,rundll32_wclass,rundll32_wtitle,0,CW_USEDEFAULT,0,CW_USEDEFAULT,0,0,0,hInstance,0);
if (fnDllWinMainW) {
// Convert the command-line string to unicode and call the dll function
lpwCmdLine = ConvertToWideChar(lptCmdLine);
fnDllWinMainW(hWindow,hInstance,lpwCmdLine,nCmdShow);
FreeConvertedWideChar(lpwCmdLine);
}
else if (fnDllWinMainA) {
// Convert the command-line string to ansi and call the dll function
lpaCmdLine = ConvertToMultiByte(lptCmdLine);
fnDllWinMainA(hWindow,hInstance,lpaCmdLine,nCmdShow);
FreeConvertedMultiByte(lpaCmdLine);
}
else {
// The specified dll function was not found; display an error message
GetModuleTitle();
LoadString( GetModuleHandle(NULL), IDS_MissingEntry, (LPTSTR) szMsg,RC_STRING_MAX_SIZE);
lptMsgBuffer = (LPTSTR)malloc((_tcslen(szMsg) - 4 + _tcslen(lptFuncName) + _tcslen(lptDllName) + 1) * sizeof(TCHAR));
_stprintf(lptMsgBuffer,szMsg,lptFuncName,lptDllName);
MessageBox(0,lptMsgBuffer,ModuleTitle,MB_ICONERROR);
free(lptMsgBuffer);
}
DestroyWindow(hWindow);
UnregisterClass(rundll32_wclass,hInstance);
// The dll function has finished executing, so unload it
FreeLibrary(hDll);
}
else {
// The dll could not be loaded; display an error message
GetModuleTitle();
LoadString( GetModuleHandle(NULL), IDS_DllNotLoaded, (LPTSTR) szMsg,RC_STRING_MAX_SIZE);
lptMsgBuffer = (LPTSTR)malloc((_tcslen(szMsg) - 2 + _tcslen(lptDllName) + 1) * sizeof(TCHAR));
_stprintf(lptMsgBuffer,szMsg,lptDllName);
MessageBox(0,lptMsgBuffer,ModuleTitle,MB_ICONERROR);
free(lptMsgBuffer);
}
if (argv) free(argv);
return 0; /* rundll32 always returns 0! */
}
int CMPIPTV_RTSP::OpenConnection(void)
{
this->logger.Log(LOGGER_INFO, METHOD_START_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME);
int result = STATUS_OK;
this->rtspClient = RTSPClient::createNew(*this->rtspEnvironment);
result |= (this->rtspClient == NULL);
if (result == STATUS_OK)
{
// RTSPClient works with char, not with TCHAR
char *tempRtspUrl = ConvertToMultiByte(this->rtspUrl);
result |= (tempRtspUrl == NULL);
if (result == STATUS_OK)
{
char* optionsResult = this->rtspClient->sendOptionsCmd(tempRtspUrl, NULL, NULL, NULL, this->receiveDataTimeout / 2000);
result |= (optionsResult == NULL);
if (result != STATUS_OK)
{
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error occured while sending OPTIONS command"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("OPTIONS result"));
this->LogFullRtspMessage(LOGGER_VERBOSE, message, optionsResult);
FREE_MEM(message);
char *describeResult = this->rtspClient->describeURL(tempRtspUrl, NULL, FALSE, this->receiveDataTimeout / 2000);
result |= (describeResult == NULL);
if (result != STATUS_OK)
{
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error occured while sending DESCRIBE command"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("DESCRIBE result"));
this->LogFullRtspMessage(LOGGER_VERBOSE, message, describeResult);
FREE_MEM(message);
this->rtspSession = MediaSession::createNew(*this->rtspEnvironment, describeResult);
result |= (this->rtspSession == NULL);
if (result != STATUS_OK)
{
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error occured while creating new session"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
result |= (!this->rtspSession->hasSubsessions());
if (result != STATUS_OK)
{
this->logger.Log(LOGGER_ERROR, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("session doesn't have subsessions"));
}
else
{
// Then, setup the "RTPSource"s for the session:
MediaSubsessionIterator iter(*this->rtspSession);
MediaSubsession *subsession = NULL;
while ((result == STATUS_OK) && ((subsession = iter.next()) != NULL))
{
char *tempSubSessionName = (char *)subsession->mediumName();
char *tempSubSessionCodecName = (char *)subsession->codecName();
#ifdef _MBCS
TCHAR *subSessionName = ConvertToMultiByteA(tempSubSessionName);
TCHAR *subSessionCodecName = ConvertToMultiByteA(tempSubSessionCodecName);
#else
TCHAR *subSessionName = ConvertToUnicodeA(tempSubSessionName);
TCHAR *subSessionCodecName = ConvertToUnicodeA(tempSubSessionCodecName);
#endif
if (!subsession->initiate())
{
result = STATUS_ERROR;
TCHAR *message = FormatString(_T("%s: %s: unable to create receiver for subsession '%s', codec '%s'"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, subSessionCodecName);
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: created receiver for subsession '%s', codec '%s'"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, subSessionCodecName);
// set session ID, doesn't matter what
subsession->sessionId = tempSubSessionName;
if (subsession->rtpSource() != NULL)
{
// because we're saving the incoming data, rather than playing
// it in real time, allow an especially large time threshold
// (1 second) for reordering misordered incoming packets:
unsigned const thresh = 1000000; // 1 second
subsession->rtpSource()->setPacketReorderingThresholdTime(thresh);
// set the RTP source's OS socket buffer size as appropriate
int socketNum = subsession->rtpSource()->RTPgs()->socketNum();
unsigned int currentBufferSize = getReceiveBufferSize(*this->rtspEnvironment, socketNum);
if (this->defaultBufferSize > currentBufferSize)
{
setReceiveBufferTo(*this->rtspEnvironment, socketNum, this->defaultBufferSize);
unsigned setBufferSize = getReceiveBufferSize(*this->rtspEnvironment, socketNum);
if (setBufferSize == this->defaultBufferSize)
{
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: set buffer size for subsession '%s' successful, previous size: %i, requested size: %i, current size: %i"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, currentBufferSize, this->defaultBufferSize, setBufferSize);
}
else
{
result = STATUS_ERROR;
this->logger.Log(LOGGER_ERROR, _T("%s: %s: set buffer size for subsession '%s' failed, previous size: %i, requested size: %i, current size: %i"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, currentBufferSize, this->defaultBufferSize, setBufferSize);
}
}
if (_tcsncicmp(subSessionName, _T("audio"), 5) == 0)
{
// audio
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: audio subsession '%s'"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName);
result |= (!rtspClient->setupMediaSubsession(*subsession));
if (result != STATUS_OK)
{
// error occured
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error while setup subsession"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
this->logger.Log(LOGGER_WARNING, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("subsession audio codec not supported"));
}
}
else if (_tcsncicmp(subSessionName, _T("video"), 5) == 0)
{
// video
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: video subsession '%s'"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName);
result |= (!rtspClient->setupMediaSubsession(*subsession));
if (result != STATUS_OK)
{
// error occured
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error while setup subsession"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
if (_tcsncicmp(subSessionCodecName, _T("MP2T"), 4) == 0)
{
// MPEG2 Transport Stream
// set new RTSP source
this->rtspSource = subsession->rtpSource();
if (subsession->rtcpInstance() != NULL)
{
this->logger.Log(LOGGER_VERBOSE, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("set subsession 'Bye' handler"));
subsession->rtcpInstance()->setByeHandler(SubsessionByeHandler, this);
}
}
else if (_tcsncicmp(subSessionCodecName, _T("H264"), 4) == 0)
{
// H264 codec, HD TV
this->logger.Log(LOGGER_ERROR, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("H264 not supported"));
result = STATUS_ERROR;
}
else
{
// SD TV
this->logger.Log(LOGGER_ERROR, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("other subsession video codec than MP2T not supported"));
result = STATUS_ERROR;
}
}
}
else
{
this->logger.Log(LOGGER_WARNING, _T("%s: %s: unknown subsession '%s', ignored"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName);
}
}
else
{
this->logger.Log(LOGGER_WARNING, _T("%s: %s: subsession '%s' doesn't have RTP source"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName);
}
}
// free subsession name and codec name
FREE_MEM(subSessionName);
FREE_MEM(subSessionCodecName);
}
// we should have some RTSP source
result |= (this->rtspSource == NULL);
if (result == STATUS_OK)
{
result |= (!this->rtspClient->playMediaSession(*this->rtspSession));
if (result != STATUS_OK)
{
// error occured
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error while playing session"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
// create UDP socket and start playing
struct in_addr destinationAddress;
destinationAddress.s_addr = our_inet_addr("127.0.0.1");
unsigned int port = this->rtspUdpPortRangeStart;
do
{
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: UDP port %u"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, port);
// special construction force not reuse same UDP port
{
NoReuse noReuse;
this->rtspUdpGroupsock = new Groupsock(*this->rtspEnvironment, destinationAddress, port, 1);
}
if (this->rtspUdpGroupsock->socketNum() == (-1))
{
this->logger.Log(LOGGER_ERROR, _T("%s: %s: UDP port %u occupied, trying another port"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, port);
port++;
delete this->rtspUdpGroupsock;
this->rtspUdpGroupsock = NULL;
}
}
while ((this->rtspUdpGroupsock == NULL) && (port <= this->rtspUdpPortRangeEnd));
result |= (this->rtspUdpGroupsock == NULL);
if (result != STATUS_OK)
{
this->logger.Log(LOGGER_ERROR, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("cannot create UDP sink, no free port"));
}
else
{
this->rtspUdpSink = BasicUDPSink::createNew(*this->rtspEnvironment, this->rtspUdpGroupsock, this->rtspUdpSinkMaxPayloadSize);
result |= (this->rtspUdpSink == NULL);
if (result != STATUS_OK)
{
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("cannot create UDP sink"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
else
{
if (this->rtspUdpSink->startPlaying(*this->rtspSource, NULL, NULL))
{
this->logger.Log(LOGGER_INFO, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("playing started"));
// now create UDP connection
TCHAR *url = FormatString(_T("udp://@127.0.0.1:%u"), port);
result |= (url == NULL);
if (result == STATUS_OK)
{
// parse UDP url
// ParseURL calls ClearSession and IsConnected must return FALSE
// in another case will be current RTSP connection closed
result = this->CMPIPTV_UDP::ParseUrl(url, NULL);
if (result == STATUS_OK)
{
// connect to UDP url
result = this->CMPIPTV_UDP::OpenConnection();
}
}
FREE_MEM(url);
}
else
{
result = STATUS_ERROR;
TCHAR *message = FormatString(METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("error occured while starting playing"));
this->LogRtspMessage(LOGGER_ERROR, message);
FREE_MEM(message);
}
}
}
}
}
}
}
}
}
if (optionsResult != NULL)
{
delete[] optionsResult;
optionsResult = NULL;
}
}
FREE_MEM(tempRtspUrl);
}
if (result == STATUS_OK)
{
// start winsock worker thread
this->rtspSchedulerThreadHandle = CreateThread(
NULL, // default security attributes
0, // use default stack size
&CMPIPTV_RTSP::RtspSchedulerWorker, // thread function name
this, // argument to thread function
0, // use default creation flags
&this->rtspSchedulerThreadId); // returns the thread identifier
if (this->rtspSchedulerThreadHandle == NULL)
{
// thread not created
result = STATUS_ERROR;
this->logger.Log(LOGGER_ERROR, _T("%s: %s: cannot create RTSP scheduler thread, error: %i"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, GetLastError());
}
}
if (result != STATUS_OK)
{
// if failed opening connection, than close connection
this->CloseConnection();
}
this->logger.Log(LOGGER_INFO, (result == STATUS_OK) ? METHOD_END_FORMAT : METHOD_END_FAIL_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME);
return (result == STATUS_OK) ? STATUS_OK : STATUS_ERROR;
}
int CMPIPTV_RTSP::OpenConnection(void)
{
this->logger.Log(LOGGER_INFO, METHOD_START_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME);
this->isRtspSessionSetup = false;
// LIVE555 works with char, not with TCHAR
char *tempRtspUrl = ConvertToMultiByte(this->rtspUrl);
if (tempRtspUrl == NULL)
{
return STATUS_ERROR;
}
// start LIVE555 worker thread
this->rtspSchedulerThreadHandle = CreateThread(
NULL, // default security attributes
0, // use default stack size
&CMPIPTV_RTSP::RtspSchedulerWorker, // thread function name
this, // argument to thread function
0, // use default creation flags
&this->rtspSchedulerThreadId); // returns the thread identifier
if (this->rtspSchedulerThreadHandle == NULL)
{
this->logger.Log(LOGGER_ERROR, _T("%s: %s: failed to create RTSP scheduler thread, error = %i"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, GetLastError());
return STATUS_ERROR;
}
this->rtspClient = MPRTSPClient::createNew(this, *this->rtspEnvironment, tempRtspUrl);
FREE_MEM(tempRtspUrl);
if (
this->rtspClient == NULL ||
SendRtspCommand(METHOD_OPEN_CONNECTION_NAME, _T("OPTIONS")) != STATUS_OK ||
SendRtspCommand(METHOD_OPEN_CONNECTION_NAME, _T("DESCRIBE")) != STATUS_OK
)
{
CloseConnection();
return STATUS_ERROR;
}
this->rtspSession = MediaSession::createNew(*this->rtspEnvironment, this->rtspResponseResultString);
if (this->rtspSession == NULL || !this->rtspSession->hasSubsessions())
{
this->LogRtspMessage(LOGGER_ERROR, METHOD_OPEN_CONNECTION_NAME, this->rtspSession == NULL ? _T("failed to create session") : _T("session doesn't have sub-sessions"));
CloseConnection();
return STATUS_ERROR;
}
// Setup the RTP source for the session. Only one sub-session expected/supported.
MediaSubsessionIterator iter(*this->rtspSession);
MediaSubsession *subsession = NULL;
FramedSource *rtspSource = NULL;
while ((subsession = iter.next()) != NULL)
{
#ifdef _MBCS
TCHAR *subSessionName = ConvertToMultiByteA(subsession->mediumName());
TCHAR *subSessionCodecName = ConvertToMultiByteA(subsession->codecName());
#else
TCHAR *subSessionName = ConvertToUnicodeA(subsession->mediumName());
TCHAR *subSessionCodecName = ConvertToUnicodeA(subsession->codecName());
#endif
if (_tcsncicmp(subSessionName, _T("video"), 5) != 0 || _tcsncicmp(subSessionCodecName, _T("MP2T"), 4) != 0)
{
TCHAR *message = FormatString(_T("sub-session medium or codec not supported, medium = %s, codec = %s"), subSessionName, subSessionCodecName);
this->LogRtspMessage(LOGGER_ERROR, METHOD_OPEN_CONNECTION_NAME, message);
FREE_MEM(message);
FREE_MEM(subSessionName);
FREE_MEM(subSessionCodecName);
continue;
}
// If a client port is configured, find a free pair of ports in the range.
// The first port is used for RTP; the second port is used for RTCP. Once
// we find one free port, we assume the next one is also free.
if (this->rtspRtpClientPortRangeStart > 0)
{
struct in_addr destinationAddress;
destinationAddress.s_addr = our_inet_addr("127.0.0.1");
unsigned int port = this->rtspRtpClientPortRangeStart;
Groupsock *groupsock = NULL;
do
{
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: RTP client port %u"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, port);
// special construction force not reuse same UDP port
{
NoReuse noReuse(*this->rtspEnvironment);
groupsock = new Groupsock(*this->rtspEnvironment, destinationAddress, port, 1);
}
if (groupsock == NULL || groupsock->socketNum() == -1)
{
this->logger.Log(LOGGER_WARNING, _T("%s: %s: RTP client port %u occupied, trying next even port"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, port);
port += 2;
if (groupsock != NULL)
{
delete groupsock;
groupsock = NULL;
}
}
}
while ((groupsock == NULL) && (port <= this->rtspRtpClientPortRangeEnd));
// Did we find a free port? If not, we fall back to a random port chosen
// by LIVE555.
if (groupsock != NULL)
{
delete groupsock;
groupsock = NULL;
subsession->setClientPortNum(port);
}
}
if (!subsession->initiate() || subsession->rtpSource() == NULL)
{
TCHAR *message = FormatString(_T("failed to create receiver for sub-session, medium = %s, codec = %s"), subSessionName, subSessionCodecName);
this->LogRtspMessage(LOGGER_ERROR, METHOD_OPEN_CONNECTION_NAME, message);
FREE_MEM(message);
FREE_MEM(subSessionName);
FREE_MEM(subSessionCodecName);
continue;
}
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: created receiver for sub-session, medium = %s, codec = %s"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, subSessionCodecName);
FREE_MEM(subSessionName);
FREE_MEM(subSessionCodecName);
// set session ID, doesn't matter what
subsession->setSessionId(subsession->mediumName());
// because we're saving the incoming data, rather than playing
// it in real time, allow an especially large time threshold
// for reordering misordered incoming packets:
subsession->rtpSource()->setPacketReorderingThresholdTime(1000000); // 1 second
// set the RTP source's OS socket buffer size as appropriate
int socketNum = subsession->rtpSource()->RTPgs()->socketNum();
unsigned int currentBufferSize = getReceiveBufferSize(*this->rtspEnvironment, socketNum);
if (this->defaultBufferSize > currentBufferSize)
{
setReceiveBufferTo(*this->rtspEnvironment, socketNum, this->defaultBufferSize);
unsigned setBufferSize = getReceiveBufferSize(*this->rtspEnvironment, socketNum);
if (setBufferSize == this->defaultBufferSize)
{
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: set buffer size for sub-session, previous size = %i, requested size = %i, current size = %i"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, currentBufferSize, this->defaultBufferSize, setBufferSize);
}
else
{
this->logger.Log(LOGGER_WARNING, _T("%s: %s: failed to set buffer size for sub-session, previous size = %i, requested size = %i, current size = %i"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, subSessionName, currentBufferSize, this->defaultBufferSize, setBufferSize);
}
}
if (SendRtspCommand(METHOD_OPEN_CONNECTION_NAME, _T("SETUP"), subsession) != STATUS_OK)
{
CloseConnection();
return STATUS_ERROR;
}
rtspSource = subsession->rtpSource();
break;
}
// If we don't have an RTSP source then we can't continue.
if (rtspSource == NULL)
{
CloseConnection();
return STATUS_ERROR;
}
this->isRtspSessionSetup = true;
if (SendRtspCommand(METHOD_OPEN_CONNECTION_NAME, _T("PLAY")) != STATUS_OK)
{
CloseConnection();
return STATUS_ERROR;
}
// create UDP socket and start playing
struct in_addr destinationAddress;
destinationAddress.s_addr = our_inet_addr("127.0.0.1");
unsigned int port = this->rtspUdpPortRangeStart;
do
{
this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: UDP port %u"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, port);
// special construction force not reuse same UDP port
{
NoReuse noReuse(*this->rtspEnvironment);
this->rtspUdpGroupsock = new Groupsock(*this->rtspEnvironment, destinationAddress, port, 1);
}
if (this->rtspUdpGroupsock == NULL || this->rtspUdpGroupsock->socketNum() == -1)
{
this->logger.Log(LOGGER_WARNING, _T("%s: %s: UDP port %u occupied, trying another port"), PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, port);
port++;
if (this->rtspUdpGroupsock != NULL)
{
delete this->rtspUdpGroupsock;
this->rtspUdpGroupsock = NULL;
}
}
}
while ((this->rtspUdpGroupsock == NULL) && (port <= this->rtspUdpPortRangeEnd));
if (this->rtspUdpGroupsock == NULL)
{
this->logger.Log(LOGGER_ERROR, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("failed to create UDP socket, no free port"));
CloseConnection();
return STATUS_ERROR;
}
this->rtspUdpSink = BasicUDPSink::createNew(*this->rtspEnvironment, this->rtspUdpGroupsock, this->rtspUdpSinkMaxPayloadSize);
if (this->rtspUdpSink == NULL)
{
this->logger.Log(LOGGER_ERROR, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("failed to create UDP sink"));
CloseConnection();
return STATUS_ERROR;
}
if (!this->rtspUdpSink->startPlaying(*rtspSource, NULL, NULL))
{
this->LogRtspMessage(LOGGER_ERROR, METHOD_OPEN_CONNECTION_NAME, _T("failed to start UDP sink"));
CloseConnection();
return STATUS_ERROR;
}
this->logger.Log(LOGGER_INFO, METHOD_MESSAGE_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME, _T("streaming started"));
// create a UDP connection to the local stream
TCHAR *url = FormatString(_T("udp://@127.0.0.1:%u"), port);
if (
url == NULL ||
this->CMPIPTV_UDP::ParseUrl(url, NULL) != STATUS_OK ||
this->CMPIPTV_UDP::OpenConnection() != STATUS_OK
)
{
FREE_MEM(url);
this->logger.Log(LOGGER_INFO, METHOD_END_FAIL_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME);
CloseConnection();
return STATUS_ERROR;
}
FREE_MEM(url);
this->logger.Log(LOGGER_INFO, METHOD_END_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_OPEN_CONNECTION_NAME);
return STATUS_OK;
}
LPSTR CExceptionHandler::GetVersionInformation()
{
LPSTR szResult = NULL;
LPVOID lpData = NULL;
// (( scope ))
{
stringstream szDetails;
// Load the version information.
wstring szFilename(GetModuleFileNameEx());
DWORD dwHandle = 0;
DWORD dwSize = GetFileVersionInfoSize(szFilename.c_str(), &dwHandle);
if (dwSize == 0)
{
goto __end;
}
lpData = malloc(dwSize);
if (!GetFileVersionInfo(szFilename.c_str(), dwHandle, dwSize, lpData))
{
goto __end;
}
// Get the product name.
UINT uLen;
LPCWSTR szData;
if (!VerQueryValue(lpData, L"\\StringFileInfo\\040904b0\\ProductName", (LPVOID*)&szData, &uLen))
{
goto __end;
}
szDetails << "ProductName=" << ConvertToMultiByte(szData) << "\n";
// Get the vendor.
if (!VerQueryValue(lpData, L"\\StringFileInfo\\040904b0\\CompanyName", (LPVOID*)&szData, &uLen))
{
goto __end;
}
szDetails << "Vendor=" << ConvertToMultiByte(szData) << "\n";
// Get the application version.
VS_FIXEDFILEINFO * lpffi;
if (!VerQueryValue(lpData, L"\\", (LPVOID *)&lpffi, &uLen))
{
goto __end;
}
ASSERT(lpffi != NULL);
wstring szVersion(Format(
L"%d.%d.%d.%d",
(INT)HIWORD(lpffi->dwProductVersionMS),
(INT)LOWORD(lpffi->dwProductVersionMS),
(INT)HIWORD(lpffi->dwProductVersionLS),
(INT)LOWORD(lpffi->dwProductVersionLS)));
szDetails << "Version=" << ConvertToMultiByte(szVersion) << "\n";
// Build the server URL.
szDetails << "ServerURL=" << ConvertToMultiByte(CRASH_SERVER_URL) << "\n";
wstring szCookie;
if (CSettings(FALSE).GetStatisticsCookie(szCookie))
{
szDetails << "Cookie=" << ConvertToMultiByte(szCookie) << "\n";
}
szResult = _strdup(szDetails.str().c_str());
}
__end:
if (lpData != NULL)
{
free(lpData);
}
return szResult;
}
