QTSS_Error DoRequestPostProcessing(ProxyClientInfo* inProxyClientInfo, QTSS_RTSPRequestObject inRequest,
QTSS_ClientSessionObject inClientSession)
{
QTSS_RTSPMethod* theMethod = NULL;
UInt32 theLen = 0;
QTSS_Error theErr = QTSS_GetValuePtr(inRequest, qtssRTSPReqMethod, 0, (void**)&theMethod, &theLen);
Assert(theErr == QTSS_NoErr);
char theTransportHeaderBuf[128];
StrPtrLen theTransportHeader(theTransportHeaderBuf, 0);
StrPtrLen theSessionID;
theErr = QTSS_GetValuePtr(inClientSession, qtssCliSesRTSPSessionID, 0, (void**)&theSessionID.Ptr, &theSessionID.Len);
Assert(theErr == QTSS_NoErr);
StrPtrLen theResponse(inProxyClientInfo->GetRTSPClient()->GetResponse(), inProxyClientInfo->GetRTSPClient()->GetResponseLen());
if ((*theMethod == qtssSetupMethod) &&
(inProxyClientInfo->GetRTSPClient()->GetStatus() == 200))
{
ProxyDemuxerTask* thisStreamsDemuxer = inProxyClientInfo->GetLastDemuxerTask();
thisStreamsDemuxer->SetOriginServerPort(inProxyClientInfo->GetRTSPClient()->GetServerPort());
//
// Build a new Transport header. This should basically be exactly what the
// server would be sending back if the proxy module wasn't generating the response
UInt16 theSvrRTPPort = 0;
UInt16 theCliRTPPort = 0;
UInt32 theLen = sizeof(theSvrRTPPort);
theErr = QTSS_GetValue(thisStreamsDemuxer->GetStream(), qtssRTPStrSvrRTPPort, 0, &theSvrRTPPort, &theLen);
Assert(theErr == QTSS_NoErr);
theErr = QTSS_GetValue(thisStreamsDemuxer->GetStream(), qtssRTPStrClientRTPPort, 0, &theCliRTPPort, &theLen);
Assert(theErr == QTSS_NoErr);
char theIPAddrStr[20];
theLen = 20;
theErr = QTSS_GetValue(inClientSession, qtssCliRTSPSessLocalAddrStr, 0, &theIPAddrStr[0], &theLen);
Assert(theErr == QTSS_NoErr);
theIPAddrStr[theLen] = '\0';
qtss_sprintf(theTransportHeader.Ptr, "Transport: RTP/AVP;unicast;client_port=%d-%d;server_port=%d-%d;source=%s\r\n",
theCliRTPPort, theCliRTPPort + 1, theSvrRTPPort, theSvrRTPPort + 1, theIPAddrStr);
theTransportHeader.Len = ::strlen(theTransportHeader.Ptr);
}
else if ((*theMethod == qtssPlayMethod) &&
(inProxyClientInfo->GetRTSPClient()->GetStatus() == 200))
{
//
// The client session needs to know that we are entering the playing state.
// Otherwise, when we write RTP packet data to the QTSS_RTPStreamObjects,
// the server won't really be able to figure out what to do with the packets.
theErr = QTSS_Play(inClientSession, inRequest, 0);
if (theErr != QTSS_NoErr)
{
Assert(theErr == QTSS_RequestFailed);
return theErr;
}
}
else if ((*theMethod == qtssPauseMethod) &&
(inProxyClientInfo->GetRTSPClient()->GetStatus() == 200))
{
//
// Same thing as above, just let the server know that we are no longer playing
theErr = QTSS_Pause(inClientSession);
Assert(theErr == QTSS_NoErr);
}
//
// Build our ioVec with the new response
// When building the iovec used for the response, we need to leave the first
// iovec in the array empty, per QTSS API conventions.
iovec theNewResponse[7];
theNewResponse[0].iov_len = 0;
UInt32 totalResponseLen = 0;
//
// Internally, the server keeps an RTSP Session ID for this QTSS_ClientSessionObject.
// We need to replace the one the upstream server has given us with this server's
// RTSP Session ID. Otherwise, when the server receives the next RTSP request,
// this server will not be able to map the RTSP session ID properly.
UInt32 theNumVecs = ReplaceSessionAndTransportHeaders(&theResponse, &theNewResponse[1], &theSessionID, &theTransportHeader, &totalResponseLen);
theNumVecs++; // Take into account that the first one is empty
//
// Also add in the content body of the response if there is one
theNewResponse[theNumVecs].iov_base = inProxyClientInfo->GetRTSPClient()->GetContentBody();
theNewResponse[theNumVecs].iov_len = inProxyClientInfo->GetRTSPClient()->GetContentLength();
totalResponseLen += theNewResponse[theNumVecs].iov_len;
theNumVecs++;
UInt32 lenWritten = 0;
theErr = QTSS_WriteV(inRequest, theNewResponse, theNumVecs, totalResponseLen, &lenWritten);
Assert(lenWritten == totalResponseLen);
Assert(theErr == QTSS_NoErr);
return QTSS_NoErr;
}
int
EnvelopeNodeRecorder::record(int commitTag, double timeStamp)
{
if (theDomain == 0 || theDofs == 0) {
return 0;
}
if (theHandler == 0) {
opserr << "EnvelopeNodeRecorder::record() - no DataOutputHandler has been set\n";
return -1;
}
if (initializationDone != true)
if (this->initialize() != 0) {
opserr << "EnvelopeNodeRecorder::record() - failed in initialize()\n";
return -1;
}
int numDOF = theDofs->Size();
if (deltaT == 0.0 || timeStamp >= nextTimeStampToRecord) {
if (deltaT != 0.0)
nextTimeStampToRecord = timeStamp + deltaT;
double timeSeriesTerm = 0.0;
if (theTimeSeries != 0) {
timeSeriesTerm += theTimeSeries->getFactor(timeStamp);
}
//
// if need nodal reactions get the domain to calculate them
// before we iterate over the nodes
//
if (dataFlag == 7)
theDomain->calculateNodalReactions(0);
else if (dataFlag == 8)
theDomain->calculateNodalReactions(1);
if (dataFlag == 9)
theDomain->calculateNodalReactions(2);
for (int i=0; i<numValidNodes; i++) {
int cnt = i*numDOF;
Node *theNode = theNodes[i];
if (dataFlag == 0) {
const Vector &response = theNode->getTrialDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof) + timeSeriesTerm;
}else
(*currentData)(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 1) {
const Vector &response = theNode->getTrialVel();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof) + timeSeriesTerm;
} else
(*currentData)(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 2) {
const Vector &response = theNode->getTrialAccel();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof) + timeSeriesTerm;
} else
(*currentData)(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 3) {
const Vector &response = theNode->getIncrDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 4) {
const Vector &response = theNode->getIncrDeltaDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (response.Size() > dof) {
(*currentData)(cnt) = response(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 5) {
const Vector &theResponse = theNode->getUnbalancedLoad();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
(*currentData)(cnt) = theResponse(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 6) {
const Vector &theResponse = theNode->getUnbalancedLoadIncInertia();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
(*currentData)(cnt) = theResponse(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 7 || dataFlag == 8 || dataFlag == 9) {
const Vector &theResponse = theNode->getReaction();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
(*currentData)(cnt) = theResponse(dof);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else if (dataFlag > 10) {
int mode = dataFlag - 10;
int column = mode - 1;
const Matrix &theEigenvectors = theNode->getEigenvectors();
if (theEigenvectors.noCols() > column) {
int noRows = theEigenvectors.noRows();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (noRows > dof) {
(*currentData)(cnt) = theEigenvectors(dof,column);
} else
(*currentData)(cnt) = 0.0;
cnt++;
}
} else {
for (int j=0; j<numDOF; j++) {
(*currentData)(cnt) = 0.0;
cnt++;
}
}
}
}
}
// check if currentData modifies the saved data
int sizeData = currentData->Size();
if (echoTimeFlag == false) {
bool writeIt = false;
if (first == true) {
for (int i=0; i<sizeData; i++) {
(*data)(0,i) = (*currentData)(i);
(*data)(1,i) = (*currentData)(i);
(*data)(2,i) = fabs((*currentData)(i));
first = false;
writeIt = true;
}
} else {
for (int i=0; i<sizeData; i++) {
double value = (*currentData)(i);
if ((*data)(0,i) > value) {
(*data)(0,i) = value;
double absValue = fabs(value);
if ((*data)(2,i) < absValue)
(*data)(2,i) = absValue;
writeIt = true;
} else if ((*data)(1,i) < value) {
(*data)(1,i) = value;
double absValue = fabs(value);
if ((*data)(2,i) < absValue)
(*data)(2,i) = absValue;
writeIt = true;
}
}
}
} else {
sizeData /= 2;
bool writeIt = false;
if (first == true) {
for (int i=0; i<sizeData; i++) {
(*data)(0,i*2) = timeStamp;
(*data)(1,i*2) = timeStamp;
(*data)(2,i*2) = timeStamp;
(*data)(0,i*2+1) = (*currentData)(i);
(*data)(1,i*2+1) = (*currentData)(i);
(*data)(2,i*2+1) = fabs((*currentData)(i));
first = false;
writeIt = true;
}
} else {
for (int i=0; i<sizeData; i++) {
double value = (*currentData)(i);
if ((*data)(0,2*i+1) > value) {
(*data)(0,i*2) = timeStamp;
(*data)(0,i*2+1) = value;
double absValue = fabs(value);
if ((*data)(2,i*2+1) < absValue) {
(*data)(2,i*2+1) = absValue;
(*data)(2,i*2) = timeStamp;
}
writeIt = true;
} else if ((*data)(1,i*2+1) < value) {
(*data)(1,i*2) = timeStamp;
(*data)(1,i*2+1) = value;
double absValue = fabs(value);
if ((*data)(2,i*2+1) < absValue) {
(*data)(2,i*2) = timeStamp;
(*data)(2,i*2+1) = absValue;
}
writeIt = true;
}
}
}
}
return 0;
}
int
NodeRecorder::record(int commitTag, double timeStamp)
{
if (theDomain == 0 || theDofs == 0) {
return 0;
}
if (theOutputHandler == 0) {
opserr << "NodeRecorder::record() - no DataOutputHandler has been set\n";
return -1;
}
if (initializationDone == false) {
if (this->initialize() != 0) {
opserr << "NodeRecorder::record() - failed in initialize()\n";
return -1;
}
}
int numDOF = theDofs->Size();
if (deltaT == 0.0 || timeStamp >= nextTimeStampToRecord) {
if (deltaT != 0.0)
nextTimeStampToRecord = timeStamp + deltaT;
//
// if need nodal reactions get the domain to calculate them
// before we iterate over the nodes
//
if (dataFlag == 7)
theDomain->calculateNodalReactions(0);
else if (dataFlag == 8)
theDomain->calculateNodalReactions(1);
if (dataFlag == 9)
theDomain->calculateNodalReactions(2);
//
// add time information if requested
//
int timeOffset = 0;
if (echoTimeFlag == true) {
timeOffset = 1;
response(0) = timeStamp;
}
double timeSeriesTerm = 0.0;
if (theTimeSeries != 0) {
for (int i=0; i<numDOF; i++) {
if (theTimeSeries[i] != 0)
timeSeriesValues[i] = theTimeSeries[i]->getFactor(timeStamp);
}
}
//
// now we go get the responses from the nodes & place them in disp vector
//
if (dataFlag != 10) {
for (int i=0; i<numValidNodes; i++) {
int cnt = i*numDOF + timeOffset;
if (dataFlag == 10000)
cnt = i + timeOffset;
Node *theNode = theNodes[i];
if (dataFlag == 0) {
// AddingSensitivity:BEGIN ///////////////////////////////////
if (sensitivity==0) {
const Vector &theResponse = theNode->getTrialDisp();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof) + timeSeriesTerm;
}
else {
response(cnt) = 0.0 + timeSeriesTerm;
}
cnt++;
}
}
else {
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
response(cnt) = theNode->getDispSensitivity(dof+1, sensitivity);
cnt++;
}
}
// AddingSensitivity:END /////////////////////////////////////
} else if (dataFlag == 1) {
const Vector &theResponse = theNode->getTrialVel();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof) + timeSeriesTerm;
} else
response(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 10000) {
const Vector &theResponse = theNode->getTrialDisp();
double sum = 0.0;
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
sum += (theResponse(dof) + timeSeriesTerm) * (theResponse(dof) + timeSeriesTerm);
} else
sum += timeSeriesTerm * timeSeriesTerm;
}
response(cnt) = sqrt(sum);
cnt++;
} else if (dataFlag == 2) {
const Vector &theResponse = theNode->getTrialAccel();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof) + timeSeriesTerm;
} else
response(cnt) = 0.0 + timeSeriesTerm;
cnt++;
}
} else if (dataFlag == 3) {
const Vector &theResponse = theNode->getIncrDisp();
for (int j=0; j<numDOF; j++) {
if (theTimeSeries != 0) {
timeSeriesTerm = timeSeriesValues[j];
}
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 4) {
const Vector &theResponse = theNode->getIncrDeltaDisp();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 5) {
const Vector &theResponse = theNode->getUnbalancedLoad();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 6) {
const Vector &theResponse = theNode->getUnbalancedLoadIncInertia();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (dataFlag == 7 || dataFlag == 8 || dataFlag == 9) {
const Vector &theResponse = theNode->getReaction();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (theResponse.Size() > dof) {
response(cnt) = theResponse(dof);
} else
response(cnt) = 0.0;
cnt++;
}
} else if (10 <= dataFlag && dataFlag < 1000) {
int mode = dataFlag - 10;
int column = mode - 1;
const Matrix &theEigenvectors = theNode->getEigenvectors();
if (theEigenvectors.noCols() > column) {
int noRows = theEigenvectors.noRows();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (noRows > dof) {
response(cnt) = theEigenvectors(dof,column);
} else
response(cnt) = 0.0;
cnt++;
}
}
} else if (dataFlag >= 1000 && dataFlag < 2000) {
int grad = dataFlag - 1000;
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
dof += 1; // Terje uses 1 through DOF for the dof indexing; the fool then subtracts 1
// his code!!
response(cnt) = theNode->getDispSensitivity(dof, grad-1); // Quan May 2009, the one above is not my comment!
cnt++;
}
} else if (dataFlag >= 2000 && dataFlag < 3000) {
int grad = dataFlag - 2000;
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
dof += 1; // Terje uses 1 through DOF for the dof indexing; the fool then subtracts 1
// his code!!
response(cnt) = theNode->getVelSensitivity(dof, grad-1); // Quan May 2009
cnt++;
}
} else if (dataFlag >= 3000) {
int grad = dataFlag - 3000;
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
dof += 1; // Terje uses 1 through DOF for the dof indexing; the fool then subtracts 1
// his code!!
response(cnt) = theNode->getAccSensitivity(dof, grad-1);// Quan May 2009
cnt++;
}
}
else {
// unknown response
for (int j=0; j<numDOF; j++) {
response(cnt) = 0.0;
}
}
}
// insert the data into the database
theOutputHandler->write(response);
} else { // output all eigenvalues
Node *theNode = theNodes[0];
const Matrix &theEigenvectors = theNode->getEigenvectors();
int numValidModes = theEigenvectors.noCols();
for (int mode=0; mode<numValidModes; mode++) {
for (int i=0; i<numValidNodes; i++) {
int cnt = i*numDOF + timeOffset;
theNode = theNodes[i];
int column = mode;
const Matrix &theEigenvectors = theNode->getEigenvectors();
if (theEigenvectors.noCols() > column) {
int noRows = theEigenvectors.noRows();
for (int j=0; j<numDOF; j++) {
int dof = (*theDofs)(j);
if (noRows > dof) {
response(cnt) = theEigenvectors(dof,column);
} else
response(cnt) = 0.0;
cnt++;
}
}
}
theOutputHandler->write(response);
}
}
}
return 0;
}
