From de4280ea209d567eedfa08084da0dea761ad5917 Mon Sep 17 00:00:00 2001 From: rdb Date: Sat, 27 Mar 2010 09:56:49 +0000 Subject: [PATCH] Remove helix --- panda/metalibs/panda/Sources.pp | 2 +- panda/src/helix/HelixClient.cxx | 798 -------------------- panda/src/helix/HelixClient.h | 120 --- panda/src/helix/HelixDefs.h | 421 ----------- panda/src/helix/HxAdviseSink.cxx | 650 ---------------- panda/src/helix/HxAdviseSink.h | 94 --- panda/src/helix/HxAuthenticationManager.cxx | 207 ----- panda/src/helix/HxAuthenticationManager.h | 5 - panda/src/helix/HxClientContext.cxx | 324 -------- panda/src/helix/HxClientContext.h | 85 --- panda/src/helix/HxErrorSink.cxx | 226 ------ panda/src/helix/HxErrorSink.h | 74 -- panda/src/helix/HxSiteSupplier.cxx | 302 -------- panda/src/helix/HxSiteSupplier.h | 64 -- panda/src/helix/MainHelix.h | 74 -- panda/src/helix/Sources.pp | 28 - panda/src/helix/config_helix.cxx | 5 - panda/src/helix/config_helix.h | 5 - panda/src/helix/fivemmap.cxx | 175 ----- panda/src/helix/fivemmap.h | 83 -- panda/src/helix/iids.cxx | 52 -- panda/src/helix/main.cpp | 46 -- panda/src/helix/print.cxx | 80 -- panda/src/helix/print.h | 62 -- 24 files changed, 1 insertion(+), 3981 deletions(-) delete mode 100644 panda/src/helix/HelixClient.cxx delete mode 100644 panda/src/helix/HelixClient.h delete mode 100644 panda/src/helix/HelixDefs.h delete mode 100644 panda/src/helix/HxAdviseSink.cxx delete mode 100644 panda/src/helix/HxAdviseSink.h delete mode 100644 panda/src/helix/HxAuthenticationManager.cxx delete mode 100644 panda/src/helix/HxAuthenticationManager.h delete mode 100644 panda/src/helix/HxClientContext.cxx delete mode 100644 panda/src/helix/HxClientContext.h delete mode 100644 panda/src/helix/HxErrorSink.cxx delete mode 100644 panda/src/helix/HxErrorSink.h delete mode 100644 panda/src/helix/HxSiteSupplier.cxx delete mode 100644 panda/src/helix/HxSiteSupplier.h delete mode 100644 panda/src/helix/MainHelix.h delete mode 100644 panda/src/helix/Sources.pp delete mode 100644 panda/src/helix/config_helix.cxx delete mode 100644 panda/src/helix/config_helix.h delete mode 100644 panda/src/helix/fivemmap.cxx delete mode 100644 panda/src/helix/fivemmap.h delete mode 100644 panda/src/helix/iids.cxx delete mode 100644 panda/src/helix/main.cpp delete mode 100644 panda/src/helix/print.cxx delete mode 100644 panda/src/helix/print.h diff --git a/panda/metalibs/panda/Sources.pp b/panda/metalibs/panda/Sources.pp index 02f9b4415e..ead9b04804 100644 --- a/panda/metalibs/panda/Sources.pp +++ b/panda/metalibs/panda/Sources.pp @@ -17,7 +17,7 @@ parametrics \ pnmimagetypes pnmimage \ pnmtext text tform lerp putil \ - audio pgui pandabase helix + audio pgui pandabase #define LOCAL_LIBS \ downloader express pandabase diff --git a/panda/src/helix/HelixClient.cxx b/panda/src/helix/HelixClient.cxx deleted file mode 100644 index 6dcb1f2a59..0000000000 --- a/panda/src/helix/HelixClient.cxx +++ /dev/null @@ -1,798 +0,0 @@ -// Filename: HelixClient.cxx -// Created by: jjtaylor (10Feb04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "helixclient.h" - -// Initialize Static Data Members. -TypeHandle HelixClient::_type_handle; - -// Static Members used for the DoEvents Method. These might -// be removed in the future since Panda calls the Win32 API -// Message calls internally. -const int HelixClient::_time_delta = 2000; -const int HelixClient::_sleep_time = 10; -const int HelixClient::_guid_length = 64; - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::HelixClient() -// Access: PUBLISHED -// Purpose: This is the default constructor for creating the -// the wrapper object that encapsulates the Helix Engine. -// The constructor calls the init() which loads the main -// Helix DLL, clntcore.dll. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HelixClient::HelixClient() - : _engine(0), - _dll_access(0) { - const char * envName = "PLAYER"; - char* envPath = getenv( envName ); - _dll_home = string(string(envPath) + "\\ExtLib\\HelixLib\\."); - init(); -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::~HelixClient() -// Access: PUBLISHED -// Purpose: This is the destructor for the HelixClient proxy class. -// The destructor simply invokes the shutdown(), which -// closes any open players on the engine, successfully -// frees the DLLAccess and engine objects. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HelixClient::~HelixClient() { - shutdown(); -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::do_event() -// Access: PUBLISHED -// Purpose: This method is was used primarily in the Win32 -// test application to give the Helix Engine the necessary -// time slices to keep it running properly. In addition, -// it has been modified to manually set each texture in -// the _textures map to dirty. This means that the image -// will be loaded once again into memory, essentially -// updating the texture each frame with the new video -// image applied to it. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::do_event() { - // Legacy Win32 API code from the test application. This can - // probably be removed since Panda already calls these methods - // for retreiving and dispatching Win32 messages. - MSG msg; - GetMessage(&msg, NULL, 0, 0); - DispatchMessage(&msg); - - // Simply iterate through the _textures map and set the texture - // dirty so that it will be updated in memory. - TEXTURES::iterator iter; - for(iter = _textures.begin(); iter != _textures.end(); iter++) { - iter->second->mark_dirty(Texture::DF_image); - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::do_events() -// Access: PUBLISHED -// Purpose: This method was used primarily in the Win32 -// test application to give the Helix Engine the necessary -// time slices to keep it running properly. It is still -// used in the HelixClient::begin() to get the engine -// started for playback, but it most likely can be safely -// removed in the future. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::do_events() { - MSG msg; - DWORD start_time, end_time, i; - BOOL sleep = TRUE; - static const int check_interval = 10; - start_time = GetTickCount(); - end_time = start_time + _time_delta; - i = 0; - while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { - DispatchMessage(&msg); - if((i % check_interval) == 0) { - if(GetTickCount() > end_time) { - break; - } - ++i; - } - sleep = FALSE; - } - if(sleep) { - Sleep(_sleep_time); - } -} - - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::create_player(...) -// Access: PUBLISHED -// Purpose: This wrapper method encapsulates the creation of a -// player object for the Helix Engine. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Desired name of the Player -// Texture* tex - Panda Texture that is to be udpated with -// the video that this player will run. -// bool sink_on - Determines with the HxAdviseSink Object -// should print out the presentation stats -// in the command prompt. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::create_player(const string &name, Texture* tex, bool sink_on) { - // Check to make certain that the engine interface has been - // instantiated, otherwise, players cannot be created! - if (_engine != 0) { - - // For now, check if there is an actual Panda texture present. If not, - // then this player should not be created. - - // NOTE: This portion of the interface must be redesigned as the current - // design forces the user to specify a valid texture. A more suitable - // approach would be to automatically generate a panda texture and allow - // the user to retreive that texture and set it for any piece of geometry - // within the world. - if( tex == 0 ) { - STDOUT("ERROR: HelixClient::CreatePlayer, INVALID Texture Object!\n"); - STDOUT("ERROR: NO PLAYER CREATED!!\n"); - return; - } - - // Initialize necessary Helix pointers. - IHXPlayer* tmp_player = 0; - HxClientContext* context = 0; - IHXErrorSinkControl* controller = 0; - IHXErrorSink* error_sink = 0; - - // Tell the texture object to keep the actual image buffer in memory. If - // the image buffer is deallocated, which is the default in panda, Helix - // and Panda because the engine will try to Blit to an invalid buffer. - tex->set_keep_ram_image(true); - - // Try and create a valid helix player on the engine - if (HXR_OK != _engine->CreatePlayer(tmp_player)) { - STDOUT("ERROR: HelixClient::CreatePlayer, Failed Player Creation!\n"); - } - else { - // Since a player has been successfully instantiated, a context - // for that player must be created. - context = new HxClientContext(_players.size()); - if(context != 0) { - context->AddRef(); - - // Specify a default GUID. Not really necessary, but here for - // convenience if needed later on. - char guid[_guid_length + 1]; - IHXPreferences * pref = 0; - guid[0] = '\0'; - - // Query the Preferences Interface for the player. - tmp_player->QueryInterface(IID_IHXPreferences, (void**)&pref); - - // Send the Texture buffer down into the Context. It will then - // ship the buffer to the site supplier, where the actual site - // and surface are generated. - context->init(tmp_player, pref, guid, sink_on, tex); - tmp_player->SetClientContext(context); - HX_RELEASE(pref); - - // Query the Error Sink Controller - tmp_player->QueryInterface(IID_IHXErrorSinkControl, (void**)&controller); - if(controller != 0) { - context->QueryInterface(IID_IHXErrorSink, (void**)&error_sink); - if(error_sink != 0) { - controller->AddErrorSink(error_sink, HXLOG_EMERG, HXLOG_INFO); - } - HX_RELEASE(error_sink); - error_sink = 0; - } - HX_RELEASE(controller); - controller = 0; - context = 0; - } - - // Create a new map object for the player and its respective texture. - pair player(name, tmp_player); - pair texture(name, tex); - - // Now that the pair has been created, set the tmp_player - // address to 0 to protect against dangling references. - tmp_player = 0; - - // Now, actually insert the pairs into their respective maps. - _players.insert(player); - _textures.insert(texture); - } - } - else { - STDOUT("ERROR: In HelixClient::CreatePlayer, pEngine = NULL"); - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::close_player(...) -// Access: PUBLISHED -// Purpose: This wrapper method encapsulates the closing of a -// player object for the Helix Engine. This method -// determines if a player with the designated name exists -// by searching the _players map. If it does, it properly -// closes the player, deletes it from memory, and removes -// the pair instance from the map as well as its texture -// counter part. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Desired name of the Player to close. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::close_player(const string &name) { - if (_engine != 0) { - IUnknown* context = 0; - // Determine if the player is in the map. If so, go about - // removing that player from the engine. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - iter->second->Stop(); - iter->second->GetClientContext(context); - context->Release(); - context = 0; - _engine->ClosePlayer(iter->second); - iter->second->Release(); - iter->second = 0; - // Remove the player its associated texture from their - // respective maps. - _players.erase(name); - _textures.erase(name); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::close_all_players() -// Access: PUBLISHED -// Purpose: This wrapper method encapsulates the closing of every -// player object for the Helix Engine. This method simply -// iterates through the _players map, and invokes the -// the close_player routine to actually close the player. -//////////////////////////////////////////////////////////////////// -// Params: none -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::close_all_players() { - if (_engine != 0) { - if (!_players.empty()) { - IUnknown* context = 0; - PLAYERS::iterator iter; - - // Iterate through the _players map to close each player - // currently associated with the engine. - unsigned int total_players = _players.size(); - for (unsigned int cntr = 0; cntr <= total_players; cntr++) { - close_player(_players.begin()->first); - } - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::get_player_count() -// Access: PUBLISHED -// Purpose: This wrapper method simply returns the current number -// of players that are associated with the Helix Engine. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: Int - the number of players currently associated with -// the Helix Engine. -//////////////////////////////////////////////////////////////////// -int HelixClient::get_player_count() { - if (_engine != 0) { - return _engine->GetPlayerCount(); - } - else { - return 0; - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::init() -// Access: Private -// Purpose: This member function provides all of the dirty work -// for instantiating a Helix Engine object. First it -// searches for the main Helix DLL, clntcore.dll, and then -// it instantiates the actual engine itself. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: bool - True if the engine is successfully initialized. -//////////////////////////////////////////////////////////////////// -bool HelixClient::init() { - // Local Variable Defination and Initialization - FPRMCREATEENGINE create_engine = 0; - FPRMSETDLLACCESSPATH set_dll_access_path = 0; - // Instantiate a DLLAccess object which will be used to properly - // load the clntcore.dll at runtime. - _dll_access = new DLLAccess(); - - // Attempt to load the clntcore.dll. If this fails, an error message will - // be generated and printed to the console. - STDOUT("HelixClient is looking for the client core at %s\n", _dll_home.c_str()); - if(DLLAccess::DLL_OK != _dll_access->open(string(_dll_home+"\\clntcore.dll").c_str())) { - const char * error_string = 0; - error_string = _dll_access->getErrorString(); - STDERR("HelixClient: %s\n\n", error_string); - - // Print out an explanation of what is wrong. - STDERR("You must tell the player where to find the client core and\n"); - STDERR("all of its supporting DLLs and codecs.\n"); - - // Deallocate the memory from the heap to avoid a memory leak. - delete _dll_access; - _dll_access = 0; - return false; - } - - // Now that the client core has been loaded, retrieve the function pointer - // to the engine and the DLL access path. - create_engine = (FPRMCREATEENGINE) _dll_access->getSymbol("CreateEngine"); - set_dll_access_path = (FPRMSETDLLACCESSPATH) _dll_access->getSymbol("SetDLLAccessPath"); - - // If either function pointer was not retreived, print an error message to - // the console, deallocate the DLLAccess object from memory, and abort the - // initialization of the engine. - if((create_engine == 0) || (set_dll_access_path == 0)) { - STDOUT("---{ERROR: HelixClient::Init, set_dll_access_path}---"); - - delete _dll_access; - _dll_access = 0; - return false; - } - - // Now that the clntcore.dll has been succesfully loaded. Specify where it - // can find all of the accompanying DLLs that are necessary for Helix to - // function. - char paths[256]; - char* path_next_position = paths; - memset(paths, 0, 256); - UINT32 bytes_left = 256; - - char next_path[256]; - memset(next_path, 0, 256); - - // Apply the Common DLL Path to the paths string. For simplicity, - // this is the same path as the clntcore.dll path. - SafeSprintf(next_path, 256, "DT_Common=%s", _dll_home.c_str()); - STDERR("Common DLL path %s\n", next_path ); - UINT32 bytes_to_copy = strlen(next_path) + 1; - if (bytes_to_copy <= bytes_left) - { - memcpy(path_next_position, next_path, bytes_to_copy); - path_next_position += bytes_to_copy; - bytes_left -= bytes_to_copy; - } - - // Apply the Plug-in DLL Path to the paths string. For simplicity, - // this is the same path as the clntcore.dll path. - SafeSprintf(next_path, 256, "DT_Plugins=%s", _dll_home.c_str()); - STDERR("Plugin path %s\n", next_path ); - bytes_to_copy = strlen(next_path) + 1; - - if (bytes_to_copy <= bytes_left) - { - memcpy(path_next_position, next_path, bytes_to_copy); - path_next_position += bytes_to_copy; - bytes_left -= bytes_to_copy; - } - - // Apply the Codecs DLL Path to the paths string. For simplicity, - // this is the same path as the clntcore.dll path. - SafeSprintf(next_path, 256, "DT_Codecs=%s", _dll_home.c_str()); - bytes_to_copy = strlen(next_path) + 1; - if (bytes_to_copy <= bytes_left) - { - memcpy(path_next_position, next_path, bytes_to_copy); - path_next_position += bytes_to_copy; - bytes_left -= bytes_to_copy; - *path_next_position='\0'; - } - STDOUT((char*)paths); - set_dll_access_path((char*)paths); - - // The dll_access_path has been set, so the engine can now be initialized. If - // this fails, then deallocate the DLLAccess object from memory and abort the - // initialization of the engine. - if (HXR_OK != create_engine((IHXClientEngine**) &_engine)) { - STDOUT("---{ERROR: HelixClient::Init, Creating Engine Problem}---"); - - delete _dll_access; - _dll_access = 0; - return false; - } - return false; -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::shutdown() -// Access: PUBLISHED -// Purpose: This member function closes all open players before it -// proceeds to close the engine itself. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::shutdown() { - if (_engine != 0) { - // Close All Open Players that are associated with the - // given Helix Engine. - close_all_players(); - - - // Retrieve the Function Pointer for closing the Helix engine. - FPRMCLOSEENGINE close_engine = (FPRMCLOSEENGINE) _dll_access->getSymbol("CloseEngine"); - - // If the function pointer was successfully retrieved, close - // the helix engine. - if (close_engine != 0) { - STDOUT("Closing Helix Engine...\n"); - close_engine(_engine); - _engine = 0; - } - - // Close the link with the clntCore.dll and freeing the DLLAccess - // object from memory to prevent a memory leak on the heap. - STDOUT("Closing the link to clntCore.dll...\n"); - _dll_access->close(); - delete _dll_access; - _dll_access = 0; - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::begin(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// Begin method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::Begin method. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to begin playback. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::begin(const string &name) { - if (_engine != 0) { - - // Search for the specified player in the map. If the player - // is found, begin playback of the media file. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - iter->second->Begin(); - } - - // This is legacy code from the test application, however, it - // was necessary for helix to function since do_events was called - // to give helix the necessary time-slice of the CPU. I think this - // most likely can be removed since Panda calls the necessary - // Win32 API Message calls. - //UINT curr_time = 0; - //UINT32 start_time = GetTickCount(); - //UINT32 end_time = start_time + _time_delta; - //while(1) { - // do_events(); - //curr_time = GetTickCount(); - //if(curr_time >= end_time) - // break; - //} - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::begin_all() -// Access: PUBLISHED -// Purpose: This wrapper function simply calls the IHXPlayer::Begin -// routine for each player currently associated with the -// the engine. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::begin_all() { - if (_engine != 0) { - - // Iterate through the _players map and call the Begin - // routine to start playback of the media. - PLAYERS::iterator iter; - for(iter = _players.begin(); iter != _players.end(); iter++) { - iter->second->Begin(); - } - - // This is legacy code from the test application, however, it - // was necessary for helix to function since do_events was called - // to give helix the necessary time-slice of the CPU. I think this - // most likely can be removed since Panda calls the necessary - // Win32 API Message calls. - // UINT curr_time = 0; - // UINT32 start_time = GetTickCount(); - // UINT32 end_time = start_time + _time_delta; - // while(1) { - // do_events(); - // curr_time = GetTickCount(); - // if (curr_time >= end_time) - // break; - // } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::pause(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// Pause method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::Pause method. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to pause playback. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::pause(const string &name) { - // Search for the specified player in the map. If the player - // is found, pause the playback of the media file. - if (_engine != 0) { - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - iter->second->Pause(); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::pause_all() -// Access: PUBLISHED -// Purpose: This wrapper function simply calls the IHXPlayer::Pause -// routine for each player currently associated with the -// the engine. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::pause_all() { - if (_engine != 0) { - // Iterate through the _players map and call the Pause - // routine to start playback of the media. - PLAYERS::iterator iter; - for(iter = _players.begin(); iter != _players.end(); iter++) { - iter->second->Pause(); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::seek(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// Pause method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::Pause method. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to seek to a -// current time in the playback. -// long &time - the time to seek to in the playback. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::seek_time(const string &name, long time) { - if (_engine != 0) { - // Search for the specified player in the map. If the player - // is found, seek to the current time in the playback of the - // media file. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - iter->second->Seek(time); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::stop(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// Stop method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::Stop method which -// stops the playback of the media. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to stop playback. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::stop(const string &name) { - if (_engine != 0) { - // Search for the specified player in the map. If the player - // is found, stop the playback of the media file. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - iter->second->Stop(); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::stop_all() -// Access: PUBLISHED -// Purpose: This wrapper function simply calls the IHXPlayer::Stop -// routine for each player currently associated with the -// the engine. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::stop_all() { - if (_engine != 0) { - // Iterate through the _players map and call the Pause - // routine to stop playback of the media. - PLAYERS::iterator iter; - for(iter = _players.begin(); iter != _players.end(); iter++) { - iter->second->Stop(); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::open_url(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// OpenURL method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::OpenURL method which -// actually opens the specified media format. URLs can -// come in two forms: -// -// Remote File: rtsp://www.realone.com/somevideo.ram -// Local File: file://f:\\smildemohurl.ram -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to open the URL. -// string url - Name of the URL to be opened for playback. -// Return: None -//////////////////////////////////////////////////////////////////// -void HelixClient::open_url(const string &name, string url) { - if (_engine != 0) { - // Determine if a URL has been specified within the string. - // If it hasn't, assume that the request has been made for - // a local file, so insert, file://, at the beginning of the - // string. - if (url.find("://")==string::npos) { - url.insert(0,"file://"); - } - - // Check wheter the player specified exists - // within the map. If it does, call the IHXPlayer::OpenURL(...) - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - iter->second->OpenURL(url.c_str()); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::is_live(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// IsLive method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::IsLive method. This -// indicates whether the player contains a live source -// or not. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to check. -// Return: None -//////////////////////////////////////////////////////////////////// -bool HelixClient::is_live(const string &name) { - if (_engine != 0) { - // Search for the specified player in the map. If the player - // is found, check to see if it contains a live media source. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - return (iter->second->IsLive()) ? true : false; - } - } - return false; -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::is_done(...) -// Access: PUBLISHED -// Purpose: This wrapper function encapsulates the Helix Player -// IsDone method. It first searches for the name of the -// specified player within the _players map. If that -// is found, it calls the IHXPlayer::IsDone method. This -// indicates whether the player is finished playing the -// the current presentation. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to check. -// Return: bool - true if the player has finished playback, -// otherwise it is false. -//////////////////////////////////////////////////////////////////// -bool HelixClient::is_done(const string &name) { - if (_engine != 0) { - // Search for the specified player in the map. If the player - // is found, check to see if it has finished playing the - // the current presentation. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - return iter->second->IsDone(); - } - } - return true; -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::are_players_done() -// Access: PUBLISHED -// Purpose: This wrapper function simply calls the IHXPlayer::IsDone -// routine for each player currently associated with the -// the engine. If all of the players have finished with -// their respective presentations, it returns true. -// Otherwise it would return false. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: bool - true if all players finished playback, otherwise -// it is false. -//////////////////////////////////////////////////////////////////// -bool HelixClient::are_players_done() { - if (_engine != 0) { - bool done = true; - PLAYERS::iterator iter; - for(iter = _players.begin(); iter != _players.end(); iter++) { - if(!iter->second->IsDone()) { - done = false; - } - } - return done; - } - return true; -} - -//////////////////////////////////////////////////////////////////// -// Method: HelixClient::get_source_count() -// Access: PUBLISHED -// Purpose: This wrapper function simply calls the -// IHXPlayer::GetSourceCount routine. This returns the -// number of stream source instances currently used by -// the player. In case of audio, it would be 1. In case -// of a movie file, it would be 2. -//////////////////////////////////////////////////////////////////// -// Params: const string &name - Name of the Player to check. -// Return: Int - value of source count or -1 if there is no player -// or engine. -//////////////////////////////////////////////////////////////////// -int HelixClient::get_source_count(const string &name) { - if (_engine != 0) { - // Search for the specified player in the map. If the player - // is found, check to see if it has finished playing the - // the current presentation. - PLAYERS::iterator iter = _players.find(name); - if (iter != _players.end()) { - return iter->second->GetSourceCount(); - } - } - return -1; -} diff --git a/panda/src/helix/HelixClient.h b/panda/src/helix/HelixClient.h deleted file mode 100644 index 5cb6f9b076..0000000000 --- a/panda/src/helix/HelixClient.h +++ /dev/null @@ -1,120 +0,0 @@ -// Filename: HelixClient.h -// Created by: jjtaylor (10Feb04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// -#ifndef HELIXCLIENT_H -#define HELIXCLIENT_H - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "pandabase.h" - -#include "typedObject.h" -#include "texture.h" -#include "pmap.h" - -//////////////////////////////////////////////////////////////////// -// Helix Main Header Files -//////////////////////////////////////////////////////////////////// -#include - -//////////////////////////////////////////////////////////////////// -// Normal Header Files -//////////////////////////////////////////////////////////////////// -#include -#include - -//////////////////////////////////////////////////////////////////// -// Class: HelixClient -// Purpose: This proxy class provides the top-level interface for -// loading the Helix Client Engine, creating players on -// the Helix engine, and initializing the media playback. -//////////////////////////////////////////////////////////////////// -class EXPCL_PANDA_HELIX HelixClient { -public: - static TypeHandle get_class_type() { - return _type_handle; - } - static void init_type() { - register_type(_type_handle, "HelixClient"); - } -private: - static TypeHandle _type_handle; -PUBLISHED: - HelixClient(); - ~HelixClient(); - -//////////////////////////////////////////////////////////////////// -// IHXClientEngine Interface Methods -// Purpose: These are wrapper methods that invoke the actual Helix -// Engine Interface method calls. For instance, the method -// create_player invotes the Helix Engine method -// engine->CreatePlayer(). -//////////////////////////////////////////////////////////////////// - void create_player(const string &name, Texture* tex = 0, bool sink_on = false); - void close_player(const string &name); - void close_all_players(); - int get_player_count(); - -//////////////////////////////////////////////////////////////////// -// IHXPlayer Interface Methods Prototypes -// Purpose: These are wrapper methods that invoke the actual Helix -// Player Interface method calls. For instance, the method -// begin invotes the Helix Engine method player->Begin(). -//////////////////////////////////////////////////////////////////// - void begin(const string &name); - void pause(const string &name); - void seek_time(const string &name, long time); - void stop(const string &name); - - void begin_all(); - void pause_all(); - void stop_all(); - - void open_url(const string &name, string url); - int get_source_count(const string &name); - bool is_done(const string &name); - bool is_live(const string &name); - bool are_players_done(); - -//////////////////////////////////////////////////////////////////// -// Utility Method Prototypes -// Purpose: These methods provide basic utility functions which are -// necessary for the Helix engine to play and close. -//////////////////////////////////////////////////////////////////// - void do_event(); - void do_events(); - void shutdown(); -private: - // Private Member Functions - bool init(); - - // Private Member variables - DLLAccess* _dll_access; - - string _dll_home; - static const int _time_delta; - static const int _sleep_time; - static const int _guid_length; - - // Where the Engine will actually reside. - IHXClientEngine* _engine; - - typedef pmap PLAYERS; - typedef pmap TEXTURES; - - PLAYERS _players; - TEXTURES _textures; -}; -#endif diff --git a/panda/src/helix/HelixDefs.h b/panda/src/helix/HelixDefs.h deleted file mode 100644 index 277df8f58d..0000000000 --- a/panda/src/helix/HelixDefs.h +++ /dev/null @@ -1,421 +0,0 @@ -#ifndef HELIX_CONFIG_MS_PSDK -#define HELIX_CONFIG_MS_PSDK 1 -#endif -#ifndef HELIX_FEATURE_3GPP -#define HELIX_FEATURE_3GPP 1 -#endif -#ifndef HELIX_FEATURE_ADVANCEDGROUPMGR -#define HELIX_FEATURE_ADVANCEDGROUPMGR 1 -#endif -#ifndef HELIX_FEATURE_ALT_URL -#define HELIX_FEATURE_ALT_URL 1 -#endif -#ifndef HELIX_FEATURE_ASM -#define HELIX_FEATURE_ASM 1 -#endif -#ifndef HELIX_FEATURE_AUDIO -#define HELIX_FEATURE_AUDIO 1 -#endif -#ifndef HELIX_FEATURE_AUDIOHOOK -#define HELIX_FEATURE_AUDIOHOOK 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_28_8 -#define HELIX_FEATURE_AUDIO_CODEC_28_8 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_AMRNB -#define HELIX_FEATURE_AUDIO_CODEC_AMRNB 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_AMRWB -#define HELIX_FEATURE_AUDIO_CODEC_AMRWB 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_GECKO -#define HELIX_FEATURE_AUDIO_CODEC_GECKO 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_INTERLEAVE_ALL -#define HELIX_FEATURE_AUDIO_CODEC_INTERLEAVE_ALL 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_O5_6 -#define HELIX_FEATURE_AUDIO_CODEC_O5_6 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_RAAC -#define HELIX_FEATURE_AUDIO_CODEC_RAAC 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_SIPRO -#define HELIX_FEATURE_AUDIO_CODEC_SIPRO 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_CODEC_TOKYO -#define HELIX_FEATURE_AUDIO_CODEC_TOKYO 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_INACCURATESAMPLING -#define HELIX_FEATURE_AUDIO_INACCURATESAMPLING 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_INCOMPLETESAMPLE -#define HELIX_FEATURE_AUDIO_INCOMPLETESAMPLE 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_MPA_LAYER1 -#define HELIX_FEATURE_AUDIO_MPA_LAYER1 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_MPA_LAYER2 -#define HELIX_FEATURE_AUDIO_MPA_LAYER2 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_MPA_LAYER3 -#define HELIX_FEATURE_AUDIO_MPA_LAYER3 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_MPEG4 -#define HELIX_FEATURE_AUDIO_MPEG4 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_MULTIPLAYER_PAUSE -#define HELIX_FEATURE_AUDIO_MULTIPLAYER_PAUSE 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_POSTMIXHOOK -#define HELIX_FEATURE_AUDIO_POSTMIXHOOK 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_PREMIXHOOK -#define HELIX_FEATURE_AUDIO_PREMIXHOOK 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_RALF -#define HELIX_FEATURE_AUDIO_RALF 1 -#endif -#ifndef HELIX_FEATURE_AUDIO_REAL -#define HELIX_FEATURE_AUDIO_REAL 1 -#endif -#ifndef HELIX_FEATURE_AUTHENTICATION -#define HELIX_FEATURE_AUTHENTICATION 1 -#endif -#ifndef HELIX_FEATURE_AUTOUPGRADE -#define HELIX_FEATURE_AUTOUPGRADE 1 -#endif -#ifndef HELIX_FEATURE_BASICGROUPMGR -#define HELIX_FEATURE_BASICGROUPMGR 1 -#endif -#ifndef HELIX_FEATURE_CHUNKRES -#define HELIX_FEATURE_CHUNKRES 1 -#endif -#ifndef HELIX_FEATURE_COOKIES -#define HELIX_FEATURE_COOKIES 1 -#endif -#ifndef HELIX_FEATURE_CORECOMM -#define HELIX_FEATURE_CORECOMM 1 -#endif -#ifndef HELIX_FEATURE_CROSSFADE -#define HELIX_FEATURE_CROSSFADE 1 -#endif -#ifndef HELIX_FEATURE_DBG_LOG -#define HELIX_FEATURE_DBG_LOG 1 -#endif -#ifndef HELIX_FEATURE_DIRECT_SOUND -#define HELIX_FEATURE_DIRECT_SOUND 1 -#endif -#ifndef HELIX_FEATURE_DRM -#define HELIX_FEATURE_DRM 1 -#endif -#ifndef HELIX_FEATURE_DTDR_AUDIO_DECODER -#define HELIX_FEATURE_DTDR_AUDIO_DECODER 1 -#endif -#ifndef HELIX_FEATURE_DTDR_AVSYNC_ADJUSTER -#define HELIX_FEATURE_DTDR_AVSYNC_ADJUSTER 1 -#endif -#ifndef HELIX_FEATURE_DTDR_DECRYPTER -#define HELIX_FEATURE_DTDR_DECRYPTER 1 -#endif -#ifndef HELIX_FEATURE_DTDR_ENCODER -#define HELIX_FEATURE_DTDR_ENCODER 1 -#endif -#ifndef HELIX_FEATURE_EVENTMANAGER -#define HELIX_FEATURE_EVENTMANAGER 1 -#endif -#ifndef HELIX_FEATURE_FIFOCACHE -#define HELIX_FEATURE_FIFOCACHE 1 -#endif -#ifndef HELIX_FEATURE_FILESYSTEMMGR -#define HELIX_FEATURE_FILESYSTEMMGR 1 -#endif -#ifndef HELIX_FEATURE_FRAGMENTBUFFER -#define HELIX_FEATURE_FRAGMENTBUFFER 1 -#endif -#ifndef HELIX_FEATURE_FULLGUID -#define HELIX_FEATURE_FULLGUID 1 -#endif -#ifndef HELIX_FEATURE_GAINTOOL -#define HELIX_FEATURE_GAINTOOL 1 -#endif -#ifndef HELIX_FEATURE_GIF_BROKENIMAGE -#define HELIX_FEATURE_GIF_BROKENIMAGE 1 -#endif -#ifndef HELIX_FEATURE_GROUPMGR -#define HELIX_FEATURE_GROUPMGR 1 -#endif -#ifndef HELIX_FEATURE_HTTPCLOAK -#define HELIX_FEATURE_HTTPCLOAK 1 -#endif -#ifndef HELIX_FEATURE_HTTP_GZIP -#define HELIX_FEATURE_HTTP_GZIP 1 -#endif -#ifndef HELIX_FEATURE_HYPER_NAVIGATE -#define HELIX_FEATURE_HYPER_NAVIGATE 1 -#endif -#ifndef HELIX_FEATURE_IGNORE_SIGPIPE -#define HELIX_FEATURE_IGNORE_SIGPIPE 1 -#endif -#ifndef HELIX_FEATURE_ISMA -#define HELIX_FEATURE_ISMA 1 -#endif -#ifndef HELIX_FEATURE_LIMITER -#define HELIX_FEATURE_LIMITER 1 -#endif -#ifndef HELIX_FEATURE_MASTERTAC -#define HELIX_FEATURE_MASTERTAC 1 -#endif -#ifndef HELIX_FEATURE_MEDIAMARKER -#define HELIX_FEATURE_MEDIAMARKER 1 -#endif -#ifndef HELIX_FEATURE_MEMMAP_IO -#define HELIX_FEATURE_MEMMAP_IO 1 -#endif -#ifndef HELIX_FEATURE_META -#define HELIX_FEATURE_META 1 -#endif -#ifndef HELIX_FEATURE_MIXER -#define HELIX_FEATURE_MIXER 1 -#endif -#ifndef HELIX_FEATURE_MP3FF_LENIENT -#define HELIX_FEATURE_MP3FF_LENIENT 1 -#endif -#ifndef HELIX_FEATURE_MP3FF_ONDEMANDMETAINFO -#define HELIX_FEATURE_MP3FF_ONDEMANDMETAINFO 1 -#endif -#ifndef HELIX_FEATURE_MP3FF_SHOUTCAST -#define HELIX_FEATURE_MP3FF_SHOUTCAST 1 -#endif -#ifndef HELIX_FEATURE_NESTEDMETA -#define HELIX_FEATURE_NESTEDMETA 1 -#endif -#ifndef HELIX_FEATURE_NETCHECK -#define HELIX_FEATURE_NETCHECK 1 -#endif -#ifndef HELIX_FEATURE_NETINTERFACES -#define HELIX_FEATURE_NETINTERFACES 1 -#endif -#ifndef HELIX_FEATURE_NEXTGROUPMGR -#define HELIX_FEATURE_NEXTGROUPMGR 1 -#endif -#ifndef HELIX_FEATURE_OPTIMIZED_SCHEDULER -#define HELIX_FEATURE_OPTIMIZED_SCHEDULER 1 -#endif -#ifndef HELIX_FEATURE_OVERLAYMGR -#define HELIX_FEATURE_OVERLAYMGR 1 -#endif -#ifndef HELIX_FEATURE_PAC -#define HELIX_FEATURE_PAC 1 -#endif -#ifndef HELIX_FEATURE_PACKETHOOKMGR -#define HELIX_FEATURE_PACKETHOOKMGR 1 -#endif -#ifndef HELIX_FEATURE_PLAYBACK_LOCAL -#define HELIX_FEATURE_PLAYBACK_LOCAL 1 -#endif -#ifndef HELIX_FEATURE_PLAYBACK_NET -#define HELIX_FEATURE_PLAYBACK_NET 1 -#endif -#ifndef HELIX_FEATURE_PLAYERNAVIGATOR -#define HELIX_FEATURE_PLAYERNAVIGATOR 1 -#endif -#ifndef HELIX_FEATURE_PLUGINHANDLER2 -#define HELIX_FEATURE_PLUGINHANDLER2 1 -#endif -#ifndef HELIX_FEATURE_PNA -#define HELIX_FEATURE_PNA 1 -#endif -#ifndef HELIX_FEATURE_PREFERENCES -#define HELIX_FEATURE_PREFERENCES 1 -#endif -#ifndef HELIX_FEATURE_PREFETCH -#define HELIX_FEATURE_PREFETCH 1 -#endif -#ifndef HELIX_FEATURE_PROXYMGR -#define HELIX_FEATURE_PROXYMGR 1 -#endif -#ifndef HELIX_FEATURE_RAREND_ADV_PACKET_FEEDER -#define HELIX_FEATURE_RAREND_ADV_PACKET_FEEDER 1 -#endif -#ifndef HELIX_FEATURE_RAREND_BANDWIDTH_LISTER -#define HELIX_FEATURE_RAREND_BANDWIDTH_LISTER 1 -#endif -#ifndef HELIX_FEATURE_RAREND_PREREDSTONE_SUPPORT -#define HELIX_FEATURE_RAREND_PREREDSTONE_SUPPORT 1 -#endif -#ifndef HELIX_FEATURE_RAREND_SURESTREAM -#define HELIX_FEATURE_RAREND_SURESTREAM 1 -#endif -#ifndef HELIX_FEATURE_RDT -#define HELIX_FEATURE_RDT 1 -#endif -#ifndef HELIX_FEATURE_RECORDCONTROL -#define HELIX_FEATURE_RECORDCONTROL 1 -#endif -#ifndef HELIX_FEATURE_REGISTRY -#define HELIX_FEATURE_REGISTRY 1 -#endif -#ifndef HELIX_FEATURE_RESAMPLER -#define HELIX_FEATURE_RESAMPLER 1 -#endif -#ifndef HELIX_FEATURE_RESOURCEMGR -#define HELIX_FEATURE_RESOURCEMGR 1 -#endif -#ifndef HELIX_FEATURE_REVERTER -#define HELIX_FEATURE_REVERTER 1 -#endif -#ifndef HELIX_FEATURE_RMFF_BANDWIDTH_NEGOTIATOR -#define HELIX_FEATURE_RMFF_BANDWIDTH_NEGOTIATOR 1 -#endif -#ifndef HELIX_FEATURE_RMFF_DYNAMICASM -#define HELIX_FEATURE_RMFF_DYNAMICASM 1 -#endif -#ifndef HELIX_FEATURE_RMFF_LEGACYAUDIO -#define HELIX_FEATURE_RMFF_LEGACYAUDIO 1 -#endif -#ifndef HELIX_FEATURE_RMFF_LICENSING -#define HELIX_FEATURE_RMFF_LICENSING 1 -#endif -#ifndef HELIX_FEATURE_RMFF_LIVEINFO -#define HELIX_FEATURE_RMFF_LIVEINFO 1 -#endif -#ifndef HELIX_FEATURE_RMFF_MULTIRATE -#define HELIX_FEATURE_RMFF_MULTIRATE 1 -#endif -#ifndef HELIX_FEATURE_RMFF_ONDEMANDMETAINFO -#define HELIX_FEATURE_RMFF_ONDEMANDMETAINFO 1 -#endif -#ifndef HELIX_FEATURE_RMFF_TIMEOFFSET_FIXUP -#define HELIX_FEATURE_RMFF_TIMEOFFSET_FIXUP 1 -#endif -#ifndef HELIX_FEATURE_RMFF_TIMEOFFSET_HANDLER -#define HELIX_FEATURE_RMFF_TIMEOFFSET_HANDLER 1 -#endif -#ifndef HELIX_FEATURE_RMFF_VIEWSOURCE -#define HELIX_FEATURE_RMFF_VIEWSOURCE 1 -#endif -#ifndef HELIX_FEATURE_RTP -#define HELIX_FEATURE_RTP 1 -#endif -#ifndef HELIX_FEATURE_SECURECONN -#define HELIX_FEATURE_SECURECONN 1 -#endif -#ifndef HELIX_FEATURE_SETSRCPROPS -#define HELIX_FEATURE_SETSRCPROPS 1 -#endif -#ifndef HELIX_FEATURE_SINKCONTROL -#define HELIX_FEATURE_SINKCONTROL 1 -#endif -#ifndef HELIX_FEATURE_SMARTERNETWORK -#define HELIX_FEATURE_SMARTERNETWORK 1 -#endif -#ifndef HELIX_FEATURE_SMIL1 -#define HELIX_FEATURE_SMIL1 1 -#endif -#ifndef HELIX_FEATURE_SMIL2 -#define HELIX_FEATURE_SMIL2 1 -#endif -#ifndef HELIX_FEATURE_SMIL2_ANIMATION -#define HELIX_FEATURE_SMIL2_ANIMATION 1 -#endif -#ifndef HELIX_FEATURE_SMIL2_BRUSH -#define HELIX_FEATURE_SMIL2_BRUSH 1 -#endif -#ifndef HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT -#define HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT 1 -#endif -#ifndef HELIX_FEATURE_SMIL2_TRANSITIONS -#define HELIX_FEATURE_SMIL2_TRANSITIONS 1 -#endif -#ifndef HELIX_FEATURE_SMIL2_VALIDATION -#define HELIX_FEATURE_SMIL2_VALIDATION 1 -#endif -#ifndef HELIX_FEATURE_SMIL_REPEAT -#define HELIX_FEATURE_SMIL_REPEAT 1 -#endif -#ifndef HELIX_FEATURE_SMIL_SOUNDLEVEL -#define HELIX_FEATURE_SMIL_SOUNDLEVEL 1 -#endif -#ifndef HELIX_FEATURE_STATS -#define HELIX_FEATURE_STATS 1 -#endif -#ifndef HELIX_FEATURE_SYSTEMREQUIRED -#define HELIX_FEATURE_SYSTEMREQUIRED 1 -#endif -#ifndef HELIX_FEATURE_THREADSAFE_MEMMAP_IO -#define HELIX_FEATURE_THREADSAFE_MEMMAP_IO 1 -#endif -#ifndef HELIX_FEATURE_TIMEDTEXT -#define HELIX_FEATURE_TIMEDTEXT 1 -#endif -#ifndef HELIX_FEATURE_TRANSPORT_MULTICAST -#define HELIX_FEATURE_TRANSPORT_MULTICAST 1 -#endif -#ifndef HELIX_FEATURE_TURBOPLAY -#define HELIX_FEATURE_TURBOPLAY 1 -#endif -#ifndef HELIX_FEATURE_VIDEO -#define HELIX_FEATURE_VIDEO 1 -#endif -#ifndef HELIX_FEATURE_VIDEO_CODEC_RV20 -#define HELIX_FEATURE_VIDEO_CODEC_RV20 1 -#endif -#ifndef HELIX_FEATURE_VIDEO_CODEC_RV30 -#define HELIX_FEATURE_VIDEO_CODEC_RV30 1 -#endif -#ifndef HELIX_FEATURE_VIDEO_CODEC_RV40 -#define HELIX_FEATURE_VIDEO_CODEC_RV40 1 -#endif -#ifndef HELIX_FEATURE_VIDEO_H263 -#define HELIX_FEATURE_VIDEO_H263 1 -#endif -#ifndef HELIX_FEATURE_VIDEO_MPEG4 -#define HELIX_FEATURE_VIDEO_MPEG4 1 -#endif -#ifndef HELIX_FEATURE_VIDEO_REAL -#define HELIX_FEATURE_VIDEO_REAL 1 -#endif -#ifndef HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO -#define HELIX_FEATURE_VIDREND_OPTIMIZEDVIDEO 1 -#endif -#ifndef HELIX_FEATURE_VIDREND_SYNCSMOOTHING -#define HELIX_FEATURE_VIDREND_SYNCSMOOTHING 1 -#endif -#ifndef HELIX_FEATURE_VIEWPORT -#define HELIX_FEATURE_VIEWPORT 1 -#endif -#ifndef HELIX_FEATURE_VIEWSOURCE -#define HELIX_FEATURE_VIEWSOURCE 1 -#endif -#ifndef HELIX_FEATURE_VOLUME -#define HELIX_FEATURE_VOLUME 1 -#endif -#ifndef HELIX_FEATURE_XMLPARSER -#define HELIX_FEATURE_XMLPARSER 1 -#endif -#ifndef HELIX_FEATURE_PANDA3D -#define HELIX_FEATURE_PANDA3D 1 -#endif -#ifndef STRICT -#define STRICT 1 -#endif -#ifndef THREADS_SUPPORTED -#define THREADS_SUPPORTED 1 -#endif -#ifndef WIN32 -#define WIN32 1 -#endif -#ifndef _LITTLE_ENDIAN -#define _LITTLE_ENDIAN 1 -#endif -#ifndef _M_IX86 -#define _M_IX86 1 -#endif -#ifndef _WIN32 -#define _WIN32 1 -#endif -#ifndef _WINDOWS -#define _WINDOWS 1 -#endif - diff --git a/panda/src/helix/HxAdviseSink.cxx b/panda/src/helix/HxAdviseSink.cxx deleted file mode 100644 index 6b1c8ee6e0..0000000000 --- a/panda/src/helix/HxAdviseSink.cxx +++ /dev/null @@ -1,650 +0,0 @@ -// Filename: HxAdviseSink.cpp -// Created by: jjtaylor (27Jan04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "HxAdviseSink.h" - -//////////////////////////////////////////////////////////////////// -// Normal Header Files -//////////////////////////////////////////////////////////////////// -#include - -//////////////////////////////////////////////////////////////////// -// Method: HxAdviseSink::Constructor -// Access: Public -// Purpose: Initializes member variables and sets up object -// related interfaces. -//////////////////////////////////////////////////////////////////// -// Input: pUnknown - Pointer to an IUnknown Interface -// client_index - Client Instance Identifier -// Output: None -//////////////////////////////////////////////////////////////////// -HxAdviseSink::HxAdviseSink(IUnknown* unknown, LONG32 client_index, bool sink_on) - : _ref_count (0), - _client_index (client_index), - _unknown (0), - _registry (0), - _scheduler (0), - _current_bandwidth(0), - _average_bandwidth(0), - _on_stop(0), - _sink_on(sink_on) -{ - if (unknown != 0) { - _unknown = unknown; - _unknown->AddRef(); - - if (HXR_OK != _unknown->QueryInterface(IID_IHXRegistry, (void**)&_registry)) { - _registry = 0; - } - - if (HXR_OK != _unknown->QueryInterface(IID_IHXScheduler, (void**)&_scheduler)) { - _scheduler = 0; - } - - IHXPlayer* player; - if(HXR_OK == _unknown->QueryInterface(IID_IHXPlayer, (void**)&player)) { - player->AddAdviseSink(this); - player->Release(); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::~HxClientAdviseSink -// Access: Private -// Purpose: Class destructor which releases corresponding -// interfaces which are related to this class. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HxAdviseSink::~HxAdviseSink() { - // Release components and set the member variables to the - // NULL-state. - if (_scheduler != 0) { - _scheduler->Release(); - _scheduler = 0; - } - - if (_registry != 0) { - _registry->Release(); - _registry = 0; - } - - if (_unknown != 0) { - _unknown->Release(); - _unknown = 0; - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::QueryInterface -// Access: Public -// Purpose: Queries this class to determine whether it supports -// supports a specific interface. If the call succeeds -// then the methods of that interface are made -// available for use. -//////////////////////////////////////////////////////////////////// -// Params: id - Indicates the reference identifier of the -// the interface being queried. -// interface_obj - Points to an interface pointer that is -// filled in if the query succeeds. -// Return: HX_RESULT - Varies based on wheter the interface is -// supported or not. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::QueryInterface(REFIID id, void** interface_obj) { - // Determine if the IUnknown and ClientAdviseSink interfaces - // are supported. - if (IsEqualIID(id, IID_IUnknown)) { - // Increase the reference count, set the Interface Object, - // and return that the interface is supported within this - // object. - AddRef(); - *interface_obj = (IUnknown*)(IHXClientAdviseSink*)this; - } - else if (IsEqualIID(id, IID_IHXClientAdviseSink)) { - // Same as above. - AddRef(); - *interface_obj = (IHXClientAdviseSink*)this; - } - else { - // This Interface is not supported by this object. Set the - // Interface Object to the NULL-state and return. - *interface_obj = 0; - return HXR_NOINTERFACE; - } - return HXR_OK; -} - - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::AddRef -// Access: Public -// Purpose: Increases the classes reference count by one. -// Whenever an object is created, it's reference count -// begins at 1. If an application calls IUnknown::AddRef, -// queries an interface belonging to a specific object, -// or uses a creation function like HXCreateInstance, -// the reference count is incremented by 1. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: Returns the new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxAdviseSink::AddRef() { - return InterlockedIncrement(&_ref_count); -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::Release -// Access: Public -// Purpose: Decreases the object's reference count by one. -// Every call to IUnknown::AddRef, -// IUnknown::QueryInterface, or a creation function -// such as HXCreateInstance must have a corresponding -// call to IUnknown::Release. When the reference count -// reaches 0 (zero), the object is destroyed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: Returns the new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxAdviseSink::Release() { - // As long as the reference count is greater than 0, then this - // object is still in "scope." - if (InterlockedDecrement(&_ref_count) > 0 ) { - return _ref_count; - } - - // Otherwise, this object is no longer necessary and should be - // removed from memory. - delete this; - return 0; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnPosLength -// Access: Public -// Purpose: Advises the client that the position or length of -// the current playback context has changed -//////////////////////////////////////////////////////////////////// -// Params: ulPosition - The new position of the playback. -// ulLength - The new length of the playback. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnPosLength(ULONG32 ulPosition, ULONG32 ulLength) { - // Initialize Variables - if(_sink_on) { - STDOUT("OnPosLength(%ld, %ld)\n", ulPosition, ulLength); - } - return HXR_OK; -} - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnPresentationOpened -// Access: Public -// Purpose: Advises the client that a presentation has been -// opened. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnPresentationOpened() { - // For now, check if advise sinking is enabled. If so, print that - // a presenatation has been opened. - if(_sink_on) { - STDOUT("OnPresentationOpened()\n"); - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnPresentationClosed() -// Access: Public -// Purpose: Advises the cleint that a presentation has been -// closed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnPresentationClosed() { - // For now, check if advise sinking is enabled. If so, print that - // a presenatation has been closed. - if(_sink_on) { - STDOUT("OnPresentationClosed()\n"); - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxAdviseSink::get_statistics -// Access: Private -// Purpose: Retrieves the statistic for the particular key that -// is in the Helix Registry Interface. -//////////////////////////////////////////////////////////////////// -// Params: char* registry_key - the key whose value we wish to -// retrieve from the registry. -// Return: None -//////////////////////////////////////////////////////////////////// -void HxAdviseSink::get_statistics(char* registry_key) { - if(_sink_on) { - char RegistryValue[MAX_DISPLAY_NAME] = {0}; - INT32 lValue = 0; - INT32 i = 0; - INT32 lStatistics = 8; - UINT32 *plValue; - - // Collect all of the necessary statistics from the registry - // and print them to the screen. - for (i = 0; i < lStatistics; i++) { - plValue = NULL; - switch (i) { - case 0: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s.Normal", registry_key); - break; - case 1: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s.Recovered", registry_key); - break; - case 2: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s.Received", registry_key); - break; - case 3: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s.Lost", registry_key); - break; - case 4: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s.Late", registry_key); - break; - case 5: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s.ClipBandwidth", registry_key); - break; - case 6: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s._average_bandwidth", registry_key); - plValue = &_average_bandwidth; - break; - case 7: - SafeSprintf(RegistryValue, MAX_DISPLAY_NAME, "%s._current_bandwidth", registry_key); - plValue = &_current_bandwidth; - break; - default: - break; - } - - _registry->GetIntByName(RegistryValue, lValue); - if (plValue) { - if (_on_stop || lValue == 0) { - lValue = *plValue; - } - else { - *plValue = lValue; - } - } - STDOUT("%s = %ld\n", RegistryValue, lValue); - } - } -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::get_all_statistics -// Access: Private -// Purpose: Displays the content of the entire registry. Not -// truly necessary for Panda, however, it is useful -// for debugging purposes of streaming files. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HxAdviseSink::get_all_statistics() { - if(_sink_on) { - UINT32 PlayerIndex = 0; - UINT32 SourceIndex = 0; - UINT32 StreamIndex = 0; - - char* RegistryPrefix = "Statistics"; - char RegistryName[MAX_DISPLAY_NAME] = {0}; - - // Display the content of whole statistic registry - if (_registry) { - // Start from the first player. - SafeSprintf(RegistryName, MAX_DISPLAY_NAME, "%s.Player%ld", RegistryPrefix, _client_index); - if (PT_COMPOSITE == _registry->GetTypeByName(RegistryName)) { - // Display player statistic - get_statistics(RegistryName); - - SafeSprintf(RegistryName, MAX_DISPLAY_NAME, "%s.Source%ld", RegistryName, SourceIndex); - while (PT_COMPOSITE == _registry->GetTypeByName(RegistryName)) { - // Display source statistic - get_statistics(RegistryName); - - - SafeSprintf(RegistryName, MAX_DISPLAY_NAME, "%s.Stream%ld", RegistryName, StreamIndex); - while (PT_COMPOSITE == _registry->GetTypeByName(RegistryName)) { - // Display stream statistic - get_statistics(RegistryName); - - StreamIndex++; - - SafeSprintf(RegistryName, MAX_DISPLAY_NAME, "%s.Player%ld.Source%ld.Stream%ld", - RegistryPrefix, PlayerIndex, SourceIndex, StreamIndex); - } - SourceIndex++; - SafeSprintf(RegistryName, MAX_DISPLAY_NAME, "%s.Player%ld.Source%ld", - RegistryPrefix, PlayerIndex, SourceIndex); - } - PlayerIndex++; - SafeSprintf(RegistryName, MAX_DISPLAY_NAME, "%s.Player%ld", - RegistryPrefix, PlayerIndex); - } - } - } -} -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnStatisticsChanged -// Access: Public -// Purpose: Advises the client that the presentation statistics -// have changed and prints those statistics out. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnStatisticsChanged() { - if(_sink_on) { - char Buff[1024]; - HX_RESULT res = HXR_OK; - UINT16 Player = 0; - - STDOUT("OnStatisticsChanged():\n"); - - SafeSprintf(Buff, 1024, "Statistics.Player%u", Player); - while( HXR_OK == res ) { - res = dump_reg_tree( Buff ); - Player++; - SafeSprintf(Buff, 1024, "Statistics.Player%u", Player ); - } - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::DumpRegTree -// Access: Private -// Purpose: Prints the contents of the Registry tree for this -// particular object. -//////////////////////////////////////////////////////////////////// -// Params: pszTreeName - The name of the Registry tree that should -// be printed. -// Return: HX_RESULT - result varies. -//////////////////////////////////////////////////////////////////// -HX_RESULT HxAdviseSink::dump_reg_tree(const char* tree_name) { - //Initialize Local Variables related to the Registry Tree - const char* pszName = NULL; - ULONG32 ulRegID = 0; - HX_RESULT res = HXR_OK; - INT32 nVal = 0; - IHXBuffer* pBuff = NULL; - IHXValues* pValues = NULL; - - - // Check if the name exists in the registry. If its not - // return a failure. - res = _registry->GetPropListByName(tree_name, pValues); - if (HXR_OK!=res || !pValues) { - return HXR_FAIL; - } - - // Make sure this is a PT_COMPOSITE type registry entry. If - // its not, return a failure. - if (PT_COMPOSITE != _registry->GetTypeByName(tree_name)) { - return HXR_FAIL; - } - - // Print out the value of each member of this tree. - res = pValues->GetFirstPropertyULONG32( pszName, ulRegID ); - while( HXR_OK == res ) { - // There is at least one entry in the Registry. Now - // check the type. - HXPropType pt = _registry->GetTypeById(ulRegID); - switch(pt) { - case PT_COMPOSITE: - dump_reg_tree(pszName); - break; - case PT_INTEGER: - nVal = 0; - _registry->GetIntById( ulRegID, nVal ); - STDOUT("%s : %d\n", pszName, nVal ); - break; - case PT_INTREF : - nVal = 0; - _registry->GetIntById( ulRegID, nVal ); - STDOUT("%s : %d\n", pszName, nVal ); - break; - case PT_STRING : - pBuff = NULL; - _registry->GetStrById( ulRegID, pBuff ); - STDOUT("%s : \"", pszName ); - - if( pBuff ) { - STDOUT("%s", (const char *)(pBuff->GetBuffer()) ); - } - STDOUT("\"\n" ); - HX_RELEASE(pBuff); - break; - case PT_BUFFER : - STDOUT("%s : BUFFER TYPE NOT SHOWN\n", pszName, nVal ); - break; - case PT_UNKNOWN: - STDOUT("%s Unkown registry type entry\n", pszName ); - break; - default: - STDOUT("%s Unkown registry type entry\n", pszName ); - break; - } - res = pValues->GetNextPropertyULONG32(pszName, ulRegID); - } - - HX_RELEASE( pValues ); - return HXR_OK; -} - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnPreSeek -// Access: Public -// Purpose: Informs the client that a seek is about to occur. -// The client is informed of the last time in the -// stream's time line before the seek, as well as the -// first new time in the stream's time line after the -// seek is completed. -//////////////////////////////////////////////////////////////////// -// Params: ulOldTime - The end of the stream's time line before the -// current seek. -// ulNewTime - The beginning of the stream's time line after -// the current seek. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnPreSeek(ULONG32 ulOldTime, ULONG32 ulNewTime) { - // For now, check if advise sinking is enabled. If so, print that - // a seek is about to happen. - if(_sink_on) { - STDOUT("OnPreSeek(%ld, %ld)\n", ulOldTime, ulNewTime); - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnPostSeek -// Access: Public -// Purpose: Informs the client that a seek has just occured. -// The client is informed of the last time in the -// stream's time line before the seek, as well as the -// first new time in the stream's time line after the -// seek is completed. -//////////////////////////////////////////////////////////////////// -// Params: ulOldTime - The end of the stream's time line before the -// current seek. -// ulNewTime - The beginning of the stream's time line after -// the current seek. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnPostSeek(ULONG32 ulOldTime, ULONG32 ulNewTime) { - // For now, check if advise sinking is enabled. If so, print that - // a seek just happened. - if(_sink_on) { - STDOUT("OnPostSeek(%ld, %ld)\n", ulOldTime, ulNewTime); - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnStop -// Access: Public -// Purpose: Informs the client that a stop has just occured -// in a presentation, and calculates the total time -// that a file has been playing. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnStop() { - if(_sink_on) { - HXTimeval curr_time; - - STDOUT("OnStop()\n"); - - STDOUT("Player %ld stopped.\n", _client_index); - _on_stop = TRUE; - get_all_statistics(); - - // Retrieve the current time and subtract the beginning time to figure out - // how long the file has played. - curr_time = _scheduler->GetCurrentSchedulerTime(); - _stop_time = curr_time.tv_sec; - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnPause -// Access: Public -// Purpose: Informs the client that a pause has just occured. -//////////////////////////////////////////////////////////////////// -// Params: time - time in the stream's time line that the pause -// occured. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnPause(ULONG32 time) { - // For now, check if advise sinking is enabled. If so, print that - // the a pause in the presentation has occured for debugging - // purposes. - if(_sink_on) { - STDOUT("OnPause(%ld)\n", time); - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnBegin -// Access: Public -// Purpose: Informs the client that a presenentation has begun. -//////////////////////////////////////////////////////////////////// -// Params: time - The time that the presentation has begun. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnBegin(ULONG32 time) { - if(_sink_on) { - // Local Variable Declarations - HXTimeval curr_time; - - STDOUT("OnBegin(%ld)\n", time); - STDOUT("Player %ld beginning playback...\n", _client_index); - - // Record the current time that this begins so that the number - // of seconds the media file has been playing can be calculated. - curr_time = _scheduler->GetCurrentSchedulerTime(); - _start_time = curr_time.tv_sec; - } - return HXR_OK; -} - - - - - - - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnBuffering -// Access: Public -// Purpose: Informs the client that buffering of data is occuring. -// The render is informed of the reason for the buffering -// (start-up of stream, seek has occured, network congestion, -// etc.), as well as percentage complete of the buffering process. -//////////////////////////////////////////////////////////////////// -// Params: flags - The reason for buffering. Can be any of the following: -// BUFFERING_START_UP, BUFFERING_SEEK, -// BUFFERING_CONGESTION, BUFFERING_LIVE_PAUSE -// percent_complete - The percentage fo the buffering that -// has been completed. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnBuffering(ULONG32 flags, UINT16 percent_complete) { - // For now, check if advise sinking is enabled. If so, print that - // the a presentation is now buffering. - if(_sink_on) { - STDOUT("OnBuffering(%ld, %d)\n", flags, percent_complete); - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientAdviseSink::OnContacting -// Access: Public -// Purpose: Informs the client that the engine is contacting -// a host. -//////////////////////////////////////////////////////////////////// -// Params: host_name - Host name that the engine is contacting. -// Return: HXR_OK - Helix Specific result saying things are "Okay". -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAdviseSink::OnContacting(const char* host_name) { - // For now, check if advise sinking is enabled. If so, print that - // the client is contacting a host for streaming. - if(_sink_on) { - STDOUT("OnContacting(\"%s\")\n", host_name); - } - return HXR_OK; -} diff --git a/panda/src/helix/HxAdviseSink.h b/panda/src/helix/HxAdviseSink.h deleted file mode 100644 index 91706ca4f1..0000000000 --- a/panda/src/helix/HxAdviseSink.h +++ /dev/null @@ -1,94 +0,0 @@ -// Filename: HxAdviseSink.h -// Created by: jjtaylor (10Feb04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// -#ifndef HXADVISESINK_H -#define HXADVISESINK_H - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "pandabase.h" - -//////////////////////////////////////////////////////////////////// -// Helix Main Header Files -//////////////////////////////////////////////////////////////////// -#include "mainHelix.h" - -//////////////////////////////////////////////////////////////////// -// Prototype/Struct/Class Forward Delcarations -//////////////////////////////////////////////////////////////////// -struct IHXClientAdviseSink; -struct IUnknown; -struct IHXRegistry; -struct IHXScheduler; - -//////////////////////////////////////////////////////////////////// -// Class: HxAdviseSink -// Purpose: This is a derived class from the IHXClientAdviseSink -// base interface. This class is meant to receive -// notifications from the client engine about changes in -// or about a presentation's playback status. -//////////////////////////////////////////////////////////////////// -class HxAdviseSink : public IHXClientAdviseSink { - public: - HxAdviseSink(IUnknown* unknown, LONG32 client_index, bool sink_on); - -//////////////////////////////////////////////////////////////////// -// IHUnkown Interface Methods Prototypes -// Purpose: Implements the basic COM interface methods for reference -// coutning and querying of related interfaces. -//////////////////////////////////////////////////////////////////// - STDMETHOD(QueryInterface) (THIS_ REFIID id, void** interface_obj); - STDMETHOD_(ULONG32,AddRef) (THIS); - STDMETHOD_(ULONG32,Release) (THIS); - -//////////////////////////////////////////////////////////////////// -// IHXClientAdviseSink Interface Methods Prototypes -// Purpose: Implements the necessary interface methods that may -// be called during a presentations status. -//////////////////////////////////////////////////////////////////// - STDMETHOD(OnPosLength) (THIS_ UINT32 position, UINT32 length); - STDMETHOD(OnPresentationOpened) (THIS); - STDMETHOD(OnPresentationClosed) (THIS); - STDMETHOD(OnStatisticsChanged) (THIS); - STDMETHOD(OnPreSeek) (THIS_ ULONG32 old_time, ULONG32 new_time); - STDMETHOD(OnPostSeek) (THIS_ ULONG32 old_time, ULONG32 new_time); - STDMETHOD(OnStop) (THIS); - STDMETHOD(OnPause) (THIS_ ULONG32 Time); - STDMETHOD(OnBegin) (THIS_ ULONG32 Time); - STDMETHOD(OnBuffering) (THIS_ ULONG32 flags, UINT16 percent_complete); - STDMETHOD(OnContacting) (THIS_ const char* host_name); - private: - // Private Member Functions - ~HxAdviseSink(); - HX_RESULT dump_reg_tree(const char* tree_name ); - void get_statistics (char* registry_key); - void get_all_statistics (); - - // Private Member variables - LONG32 _ref_count; - LONG32 _client_index; - UINT32 _start_time; - UINT32 _stop_time; - UINT32 _current_bandwidth; - UINT32 _average_bandwidth; - BOOL _on_stop; - - bool _sink_on; - - IUnknown* _unknown; - IHXRegistry* _registry; - IHXScheduler* _scheduler; -}; -#endif diff --git a/panda/src/helix/HxAuthenticationManager.cxx b/panda/src/helix/HxAuthenticationManager.cxx deleted file mode 100644 index fafbc67d2b..0000000000 --- a/panda/src/helix/HxAuthenticationManager.cxx +++ /dev/null @@ -1,207 +0,0 @@ -// Filename: HxAuthenticationManager.cxx -// Created by: jjtaylor (10Feb04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "HxAuthenticationManager.h" -#include "print.h" - -//////////////////////////////////////////////////////////////////// -// Normal Header Files -//////////////////////////////////////////////////////////////////// -#include -#include - -//////////////////////////////////////////////////////////////////// -// Member: HxAuthenticationManager::HxAuthenticationManager -// Access: Public -// Purpose: A default constructor which initializes the member -// variables for the class. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HxAuthenticationManager::HxAuthenticationManager() - : _ref_count(0), - _sent_password(FALSE) { -} - -//////////////////////////////////////////////////////////////////// -// Member: HxAuthenticationManager::Destructor -// Access: Public -// Purpose: The default destructor which removes existing -// COM interfaces that have not been freed from -// memory. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HxAuthenticationManager::~HxAuthenticationManager() { -} - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxAuthenticationManager::QueryInterface -// Access: Public -// Purpose: Queries this class to determine whether it supports -// supports a specific interface. If the call succeeds -// then the methods of that interface are made -// available for use. -//////////////////////////////////////////////////////////////////// -// Params: id - Indicates the reference identifier of the -// the interface being queried. -// ppInterfaceObj - Points to an interface pointer that is -// filled in if the query succeeds. -// Return: HX_RESULT - Varies based on wheter the interface is -// supported or not. -//////////////////////////////////////////////////////////////////// -HX_RESULT HxAuthenticationManager::QueryInterface(THIS_ REFIID id, void** ppInterfaceObj) { - // Determine if the IUnknown and AuthenticationManager interfaces - // are supported. - if (IsEqualIID(id, IID_IUnknown)) { - // Increase the reference count, set the Interface Object, - // and return that the interface is supported within this - // object. - AddRef(); - *ppInterfaceObj = (IUnknown*)(IHXAuthenticationManager *)this; - } - else if (IsEqualIID(id, IID_IHXAuthenticationManager)) { - // Same as above. - AddRef(); - *ppInterfaceObj = (IHXAuthenticationManager *)this; - } - else { - // This Interface is not supported by this object. Set the - // Interface Object to the NULL-state and return. - *ppInterfaceObj = 0; - return HXR_NOINTERFACE; - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxAuthenticationManager::AddRef -// Access: Public -// Purpose: Increases the object's reference count by one. -// Every call to IUnknown::AddRef, -// IUnknown::QueryInterface, or a creation function -// such as HXCreateInstance must have a corresponding -// call to IUnknown::Release. When the reference count -// reaches 0 (zero), the object is destroyed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: ULONG32 - The new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxAuthenticationManager::AddRef(THIS) { - return InterlockedIncrement(&_ref_count); -} - - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxAuthenticationManager::Release -// Access: Public -// Purpose: Decreases the object's reference count by one. -// Every call to IUnknown::AddRef, -// IUnknown::QueryInterface, or a creation function -// such as HXCreateInstance must have a corresponding -// call to IUnknown::Release. When the reference count -// reaches 0 (zero), the object is destroyed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: ULONG32 - The new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxAuthenticationManager::Release(THIS) { - // As long as the reference count is greater than 0, then this - // object is still in "scope." - if (InterlockedDecrement(&_ref_count) > 0 ) { - return _ref_count; - } - - // Otherwise, this object is no longer necessary and should be - // removed from memory. - delete this; - return 0; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxAuthenticationManager:HandleAuthenticationRequest -// Access: Public -// Purpose: Retrieves the username and password which is -// needed to access a specific file or URL. -//////////////////////////////////////////////////////////////////// -// Params: pResponse - Pointer to a response interface that -// manages the response of the authentication -// of the username and password. -// Return: HX_RESULT - Based on the authentication process. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxAuthenticationManager::HandleAuthenticationRequest(IHXAuthenticationManagerResponse* pResponse) -{ - char username[1024] = ""; /* Flawfinder: ignore */ - char password[1024] = ""; /* Flawfinder: ignore */ - HX_RESULT res = HXR_FAIL; - - if( !_sent_password ) - { - res = HXR_OK; - - STDOUT("\nSending Username and Password...\n"); - - SafeStrCpy(username, "", 1024); - SafeStrCpy(password, "", 1024); - - //strip trailing whitespace - char* c; - for(c = username + strlen(username) - 1; - c > username && isspace(*c); - c--) - ; - *(c+1) = 0; - - for(c = password + strlen(password) - 1; - c > password && isspace(*c); - c--) - ; - *(c+1) = 0; - - _sent_password = TRUE; - } - if (FAILED(res)) - STDOUT("\nInvalid Username and/or Password.\n"); - - pResponse->AuthenticationRequestDone(res, username, password); - return res; -} diff --git a/panda/src/helix/HxAuthenticationManager.h b/panda/src/helix/HxAuthenticationManager.h deleted file mode 100644 index 2311364b04..0000000000 --- a/panda/src/helix/HxAuthenticationManager.h +++ /dev/null @@ -1,5 +0,0 @@ -// Filename: hxAuthenticationManager.cxx -// Created by: jjtaylor (28Jan04) -// -//////////////////////////////////////////////////////////////////// -// diff --git a/panda/src/helix/HxClientContext.cxx b/panda/src/helix/HxClientContext.cxx deleted file mode 100644 index d6a25a4f2c..0000000000 --- a/panda/src/helix/HxClientContext.cxx +++ /dev/null @@ -1,324 +0,0 @@ -// Filename: HxClientContext.h -// Created by: jjtaylor (01Feb04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Helix Main Header Files -//////////////////////////////////////////////////////////////////// -#include "mainHelix.h" - -//////////////////////////////////////////////////////////////////// -// Member: HxClientContext::Constructor -// Access: Public -// Purpose: The constructor simply initializes all of the -// member variables. -//////////////////////////////////////////////////////////////////// -// Params: LONG32 client_index - the player/client count -// Return: None -//////////////////////////////////////////////////////////////////// -HxClientContext::HxClientContext(LONG32 client_index) - : _ref_count(0), - _client_index(client_index), - _client_sink(0), - _error_sink(0), - _auth_mgr(0), - _site_supplier(0), - _default_prefs(0) { -} - -//////////////////////////////////////////////////////////////////// -// Member: HxClientContext::Destructor -// Access: Public -// Purpose: The destructor simply calls the close member -// function. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HxClientContext::~HxClientContext(){ - close(); -} - - - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxClientContext::init -// Access: Public -// Purpose: This member performs all of the dirty work for -// initializing the the client context for a player -// as well as instantiating all of the necessary -// Helix interface objects that must be declared so -// the engine can properly communicate with the player -//////////////////////////////////////////////////////////////////// -// Params: IUnknown* unknown - a Helix Interface Object -// IHXPreferences* prefs - -// char* guid - a GUID, if applicable. -// bool sink_on - True if the AdviseSink should broadcast -// presentation statistics. -// Texture* tex - a Panda Texture Object which will be -// updated with the video each frame. -// Return: None -//////////////////////////////////////////////////////////////////// -void HxClientContext::init(IUnknown* unknown, IHXPreferences* prefs, char* guid, bool sink_on, Texture* tex) { - char * cipher = 0; - - _client_sink = new HxAdviseSink(unknown, _client_index, sink_on); - _error_sink = new HxErrorSink(unknown); - _auth_mgr = new HxAuthenticationManager(); -#if defined(HELIX_FEATURE_VIDEO) - // From this point, we need to create a site supplier object since we are dealing with video. - // In addtion, we must send the Panda Texture buffer down to the site supplier, where it will - // inevitably be sent to the video surface object so that it can be updated. - //cout << "Buffer: " << buffer << endl; - _site_supplier = new HxSiteSupplier(unknown, tex); -#endif - - if (_client_sink != 0) { - _client_sink->AddRef(); - } - - if (_error_sink != 0) { - _error_sink->AddRef(); - } - - if (_auth_mgr != 0) { - _auth_mgr->AddRef(); - } - - if (_site_supplier != 0) { - _site_supplier->AddRef(); - } - - if (prefs != 0) { - _default_prefs = prefs; - _default_prefs->AddRef(); - } - - if (guid && *guid) { - // Encode GUID - cipher = Cipher(guid); - SafeStrCpy(_guid, cipher, 256); - } - else { - _guid[0] = '\0'; - } -} - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxClientContext::close -// Access: Public -// Purpose: This method simply releases each of the helix -// interface objects that are associated with the -// player. For instance, the site supplier and the -// error sink. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -void HxClientContext::close() { - HX_RELEASE(_client_sink); - HX_RELEASE(_error_sink); - HX_RELEASE(_auth_mgr); - HX_RELEASE(_site_supplier); - HX_RELEASE(_default_prefs); -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientContext::QueryInterface -// Access: Public -// Purpose: Queries this class to determine whether it supports -// supports a specific interface. If the call succeeds -// then the methods of that interface are made -// available for use. -//////////////////////////////////////////////////////////////////// -// Params: id - Indicates the reference identifier of the -// the interface being queried. -// interface_obj - Points to an interface pointer that is -// filled in if the query succeeds. -// Return: HX_RESULT - Varies based on wheter the interface is -// supported or not. -//////////////////////////////////////////////////////////////////// -HX_RESULT HxClientContext::QueryInterface(THIS_ REFIID id, void** interface_obj) { - HX_RESULT result = HXR_NOINTERFACE; - // Determine if the IUnknown and ClientAdviseSink interfaces - // are supported. - if (IsEqualIID(id, IID_IUnknown)) { - // Increase the reference count, set the Interface Object, - // and return that the interface is supported within this - // object. - AddRef(); - *interface_obj = (IUnknown*)(IHXClientAdviseSink*)this; - result = HXR_OK; - } - else if (IsEqualIID(id, IID_IHXPreferences)) { - // Same as above. - AddRef(); - *interface_obj = (IHXPreferences*)this; - result = HXR_OK; - } - else if ((_client_sink != 0) && - (_client_sink->QueryInterface(id, interface_obj) == HXR_OK)) { - result = HXR_OK; - } - else if ((_error_sink != 0) && - (_error_sink->QueryInterface(id, interface_obj) == HXR_OK)) { - result = HXR_OK; - } - else if ((_auth_mgr != 0) && - (_auth_mgr->QueryInterface(id, interface_obj) == HXR_OK)) { - result = HXR_OK; - } - else if ((_site_supplier != 0) && - (_site_supplier->QueryInterface(id, interface_obj) == HXR_OK)) { - result = HXR_OK; - } - else { - // This Interface is not supported by this object. Set the - // Interface Object to the NULL-state and return. - *interface_obj = 0; - } - return result; -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientContex::AddRef -// Access: Public -// Purpose: Increases the classes reference count by one. -// Whenever an object is created, it's reference count -// begins at 1. If an application calls IUnknown::AddRef, -// queries an interface belonging to a specific object, -// or uses a creation function like HXCreateInstance, -// the reference count is incremented by 1. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: Returns the new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxClientContext::AddRef(THIS) { - return InterlockedIncrement(&_ref_count); -} - -//////////////////////////////////////////////////////////////////// -// Method: HxClientContext::Release -// Access: Public -// Purpose: Decreases the object's reference count by one. -// Every call to IUnknown::AddRef, -// IUnknown::QueryInterface, or a creation function -// such as HXCreateInstance must have a corresponding -// call to IUnknown::Release. When the reference count -// reaches 0 (zero), the object is destroyed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: Returns the new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxClientContext::Release(THIS) { - // As long as the reference count is greater than 0, then this - // object is still in "scope." - if (InterlockedDecrement(&_ref_count) > 0 ) { - return _ref_count; - } - - // Otherwise, this object is no longer necessary and should be - // removed from memory. - delete this; - return 0; -} - - - - - - - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxClientContext::ReadPref -// Access: Public -// Purpose: This method reads a preference from the client -// registry. -//////////////////////////////////////////////////////////////////// -// Params: const char* pref_key - preference key to add to the -// registry. -// IHXBuffer* buffer - a buffer that manages the value of -// the preference. -// Return: IHXBuffer* buffer - returns a buffer that manages -// the value of the preference. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxClientContext::ReadPref(const char* pref_key, IHXBuffer*& buffer) { - HX_RESULT result = HXR_OK; - char * cipher = 0; - - if ((stricmp(pref_key, CLIENT_GUID_REGNAME) == 0) && - (*_guid != 0 )) { - // Create a buffer - buffer = new CHXBuffer(); - buffer->AddRef(); - - buffer->Set((UCHAR*)_guid, strlen(_guid) + 1); - } - else if (_default_prefs != 0) { - result = _default_prefs->ReadPref(pref_key, buffer); - } - else { - result = HXR_NOTIMPL; - } - return result; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxClientContext::WritePref -// Access: Public -// Purpose: This method writes a preference to the helix -// client registry. -//////////////////////////////////////////////////////////////////// -// Params: const char* pref_key - preference key to add to the -// registry. -// IHXBuffer* buffer - a buffer that manages the value of -// the preference. -// Return: IHXBuffer* buffer - returns a buffer that manages -// the value of the preference. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxClientContext::WritePref(const char* pref_key, IHXBuffer *buffer) { - if (_default_prefs != 0) { - return _default_prefs->WritePref(pref_key, buffer); - } - else { - return HXR_OK; - } -} diff --git a/panda/src/helix/HxClientContext.h b/panda/src/helix/HxClientContext.h deleted file mode 100644 index 1a02fa18d2..0000000000 --- a/panda/src/helix/HxClientContext.h +++ /dev/null @@ -1,85 +0,0 @@ -// Filename: HxClientContext.h -// Created by: jjtaylor (01Feb04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// -#ifndef HXCLIENTCONTEXT_H -#define HXCLIENTCONTEXT_H - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "pandabase.h" -#include "texture.h" - -//////////////////////////////////////////////////////////////////// -// Helix Main Header Files -//////////////////////////////////////////////////////////////////// -#include "mainHelix.h" - -//////////////////////////////////////////////////////////////////// -// Prototype/Struct/Class Forward Delcarations -//////////////////////////////////////////////////////////////////// -struct IUnknown; -struct IHXPreferences; -class HxAdviseSink; -class HxErrorSink; -class HxAuthenticationManager; - -//////////////////////////////////////////////////////////////////// -// Class: HxClientContext -// Purpose: This is a derived class from the IHXPreferences -// base interface. This class is meant to set the -// default preferences for a player. It contains the -// necessary interface objects such as the Advise Sink, -// Error Sink, and Site Supplier. -//////////////////////////////////////////////////////////////////// -class HxClientContext : public IHXPreferences { -public: - HxClientContext(LONG32 client_index); - ~HxClientContext(); - void init(IUnknown* unknown, IHXPreferences* prefs, char* guid, bool sink_on, Texture* tex); - void close(); - -//////////////////////////////////////////////////////////////////// -// IHUnkown Interface Methods Prototypes -// Purpose: Implements the basic COM interface methods for reference -// coutning and querying of related interfaces. -//////////////////////////////////////////////////////////////////// - STDMETHOD (QueryInterface) (THIS_ REFIID id, void** interface_obj); - STDMETHOD_ (ULONG32, AddRef) (THIS); - STDMETHOD_ (ULONG32, Release) (THIS); - - - - - -//////////////////////////////////////////////////////////////////// -// IHXPreference Interface Methods Prototypes -// Purpose: Implements the necessary interface methods that are -// called to read or write from the Helix client registry. -//////////////////////////////////////////////////////////////////// - STDMETHOD(ReadPref) (THIS_ const char* pref_key, IHXBuffer*& buffer); - STDMETHOD(WritePref) (THIS_ const char* pref_key, IHXBuffer* buffer); -private: - // Private Class Variable Declarations - LONG32 _ref_count; - LONG32 _client_index; - char _guid[256]; - - HxAdviseSink* _client_sink; - HxErrorSink* _error_sink; - HxAuthenticationManager* _auth_mgr; - HxSiteSupplier * _site_supplier; - IHXPreferences * _default_prefs; -}; -#endif diff --git a/panda/src/helix/HxErrorSink.cxx b/panda/src/helix/HxErrorSink.cxx deleted file mode 100644 index 4067ffd5e1..0000000000 --- a/panda/src/helix/HxErrorSink.cxx +++ /dev/null @@ -1,226 +0,0 @@ -// Filename: hxErrorSink.cpp -// Created by: jjtaylor (27Jan04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "HxErrorSink.h" -#include "print.h" - -//////////////////////////////////////////////////////////////////// -// Normal Header Files -//////////////////////////////////////////////////////////////////// -#include - -//////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::Constructor -// Access: Public -// Purpose: The default constructor of the class which -// initializes the member variables. -//////////////////////////////////////////////////////////////////// -// Params: IUnknown * - Pointer to an IUnknown COM Interface -// Return: None -//////////////////////////////////////////////////////////////////// -HxErrorSink::HxErrorSink(IUnknown* unknown) - : ref_count(0), - _player(0) -{ - IHXClientEngine* pEngine = 0; - unknown->QueryInterface(IID_IHXClientEngine, (void**)&pEngine ); - if( pEngine != 0 ) - { - IUnknown* pTemp = 0; - pEngine->GetPlayer(0, pTemp); - _player = (IHXPlayer*)pTemp; - } - - HX_RELEASE(pEngine); - HX_ASSERT(_player); -} - -///////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::Destructor -// Access: Private -// Purpose: The default destructor of the class that releases -// the interface member variables from memory. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HxErrorSink::~HxErrorSink() { - HX_RELEASE(_player); -} - - -//////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::QueryInterface -// Access: -// Purpose: Queries this class to determine whether it supports -// supports a specific interface. If the call succeeds -// then the methods of that interface are made -// available for use. -///////////////////////////////////////////////////////////////////// -// Params: _id - Indicates the reference identifier of the -// the interface being queried. -// _interface_obj - Points to an interface pointer that is -// filled in if the query succeeds. -// Return: HX_RESULT - Varies based on wheter the interface is -// supported or not. -//////////////////////////////////////////////////////////////////// -HX_RESULT HxErrorSink::QueryInterface(REFIID _id, void** _interface_obj) { - // Determine if the IUnknown and ErrorSink interfaces - // are supported. - if (IsEqualIID(_id, IID_IUnknown)) { - // Increase the reference count, set the Interface Object, - // and return that the interface is supported within this - // object. - AddRef(); - *_interface_obj = (IUnknown*)(IHXErrorSink*)this; - } - else if (IsEqualIID(_id, IID_IHXErrorSink)) { - // Same as above. - AddRef(); - *_interface_obj = (IHXErrorSink*)this; - } - else { - // This Interface is not supported by this object. Set the - // Interface Object to the NULL-state and return. - *_interface_obj = 0; - return HXR_NOINTERFACE; - } - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::AddRef -// Access: Public -// Purpose: Increases the object's reference count by one. -// Whenever an object is created, it's reference count -// begins at 1. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: ULONG32 - The new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxErrorSink::AddRef() { - return InterlockedIncrement(&ref_count); -} - - - - - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::Release -// Access: Public -// Purpose: Decreases the object's reference count by one. -// Every call to IUnknown::AddRef, -// IUnknown::QueryInterface, or a creation function -// such as HXCreateInstance must have a corresponding -// call to IUnknown::Release. When the reference count -// reaches 0 (zero), the object is destroyed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: ULONG32 - The new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxErrorSink::Release() { - // As long as the reference count is greater than 0, then this - // object is still in "scope." - if (InterlockedDecrement(&ref_count) > 0 ) { - return ref_count; - } - - // Otherwise, this object is no longer necessary and should be - // removed from memory. - delete this; - return 0; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::ErrorOccurred -// Access: Public -// Description: Reports an error, event, or status message -//////////////////////////////////////////////////////////////////// -// Params: severity - Severity or level of the error message. -// hx_code - Specific Error Code -// user_code - User-Specific Error Code -// user_string - Pointer to a user-specific string. -// more_info_url - Pointer to a specific more information -// URL string. -// Return: None -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxErrorSink::ErrorOccurred(const UINT8 severity, const UINT32 hx_code, - const UINT32 user_code, const char* user_string, - const char* more_info_url) { - // Initialize Local Variables to the Method. - char HXDefine[256]; - - // Store the error code that was generated. - convert_to_string(hx_code, HXDefine, 256); - - STDOUT("Report(%d, %ld, \"%s\", %ld, \"%s\", \"%s\")\n", severity, - hx_code, (user_string && *user_string) ? user_string : "(NULL)", - user_code, (more_info_url && *more_info_url) ? more_info_url : "(NULL)", - HXDefine); - - return HXR_OK; -} - - - - - - - - - - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxErrorSink::ConvertErrorToText -// Access: Protected -// Purpose: Converts the Helix error code to text for the -// client to display. -//////////////////////////////////////////////////////////////////// -// Params: hx_code - the error code to be translated to text. -// buffer - Text buffer that holds the code. -// buffer_length - The length of the text buffer. -// Return: None -//////////////////////////////////////////////////////////////////// -void HxErrorSink::convert_to_string(const ULONG32 hx_code, char* buffer, UINT32 buffer_length) { - // Initialize Local Variables to this method. - //IHXErrorMessages * pErrMsg = 0; - - // If the buffer is not empty, then there is nothing to do. - if( !buffer ) { - return; - } - buffer[0] = '\0'; - - if (strlen(buffer) == 0) { - SafeSprintf(buffer, buffer_length, "Can't convert the error code %p", hx_code); - } -} diff --git a/panda/src/helix/HxErrorSink.h b/panda/src/helix/HxErrorSink.h deleted file mode 100644 index dd935d5c4e..0000000000 --- a/panda/src/helix/HxErrorSink.h +++ /dev/null @@ -1,74 +0,0 @@ -// Filename: hxErrorSink.h -// Created by: jjtaylor (29Jan04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// -#if !defined (_HXERRORSINK_H_) -#define _HXERRORSINK_H_ - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "pandabase.h" - -//////////////////////////////////////////////////////////////////// -// Helix Main Header Files -//////////////////////////////////////////////////////////////////// -#include "mainHelix.h" - -//////////////////////////////////////////////////////////////////// -// Prototype/Struct/Class Forward Delcarations -//////////////////////////////////////////////////////////////////// -struct IUnknown; -struct IHXErrorMessages; -struct IHXPlayer; - -//////////////////////////////////////////////////////////////////// -// Class: HxErrorSink -// Purpose: This is a derived class from the IHXErrorSink -// base interface. This class is meant to receive -// error messages from the client engine. -//////////////////////////////////////////////////////////////////// -class HxErrorSink : public IHXErrorSink { -public: - HxErrorSink(IUnknown* unknown); - ~HxErrorSink(); - -//////////////////////////////////////////////////////////////////// -// IHXErrorSink Interface Methods Prototypes -// Purpose: Implements the necessary interface methods that may -// be called when an error message is generated. -//////////////////////////////////////////////////////////////////// - STDMETHOD (ErrorOccurred) (THIS_ const UINT8 severity, const UINT32 hx_code, - const UINT32 user_code, const char* user_string, - const char* more_info_url); - -//////////////////////////////////////////////////////////////////// -// IHUnkown Interface Methods Prototypes -// Purpose: Implements the basic COM interface methods for reference -// coutning and querying of related interfaces. -//////////////////////////////////////////////////////////////////// - STDMETHOD (QueryInterface) (THIS_ REFIID _id, void** _interface_obj); - STDMETHOD_ (ULONG32, AddRef) (THIS); - STDMETHOD_ (ULONG32, Release) (THIS); - - - -protected: - // Protected Class Method Declarations - void convert_to_string(const ULONG32 hx_code, char * buffer, UINT32 buffer_length); - - // Protected Class Variable Declarations - INT32 ref_count; - IHXPlayer* _player; -}; -#endif diff --git a/panda/src/helix/HxSiteSupplier.cxx b/panda/src/helix/HxSiteSupplier.cxx deleted file mode 100644 index 13ad59febf..0000000000 --- a/panda/src/helix/HxSiteSupplier.cxx +++ /dev/null @@ -1,302 +0,0 @@ -// Filename: hxSiteSupplier.cxx -// Created by: jjtaylor (29Jan04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////// -// Helix Main Header Files -//////////////////////////////////////////////////////////////////// -#include "mainHelix.h" - -//////////////////////////////////////////////////////////////////// -// Normal Header Files -//////////////////////////////////////////////////////////////////// -#include - -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::Constructor -// Access: Public -// Purpose: The default constructor of the class which -// initializes the member variables, and queries -// the appropriate Helix Interfaces. -//////////////////////////////////////////////////////////////////// -// Params: IUnknown * - Pointer to an IUnknown COM Interface -// Texture * tex- Pointer to the Panda texture object. -// Return: None -//////////////////////////////////////////////////////////////////// -HxSiteSupplier::HxSiteSupplier(IUnknown* unknown, Texture* tex) - : _ref_count(0), - _site_manager(0), - _ccf(0), - _unknown(unknown), - _dest_buffer(0), - _texture(tex) { - - if(_unknown) { - _unknown->QueryInterface(IID_IHXSiteManager, (void**)&_site_manager); - _unknown->QueryInterface(IID_IHXCommonClassFactory, (void**)&_ccf); - _unknown->AddRef(); - } -} - -///////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier:Destructor -// Access: Private -// Purpose: The default destructor of the class that releases -// the interface member variables from memory. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -HxSiteSupplier::~HxSiteSupplier() { - HX_RELEASE(_site_manager); - HX_RELEASE(_ccf); - HX_RELEASE(_unknown); -} -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::QueryInterface -// Access: -// Purpose: Queries this class to determine whether it supports -// supports a specific interface. If the call succeeds -// then the methods of that interface are made -// available for use. -///////////////////////////////////////////////////////////////////// -// Params: _id - Indicates the reference identifier of the -// the interface being queried. -// _interface_obj - Points to an interface pointer that is -// filled in if the query succeeds. -// Return: HX_RESULT - Varies based on wheter the interface is -// supported or not. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxSiteSupplier::QueryInterface(REFIID _id, void** _interface_obj) { - if (IsEqualIID(_id, IID_IUnknown)) { - AddRef(); - *_interface_obj = (IUnknown*)(IHXSiteSupplier*)this; - return HXR_OK; - } - else if (IsEqualIID(_id, IID_IHXSiteSupplier)) { - AddRef(); - *_interface_obj = (IHXSiteSupplier*)this; - return HXR_OK; - } - *_interface_obj = NULL; - return HXR_NOINTERFACE; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::AddRef -// Access: Public -// Purpose: Increases the object's reference count by one. -// Whenever an object is created, it's reference count -// begins at 1. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: ULONG32 - The new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32) HxSiteSupplier::AddRef() { - return InterlockedIncrement(&_ref_count); -} - -//////////////////////////////////////////////////////////////////// -// Member: HxSite::Release -// Access: Public -// Purpose: Decreases the object's reference count by one. -// Every call to IUnknown::AddRef, -// IUnknown::QueryInterface, or a creation function -// such as HXCreateInstance must have a corresponding -// call to IUnknown::Release. When the reference count -// reaches 0 (zero), the object is destroyed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: ULONG32 - The new reference count. -//////////////////////////////////////////////////////////////////// -STDMETHODIMP_(ULONG32)HxSiteSupplier::Release() { - if (InterlockedDecrement(&_ref_count) > 0) { - return _ref_count; - } - delete this; - return 0; -} - - - - -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::SitesNeeded -// Access: Public -// Purpose: Informs the site supplier that a site with a -// particular set of characteristics is needed. If the -// supplier can fulfill the requestion, it should call -// the site manager and add a new site to it. -//////////////////////////////////////////////////////////////////// -// Params: UINT32 request_id - ID used to map between corresponding -// "sites needed" and "sites not needed" -// calls. -// IHXValues * pProps - The properties of the requested site -// Return: None -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxSiteSupplier::SitesNeeded(UINT32 request_id, IHXValues* pProps) { - // Determine if there are valid properties. If not then a site - // can not properly be created. - if (!pProps) { - return HXR_INVALID_PARAMETER; - } - - // Local Variable Declaration and Intialization - HRESULT hres = HXR_OK; - IHXValues* site_props = NULL; - IHXSiteWindowed* pSiteWindowed = NULL; - IHXBuffer* pValue = NULL; - UINT32 style = 0; - IHXSite* pSite = NULL; - - // Just let the Helix client core create a windowed site for us. - hres = _ccf->CreateInstance(CLSID_IHXSiteWindowed,(void**)&pSiteWindowed); - if (HXR_OK != hres) { - goto exit; - } - - hres = pSiteWindowed->QueryInterface(IID_IHXSite,(void**)&pSite); - if (HXR_OK != hres) { - goto exit; - } - - hres = pSiteWindowed->QueryInterface(IID_IHXValues,(void**)&site_props); - if (HXR_OK != hres) { - goto exit; - } - - // Figures out what type of site must be created. - hres = pProps->GetPropertyCString("playto",pValue); - if (HXR_OK == hres) { - site_props->SetPropertyCString("channel",pValue); - HX_RELEASE(pValue); - } - else { - hres = pProps->GetPropertyCString("name",pValue); - if (HXR_OK == hres) { - site_props->SetPropertyCString("LayoutGroup",pValue); - HX_RELEASE(pValue); - } - } - -#ifdef _WINDOWS - style = WS_OVERLAPPED | WS_VISIBLE | WS_CLIPCHILDREN; -#endif - - pSiteWindowed->SetDstBuffer(_texture->modify_ram_image(), - _texture->get_x_size(), - _texture->get_y_size()); - - // Create the window. Not necessary later on. - hres = pSiteWindowed->Create(NULL, style); - //hres = pSiteWindowed->AttachWindow(NULL); - if (HXR_OK != hres) { - goto exit; - } - - // Add the site to the site manager. - hres = _site_manager->AddSite(pSite); - if (HXR_OK != hres) { - goto exit; - } - - _created_sites.SetAt((void*)request_id,pSite); - //pair site(request_id, pSite); - //_created_sites.insert(site); - - pSite->AddRef(); - - exit: - HX_RELEASE(site_props); - HX_RELEASE(pSiteWindowed); - HX_RELEASE(pSite); - - return hres; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::SitesNotNeeded -// Access: Public -// Purpose: Informs the site supplier that all sites from a -// previous site request are no longer needed. -//////////////////////////////////////////////////////////////////// -// Params: UINT32 request_id - ID used to map between corresponding -// "sites needed" and "sites not needed" -// calls. -// Return: None -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxSiteSupplier::SitesNotNeeded(UINT32 request_id) { - // Local Variable Declaration and Initialization - IHXSite* pSite = NULL; - IHXSiteWindowed* pSiteWindowed = NULL; - void* pVoid = NULL; - - // search for the site id in the map - if (!_created_sites.Lookup((void*)request_id,pVoid)) { - return HXR_INVALID_PARAMETER; - } - //SITES::iterator iter = _created_sites.find(request_id); - //if(iter == _created_sites.end()) { - // return HXR_INVALID_PARAMETER; - //} - pSite = (IHXSite*)pVoid; - - // Remove the site from the site manager. - _site_manager->RemoveSite(pSite); - - // Need to actually do the work on destroying the window - // and all that jazz. - pSite->QueryInterface(IID_IHXSiteWindowed,(void**)&pSiteWindowed); - - pSiteWindowed->Destroy(); - - // ref count = 2 - pSiteWindowed->Release(); - - // ref count = 1; deleted from this object's view! - pSite->Release(); - - // Remove the site from the map. - _created_sites.RemoveKey((void*)request_id); - //_created_sites.erase(request_id); - - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::BeginChangeLayout -// Access: Public -// Purpose: Informs the site supplier that a layout change -// has begun and that it can expect to receive calls -// to the SitesNeeded and SitesNotNeeded method. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxSiteSupplier::BeginChangeLayout() { - return HXR_OK; -} - -//////////////////////////////////////////////////////////////////// -// Member: HxSiteSupplier::DoneChangeLayout -// Access: Public -// Purpose: Informs the site supplier that the layout changes -// are completed. -//////////////////////////////////////////////////////////////////// -// Params: None -// Return: None -//////////////////////////////////////////////////////////////////// -STDMETHODIMP HxSiteSupplier::DoneChangeLayout() { - return HXR_OK; -} diff --git a/panda/src/helix/HxSiteSupplier.h b/panda/src/helix/HxSiteSupplier.h deleted file mode 100644 index fb042cdedc..0000000000 --- a/panda/src/helix/HxSiteSupplier.h +++ /dev/null @@ -1,64 +0,0 @@ -// Filename: HxSiteSupplier.h -// Created by: jjtaylor (29Jan04) -// -//////////////////////////////////////////////////////////////////// -// -// -// PANDA 3D SOFTWARE -// Copyright (c) Carnegie Mellon University. All rights reserved. -// -// All use of this software is subject to the terms of the revised BSD -// license. You should have received a copy of this license along -// with this source code in a file named "LICENSE." -// -//////////////////////////////////////////////////////////////////// -#ifndef HXSITESUPPLIER_H -#define HXSITESUPPLIER_H - -//////////////////////////////////////////////////////////////////// -// Panda Header Files -//////////////////////////////////////////////////////////////////// -#include "pandabase.h" -#include "pmap.h" -#include "texture.h" -#include "fivemmap.h" - -//////////////////////////////////////////////////////////////////// -// Class: HxSiteSupplier -// Purpose: This is a derived class from the IHXSiteSupplier -// base interface. This class is meant to create or -// remove Helix Sites. -//////////////////////////////////////////////////////////////////// -class HxSiteSupplier : public IHXSiteSupplier { -public: - HxSiteSupplier(IUnknown* unknown, Texture* tex); - ~HxSiteSupplier(); - -//////////////////////////////////////////////////////////////////// -// IHUnkown Interface Methods Prototypes -// Purpose: Implements the basic COM interface methods for reference -// coutning and querying of related interfaces. -//////////////////////////////////////////////////////////////////// - STDMETHOD(QueryInterface) (THIS_ REFIID id, void** interface_obj); - STDMETHOD_(ULONG32,AddRef) (THIS); - STDMETHOD_(ULONG32,Release) (THIS); - -//////////////////////////////////////////////////////////////////// -// IHXClientAdviseSink Interface Methods Prototypes -// Purpose: Implements the necessary interface methods that may -// be called when a site must be created or closed. -//////////////////////////////////////////////////////////////////// - STDMETHOD(SitesNeeded) (THIS_ UINT32 request_id, IHXValues* site_props); - STDMETHOD(SitesNotNeeded) (THIS_ UINT32 request_id); - STDMETHOD(BeginChangeLayout) (THIS); - STDMETHOD(DoneChangeLayout) (THIS); -private: - LONG32 _ref_count; - IHXSiteManager* _site_manager; - IHXCommonClassFactory* _ccf; - IUnknown* _unknown; - FiveMinuteMap _created_sites; - UCHAR* _dest_buffer; - Texture* _texture; -}; -#endif diff --git a/panda/src/helix/MainHelix.h b/panda/src/helix/MainHelix.h deleted file mode 100644 index 7dd165dcea..0000000000 --- a/panda/src/helix/MainHelix.h +++ /dev/null @@ -1,74 +0,0 @@ -#if !defined (_MAINHELIX_H_) -#define _MAINHELIX_H_ - -// This file basically just contains all of the header -// files that I will need to invoke the client core -// and start an engine. -#include "pandabase.h" -#include "helixDefs.h" - -#include - -#include - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -//#include "fivemmap.h" -#include -#include -#include - -#include -#include -#include -#include -#include -#include "print.h" - -typedef HX_RESULT (HXEXPORT_PTR FPRMSETDLLACCESSPATH) (const char*); - -#endif -/* - -#include "hxtypes.h> - -#include - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -//#include "fivemmap.h" -#include -#include -#include */ diff --git a/panda/src/helix/Sources.pp b/panda/src/helix/Sources.pp deleted file mode 100644 index d86428efa1..0000000000 --- a/panda/src/helix/Sources.pp +++ /dev/null @@ -1,28 +0,0 @@ -#define BUILD_DIRECTORY $[HAVE_HELIX] - -#define OTHER_LIBS interrogatedb:c dconfig:c dtoolconfig:m \ - dtoolutil:c dtoolbase:c dtool:m - -#begin lib_target - #define TARGET helix - #define LOCAL_LIBS \ - dgraph - #define WIN_SYS_LIBS $[WIN_SYS_LIBS] user32.lib advapi32.lib winmm.lib - #define USE_PACKAGES helix - - #define SOURCES \ - config_helix.cxx config_helix.h fivemmap.cxx fivemmap.h \ - HelixClient.cxx HelixClient.h HxAdviseSink.cxx HxAdviseSink.h \ - HxAuthenticationManager.cxx HxAuthenticationManager.h \ - HxClientContext.cxx HxClientContext.h HxErrorSink.cxx HxErrorSink.h \ - HxSiteSupplier.cxx HxSiteSupplier.h iids.cxx MainHelix.h print.cxx print.h - - - #define INSTALL_HEADERS \ - config_helix.h \ - HelixClient.h - - #define IGATESCAN \ - HelixClient.cxx - -#end lib_target diff --git a/panda/src/helix/config_helix.cxx b/panda/src/helix/config_helix.cxx deleted file mode 100644 index 9511d2c801..0000000000 --- a/panda/src/helix/config_helix.cxx +++ /dev/null @@ -1,5 +0,0 @@ -// Filename: config_helix.h -// Created by: jjtaylor (27Feb04) -// -//////////////////////////////////////////////////////////////////// -// diff --git a/panda/src/helix/config_helix.h b/panda/src/helix/config_helix.h deleted file mode 100644 index 9511d2c801..0000000000 --- a/panda/src/helix/config_helix.h +++ /dev/null @@ -1,5 +0,0 @@ -// Filename: config_helix.h -// Created by: jjtaylor (27Feb04) -// -//////////////////////////////////////////////////////////////////// -// diff --git a/panda/src/helix/fivemmap.cxx b/panda/src/helix/fivemmap.cxx deleted file mode 100644 index b7639b0a96..0000000000 --- a/panda/src/helix/fivemmap.cxx +++ /dev/null @@ -1,175 +0,0 @@ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: RCSL 1.0/RPSL 1.0 - * - * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. - * - * The contents of this file, and the files included with this file, are - * subject to the current version of the RealNetworks Public Source License - * Version 1.0 (the "RPSL") available at - * http://www.helixcommunity.org/content/rpsl unless you have licensed - * the file under the RealNetworks Community Source License Version 1.0 - * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, - * in which case the RCSL will apply. You may also obtain the license terms - * directly from RealNetworks. You may not use this file except in - * compliance with the RPSL or, if you have a valid RCSL with RealNetworks - * applicable to this file, the RCSL. Please see the applicable RPSL or - * RCSL for the rights, obligations and limitations governing use of the - * contents of the file. - * - * This file is part of the Helix DNA Technology. RealNetworks is the - * developer of the Original Code and owns the copyrights in the portions - * it created. - * - * This file, and the files included with this file, is distributed and made - * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, - * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. - * - * Technology Compatibility Kit Test Suite(s) Location: - * http://www.helixcommunity.org/content/tck - * - * Contributor(s): - * - * ***** END LICENSE BLOCK ***** */ - -#include -//#include "hxtypes.h" -#include "fivemmap.h" - -void* FiveMinuteMap::GetFirstValue() -{ - m_nCursor = 0; - - if (m_nMapSize) - { - return ValueArray[m_nCursor]; - } - else - { - return NULL; - } -} - -void* FiveMinuteMap::GetNextValue() -{ - m_nCursor++; - - if (m_nCursor < m_nMapSize) - { - return ValueArray[m_nCursor]; - } - else - { - return NULL; - } -} - -BOOL FiveMinuteMap::Lookup(void* Key, void*& Value) const -{ - BOOL bFound = FALSE; - int nIndex = 0; - - // If Key is alrady in the list, replace value - for (; nIndex < m_nMapSize; nIndex++) - { - if (KeyArray[nIndex] == Key) - { - Value = ValueArray[nIndex]; - bFound = TRUE; - goto exit; - } - } - -exit: - return bFound; -} - -void FiveMinuteMap::RemoveKey(void* Key) -{ - BOOL bFound = FALSE; - int nIndex = 0; - - // If Key is alrady in the list, replace value - for (; nIndex < m_nMapSize; nIndex++) - { - if (KeyArray[nIndex] == Key) - { - if (nIndex < (m_nMapSize-1)) - { - memmove(&(KeyArray[nIndex]),&(KeyArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); - memmove(&(ValueArray[nIndex]),&(ValueArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); - } - m_nMapSize--; - goto exit; - } - } - -exit: - (NULL); // We're done! -} - -void FiveMinuteMap::RemoveValue(void* Value) -{ - BOOL bFound = FALSE; - int nIndex = 0; - - // If Value is alrady in the list, replace value - for (; nIndex < m_nMapSize; nIndex++) - { - if (ValueArray[nIndex] == Value) - { - if (nIndex < (m_nMapSize-1)) - { - memmove(&(KeyArray[nIndex]),&(KeyArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); - memmove(&(ValueArray[nIndex]),&(ValueArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1))); - } - m_nMapSize--; - goto exit; - } - } - -exit: - (NULL); // We're done! -} - - -void FiveMinuteMap::SetAt(void* Key, void* Value) -{ - int nIndex = 0; - - // If Key is alrady in the list, replace value - for (; nIndex < m_nMapSize; nIndex++) - { - if (KeyArray[nIndex] == Key) - { - ValueArray[nIndex] = Value; - goto exit; - } - } - - // If we have room, add it to the end! - if (m_nAllocSize == m_nMapSize) - { - m_nAllocSize += AllocationSize; - void** pNewKeys = new void*[m_nAllocSize]; - void** pNewValues = new void*[m_nAllocSize]; - - memcpy(pNewKeys,KeyArray,sizeof(void*)*m_nMapSize); /* Flawfinder: ignore */ - memcpy(pNewValues,ValueArray,sizeof(void*)*m_nMapSize); /* Flawfinder: ignore */ - - delete [] KeyArray; - delete [] ValueArray; - - KeyArray = pNewKeys; - ValueArray = pNewValues; - } - - KeyArray[m_nMapSize] = Key; - ValueArray[m_nMapSize] = Value; - m_nMapSize++; - -exit: - (NULL); // We're done! -} - diff --git a/panda/src/helix/fivemmap.h b/panda/src/helix/fivemmap.h deleted file mode 100644 index ad737dcb67..0000000000 --- a/panda/src/helix/fivemmap.h +++ /dev/null @@ -1,83 +0,0 @@ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: RCSL 1.0/RPSL 1.0 - * - * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. - * - * The contents of this file, and the files included with this file, are - * subject to the current version of the RealNetworks Public Source License - * Version 1.0 (the "RPSL") available at - * http://www.helixcommunity.org/content/rpsl unless you have licensed - * the file under the RealNetworks Community Source License Version 1.0 - * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, - * in which case the RCSL will apply. You may also obtain the license terms - * directly from RealNetworks. You may not use this file except in - * compliance with the RPSL or, if you have a valid RCSL with RealNetworks - * applicable to this file, the RCSL. Please see the applicable RPSL or - * RCSL for the rights, obligations and limitations governing use of the - * contents of the file. - * - * This file is part of the Helix DNA Technology. RealNetworks is the - * developer of the Original Code and owns the copyrights in the portions - * it created. - * - * This file, and the files included with this file, is distributed and made - * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, - * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. - * - * Technology Compatibility Kit Test Suite(s) Location: - * http://www.helixcommunity.org/content/tck - * - * Contributor(s): - * - * ***** END LICENSE BLOCK ***** */ - -#ifndef _FIVEMMAP_H_ -#define _FIVEMMAP_H_ - -#include "pandabase.h" -#include "helixDefs.h" - -#include - -#ifndef _HXTYPES_H_ -#error FiveMinuteMap assumes pntypes.h. -#endif - -class FiveMinuteMap { - const int AllocationSize; - - void** KeyArray; - void** ValueArray; - int m_nMapSize; - int m_nAllocSize; - int m_nCursor; -public: - FiveMinuteMap() - : KeyArray(NULL) - , ValueArray(NULL) - , m_nMapSize(0) - , m_nAllocSize(0) - , m_nCursor(0) - , AllocationSize(10) - {}; - - ~FiveMinuteMap() - { - delete [] KeyArray; - delete [] ValueArray; - }; - - int GetCount() {return m_nMapSize;} - - void* GetFirstValue(); - void* GetNextValue(); - - BOOL Lookup(void* Key, void*& Value) const; - void RemoveKey(void* Key); - void RemoveValue(void* Value); - void SetAt(void* Key, void* Value); -}; - -#endif /* _FIVEMMAP_H_ */ diff --git a/panda/src/helix/iids.cxx b/panda/src/helix/iids.cxx deleted file mode 100644 index 36740b81a2..0000000000 --- a/panda/src/helix/iids.cxx +++ /dev/null @@ -1,52 +0,0 @@ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: RCSL 1.0/RPSL 1.0 - * - * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. - * - * The contents of this file, and the files included with this file, are - * subject to the current version of the RealNetworks Public Source License - * Version 1.0 (the "RPSL") available at - * http://www.helixcommunity.org/content/rpsl unless you have licensed - * the file under the RealNetworks Community Source License Version 1.0 - * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, - * in which case the RCSL will apply. You may also obtain the license terms - * directly from RealNetworks. You may not use this file except in - * compliance with the RPSL or, if you have a valid RCSL with RealNetworks - * applicable to this file, the RCSL. Please see the applicable RPSL or - * RCSL for the rights, obligations and limitations governing use of the - * contents of the file. - * - * This file is part of the Helix DNA Technology. RealNetworks is the - * developer of the Original Code and owns the copyrights in the portions - * it created. - * - * This file, and the files included with this file, is distributed and made - * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, - * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. - * - * Technology Compatibility Kit Test Suite(s) Location: - * http://www.helixcommunity.org/content/tck - * - * Contributor(s): - * - * ***** END LICENSE BLOCK ***** */ - -// define all guids here once... -#define INITGUID -#define NCIHACK -#include "pandabase.h" -#include "helixDefs.h" -#include "hxtypes.h" -#include "hxcom.h" -#include "hxiids.h" -#include "hxpiids.h" -#if defined _WINDOWS -#if defined (HELIX_FEATURE_DIRECT_SOUND) -#include "dsound.h" -#endif /* HELIX_FEATURE_DIRECT_SOUND */ -#if defined (HELIX_FEATURE_VIDEO) && !defined(_WINCE) -#include "ddraw.h" -#endif /* HELIX_FEATURE_VIDEO */ -#endif diff --git a/panda/src/helix/main.cpp b/panda/src/helix/main.cpp deleted file mode 100644 index f0168687a9..0000000000 --- a/panda/src/helix/main.cpp +++ /dev/null @@ -1,46 +0,0 @@ -#include "dllpath.h" - -#include "HelixClient.h" - - -// typedef for SetDLLAccessPath - -#if defined _DEBUG || defined DEBUG -#include "debug.h" -#endif - -#if defined(HELIX_CONFIG_NOSTATICS) -# include "globals/hxglobals.h" -#endif - -DLLAccessPath statClnt; -DLLAccessPath* GetDLLAccessPath() -{ - return &statClnt; -} - -int main( int argc, char *argv[] ) -{ - setvbuf(stdout, NULL, _IONBF, 0); - HelixClient* myClient = new HelixClient(); - STDOUT("%s", argv[1]); - myClient->create_player("myPlayer", true); - - //myClient->open_url("myPlayer", argv[1]); - myClient->open_url("myPlayer", "rage.mp3"); - - bool done = true; - myClient->begin("myPlayer"); - while (done != myClient->is_done("myPlayer")) { - //Do Nothing for now - MSG msg; - - GetMessage(&msg, NULL, 0, 0); - DispatchMessage(&msg); - } - - delete myClient; - myClient = 0; - - return 0; -} diff --git a/panda/src/helix/print.cxx b/panda/src/helix/print.cxx deleted file mode 100644 index d17bc1b12f..0000000000 --- a/panda/src/helix/print.cxx +++ /dev/null @@ -1,80 +0,0 @@ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: RCSL 1.0/RPSL 1.0 - * - * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. - * - * The contents of this file, and the files included with this file, are - * subject to the current version of the RealNetworks Public Source License - * Version 1.0 (the "RPSL") available at - * http://www.helixcommunity.org/content/rpsl unless you have licensed - * the file under the RealNetworks Community Source License Version 1.0 - * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, - * in which case the RCSL will apply. You may also obtain the license terms - * directly from RealNetworks. You may not use this file except in - * compliance with the RPSL or, if you have a valid RCSL with RealNetworks - * applicable to this file, the RCSL. Please see the applicable RPSL or - * RCSL for the rights, obligations and limitations governing use of the - * contents of the file. - * - * This file is part of the Helix DNA Technology. RealNetworks is the - * developer of the Original Code and owns the copyrights in the portions - * it created. - * - * This file, and the files included with this file, is distributed and made - * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, - * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. - * - * Technology Compatibility Kit Test Suite(s) Location: - * http://www.helixcommunity.org/content/tck - * - * Contributor(s): - * - * ***** END LICENSE BLOCK ***** */ - -#include -#include -#include "print.h" -#ifdef WIN32_PLATFORM_PSPC -#include "hlxosstr.h" -#include -#endif - -int print2stdout(const char* pFmt, ...) -{ - va_list args; - - va_start(args, pFmt); - -#ifdef WIN32_PLATFORM_PSPC - char Message[512]; - int ret = vsprintf(Message, pFmt, args); - OutputDebugString(OS_STRING(Message)); -#else - int ret = vfprintf(stdout, pFmt, args); -#endif - - va_end(args); - - return ret; -} - -int print2stderr(const char* pFmt, ...) -{ - va_list args; - - va_start(args, pFmt); - -#ifdef WIN32_PLATFORM_PSPC - char Message[512]; - int ret = vsprintf(Message, pFmt, args); - OutputDebugString(OS_STRING(Message)); -#else - int ret = vfprintf(stderr, pFmt, args); -#endif - - va_end(args); - - return ret; -} diff --git a/panda/src/helix/print.h b/panda/src/helix/print.h deleted file mode 100644 index d6fc13526d..0000000000 --- a/panda/src/helix/print.h +++ /dev/null @@ -1,62 +0,0 @@ -/* ***** BEGIN LICENSE BLOCK ***** - * Version: RCSL 1.0/RPSL 1.0 - * - * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. - * - * The contents of this file, and the files included with this file, are - * subject to the current version of the RealNetworks Public Source License - * Version 1.0 (the "RPSL") available at - * http://www.helixcommunity.org/content/rpsl unless you have licensed - * the file under the RealNetworks Community Source License Version 1.0 - * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, - * in which case the RCSL will apply. You may also obtain the license terms - * directly from RealNetworks. You may not use this file except in - * compliance with the RPSL or, if you have a valid RCSL with RealNetworks - * applicable to this file, the RCSL. Please see the applicable RPSL or - * RCSL for the rights, obligations and limitations governing use of the - * contents of the file. - * - * This file is part of the Helix DNA Technology. RealNetworks is the - * developer of the Original Code and owns the copyrights in the portions - * it created. - * - * This file, and the files included with this file, is distributed and made - * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER - * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, - * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS - * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. - * - * Technology Compatibility Kit Test Suite(s) Location: - * http://www.helixcommunity.org/content/tck - * - * Contributor(s): - * - * ***** END LICENSE BLOCK ***** */ - -#ifndef PRINT_H -#define PRINT_H - -#include "pandabase.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef _SYMBIAN -#include "platform/symbian/symbian_print.h" - -#define STDOUT symbianPrint -#define STDERR symbianPrint -#else -int print2stdout(const char* pFmt, ...); -int print2stderr(const char* pFmt, ...); -#define STDOUT print2stdout -#define STDERR print2stderr -#endif - -#ifdef __cplusplus -}; -#endif - - -#endif /* PRINT_H */