C++ processBuffer函数代码示例

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;
}