/********************************************************************************************
* AutoMimic
* purpose : Automatically open a channel for an incoming channel
* input : InChan - The incoming channel to mimic
* output : none
* return : none
********************************************************************************************/
void AutoMimic(ChannelInfo* InChan)
{
CallInfo * CurrentCall;
char * isAutoMimic;
int isDuplex;
char DataType[20];
/* Check if auto-mimic option is set or not */
isAutoMimic = TclGetVariable("app(options,autoMimic)");
if ((isAutoMimic == NULL) || (atoi(isAutoMimic) != 1)) return;
/* We only mimic unidirectional channels */
isDuplex = cmChannelIsDuplex(InChan->hChan);
if (isDuplex) return;
/* Check this channel's information and mimic them */
CurrentCall = InChan->call;
strncpy(DataType, InChan->dataType, sizeof(DataType));
/* Open the channel */
OpenChannel(CurrentCall,
DataType,
InChan,
NULL);
}
/********************************************************************************************
* Channel_ConnectOutgoing
* purpose : Connect a new outgoing channel
* This function is called from the TCL when the "Ok" button is pressed in the
* "New Channel" window.
* input : clientData - used for creating new command in tcl
* interp - interpreter for tcl commands
* argc - number of parameters entered to the new command
* argv - the parameters entered to the tcl command
* output : none
* return : TCL_OK - the command was invoked successfully.
********************************************************************************************/
int Channel_ConnectOutgoing(ClientData clientData, Tcl_Interp *interp,int argc, char *argv[])
{
char * dataType;
int status;
CallInfo * CurrentCall;
ChannelInfo * MimicChan = NULL;
ChannelInfo * ReplaceChan = NULL;
/* Make sure we've got a call related to the channel */
if ((argv[1] == NULL) || (strlen(argv[1]) == 0)) return TCL_OK;
if (sscanf(argv[1], "%*d 0x%p:", &CurrentCall) != 1) return TCL_OK;
/* set the dataType */
dataType = TclGetVariable("tmp(newchan,dataType)");
/* see if replace or mimic operation is called for */
if(argv[2][0])
{/* argv[2] is not "" */
if(argv[2][0] == 'S') /* "SameAs" -> mimic chan */
sscanf(argv[3], "%*d 0x%p", &MimicChan);
else if(argv[2][0] == 'R') /* "Replace" -> replace chan */
sscanf(argv[3], "%*d 0x%p", &ReplaceChan);
else return TCL_ERROR; /* something not right with the command */
}
status = OpenChannel(CurrentCall, dataType, MimicChan, ReplaceChan);
if((argv[2][0] == 'R') && (status >= 0))
/* The app is reponsible for opening the channle, so here it is: */
TclExecute("after 3000 {Channel.Drop \"\" {%s} 3}", argv[3]);
return status;
}
nsresult
ChannelMediaResource::CacheClientSeek(int64_t aOffset, bool aResume)
{
NS_ASSERTION(NS_IsMainThread(), "Don't call on non-main thread");
CMLOG("CacheClientSeek requested for aOffset [%lld] for decoder [%p]",
aOffset, mDecoder);
CloseChannel();
if (aResume) {
NS_ASSERTION(mSuspendCount > 0, "Too many resumes!");
// No need to mess with the channel, since we're making a new one
--mSuspendCount;
}
mOffset = aOffset;
if (mSuspendCount > 0) {
// Close the existing channel to force the channel to be recreated at
// the correct offset upon resume.
if (mChannel) {
mIgnoreClose = true;
CloseChannel();
}
return NS_OK;
}
nsresult rv = RecreateChannel();
if (NS_FAILED(rv))
return rv;
return OpenChannel(nullptr);
}
void RakVoice::OnOpenChannelRequest(Packet *packet)
{
if (voiceChannels.HasData(packet->guid))
return;
// If the system is not initialized, just return
if (bufferedOutput==0)
return;
OpenChannel(packet);
RakNet::BitStream out;
out.Write((unsigned char)ID_RAKVOICE_OPEN_CHANNEL_REPLY);
out.Write((int32_t)sampleRate);
SendUnified(&out, HIGH_PRIORITY, RELIABLE_ORDERED,0,packet->systemAddress,false);
}
std::list<MessageBoxCF *>::iterator ChannelHandler::FindChannelIteratorByName(string Name)
{
if(ChannelList->begin() != ChannelList->end())
{
for (std::list<MessageBoxCF *>::iterator tempIter = ChannelList->begin(); tempIter != ChannelList->end(); tempIter++)
{
//Name exactly the same?
if(!(*tempIter)->GetName().compare(Name))
{
//found it, exit the loop!
return tempIter;
}
}
}
//couldn't find Channel? Create it.
OpenChannel(Name);
return ChannelList->begin();
}
void RakVoice::SetLoopbackMode(bool enabled)
{
if (enabled)
{
Packet p;
RakNet::BitStream out;
out.Write((unsigned char)ID_RAKVOICE_OPEN_CHANNEL_REQUEST);
out.Write((int32_t)sampleRate);
p.data=out.GetData();
p.systemAddress=UNASSIGNED_SYSTEM_ADDRESS;
p.guid=UNASSIGNED_RAKNET_GUID;
p.length=out.GetNumberOfBytesUsed();
OpenChannel(&p);
}
else
{
FreeChannelMemory(UNASSIGNED_RAKNET_GUID);
}
loopbackMode=enabled;
}
void* RPCFile::ReadWholeChannel(unsigned int index) const
{
ChannelReader* reader = OpenChannel(index, false);
if(!reader)
return NULL;
uint64_t dataSize = reader->GetDataSize();
void* data = malloc((size_t)dataSize);
if(data)
{
if(!reader->ReadData(data, dataSize))
{
free(data);
data = NULL;
}
}
delete reader;
return data;
}
void createReceiveChannel() {
fprintf(stderr,"OpenChannel %d buffer_size=%d fft_size=%d sample_rate=%d dspRate=%d outputRate=%d\n",
CHANNEL_RX,
buffer_size,
fft_size,
sample_rate,
dspRate,
outputRate);
OpenChannel(CHANNEL_RX,
buffer_size,
fft_size,
sample_rate,
dspRate,
outputRate,
0, // receive
0, // run
0.010, 0.025, 0.0, 0.010, 0);
}
nsresult ChannelMediaResource::Open(nsIStreamListener **aStreamListener)
{
NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
if (!mChannelStatistics) {
mChannelStatistics = new MediaChannelStatistics();
}
nsresult rv = mCacheStream.Init();
if (NS_FAILED(rv))
return rv;
NS_ASSERTION(mOffset == 0, "Who set mOffset already?");
if (!mChannel) {
// When we're a clone, the decoder might ask us to Open even though
// we haven't established an mChannel (because we might not need one)
NS_ASSERTION(!aStreamListener,
"Should have already been given a channel if we're to return a stream listener");
return NS_OK;
}
return OpenChannel(aStreamListener);
}
nsresult
nsUrlClassifierHashCompleterRequest::Begin()
{
LOG(("nsUrlClassifierHashCompleterRequest::Begin [%p]", this));
if (PR_IntervalNow() < mCompleter->GetNextRequestTime()) {
NS_WARNING("Gethash server backed off, failing gethash request.");
NotifyFailure(NS_ERROR_ABORT);
return NS_ERROR_ABORT;
}
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
if (observerService)
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
nsresult rv = OpenChannel();
if (NS_FAILED(rv)) {
NotifyFailure(rv);
return rv;
}
return NS_OK;
}
void RakVoice::OnOpenChannelReply(Packet *packet)
{
if (voiceChannels.HasData(packet->guid))
return;
OpenChannel(packet);
}
void FASTDataset::TryEuromap_IRS_1C_1D_ChannelNameConvention()
{
// Filename convention explained in:
// http://www.euromap.de/download/em_names.pdf
char chLastLetterHeader = pszFilename[strlen(pszFilename)-1];
if( EQUAL(GetMetadataItem("SENSOR"), "PAN") )
{
/* Converting upper-case to lower case */
if( chLastLetterHeader >= 'A' && chLastLetterHeader <= 'M' )
chLastLetterHeader += 'a' - 'A';
if( chLastLetterHeader >= 'a' && chLastLetterHeader <= 'j' )
{
const char chLastLetterData = chLastLetterHeader - 'a' + '0';
char* pszChannelFilename = CPLStrdup(pszFilename);
pszChannelFilename[strlen(pszChannelFilename)-1] = chLastLetterData;
if( OpenChannel( pszChannelFilename, 0 ) )
nBands++;
else
CPLDebug("FAST", "Could not find %s", pszChannelFilename);
CPLFree(pszChannelFilename);
}
else if( chLastLetterHeader >= 'k' && chLastLetterHeader <= 'm' )
{
const char chLastLetterData = chLastLetterHeader - 'k' + 'n';
char* pszChannelFilename = CPLStrdup(pszFilename);
pszChannelFilename[strlen(pszChannelFilename)-1] = chLastLetterData;
if( OpenChannel( pszChannelFilename, 0 ) )
{
nBands++;
}
else
{
/* Trying upper-case */
pszChannelFilename[strlen(pszChannelFilename)-1] =
chLastLetterData - 'a' + 'A';
if( OpenChannel( pszChannelFilename, 0 ) )
nBands++;
else
CPLDebug("FAST", "Could not find %s", pszChannelFilename);
}
CPLFree(pszChannelFilename);
}
else
{
CPLDebug(
"FAST",
"Unknown last letter (%c) for a IRS PAN Euromap FAST dataset",
chLastLetterHeader );
}
}
else if( EQUAL(GetMetadataItem("SENSOR"), "LISS3") )
{
const char apchLISSFilenames[7][5] = {
{ '0', '2', '3', '4', '5' },
{ '6', '7', '8', '9', 'a' },
{ 'b', 'c', 'd', 'e', 'f' },
{ 'g', 'h', 'i', 'j', 'k' },
{ 'l', 'm', 'n', 'o', 'p' },
{ 'q', 'r', 's', 't', 'u' },
{ 'v', 'w', 'x', 'y', 'z' } };
int i = 0;
for ( ; i < 7 ; i++ )
{
if( chLastLetterHeader == apchLISSFilenames[i][0] ||
(apchLISSFilenames[i][0] >= 'a' &&
apchLISSFilenames[i][0] <= 'z' &&
(apchLISSFilenames[i][0] - chLastLetterHeader == 0 ||
apchLISSFilenames[i][0] - chLastLetterHeader == 32)) )
{
for ( int j = 0; j < 4; j ++ )
{
char* pszChannelFilename = CPLStrdup(pszFilename);
pszChannelFilename[strlen(pszChannelFilename)-1] =
apchLISSFilenames[i][j+1];
if( OpenChannel( pszChannelFilename, nBands ) )
nBands++;
else if( apchLISSFilenames[i][j+1] >= 'a' &&
apchLISSFilenames[i][j+1] <= 'z' )
{
/* Trying upper-case */
pszChannelFilename[strlen(pszChannelFilename)-1] =
apchLISSFilenames[i][j+1] - 'a' + 'A';
if( OpenChannel( pszChannelFilename, nBands ) )
{
nBands++;
}
else
{
CPLDebug(
"FAST", "Could not find %s",
pszChannelFilename );
}
}
else
{
CPLDebug(
"FAST", "Could not find %s", pszChannelFilename );
}
CPLFree(pszChannelFilename);
}
break;
}
}
if( i == 7 )
{
CPLDebug(
"FAST",
"Unknown last letter (%c) for a IRS LISS3 Euromap FAST dataset",
chLastLetterHeader );
}
}
else if( EQUAL(GetMetadataItem("SENSOR"), "WIFS") )
{
if( chLastLetterHeader == '0' )
{
for( int j = 0; j < 2; j++ )
{
char* pszChannelFilename = CPLStrdup(pszFilename);
pszChannelFilename[strlen(pszChannelFilename)-1]
= static_cast<char>( '1' + j );
if (OpenChannel( pszChannelFilename, nBands ))
{
nBands++;
}
else
{
CPLDebug( "FAST", "Could not find %s", pszChannelFilename );
}
CPLFree(pszChannelFilename);
}
}
else
{
CPLDebug(
"FAST",
"Unknown last letter (%c) for a IRS WIFS Euromap FAST dataset",
chLastLetterHeader );
}
}
else
{
CPLAssert(false);
}
}
VSILFILE *FASTDataset::FOpenChannel( const char *pszBandname,
int iBand, int iFASTBand )
{
const char *pszChannelFilename = NULL;
char *pszPrefix = CPLStrdup( CPLGetBasename( pszFilename ) );
char *pszSuffix = CPLStrdup( CPLGetExtension( pszFilename ) );
fpChannels[iBand] = NULL;
switch ( iSatellite )
{
case LANDSAT:
if ( pszBandname && !EQUAL( pszBandname, "" ) )
{
pszChannelFilename =
CPLFormCIFilename( pszDirname, pszBandname, NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename =
CPLFormFilename( pszDirname,
CPLSPrintf( "%s.b%02d", pszPrefix, iFASTBand ),
NULL );
CPL_IGNORE_RET_VAL(OpenChannel( pszChannelFilename, iBand ));
}
break;
case IRS:
default:
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "%s.%d", pszPrefix, iFASTBand ), pszSuffix );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "IMAGERY%d", iFASTBand ), pszSuffix );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "imagery%d", iFASTBand ), pszSuffix );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "IMAGERY%d.DAT", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "imagery%d.dat", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "IMAGERY%d.dat", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "imagery%d.DAT", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "BAND%d", iFASTBand ), pszSuffix );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "band%d", iFASTBand ), pszSuffix );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "BAND%d.DAT", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "band%d.dat", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "BAND%d.dat", iFASTBand ), NULL );
if ( OpenChannel( pszChannelFilename, iBand ) )
break;
pszChannelFilename = CPLFormFilename( pszDirname,
CPLSPrintf( "band%d.DAT", iFASTBand ), NULL );
CPL_IGNORE_RET_VAL(OpenChannel( pszChannelFilename, iBand ));
break;
}
CPLDebug( "FAST", "Band %d filename=%s",
iBand + 1, pszChannelFilename ? pszChannelFilename : "(null)" );
CPLFree( pszPrefix );
CPLFree( pszSuffix );
return fpChannels[iBand];
}
void wdsp_init(int rx,int pixels,int protocol) {
int rc;
receiver=rx;
spectrumWIDTH=pixels;
fprintf(stderr,"wdsp_init: %d\n",rx);
if(protocol==ORIGINAL_PROTOCOL) {
micOutputRate=48000;
} else {
micOutputRate=192000;
}
while (gtk_events_pending ())
gtk_main_iteration ();
fprintf(stderr,"OpenChannel %d buffer_size=%d fft_size=%d sample_rate=%d dspRate=%d outputRate=%d\n",
rx,
buffer_size,
fft_size,
sample_rate,
dspRate,
outputRate);
OpenChannel(rx,
buffer_size,
fft_size,
sample_rate,
dspRate,
outputRate,
0, // receive
1, // run
0.010, 0.025, 0.0, 0.010, 0);
while (gtk_events_pending ())
gtk_main_iteration ();
switch(sample_rate) {
case 48000:
tx_buffer_size=BUFFER_SIZE;
break;
case 96000:
tx_buffer_size=BUFFER_SIZE/2;
break;
case 192000:
tx_buffer_size=BUFFER_SIZE/4;
break;
case 384000:
tx_buffer_size=BUFFER_SIZE/8;
break;
}
fprintf(stderr,"OpenChannel %d buffer_size=%d fft_size=%d sample_rate=%d dspRate=%d outputRate=%d\n",
CHANNEL_TX,
tx_buffer_size,
fft_size,
sample_rate, //micSampleRate,
micDspRate,
micOutputRate);
OpenChannel(CHANNEL_TX,
buffer_size,
fft_size,
sample_rate, //micSampleRate,
micDspRate,
micOutputRate,
1, // transmit
1, // run
0.010, 0.025, 0.0, 0.010, 0);
while (gtk_events_pending ())
gtk_main_iteration ();
fprintf(stderr,"XCreateAnalyzer %d\n",rx);
int success;
XCreateAnalyzer(rx, &success, 262144, 1, 1, "");
if (success != 0) {
fprintf(stderr, "XCreateAnalyzer %d failed: %d\n" ,rx,success);
}
initAnalyzer(rx,buffer_size);
SetDisplayDetectorMode(rx, 0, display_detector_mode);
SetDisplayAverageMode(rx, 0, display_average_mode);
calculate_display_average();
//SetDisplayAvBackmult(rx, 0, display_avb);
//SetDisplayNumAverage(rx, 0, display_average);
while (gtk_events_pending ())
gtk_main_iteration ();
XCreateAnalyzer(CHANNEL_TX, &success, 262144, 1, 1, "");
if (success != 0) {
fprintf(stderr, "XCreateAnalyzer CHANNEL_TX failed: %d\n" ,success);
}
initAnalyzer(CHANNEL_TX,tx_buffer_size);
setupRX(rx);
setupTX(CHANNEL_TX);
}
RPCFile::ChannelReader* RPCFile::OpenChannel(const char* name, bool newFileStream) const
{
int idx = FindChannelIndex(name);
return (idx >= 0) ? OpenChannel(idx, newFileStream) : NULL;
}
