void InterSense::deviceThreadMethod(void)
	{
	/* Reset first measurement flags: */
	for(int i=0;i<numTrackers;++i)
		notFirstMeasurements[i]=false;
	
	/* Read first record in synchronizing mode: */
	int stationId;
	char recordBuffer[256];
	stationId=readRecordSync(recordBuffer);
	
	/* Parse read buffer: */
	processBuffer(stationIdToIndex[stationId],recordBuffer);
	
	while(true)
		{
		/* Try reading record in synchronized mode: */
		if((stationId=readRecordNoSync(recordBuffer))==0)
			{
			/* Fall back to synchronizing mode: */
			#ifdef VERBOSE
			printf("InterSense: Resynchronizing with tracker stream\n");
			fflush(stdout);
			#endif
			stationId=readRecordSync(recordBuffer);
			}
		
		/* Parse read buffer: */
		processBuffer(stationIdToIndex[stationId],recordBuffer);
		}
	}

static void readLogLines(int logfd)
{
    while (1) {
        unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1] __attribute__((aligned(4)));
        struct logger_entry *entry = (struct logger_entry *) buf;
        int ret;

        ret = read(logfd, entry, LOGGER_ENTRY_MAX_LEN);
        if (ret < 0) {
            if (errno == EINTR)
                continue;
            if (errno == EAGAIN)
                break;
            perror("logcat read");
            exit(EXIT_FAILURE);
        }
        else if (!ret) {
            fprintf(stderr, "read: Unexpected EOF!\n");
            exit(EXIT_FAILURE);
        }

        /* NOTE: driver guarantees we read exactly one full entry */

        entry->msg[entry->len] = '\0';

        if (g_printBinary) {
            printBinary(entry);
        } else {
            (void) processBuffer(entry);
        }
    }
}

bool KeyStream::decodeMessage(QByteArray& buffer, int macOffset, int offset, int length)
{
    //qDebug() << "decodeMessage seq:" << seq;
    QByteArray base = buffer.left(buffer.size() - 4);
    QByteArray hmac = buffer.right(4);
    QByteArray buffer2 = processBuffer(base, seq++);
    buffer2 = mac->hmacSha1(buffer2);

    QByteArray origBuffer = buffer;
    buffer = base;
    rc4->Cipher(buffer.data(),0,buffer.size());

    for (int i = 0; i < 4; i++)
    {
        if (buffer2[macOffset + i] != hmac[i])
        {
            qDebug() << "error decoding message. macOffset:" << macOffset << "offset:" << offset << "length:" << length << "bufferSize:" << buffer.size();
            qDebug() << "buffer mac:" << buffer2.toHex() << "hmac:" << hmac.toHex();
            qDebug() << "buffer:" << buffer.toHex();
            qDebug() << "origBuffer:" << origBuffer.toHex();
            return false;
        }
    }
    return true;
}

void ttSerialDevice::update() {
	if ( m_connection.isInitialized() ) {
		int available = m_connection.available();
		if ( available > 0 ) {
			unsigned char* buffer = new unsigned char [ available + 1 ];
			buffer[ available ] = 0;
			m_connection.readBytes(buffer,available);
			//
			//
			//
			bool partial_message = m_buffer.tellp() > 0;
			for ( int i = 0; i < available; i++ ) {
				if ( partial_message ) {
					if ( buffer[ i ] == ']' ) { // end message
						processBuffer();
						return;
					} else {
						m_buffer << buffer[ i ];
					}
				} else if ( buffer[ i ] == '[' ) { // start of message
					partial_message = true;
				}
			}
		}
	}
}

void EPDStreamer::processResponse()
{
    while (connState == STATE_CONN_CONNECTED) {
        while (client.available()) {
            char c = client.read();

            if (httpState == STATE_HTTP_BODY) {
                if (callbacksEnabled && onBodyByteReadCallback) {
                    onBodyByteReadCallback(c);
                }
            } else {
                if (c == 13) {
                    continue;
                } else if (c == 10) {
                    buffer[bufferPtr] = 0;
                    processBuffer();
                    bufferPtr = 0;
                } else {
                    buffer[bufferPtr++] = c;
                }
            }
        }

        if (!client.connected()) {
            Serial.println("The client has disconnected");
            client.stop();
            connState = STATE_CONN_DISCONNECTED;

            if (httpState == STATE_HTTP_BODY && callbacksEnabled && onStreamingCompletedCallback) {
                onStreamingCompletedCallback();
            }
        }
    }
}

void WebSocketChannel::didReceiveSocketStreamData(SocketStreamHandle& handle, const char* data, std::optional<size_t> len)
{
    if (len)
        LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received %zu bytes", this, len.value());
    else
        LOG(Network, "WebSocketChannel %p didReceiveSocketStreamData() Received no bytes", this);
    Ref<WebSocketChannel> protectedThis(*this); // The client can close the channel, potentially removing the last reference.
    ASSERT(&handle == m_handle);
    if (!m_document) {
        return;
    }
    if (!len || !len.value()) {
        handle.disconnect();
        return;
    }
    if (!m_client) {
        m_shouldDiscardReceivedData = true;
        handle.disconnect();
        return;
    }
    if (m_shouldDiscardReceivedData)
        return;
    if (!appendToBuffer(data, len.value())) {
        m_shouldDiscardReceivedData = true;
        fail("Ran out of memory while receiving WebSocket data.");
        return;
    }
    while (!m_suspended && m_client && !m_buffer.isEmpty()) {
        if (!processBuffer())
            break;
    }
}

void PackParser::processBuffer()
{
    if(last_pack_unfinished){
        if(raw_buffer_.bytesAvailable() >= pack_size){
            QByteArray info = raw_buffer_.read(pack_size);
            last_pack_unfinished = false;
            emit newRawPack(info);
        }else{
            return;
        }
    }

    if(raw_buffer_.size() < 4){
        return;
    }

    // in case we have a lot of data to process
    QCoreApplication::processEvents();
    char c1, c2, c3, c4;
    raw_buffer_.getChar(&c1);
    raw_buffer_.getChar(&c2);
    raw_buffer_.getChar(&c3);
    raw_buffer_.getChar(&c4);
    pack_size = (uchar(c1) << 24) + (uchar(c2) << 16)
            + (uchar(c3) << 8) + uchar(c4);

    processBuffer();
}

void MainThreadWebSocketChannel::resumeTimerFired(Timer<MainThreadWebSocketChannel>* timer)
{
    ASSERT_UNUSED(timer, timer == &m_resumeTimer);

    processBuffer();
    if (!m_suspended && m_client && (m_state == ChannelClosed) && m_handle)
        didCloseSocketStream(m_handle.get());
}

static void printNextEntry(log_device_t* dev) {
    maybePrintStart(dev);
    if (g_printBinary) {
        printBinary(&dev->queue->entry);
    } else {
        processBuffer(dev, &dev->queue->entry);
    }
    skipNextEntry(dev);
}

void WebSocketChannel::resumeTimerFired()
{
    Ref<WebSocketChannel> protectedThis(*this); // The client can close the channel, potentially removing the last reference.
    while (!m_suspended && m_client && !m_buffer.isEmpty())
        if (!processBuffer())
            break;
    if (!m_suspended && m_client && m_closed && m_handle)
        didCloseSocketStream(*m_handle);
}

void TCPStreamSink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes) {
  if (numTruncatedBytes > 0) {
    envir() << "TCPStreamSink::afterGettingFrame(): The input frame data was too large for our buffer.  "
	    << numTruncatedBytes
	    << " bytes of trailing data was dropped!  Correct this by increasing the definition of \"TCP_STREAM_SINK_BUFFER_SIZE\" in \"include/TCPStreamSink.hh\".\n";
  }
  fUnwrittenBytesEnd += frameSize;
  processBuffer();
}

void Connection::socketData() {

    int toRead;
    int bytesRead=0;
    int thisRead;

    toRead=tcpSocket->bytesAvailable();
    while(bytesRead<toRead) {
        switch(state) {
        case READ_HEADER_TYPE:
            thisRead=tcpSocket->read(&hdr[0],1);
            if (thisRead == 1) bytes++;
            if (hdr[0] == AUDIO_BUFFER) state=READ_AUDIO_HEADER;
            else state=READ_HEADER;
            break;

        case READ_AUDIO_HEADER:
            thisRead=tcpSocket->read(&hdr[bytes],AUDIO_HEADER_SIZE - bytes);
            bytes+=thisRead;
            if ((bytes == AUDIO_HEADER_SIZE)){
                    length = atoi(&hdr[AUDIO_LENGTH_POSITION]);
                    buffer = (char*)malloc(length);
                    bytes = 0;
                    state = READ_BUFFER;
             }
            break;

         case READ_HEADER:
            thisRead=tcpSocket->read(&hdr[bytes],HEADER_SIZE - bytes);
            bytes+=thisRead;
            if(bytes==HEADER_SIZE) {
                length=atoi(&hdr[26]);
                buffer=(char*)malloc(length);
                bytes=0;
                state=READ_BUFFER;
            }
            break;

        case READ_BUFFER:
            thisRead=tcpSocket->read(&buffer[bytes],length-bytes);
            bytes+=thisRead;
            //qDebug() << "READ_BUFFER: read " << bytes << " of " << length;
            if(bytes==length) {
                queue.enqueue(new Buffer(hdr,buffer));
                QTimer::singleShot(0,this,SLOT(processBuffer()));
                hdr=(char*)malloc(HEADER_SIZE);
                bytes=0;
                state=READ_HEADER_TYPE;
            }
            break;
        }
        bytesRead+=thisRead;
    }
}

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    Fdata=new fft;
    Wdata=new wavedata;
    probe=new QAudioProbe;
    Ddata=new detaildata;
    l=new QStringList;
    label=new QLabel;

    label->resize( QSize( 500, 100 ));
    QPalette pa;

    pa.setColor(QPalette::Background, QColor(0x00,0xff,0x00,0x00));
    pa.setColor(QPalette::WindowText,Qt::white);

    label->setPalette (pa);

    QFont ft;
    ft.setPointSize(14);
    label->setFont(ft);
    volume=80;
    order=0;
    ismute=0;
    ui->setupUi(this);
    pushButtonc=0;
    ui->tableWidget->clearContents();
    ui->tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
    playList=new QMediaPlaylist;
    playList->setPlaybackMode(QMediaPlaylist::Loop);
    player=new QMediaPlayer;
    player->setPlaylist(playList);
    player->setVolume(volume);
    ui->horizontalSlider->setRange(0, 0);
    ui->tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->tableWidget, SIGNAL(customContextMenuRequested(const QPoint&)),
            this, SLOT(show_contextmenu(const QPoint&)));

    connect(player, SIGNAL(positionChanged(qint64)), this, SLOT(positionChanged1(qint64)));
    connect(player, SIGNAL(durationChanged(qint64)), this, SLOT(durationChanged1(qint64)));

    probe->setSource(player);
    connect(probe,SIGNAL(audioBufferProbed(QAudioBuffer)),Wdata,SLOT(processBuffer(QAudioBuffer)));
    //connect(probe,SIGNAL(audioBufferProbed(QAudioBuffer)),this,SLOT(test(QAudioBuffer)));
    connect(Wdata,SIGNAL(wavedataUpdated(wavedata&)),Fdata,SLOT(calculateFFT(wavedata&)));
    connect(Wdata,SIGNAL(wavedataUpdated(wavedata&)),Ddata,SLOT(processWaveData(wavedata&)));
    connect(Fdata,SIGNAL(FFTstandby(fft&)),Ddata,SLOT(processFFTData(fft&)));
    connect(Ddata,SIGNAL(detailDataStandbyT(QString&)),this,SLOT(update_ZhuangBi(QString&)));


}

void StreamingPlayer::poling() {

    int processed = cross::AudioSystem::getSourceProcessed(source_id_);

    if (processed) {
        cross::AudioSystem::BufferID buffer;

        // 処理を終えたキューをデキュー
        cross::AudioSystem::unqueueBuffers(source_id_, 1, &buffer);

        // バッファを埋める
        processBuffer(buffer);
        
        // エンキュー
        cross::AudioSystem::queueBuffers(source_id_, 1, &buffer);
    }

}

bool ImuseChannel::appendData(Common::SeekableReadStream &b, int32 size) {
	if (_dataSize == -1) {
		assert(size > 8);
		uint32 imus_type = b.readUint32BE();
		/*uint32 imus_size =*/ b.readUint32BE();
		if (imus_type != MKTAG('i','M','U','S'))
			error("Invalid Chunk for imuse_channel");
		size -= 8;
		_tbufferSize = size;
		assert(_tbufferSize);
		_tbuffer = (byte *)malloc(_tbufferSize);
		if (!_tbuffer)
			error("imuse_channel failed to allocate memory");
		b.read(_tbuffer, size);
		_dataSize = -2;
	} else {
		if (_tbuffer) {
			byte *old = _tbuffer;
			int32 new_size = size + _tbufferSize;
			_tbuffer = (byte *)malloc(new_size);
			if (!_tbuffer)
				error("imuse_channel failed to allocate memory");
			memcpy(_tbuffer, old, _tbufferSize);
			free(old);
			b.read(_tbuffer + _tbufferSize, size);
			_tbufferSize += size;
		} else {
			_tbufferSize = size;
			_tbuffer = (byte *)malloc(_tbufferSize);
			if (!_tbuffer)
				error("imuse_channel failed to allocate memory");
			b.read(_tbuffer, size);
		}
	}

	processBuffer();

	_srbufferSize = _sbufferSize;
	if (_sbuffer && _bitsize == 12)
		decode();

	return true;
}

// 读取客户端数据
void ReadFromClient(aeEventLoop *el, int fd, void *privdata, int mask)
{
	int res;
	client_t* c = privdata;
	res = read(fd, c->request + c->len, MAX_LEN - c->len);
	if( res <= 0 )
	{
		ClientClose(el, c, res);
		return;
	}
	c->len += res;	
	
	if(processBuffer(el, c, res) == OK) {
		if(aeCreateFileEvent(el, fd, AE_WRITABLE, sendReplyToClient, c) == AE_ERR)  {
			fprintf(stderr, "Can't Register File Writeable Event.\n");
			ClientClose(el, c, res);
		}			
	}
	
}

// figure processing latency by doing 'dry runs' of processBuffer()
bigtime_t AudioFilterNode::calcProcessingLatency() {

	PRINT(("AudioFilterNode::calcProcessingLatency()\n"));
	
	ASSERT(m_input.source != media_source::null);
	ASSERT(m_output.destination != media_destination::null);
	ASSERT(m_op);

	// initialize filter
	m_op->init();

	size_t maxSize = max_c(
		m_input.format.u.raw_audio.buffer_size,
		m_output.format.u.raw_audio.buffer_size);

	// allocate a temporary buffer group
	BBufferGroup* testGroup = new BBufferGroup(
		maxSize, 1);
	
	// fetch a buffer big enough for in-place processing
	BBuffer* buffer = testGroup->RequestBuffer(
		maxSize, -1);
	ASSERT(buffer);
	
	buffer->Header()->type = B_MEDIA_RAW_AUDIO;
	buffer->Header()->size_used = m_input.format.u.raw_audio.buffer_size;
	
	// run the test
	bigtime_t preTest = system_time();
	processBuffer(buffer, buffer);
	bigtime_t elapsed = system_time()-preTest;
	
	// clean up
	buffer->Recycle();
	delete testGroup;

	// reset filter state
	m_op->init();

	return elapsed;// + 100000LL;
}

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);

    createTrayIcon();
    createAudioRecorder();
    createDeviceList();
    createRecordButtonsGroup();

    connect(audioRecorder, SIGNAL(stateChanged(QMediaRecorder::State)),
            this, SLOT(onStateChanged(QMediaRecorder::State)));
    connect(audioRecorder, SIGNAL(durationChanged(qint64)),
            this, SLOT(updateProgress(qint64)));
    connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
            this, SLOT(iconActivated(QSystemTrayIcon::ActivationReason)));
    connect(recordButtons, SIGNAL(buttonClicked(QAbstractButton*)),
            this, SLOT(toggleRecord(QAbstractButton*)));
    connect(probe, SIGNAL(audioBufferProbed(QAudioBuffer)),
            this, SLOT(processBuffer(QAudioBuffer)));
}

bool SaudChannel::appendData(Common::SeekableReadStream &b, int32 size) {
	if (_dataSize == -1) {
		assert(size > 8);
		uint32 saud_type = b.readUint32BE();
		/*uint32 saud_size =*/ b.readUint32BE();
		if (saud_type != MKID_BE('SAUD'))
			error("Invalid Chunk for SaudChannel : %X", saud_type);
		size -= 8;
		_dataSize = -2;
	}
	if (_tbuffer) {
		byte *old = _tbuffer;
		_tbuffer = (byte *)malloc(_tbufferSize + size);
		if (!_tbuffer)
			error("saud_channel failed to allocate memory");
		memcpy(_tbuffer, old, _tbufferSize);
		free(old);
		b.read(_tbuffer + _tbufferSize, size);
		_tbufferSize += size;
	} else {
		_tbufferSize = size;
		_tbuffer = (byte *)malloc(_tbufferSize);
		if (!_tbuffer)
			error("saud_channel failed to allocate memory");
		b.read(_tbuffer, _tbufferSize);
	}

	if (_keepSize) {
		_sbufferSize = _tbufferSize;
		_sbuffer = _tbuffer;
		_tbufferSize = 0;
		_tbuffer = 0;
	} else {
		processBuffer();
	}

	return true;
}

/// return latest hash as 16 hex characters
std::string Keccak::getHash()
{
  // process remaining bytes
  processBuffer();

  // convert hash to string
  static const char dec2hex[16 + 1] = "0123456789abcdef";

  // number of significant elements in hash (uint64_t)
  unsigned int hashLength = m_bits / 64;

  std::string result;
  for (unsigned int i = 0; i < hashLength; i++)
    for (unsigned int j = 0; j < 8; j++) // 64 bits => 8 bytes
    {
      // convert a byte to hex
      unsigned char oneByte = (unsigned char) (m_hash[i] >> (8 * j));
      result += dec2hex[oneByte >> 4];
      result += dec2hex[oneByte & 15];
    }

  return result;
}