/*
* Initialization for the stream opened by the other process
*/
static int
openStream(Stream *stream)
{
jint error;
CHECK_ERROR(sysIPMutexOpen(stream->shared->mutexName, &stream->mutex));
error = sysEventOpen(stream->shared->hasDataEventName,
&stream->hasData);
if (error != SYS_OK) {
setLastError(error);
(void)closeStream(stream, JNI_FALSE);
return error;
}
error = sysEventOpen(stream->shared->hasSpaceEventName,
&stream->hasSpace);
if (error != SYS_OK) {
setLastError(error);
(void)closeStream(stream, JNI_FALSE);
return error;
}
stream->state = STATE_OPEN;
return SYS_OK;
}
/*
* Initialization for the stream opened by the other process
*/
static int
openStream(Stream *stream)
{
jint error;
error = sysIPMutexOpen(stream->shared->mutexName, &stream->mutex);
if (error != SYS_OK) {
fprintf(stderr,"Error accessing mutex, rc = %d\n", error);
return error;
}
error = sysEventOpen(stream->shared->hasDataEventName,
&stream->hasData);
if (error != SYS_OK) {
fprintf(stderr,"Error accessing mutex, rc = %d\n", error);
(void)closeStream(stream);
return error;
}
error = sysEventOpen(stream->shared->hasSpaceEventName,
&stream->hasSpace);
if (error != SYS_OK) {
fprintf(stderr,"Error accessing mutex, rc = %d\n", error);
(void)closeStream(stream);
return error;
}
stream->state = STATE_OPEN;
return SYS_OK;
}
/*
* Server creates stream.
*/
static int
createStream(char *name, Stream *stream)
{
jint error;
char prefix[MAX_IPC_PREFIX];
sprintf(prefix, "%s.mutex", name);
error = createWithGeneratedName(prefix, stream->shared->mutexName,
createMutex, &stream->mutex);
if (error != SYS_OK) {
return error;
}
sprintf(prefix, "%s.hasData", name);
error = createWithGeneratedName(prefix, stream->shared->hasDataEventName,
createEvent, &stream->hasData);
if (error != SYS_OK) {
(void)closeStream(stream, JNI_FALSE);
return error;
}
sprintf(prefix, "%s.hasSpace", name);
error = createWithGeneratedName(prefix, stream->shared->hasSpaceEventName,
createEvent, &stream->hasSpace);
if (error != SYS_OK) {
(void)closeStream(stream, JNI_FALSE);
return error;
}
stream->shared->readOffset = 0;
stream->shared->writeOffset = 0;
stream->shared->isFull = JNI_FALSE;
stream->state = STATE_OPEN;
return SYS_OK;
}
static void
closeConnection(SharedMemoryConnection *connection)
{
/*
* Signal all threads accessing this connection that we are
* shutting down.
*/
if (connection->shutdown) {
sysEventSignal(connection->shutdown);
}
(void)closeStream(&connection->incoming);
(void)closeStream(&connection->outgoing);
if (connection->sharedMemory) {
sysSharedMemClose(connection->sharedMemory, connection->shared);
}
if (connection->otherProcess) {
sysProcessClose(connection->otherProcess);
}
/*
* Ideally we should close the connection->shutdown event and
* free the connection structure. However as closing the
* connection is asynchronous it means that other threads may
* still be accessing the connection structure. On Win32 this
* means we leak 132 bytes and one event per connection. This
* memory will be reclaim at process exit.
*
* if (connection->shutdown)
* sysEventClose(connection->shutdown);
* freeConnection(connection);
*/
}
bool AlsaCtlPortConfig::sendToHW(string &error)
{
PortConfig portConfig;
blackboardRead(&portConfig, sizeof(portConfig));
// If device update is needed, close all the stream
if (isDeviceUpdateNeeded(portConfig)) {
// Close playback and capture
closeStream(Playback);
closeStream(Capture);
// Save new configuration
_portConfig.channelNumber = portConfig.channelNumber;
_portConfig.format = portConfig.format;
_portConfig.sampleRate = portConfig.sampleRate;
} else {
// Close playback/capture streams if asked for
if (!portConfig.isStreamEnabled[Playback]) {
closeStream(Playback);
}
if (!portConfig.isStreamEnabled[Capture]) {
closeStream(Capture);
}
}
// Open and configure required streams
if (portConfig.isStreamEnabled[Playback]) {
if (!openStream(Playback, error)) {
return false;
}
}
if (portConfig.isStreamEnabled[Capture]) {
if (!openStream(Capture, error)) {
return false;
}
}
// Check port configuration has been considered
assert(!memcmp(&_portConfig, &portConfig, sizeof(_portConfig)));
return true;
}
I8KView::~I8KView()
{
closeStream();
delete m_timer;
delete m_reData;
}
void test_cftNew_should_create_cft_for_symbols_from_file(){
Stream *in = NULL;
CFT *cftPtr;
int tableSize;
CEXCEPTION_T error;
Try{
// Please check cftData.txt, inside has a lengthy string
in = openStream("cftData.txt","r");
cftPtr = cftNew(in, &tableSize);
}Catch(error){
TEST_ASSERT_NOT_EQUAL(ERR_FILE_NOT_EXIST,error);
}
dumpCFT(cftPtr,0);
dumpCFT(cftPtr,1);
dumpCFT(cftPtr,2);
TEST_ASSERT_EQUAL(3,tableSize);
TEST_ASSERT_EQUAL('a', cftPtr[0].symbol);
TEST_ASSERT_EQUAL(40, cftPtr[0].cum_Freq);
TEST_ASSERT_EQUAL(40, cftPtr[0].occurNo);
TEST_ASSERT_EQUAL('b', cftPtr[1].symbol);
TEST_ASSERT_EQUAL(41, cftPtr[1].cum_Freq);
TEST_ASSERT_EQUAL(1, cftPtr[1].occurNo);
TEST_ASSERT_EQUAL('c', cftPtr[2].symbol);
TEST_ASSERT_EQUAL(50, cftPtr[2].cum_Freq);
TEST_ASSERT_EQUAL(9, cftPtr[2].occurNo);
if(in != NULL){
closeStream(in);
}
}
LadybugWidget::~LadybugWidget()
{
// make sure the thread gets stopped and stream closed
closeStream();
delete mNextFrame;
}
void plotly::reconnectStream(){
while(!client.connected()){
if(log_level<4) Serial.println(F("... Disconnected from streaming servers"));
closeStream();
openStream();
}
}
FILE*
HTTPClient::openClientFile()
{
FILE* result = fdevopen(clientWrite, clientRead);
if (result == NULL)
{
return NULL;
}
http_stream_udata* udata = (http_stream_udata*) malloc(
sizeof(http_stream_udata));
fdev_set_udata(result,udata);
udata->client = this;
udata->encode = 0;
if (connected())
{
stop();
}
if (connect())
{
return result;
}
else
{
closeStream(result);
return NULL;
}
}
audio::orchestra::api::Core::~Core() {
// The subclass destructor gets called before the base class
// destructor, so close an existing stream before deallocating
// apiDeviceId memory.
if (m_state != audio::orchestra::state::closed) {
closeStream();
}
}
void PacketReceiver::exit()
{
destroyFrames();
destroyPictureConverter();
closeStream();
mainWindow->log("Stream geschlossen", INFO);
exitAVLibs();
}
JavaInputStream::~JavaInputStream() {
JNIEnv *env = AndroidUtil::getEnv();
if (myJavaInputStream != 0) {
closeStream(env);
}
env->DeleteGlobalRef(myJavaFile);
env->DeleteGlobalRef(myJavaBuffer);
}
void handleClientRequest(int i)
{
ssize_t r;
char * p;
size_t remain;
if (stream[i].len >= sizeof(stream[i].buffer) - 2)
{
logAbort("Input line on stream %d too long: %s\n", i, stream[i].buffer);
}
remain = sizeof(stream[i].buffer) - stream[i].len - 2;
logDebug("handleClientRequest: read i=%d\n", i);
logDebug("read %s i=%d fd=%d len=%u remain=%u\n", streamTypeName[stream[i].type], i, stream[i].fd, stream[i].len, remain);
r = read(stream[i].fd, stream[i].buffer + stream[i].len, remain);
if (r <= 0)
{
logDebug("read %s i=%d fd=%d r=%d\n", streamTypeName[stream[i].type], i, stream[i].fd, r);
if (stream[i].type == DATA_INPUT_STREAM)
{
logAbort("EOF on reading stdin\n");
}
closeStream(i);
return;
}
stream[i].len += r;
stream[i].buffer[stream[i].len] = 0;
while (stream[i].len > 0)
{
size_t len;
p = strchr(stream[i].buffer, '\n');
if (!p)
{
break;
}
len = p - stream[i].buffer;
sbAppendData(&tcpMessage, stream[i].buffer, len + 1);
if (stream[i].type != DATA_INPUT_STREAM || stream[outputIdx].type == DATA_OUTPUT_COPY)
{
/* Send all TCP client input and the main stdin stream if the mode is -o */
/* directly to stdout */
sbAppendData(&outMessage, stream[i].buffer, len + 1);
}
*p = 0;
if (storeMessage(stream[i].buffer, len))
{
convertJSONToNMEA0183(&nmeaMessage, stream[i].buffer);
}
p++, len++;
stream[i].len -= len;
/* Now remove [buffer..p> == the entire line */
memmove(stream[i].buffer, p, stream[i].len + 1);
}
}
void NodeDataInterface::streamToOutput(AbstractWriteFacet &write_to_storeentity) {
static char readBuffer[4096];
size_t bytesRead;
openStream();
while((bytesRead = streamRead(readBuffer, 4096)) > 0){
write_to_storeentity(readBuffer, bytesRead);
}
closeStream();
}
// destructor
slgAudio::~slgAudio(){
if( m_audio )
{
stopStream();
closeStream();
}
delete m_audio;
m_audio = NULL;
}
//! Disconnect old streams
void SimpleDashelConnection::closeOldStreams()
{
for (size_t i = 0; i < toDisconnect.size(); ++i)
{
SEND_NOTIFICATION(LOG_WARNING, "old client disconnected", toDisconnect[i]->getTargetName());
closeStream(toDisconnect[i]);
}
toDisconnect.clear();
}
void ConsoleAppender::close()
{
QMutexLocker locker(&mObjectGuard);
if (isClosed())
return;
WriterAppender::close();
closeStream();
}
int NetworkInputStream::checkStatus() {
if (_open) {
int res = waitAvailable(2000);
if (res < 0) {
closeStream();
}
return res;
}
return 0;
}
void StreamSubscriptionResponderBase::onNextFrame(Frame_CANCEL&& frame) {
switch (state_) {
case State::RESPONDING:
state_ = State::CLOSED;
closeStream(StreamCompletionSignal::CANCEL);
break;
case State::CLOSED:
break;
}
}
//---------------------------------------------------
// MAIN
//---------------------------------------------------
int main(int argc, char **argv) {
Args args;
parseArguments(&args, argc, argv);
//TODO add macros for csvparse init
CsvDescriptor csv = {*args.delimiter, 0, NULL, NULL};
FILE *stream = resolveStream(&args);
readByLine(stream, parseCsvLine, &csv);
closeStream(stream);
exit(EXIT_SUCCESS);
}
// RtAudio configuration
void slgAudio::openStream( RtAudioCallback callback, void * userData ){
if( !callback )
{
std::cerr << "No callback provided!" << std::endl;
exit(1);
}
if( m_audio != NULL ){
stopStream();
closeStream();
}
RtAudio::StreamOptions options;
//options.flags = RTAUDIO_NONINTERLEAVED;
options.flags = RTAUDIO_SCHEDULE_REALTIME;
options.priority = 1;
// set input and output parameters to default
RtAudio::StreamParameters iParams, oParams;
//TODO: propose a choice of device not just default
iParams.deviceId = m_audio->getDefaultInputDevice();
iParams.nChannels = 2;
iParams.firstChannel = 0;
oParams.deviceId = m_audio->getDefaultOutputDevice();
oParams.nChannels = 2;
oParams.firstChannel = 0;
RtAudioFormat sample_format = ( sizeof(SAMPLE) == 8 ) ? RTAUDIO_FLOAT64 : RTAUDIO_FLOAT32;
//open stream
//!!! RTAUDIO_FLOAT32 and not 64...
try {
m_audio->openStream( &oParams, &iParams, sample_format, m_sampleRate, &m_bufferSize, callback, userData, &options);
}
catch ( RtAudioError& e ) {
try { // again
std::cout<<"hack!"<<std::endl;
// HACK: bump the oparams device id (on some systems, default in/out devices differ)
oParams.deviceId++;
// try to open stream
m_audio->openStream( &oParams, &iParams, sample_format,
m_sampleRate, &m_bufferSize, callback, userData );
}
catch( RtAudioError & e ) {
// error message
std::cerr << "[slgAudio]: cannot initialize real-time audio I/O..." << std::endl;
std::cerr << "[slgAudio]: | - " << e.getMessage() << std::endl;
// clean up
delete m_audio;
m_audio = NULL;
// done
}
}
}
void test_arithmeticEncoder_to_encode_acba_with_cftData_txt_should_generate_a_tag(){
Stream *cft = NULL, *in = NULL, *out = NULL;
CFT *cftPtr;
int dataLength = 0, tableSize;
CEXCEPTION_T error;
Try{
// Please check cftData.txt, inside has a lengthy string
cft = openStream("cftData.txt","r");
cftPtr = cftNew(cft,&tableSize);
TEST_ASSERT_EQUAL(3,tableSize);
}Catch(error){
TEST_ASSERT_NOT_EQUAL(ERR_FILE_NOT_EXIST,error);
}
Try{
/* Please check encodeACBA.txt contain the encode data
* tag.txt/.bin will store the tag generate from encode data
* acba will encode into 1100 0101 0110 1101 0101 1100 1111 1001 1100 000
*
* Unfortunately, editor cannot show the actual result as it show chinese character
* To see the final result, using a hex editor to open the tag file and compare with
* print statement at streamFlush.
*/
in = openStream("encodeACBA.txt","r");
out = openStream("tag.bin","w");
arithmeticEncode(in, &dataLength, cftPtr,tableSize,out);
}Catch(error){
TEST_ASSERT_NOT_EQUAL(ERR_FILE_NOT_EXIST,error);
}
TEST_ASSERT_EQUAL(4,dataLength);
if(in != NULL){
closeStream(in);
}if(out != NULL){
closeStream(out);
}if(cft != NULL){
closeStream(cft);
}
}
int
HTTPClient::clientWrite(char byte, FILE* stream)
{
if (stream == NULL)
{
return EOF;
}
http_stream_udata* udata = (http_stream_udata*) fdev_get_udata(stream);
HTTPClient* client = udata->client;
if (client->connected() == 0)
{
closeStream(stream);
return EOF;
}
if (udata->encode == 0)
{
client->write(byte);
if (client->debugCommunication)
{
Serial.print(byte);
}
}
else
{
if (URI_ALLOWED(byte) || ((URI_RESERVED(byte) && (udata->encode
& URI_ENCODE_RESERVED) == 0)))
{
client->write(byte);
if (client->debugCommunication)
{
Serial.print(byte);
}
}
else
{
char encoded[4] =
{ 0, 0, 0 };
sprintf(encoded, "%%%2x", byte);
// Write only the first three bytes, not the trailing null
for (char i = 0; i < 3; i++)
{
client->write(encoded[i]);
if (client->debugCommunication)
{
Serial.print(encoded[i]);
}
}
}
}
return 0;
}
static void svs_core_Camera_dealloc(svs_core_Camera *self) {
/* Use ready flag to determine state of readiness to deallocate */
switch (self->ready) {
case READY:
closeStream(self->stream);
case NAME_ALLOCATED:
Py_DECREF(self->name);
case CONNECTED:
closeCamera(self->handle);
break;
}
Py_TYPE(self)->tp_free((PyObject*)self);
}
virtual void connectionCreated(Dashel::Stream *stream)
{
std::string targetName = stream->getTargetName();
if (targetName.substr(0, targetName.find_first_of(':')) == "tcp")
{
std::cerr << this << " : New client connected." << std::endl;
if (this->stream)
{
closeStream(this->stream);
std::cerr << this << " : Disconnected old client." << std::endl;
}
this->stream = stream;
}
}
static int
writeString (const char *string, int reopen) {
if (!festivalStream) {
if (!reopen) return 0;
if (!openStream()) return 0;
}
fputs(string, festivalStream);
if (!ferror(festivalStream)) return 1;
logSystemError("fputs");
closeStream();
return 0;
}
void test_writeStuffedByte_given_0x0A_should_only_write_0x0A(void){
CEXCEPTION_T error;
Stream *fileStream = NULL;
Try{
fileStream = openStream("test/Data/StuffedByte_write", "wb");
}Catch(error){
TEST_ASSERT_EQUAL(ERR_END_OF_FILE, error);
}
writeStuffedByte(fileStream, 0x0A);
closeStream(fileStream);
}
void AsebaMarxbot::connectionCreated(Dashel::Stream *stream)
{
std::string targetName = stream->getTargetName();
if (targetName.substr(0, targetName.find_first_of(':')) == "tcp")
{
qDebug() << this << " : New client connected.";
if (this->stream)
{
closeStream(this->stream);
qDebug() << this << " : Disconnected old client.";
}
this->stream = stream;
}
}
void ConsoleAppender::activateOptions()
{
QMutexLocker locker(&mObjectGuard);
closeStream();
if (mTarget == STDOUT_TARGET)
mpTextStream = new QTextStream(stdout);
else
mpTextStream = new QTextStream(stderr);
setWriter(mpTextStream);
WriterAppender::activateOptions();
}
