int WAVStream::readSubchunk()
{
string subchunkId = readString(4);
int size = readInt32();
//cerr << "CHUNK " << subchunkId << ", SIZE = " << size << endl;
if (subchunkId.compare(WAVFormat::FORMAT_SUBCHUNK_ID) == 0) {
readFormatSubchunk(size);
} else if (subchunkId.compare(WAVFormat::INF1_SUBCHUNK_ID) == 0) {
readInf1Subchunk(size);
} else if (subchunkId.compare(WAVFormat::DATA_SUBCHUNK_ID) == 0) {
if (!dataRead_) {
startStream();
//if (backend_.isNotNull())
// backend_->startStream(streamInfo_);
dataRead_ = true;
}
readDataSubchunk(size);
} else {
readUnknownSubchunk(size);
}
return size + 4;
}
void CheckAllStreams(JSON::Value & data){
long long int currTime = Util::epoch();
for (JSON::ObjIter jit = data.ObjBegin(); jit != data.ObjEnd(); jit++){
if ( !Util::Procs::isActive(jit->first)){
startStream(jit->first, jit->second);
}
if (currTime - lastBuffer[jit->first] > 5){
if (jit->second.isMember("error") && jit->second["error"].asString() != ""){
jit->second["online"] = jit->second["error"];
}else{
jit->second["online"] = 0;
}
}else{
jit->second["online"] = 1;
}
}
static JSON::Value strlist;
bool changed = false;
if (strlist["config"] != Storage["config"]){
strlist["config"] = Storage["config"];
changed = true;
}
if (strlist["streams"] != Storage["streams"]){
strlist["streams"] = Storage["streams"];
changed = true;
}
if (changed){
WriteFile("/tmp/mist/streamlist", strlist.toString());
}
}
bool BoardFXO::KhompPvtFXO::onNewCall(K3L_EVENT *e)
{
DBG(FUNC,PVT_FMT(_target,"(FXO) c"));
bool ret = true;
try
{
ScopedPvtLock lock(this);
/* we always have audio */
call()->_flags.set(Kflags::HAS_PRE_AUDIO);
ret = KhompPvt::onNewCall(e);
if(!ret)
return false;
startListen();
startStream();
}
catch(ScopedLockFailed & err)
{
LOG(ERROR, PVT_FMT(target(), "(FXO) r (unable to lock %s!)") % err._msg.c_str() );
return false;
}
DBG(FUNC, PVT_FMT(_target, "(FXO) r"));
return ret;
}
void InitCycle(std::shared_ptr<NamedPipe>& pipe)
{
auto globals = globalStruct::GetGlobals();
if (!globals)
return;
auto svc = globals->GetService();
if (!svc)
return;
std::atomic_store(&globals->pipe, pipe);
StartRecv(pipe);
svc->post([pipe, globals]()
{
if (!pipe || !pipe->IsConnected())
return;
auto strm = globals->GetStreamer();
if (!strm)
return;
try
{
Writer MyWriter(pipe);
strm->startStream(MyWriter);
strm->stream(MyWriter);
}
catch (NamedPipeException& ex)
{
pipe->Cleanup();
}
});
}
void XmppStream::onFeatureFinished(bool ARestart)
{
if (!ARestart)
processFeatures();
else
startStream();
}
THREAD(StreamMusic, arg)
{
printf("\nthread started\n");
startStream();
for (;;) {
NutSleep(100);
}
}
THREAD(stream, arg)
{
startStream();
for(;;)
{
NutSleep(100);
}
}
void PluginStream::didReceiveResponse(NetscapePlugInStreamLoader* loader, const ResourceResponse& response)
{
ASSERT(loader == m_loader);
ASSERT(m_streamState == StreamBeforeStarted);
m_resourceResponse = response;
startStream();
}
///\brief Checks all streams, restoring if needed.
///\param data The stream configuration for the server.
void CheckAllStreams(JSON::Value & data) {
long long int currTime = Util::epoch();
for (JSON::ObjIter jit = data.ObjBegin(); jit != data.ObjEnd(); jit++) {
if ( !Util::Procs::isActive(jit->first)) {
startStream(jit->first, jit->second);
}
if (currTime - lastBuffer[jit->first] > 5) {
if (jit->second.isMember("source") && jit->second["source"].asString().substr(0, 1) == "/" && jit->second.isMember("error")
&& jit->second["error"].asString() == "Available") {
jit->second["online"] = 2;
} else {
if (jit->second.isMember("error") && jit->second["error"].asString() == "Available") {
jit->second.removeMember("error");
}
jit->second["online"] = 0;
}
} else {
// assume all is fine
jit->second.removeMember("error");
jit->second["online"] = 1;
// check if source is valid
if (jit->second.isMember("live") && !jit->second.isMember("meta") || !jit->second["meta"]) {
jit->second["online"] = 0;
jit->second["error"] = "No (valid) source connected";
} else {
// for live streams, keep track of activity
if (jit->second["meta"].isMember("live")) {
if (jit->second["meta"]["lastms"] != jit->second["lastms"]) {
jit->second["lastms"] = jit->second["meta"]["lastms"];
jit->second["last_active"] = currTime;
}
// mark stream as offline if no activity for 5 seconds
if (jit->second.isMember("last_active") && jit->second["last_active"].asInt() < currTime - 5) {
jit->second["online"] = 0;
jit->second["error"] = "No (valid) source connected";
}
}
}
}
}
static JSON::Value strlist;
bool changed = false;
if (strlist["config"] != Storage["config"]) {
strlist["config"] = Storage["config"];
changed = true;
}
if (strlist["streams"] != Storage["streams"]) {
strlist["streams"] = Storage["streams"];
changed = true;
}
if (changed) {
WriteFile("/tmp/mist/streamlist", strlist.toString());
}
}
///\brief Parse a given stream configuration.
///\param in The requested configuration.
///\param out The new configuration after parsing.
void CheckStreams(JSON::Value & in, JSON::Value & out) {
bool changed = false;
//check for new streams and updates
for (JSON::ObjIter jit = in.ObjBegin(); jit != in.ObjEnd(); jit++) {
if (out.isMember(jit->first)) {
if ( !streamsEqual(jit->second, out[jit->first])) {
Log("STRM", std::string("Updated stream ") + jit->first);
Util::Procs::Stop(jit->first);
startStream(jit->first, jit->second);
}
} else {
Log("STRM", std::string("New stream ") + jit->first);
startStream(jit->first, jit->second);
}
}
//check for deleted streams
for (JSON::ObjIter jit = out.ObjBegin(); jit != out.ObjEnd(); jit++) {
if ( !in.isMember(jit->first)) {
Log("STRM", std::string("Deleted stream ") + jit->first);
Util::Procs::Stop(jit->first);
}
}
//update old-style configurations to new-style
for (JSON::ObjIter jit = in.ObjBegin(); jit != in.ObjEnd(); jit++) {
if (jit->second.isMember("channel")) {
if ( !jit->second.isMember("source")) {
jit->second["source"] = jit->second["channel"]["URL"];
}
jit->second.removeMember("channel");
}
if (jit->second.isMember("preset")) {
jit->second.removeMember("preset");
}
}
out = in;
}
void LiveWidget::streamMenuActionTriggered(QAction* action)
{
if (!action->text().contains(':') && !action->text().contains(','))
return;
stopStream(this->deviceName, this->deviceChannel);
this->useKey = action->text().contains("(Key)");
this->deviceName = action->text().split(',').at(0).split(':').at(1).trimmed();
this->deviceChannel = action->text().split(',').at(1).split(':').at(1).trimmed().split(' ').at(0).trimmed();
startStream(this->deviceName, this->deviceChannel);
}
void CheckStreams(JSON::Value & in, JSON::Value & out){
bool changed = false;
for (JSON::ObjIter jit = in.ObjBegin(); jit != in.ObjEnd(); jit++){
if (out.isMember(jit->first)){
if ( !streamsEqual(jit->second, out[jit->first])){
Log("STRM", std::string("Updated stream ") + jit->first);
Util::Procs::Stop(jit->first);
startStream(jit->first, jit->second);
}
}else{
Log("STRM", std::string("New stream ") + jit->first);
startStream(jit->first, jit->second);
}
}
for (JSON::ObjIter jit = out.ObjBegin(); jit != out.ObjEnd(); jit++){
if ( !in.isMember(jit->first)){
Log("STRM", std::string("Deleted stream ") + jit->first);
Util::Procs::Stop(jit->first);
}
}
out = in;
}
bool BoardFXO::KhompPvtFXO::setupConnection()
{
if(!call()->_flags.check(Kflags::IS_INCOMING) && !call()->_flags.check(Kflags::IS_OUTGOING))
{
DBG(FUNC,PVT_FMT(_target, "Channel already disconnected"));
return false;
}
callFXO()->_flags.clear(Kflags::CALL_WAIT_SEIZE);
callFXO()->_flags.clear(Kflags::WAIT_SEND_DTMF);
/* if received some disconnect from 'drop collect call'
feature of some pbx, then leave the call rock and rolling */
//Board::board(_target.device)->_timers.del(callFXO()->_idx_disconnect);
bool fax_detected = callFXO()->_flags.check(Kflags::FAX_DETECTED) || (callFXO()->_var_fax_adjust == T_TRUE);
bool res_out_of_band_dtmf = (call()->_var_dtmf_state == T_UNKNOWN || fax_detected ?
Opt::_options._suppression_delay() && Opt::_options._out_of_band_dtmfs() && !fax_detected : (call()->_var_dtmf_state == T_TRUE));
bool res_echo_cancellator = (call()->_var_echo_state == T_UNKNOWN || fax_detected ?
Opt::_options._echo_canceller() && !fax_detected : (call()->_var_echo_state == T_TRUE));
bool res_auto_gain_cntrol = (call()->_var_gain_state == T_UNKNOWN || fax_detected ?
Opt::_options._auto_gain_control() && !fax_detected : (call()->_var_gain_state == T_TRUE));
if (!call()->_flags.check(Kflags::REALLY_CONNECTED))
{
obtainRX(res_out_of_band_dtmf);
/* esvazia buffers de leitura/escrita */
cleanupBuffers();
if (!call()->_flags.check(Kflags::KEEP_DTMF_SUPPRESSION))
dtmfSuppression(res_out_of_band_dtmf);
if (!call()->_flags.check(Kflags::KEEP_ECHO_CANCELLATION))
echoCancellation(res_echo_cancellator);
if (!call()->_flags.check(Kflags::KEEP_AUTO_GAIN_CONTROL))
autoGainControl(res_auto_gain_cntrol);
startListen(false);
startStream();
DBG(FUNC, PVT_FMT(_target, "(FXO) Audio callbacks initialized successfully"));
}
return KhompPvt::setupConnection();
}
BrainUART::BrainUART(int nChannels, int frameLength, float overlap){
this->nChannels = nChannels;
this->SamplesPerChannel = frameLength;
/*Open serial connection*/
stream.fd = bbuart_init((char *)"/dev/ttyO4", B115200);
/*Initializes data*/
bbbuffer_create(&b, nChannels, BUFFER_SIZE);
bbframe_create(&eeg, nChannels, frameLength, overlap);
stream.b = &b;
stream.f = &eeg;
startStream();
}
THREAD(AlarmCheckerThread, arg)
{
for (;;) {
NutSleep(5000);
if(CheckAlarm1())
{
printf("Alarm should go off\n");
startStream();
NutSleep(61000);
NutThreadExit();
printf("Exit thread and started new one...\n");
NutThreadCreate("Bl", AlarmCheckerThread, NULL, 512);
break;
}else{
printf("Alarm should not go off\n");
}
if(CheckAlarm2())
{
printf("Alarm should go off\n");
if(IMCconfig.alarm2.mode ==0)
{
NutThreadCreate("Bq", AlarmBeep, NULL, 512);
}
else{
startStream();
}
NutSleep(61000);
NutThreadExit();
printf("Exit thread and started new one...\n");
NutThreadCreate("Bl", AlarmCheckerThread, NULL, 512);
break;
}else{
printf("Alarm should not go off\n");
}
}
}
OSStatus AkVCam::PluginInterfacePrivate::DeviceStartStream(CMIOHardwarePlugInRef self,
CMIODeviceID device,
CMIOStreamID stream)
{
AkPluginPrivateIntefaceLogID(device);
OSStatus status = kCMIOHardwareUnspecifiedError;
if (!self)
return status;
auto _self = reinterpret_cast<PluginInterfacePrivate *>(self);
auto object = reinterpret_cast<Device *>(_self->self->findObject(device));
if (object)
status = object->startStream(stream);
return status;
}
/* AudioEntryPanel::loadEntry
* Loads an entry into the audio entry panel
*******************************************************************/
bool AudioEntryPanel::loadEntry(ArchiveEntry* entry)
{
// Are we reopening the same entry? For example having looked at
// a text file or image or any other non-audio entry, then
// going back to the original audio entry? Then no need to do
// abort the current song to restart it.
if (this->entry == entry)
return true;
// Stop anything currently playing
stopStream();
resetStream();
opened = false;
// Enable all playback controls initially
slider_seek->Enable();
btn_play->Enable();
btn_pause->Enable();
btn_stop->Enable();
btn_prev->Enable();
btn_next->Enable();
// Reset seek slider
slider_seek->SetValue(0);
// Delete previous temp file
if (wxFileExists(prevfile))
wxRemoveFile(prevfile);
// Open new data
this->entry = entry;
open();
// Autoplay if option is on
if (snd_autoplay)
{
startStream();
timer_seek->Start(10);
}
Refresh();
return true;
}
bool BoardGSM::KhompPvtGSM::setupConnection()
{
if(!call()->_flags.check(Kflags::IS_INCOMING) && !call()->_flags.check(Kflags::IS_OUTGOING))
{
DBG(FUNC,PVT_FMT(_target, "Channel already disconnected"));
return false;
}
bool res_out_of_band_dtmf = (call()->_var_dtmf_state == T_UNKNOWN ?
Opt::_options._suppression_delay() && Opt::_options._out_of_band_dtmfs() : (call()->_var_dtmf_state == T_TRUE));
bool res_echo_cancellator = (call()->_var_echo_state == T_UNKNOWN ?
Opt::_options._echo_canceller() : (call()->_var_echo_state == T_TRUE));
bool res_auto_gain_cntrol = (call()->_var_gain_state == T_UNKNOWN ?
Opt::_options._auto_gain_control() : (call()->_var_gain_state == T_TRUE));
if (!call()->_flags.check(Kflags::REALLY_CONNECTED))
{
obtainRX(res_out_of_band_dtmf);
/* esvazia buffers de leitura/escrita */
cleanupBuffers();
if (!call()->_flags.check(Kflags::KEEP_DTMF_SUPPRESSION))
dtmfSuppression(res_out_of_band_dtmf);
if (!call()->_flags.check(Kflags::KEEP_ECHO_CANCELLATION))
echoCancellation(res_echo_cancellator);
if (!call()->_flags.check(Kflags::KEEP_AUTO_GAIN_CONTROL))
autoGainControl(res_auto_gain_cntrol);
startListen(false);
startStream();
DBG(FUNC, PVT_FMT(_target, "(GSM) Audio callbacks initialized successfully"));
}
return Board::KhompPvt::setupConnection();
}
void LiveWidget::toggleWindowMode()
{
stopStream(this->deviceName, this->deviceChannel);
if (this->windowMode)
{
this->windowModeAction->blockSignals(true);
this->windowModeAction->setChecked(false);
this->windowModeAction->blockSignals(false);
this->liveDialog->hide();
}
else
{
this->liveDialog->visible();
}
this->windowMode = !this->windowMode;
setupRenderTarget(this->windowMode);
startStream(this->deviceName, this->deviceChannel);
}
// Creates the stream, registers the data and end events and starts the stream
void readFile( void * loop ){
gEventLoop = loop;
void * stream = createStream( "prod", "stahp", chunk, initRead, loop );
if (stream == NULL){
fprintf(stderr, "cannot create stream\n");
exit(-1);
}
// remember the stream for use in terminate function
gStream = stream;
registerEvent( loop, "prod", addToSum );
registerEvent( loop, "stahp", terminate );
// start the stream
startStream( stream, fileName );
}
void MainForm::setPlaylist() {
const QList<QTreeWidgetItem *> &selected = links->selectedItems();
play_list->clear();
long size = 0;
for (int i = 0; i < selected.size(); ++i) {
QTreeWidgetItem *item = selected.at(i);
// no top level items
if (item->parent() != nullptr) {
QListWidgetItem *listItem = new QListWidgetItem();
listItem->setTextAlignment(Qt::AlignCenter);
listItem->setText(item->text(Columns::NAME));
listItem->setData(Qt::ItemDataRole::UserRole, item->data(Columns::NAME, Qt::ItemDataRole::UserRole));
size += item->data(Columns::SIZE, Qt::ItemDataRole::UserRole).toInt();
play_list->addItem(listItem);
}
for (int c = 0; c < item->childCount(); ++c) {
QTreeWidgetItem *child = item->child(c);
QListWidgetItem *listItem = new QListWidgetItem();
listItem->setTextAlignment(Qt::AlignCenter);
listItem->setText(child->text(Columns::NAME));
listItem->setData(Qt::ItemDataRole::UserRole, child->data(Columns::NAME, Qt::ItemDataRole::UserRole));
size += child->data(Columns::SIZE, Qt::ItemDataRole::UserRole).toInt();
play_list->addItem(listItem);
}
}
findChild<QLabel *>("stream_size_label")->setText(bytesToMB(size));
startStream();
}
bool BoardGSM::KhompPvtGSM::onCallSuccess(K3L_EVENT *e)
{
DBG(FUNC, PVT_FMT(_target, "(GSM) c"));
bool ret = true;
try
{
ScopedPvtLock lock(this);
ret = KhompPvt::onCallSuccess(e);
if (call()->_pre_answer)
{
dtmfSuppression(Opt::_options._out_of_band_dtmfs());
startListen();
startStream();
switch_channel_mark_pre_answered(getFSChannel());
}
}
catch (ScopedLockFailed & err)
{
LOG(ERROR, PVT_FMT(_target, "(GSM) r (unable to lock %s!)") % err._msg.c_str() );
return false;
}
catch (Board::KhompPvt::InvalidSwitchChannel & err)
{
LOG(ERROR, PVT_FMT(target(), "(GSM) r (%s)") % err._msg.c_str() );
return false;
}
DBG(FUNC, PVT_FMT(_target, "(GSM) r"));
return ret;
}
/* AudioEntryPanel::onBtnPlay
* Called when the play button is pressed
*******************************************************************/
void AudioEntryPanel::onBtnPlay(wxCommandEvent& e)
{
startStream();
timer_seek->Start(10);
}
bool BoardFXO::KhompPvtFXO::onDtmfSendFinish(K3L_EVENT *e)
{
DBG(FUNC, PVT_FMT(_target, "(FXO) c"));
bool ret = true;
try
{
ScopedPvtLock lock(this);
ret = KhompPvt::onDtmfSendFinish(e);
if (callFXO()->_flags.check(Kflags::EARLY_RINGBACK))
{
callFXO()->_flags.clear(Kflags::EARLY_RINGBACK);
/* start grabbing */
startListen();
/* activate resources early... */
bool fax_detected = callFXO()->_flags.check(Kflags::FAX_DETECTED);
bool res_out_of_band_dtmf = Opt::_options._suppression_delay() && Opt::_options._out_of_band_dtmfs() && !fax_detected;
bool res_echo_cancellator = Opt::_options._echo_canceller() && !fax_detected;
bool res_auto_gain_cntrol = Opt::_options._auto_gain_control() && !fax_detected;
if (!call()->_flags.check(Kflags::KEEP_DTMF_SUPPRESSION))
dtmfSuppression(res_out_of_band_dtmf);
if (!call()->_flags.check(Kflags::KEEP_ECHO_CANCELLATION))
echoCancellation(res_echo_cancellator);
if (!call()->_flags.check(Kflags::KEEP_AUTO_GAIN_CONTROL))
autoGainControl(res_auto_gain_cntrol);
/* start sending audio if wanted so */
if (Opt::_options._fxo_send_pre_audio())
startStream();
//TODO: Verificar isso aqui
if (call()->_pre_answer)
{
/* tell the user we are answered! */
switch_channel_mark_answered(getFSChannel());
//pvt->signal_state(AST_CONTROL_ANSWER);
}
else
{
/* are we ringing, now? lets try this way! */
switch_channel_mark_ring_ready(getFSChannel());
//pvt->signal_state(AST_CONTROL_RINGING);
}
}
}
catch (ScopedLockFailed & err)
{
LOG(ERROR, PVT_FMT(_target, "(FXO) r (unable to lock %s!)") % err._msg.c_str() );
return false;
}
catch(Board::KhompPvt::InvalidSwitchChannel & err)
{
LOG(ERROR, PVT_FMT(_target, "(FXO) r (no valid channel: %s)") % err._msg.c_str());
return false;
}
DBG(FUNC, PVT_FMT(_target, "(FXO) r"));
return ret;
}
void XmppStream::onConnectionConnected()
{
FKeepAliveTimer.start(KEEP_ALIVE_TIMEOUT);
insertXmppStanzaHandler(this,XSHO_XMPP_STREAM);
startStream();
}
