QT_USE_NAMESPACE
SerialPortManager::SerialPortManager(QObject *parent)
: QObject(parent)
{
m_serialPort = new QSerialPort(this);
m_settings.portName = "";
m_settings.baud = DEFAULT_BAUD;
m_settings.dataBits = DEFAULT_DATABITS;
m_settings.flowControl = DEFAULT_FLOWCONTROL;
m_settings.parity = DEFAULT_PARITY;
m_settings.stopBits = DEFAULT_STOPBITS;
// forward emit serial port errors
// qRegisterMetaType<QSerialPort::SerialPortError>("QSerialPort::SerialPortError");
connect(m_serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SIGNAL(serialPortError(QSerialPort::SerialPortError)));
// deal with readyRead()
connect(m_serialPort, &QSerialPort::readyRead, this, &SerialPortManager::handleReadyRead);
m_serialPort->clear();
emit portSettingsChanged(m_settings);
}
void SerialPortManager::changePortSettings(PortSettings newSettings)
{
if( m_settings.portName != newSettings.portName ||
m_settings.baud != newSettings.baud ||
m_settings.dataBits != newSettings.dataBits ||
m_settings.flowControl != newSettings.flowControl ||
m_settings.parity != newSettings.parity ||
m_settings.stopBits != newSettings.stopBits ){
m_settings = newSettings;
emit portSettingsChanged(m_settings);
if(m_settings.portName != ""){
reconnect();
}
}
}
// this function passed the jpeg image buffer in, and returns the decoded
// image
int
decodeImage(OPENMAX_JPEG_DECODER * decoder, char *sourceImage,
size_t imageSize)
{
char *sourceOffset = sourceImage; // we store a seperate
// buffer ot image so we
// can offset it
size_t toread = 0; // bytes left to read from buffer
toread += imageSize;
int bFilled = 0; // have we filled our output
// buffer
bufferIndex = 0;
while (toread > 0) {
// get next buffer from array
OMX_BUFFERHEADERTYPE *pBufHeader =
decoder->ppInputBufferHeader[bufferIndex];
// step index and reset to 0 if required
bufferIndex++;
if (bufferIndex >= decoder->inputBufferHeaderCount)
bufferIndex = 0;
// work out the next chunk to load into the decoder
if (toread > pBufHeader->nAllocLen)
pBufHeader->nFilledLen = pBufHeader->nAllocLen;
else
pBufHeader->nFilledLen = toread;
toread = toread - pBufHeader->nFilledLen;
// pass the bytes to the buffer
memcpy(pBufHeader->pBuffer, sourceOffset, pBufHeader->nFilledLen);
printf("Read into buffer %d\n", pBufHeader->nFilledLen);
// update the buffer pointer and set the input flags
sourceOffset = sourceOffset + pBufHeader->nFilledLen;
pBufHeader->nOffset = 0;
pBufHeader->nFlags = 0;
if (toread <= 0) {
pBufHeader->nFlags = OMX_BUFFERFLAG_EOS;
printf("Added EOS to last inout buffer\n");
}
// empty the current buffer
printf("Emptying buffer\n");
int ret =
OMX_EmptyThisBuffer(decoder->imageDecoder->handle,
pBufHeader);
if (ret != OMX_ErrorNone) {
perror("Empty input buffer");
fprintf(stderr, "return code %x\n", ret);
return OMXJPEG_ERROR_MEMORY;
}
// wait for buffer to empty or port changed event
int done = 0;
while ((done == 0) || (decoder->pOutputBufferHeader == NULL)) {
if (decoder->pOutputBufferHeader == NULL) {
ret =
ilclient_wait_for_event
(decoder->imageDecoder->component,
OMX_EventPortSettingsChanged,
decoder->imageDecoder->outPort, 0, 0, 1, 0, 5);
if (ret == 0) {
portSettingsChanged(decoder);
}
} else {
ret =
ilclient_remove_event(decoder->imageDecoder->component,
OMX_EventPortSettingsChanged,
decoder->imageDecoder->outPort,
0, 0, 1);
if (ret == 0)
portSettingsChangedAgain(decoder);
}
// check to see if buffer is now empty
if (pBufHeader->nFilledLen == 0)
done = 1;
if ((done == 0)
|| (decoder->pOutputBufferHeader == NULL)) {
printf("Buffer is now size %d\n", pBufHeader->nFilledLen);
sleep(1);
}
}
// fill the buffer if we have created the buffer
if (bFilled == 0) {
if ((decoder->pOutputBufferHeader == NULL)) {
portSettingsChanged(decoder);
}
OMX_PARAM_U32TYPE param;
param.nSize = sizeof(OMX_PARAM_U32TYPE);
param.nVersion.nVersion = OMX_VERSION;
param.nPortIndex = decoder->imageDecoder->outPort;
OMX_GetParameter(decoder->imageDecoder->handle,
OMX_IndexParamActiveStream, ¶m);
printf("Active stream %d\n", param.nU32);
printf("Trying to fill output buffer\n");
printState(decoder->imageDecoder->handle);
ret = OMX_FillThisBuffer(decoder->imageDecoder->handle,
decoder->pOutputBufferHeader);
if (ret != OMX_ErrorNone) {
perror("Filling output buffer");
fprintf(stderr, "Error code %x\n", ret);
return OMXJPEG_ERROR_MEMORY;
}
bFilled = 1;
}
}
// wait for buffer to fill
/*
* while(pBufHeader->nFilledLen == 0) { sleep(5); }
*/
// wait for end of stream events
int ret =
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventBufferFlag,
decoder->imageDecoder->outPort, 1,
OMX_BUFFERFLAG_EOS, 1,
0, 2);
if (ret != 0) {
fprintf(stderr, "No EOS event on image decoder %d\n", ret);
} else {
fprintf(stderr, "EOS event on image decoder %d\n", ret);
}
printf("Resized %d\n", decoder->pOutputBufferHeader->nFilledLen);
FILE *fp = fopen("out", "w");
int n;
for (n = 0; n < decoder->pOutputBufferHeader->nFilledLen; n++) {
//fputc(decoder->pOutputBufferHeader->pBuffer[n], fp);
fputc(decoder->ppRenderInputBufferHeader[0]->pBuffer[n], fp);
}
fclose(fp);
printf("File written\n");
renderImage(decoder);
return OMXJPEG_OK;
}
static int decodeJpeg(JPEG_DECODER * decoder, FILE *sourceImage, IMAGE *jpeg){
char pSettingsChanged = 0, end = 0, eos = 0, bFilled = 0;
int bufferIndex = 0;
int retVal = OMX_IMAGE_OK;
struct timespec wait;
OMX_BUFFERHEADERTYPE *pBufHeader = decoder->ppInputBufferHeader[bufferIndex];
ilclient_set_empty_buffer_done_callback(decoder->client, emptyBufferDone, decoder);
bufferIndex^=1;
pBufHeader->nFilledLen = fread(pBufHeader->pBuffer, 1, pBufHeader->nAllocLen, sourceImage);
pBufHeader->nOffset = 0;
pBufHeader->nFlags = 0;
if(feof(sourceImage)){
pBufHeader->nFlags = OMX_BUFFERFLAG_EOS;
}else if( pBufHeader->nFilledLen != pBufHeader->nAllocLen){
retVal|=OMX_IMAGE_ERROR_READING;
end=1;
}
pthread_mutex_init(&decoder->lock, NULL);
pthread_cond_init(&decoder->cond, NULL);
while(end == 0 && retVal == OMX_IMAGE_OK){
decoder->emptyBDone=0;
// We've got an eos event early this usually means that we are done decoding
if(ilclient_remove_event(decoder->component, OMX_EventBufferFlag, decoder->outPort,
0, OMX_BUFFERFLAG_EOS, 0 )==0){
eos=1;
break;
}
int ret = OMX_EmptyThisBuffer(decoder->handle, pBufHeader);
if (ret != OMX_ErrorNone) {
retVal|=OMX_IMAGE_ERROR_MEMORY;
break;
}
if(!feof(sourceImage)){
pBufHeader = decoder->ppInputBufferHeader[bufferIndex];
bufferIndex^=1;
pBufHeader->nFilledLen = fread(pBufHeader->pBuffer, 1, pBufHeader->nAllocLen, sourceImage);
pBufHeader->nOffset = 0;
pBufHeader->nFlags = 0;
if(feof(sourceImage)){
pBufHeader->nFlags = OMX_BUFFERFLAG_EOS;
}else if( pBufHeader->nFilledLen != pBufHeader->nAllocLen){
retVal|=OMX_IMAGE_ERROR_READING;
break;
}
}else{
end=1;
}
if(pSettingsChanged == 0 && ilclient_remove_event(decoder->component,
OMX_EventPortSettingsChanged, decoder->outPort, 0, 0, 1 ) == 0){
pSettingsChanged=1;
retVal|=portSettingsChanged(decoder, jpeg);
}
if(!decoder->emptyBDone){
clock_gettime(CLOCK_REALTIME, &wait);
wait.tv_nsec += MAX_EMPTY_BUFFER_WAIT_MS*1000000L;
wait.tv_sec += wait.tv_nsec/1000000000L;
wait.tv_nsec %= 1000000000L;
if(!decoder->emptyBDone){
decoder->emptyBDone=2;
pthread_mutex_lock(&decoder->lock);
pthread_cond_timedwait(&decoder->cond, &decoder->lock, &wait);
pthread_mutex_unlock(&decoder->lock);
}
}
if(pSettingsChanged == 0 && ilclient_wait_for_event(decoder->component,
OMX_EventPortSettingsChanged,decoder->outPort, 0, 0, 1,
ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED, 10) == 0){
pSettingsChanged=1;
retVal|=portSettingsChanged(decoder, jpeg);
}
if (bFilled == 0 && pSettingsChanged==1 && retVal == OMX_IMAGE_OK) {
ret = OMX_FillThisBuffer(decoder->handle, decoder->pOutputBufferHeader);
if (ret != OMX_ErrorNone) {
retVal|=OMX_IMAGE_ERROR_MEMORY;
break;
}
bFilled = 1;
}
}
ilclient_set_empty_buffer_done_callback(decoder->client, NULL, NULL);
if( bFilled == 1 && !eos && ilclient_wait_for_event(decoder->component, OMX_EventBufferFlag,
decoder->outPort, 0, OMX_BUFFERFLAG_EOS, 0, ILCLIENT_BUFFER_FLAG_EOS, TIMEOUT_MS) != 0 ){
retVal|=OMX_IMAGE_ERROR_NO_EOS;
}
pthread_mutex_destroy(&decoder->lock);
pthread_cond_destroy(&decoder->cond);
int i = 0;
for (i = 0; i < DECODER_BUFFER_NUM; i++) {
int ret = OMX_FreeBuffer(decoder->handle,decoder->inPort, decoder->ppInputBufferHeader[i]);
if(ret!= OMX_ErrorNone){
retVal|=OMX_IMAGE_ERROR_MEMORY;
}
}
int ret=OMX_SendCommand(decoder->handle, OMX_CommandPortDisable, decoder->inPort, NULL);
if(ret!= OMX_ErrorNone){
retVal|=OMX_IMAGE_ERROR_PORTS;
}
ilclient_wait_for_event(decoder->component, OMX_EventCmdComplete,
OMX_CommandPortDisable, 0, decoder->inPort, 0,
ILCLIENT_PORT_DISABLED, TIMEOUT_MS);
if(bFilled==1){
OMX_SendCommand(decoder->handle, OMX_CommandFlush, decoder->outPort, NULL);
ilclient_wait_for_event(decoder->component,OMX_EventCmdComplete, OMX_CommandFlush,
0, decoder->outPort, 0, ILCLIENT_PORT_FLUSH ,TIMEOUT_MS);
ret= OMX_FreeBuffer(decoder->handle, decoder->outPort, decoder->pOutputBufferHeader);
if(ret!= OMX_ErrorNone){
retVal|=OMX_IMAGE_ERROR_MEMORY;
}
}
if(pSettingsChanged==1){
ret= OMX_SendCommand(decoder->handle, OMX_CommandPortDisable, decoder->outPort, NULL);
if(ret!= OMX_ErrorNone){
retVal|=OMX_IMAGE_ERROR_PORTS;
}
}
ilclient_change_component_state(decoder->component, OMX_StateIdle);
ilclient_change_component_state(decoder->component, OMX_StateLoaded);
return retVal;
}
void SoftMPEG4::onQueueFilled(OMX_U32 portIndex) {
if (mSignalledError || mOutputPortSettingsChange != NONE) {
return;
}
List<BufferInfo *> &inQueue = getPortQueue(0);
List<BufferInfo *> &outQueue = getPortQueue(1);
while (!inQueue.empty() && outQueue.size() == kNumOutputBuffers) {
BufferInfo *inInfo = *inQueue.begin();
OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
PortInfo *port = editPortInfo(1);
OMX_BUFFERHEADERTYPE *outHeader =
port->mBuffers.editItemAt(mNumSamplesOutput & 1).mHeader;
if ((inHeader->nFlags & OMX_BUFFERFLAG_EOS) && inHeader->nFilledLen == 0) {
inQueue.erase(inQueue.begin());
inInfo->mOwnedByUs = false;
notifyEmptyBufferDone(inHeader);
++mInputBufferCount;
outHeader->nFilledLen = 0;
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
List<BufferInfo *>::iterator it = outQueue.begin();
while ((*it)->mHeader != outHeader) {
++it;
}
BufferInfo *outInfo = *it;
outInfo->mOwnedByUs = false;
outQueue.erase(it);
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
return;
}
uint8_t *bitstream = inHeader->pBuffer + inHeader->nOffset;
if (!mInitialized) {
uint8_t *vol_data[1];
int32_t vol_size = 0;
vol_data[0] = NULL;
if (inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
vol_data[0] = bitstream;
vol_size = inHeader->nFilledLen;
}
MP4DecodingMode mode =
(mMode == MODE_MPEG4) ? MPEG4_MODE : H263_MODE;
Bool success = PVInitVideoDecoder(
mHandle, vol_data, &vol_size, 1, mWidth, mHeight, mode);
if (!success) {
ALOGW("PVInitVideoDecoder failed. Unsupported content?");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
MP4DecodingMode actualMode = PVGetDecBitstreamMode(mHandle);
if (mode != actualMode) {
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
PVSetPostProcType((VideoDecControls *) mHandle, 0);
if (inHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
}
mInitialized = true;
if (mode == MPEG4_MODE && portSettingsChanged()) {
return;
}
continue;
}
if (!mFramesConfigured) {
PortInfo *port = editPortInfo(1);
OMX_BUFFERHEADERTYPE *outHeader = port->mBuffers.editItemAt(1).mHeader;
PVSetReferenceYUV(mHandle, outHeader->pBuffer);
mFramesConfigured = true;
}
uint32_t useExtTimestamp = (inHeader->nOffset == 0);
// decoder deals in ms (int32_t), OMX in us (int64_t)
// so use fake timestamp instead
uint32_t timestamp = 0xFFFFFFFF;
if (useExtTimestamp) {
mPvToOmxTimeMap.add(mPvTime, inHeader->nTimeStamp);
timestamp = mPvTime;
mPvTime++;
}
int32_t bufferSize = inHeader->nFilledLen;
int32_t tmp = bufferSize;
// The PV decoder is lying to us, sometimes it'll claim to only have
// consumed a subset of the buffer when it clearly consumed all of it.
// ignore whatever it says...
if (PVDecodeVideoFrame(
mHandle, &bitstream, ×tamp, &tmp,
&useExtTimestamp,
outHeader->pBuffer) != PV_TRUE) {
ALOGE("failed to decode video frame.");
notify(OMX_EventError, OMX_ErrorUndefined, 0, NULL);
mSignalledError = true;
return;
}
if (portSettingsChanged()) {
return;
}
// decoder deals in ms, OMX in us.
outHeader->nTimeStamp = mPvToOmxTimeMap.valueFor(timestamp);
mPvToOmxTimeMap.removeItem(timestamp);
inHeader->nOffset += bufferSize;
inHeader->nFilledLen = 0;
if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
outHeader->nFlags = OMX_BUFFERFLAG_EOS;
} else {
outHeader->nFlags = 0;
}
if (inHeader->nFilledLen == 0) {
inInfo->mOwnedByUs = false;
inQueue.erase(inQueue.begin());
inInfo = NULL;
notifyEmptyBufferDone(inHeader);
inHeader = NULL;
}
++mInputBufferCount;
outHeader->nOffset = 0;
outHeader->nFilledLen = (mWidth * mHeight * 3) / 2;
List<BufferInfo *>::iterator it = outQueue.begin();
while ((*it)->mHeader != outHeader) {
++it;
}
BufferInfo *outInfo = *it;
outInfo->mOwnedByUs = false;
outQueue.erase(it);
outInfo = NULL;
notifyFillBufferDone(outHeader);
outHeader = NULL;
++mNumSamplesOutput;
}
}
// this function passed the jpeg image buffer in, and returns the decoded
// image
int
decodeImage(OPENMAX_JPEG_DECODER * decoder, char *sourceImage,
size_t imageSize)
{
char *sourceOffset = sourceImage; // we store a seperate
// buffer ot image so we
// can offset it
size_t toread = 0; // bytes left to read from buffer
toread += imageSize;
int bFilled = 0; // have we filled our output
// buffer
bufferIndex = 0;
while (toread > 0) {
// get next buffer from array
OMX_BUFFERHEADERTYPE *pBufHeader =
decoder->ppInputBufferHeader[bufferIndex];
// step index and reset to 0 if required
bufferIndex++;
if (bufferIndex >= decoder->inputBufferHeaderCount)
bufferIndex = 0;
// work out the next chunk to load into the decoder
if (toread > pBufHeader->nAllocLen)
pBufHeader->nFilledLen = pBufHeader->nAllocLen;
else
pBufHeader->nFilledLen = toread;
toread = toread - pBufHeader->nFilledLen;
// pass the bytes to the buffer
memcpy(pBufHeader->pBuffer, sourceOffset, pBufHeader->nFilledLen);
// update the buffer pointer and set the input flags
sourceOffset = sourceOffset + pBufHeader->nFilledLen;
pBufHeader->nOffset = 0;
pBufHeader->nFlags = 0;
if (toread <= 0) {
pBufHeader->nFlags = OMX_BUFFERFLAG_EOS;
}
// empty the current buffer
int ret =
OMX_EmptyThisBuffer(decoder->imageDecoder->handle,
pBufHeader);
if (ret != OMX_ErrorNone) {
perror("Empty input buffer");
fprintf(stderr, "return code %x\n", ret);
return OMXJPEG_ERROR_MEMORY;
}
// wait for buffer to empty or port changed event
int done = 0;
while ((done == 0) && (decoder->pOutputBufferHeader == NULL)) {
if (decoder->pOutputBufferHeader == NULL) {
ret =
ilclient_wait_for_event
(decoder->imageDecoder->component,
OMX_EventPortSettingsChanged,
decoder->imageDecoder->outPort, 0, 0, 1, 0, 5);
if (ret == 0) {
ret = portSettingsChanged(decoder);
if (ret != OMXJPEG_OK)
return ret;
}
} else {
ret =
ilclient_remove_event(decoder->imageDecoder->component,
OMX_EventPortSettingsChanged,
decoder->imageDecoder->outPort,
0, 0, 1);
if (ret == 0)
portSettingsChangedAgain(decoder);
}
// check to see if buffer is now empty
if (pBufHeader->nFilledLen == 0)
done = 1;
if ((done == 0)
|| (decoder->pOutputBufferHeader == NULL))
sleep(1);
}
// fill the buffer if we have created the buffer
if ((bFilled == 0) && (decoder->pOutputBufferHeader != NULL)) {
ret = OMX_FillThisBuffer(decoder->imageResizer->handle,
decoder->pOutputBufferHeader);
if (ret != OMX_ErrorNone) {
perror("Filling output buffer");
fprintf(stderr, "Error code %x\n", ret);
return OMXJPEG_ERROR_MEMORY;
}
bFilled = 1;
}
}
// wait for buffer to fill
/*
* while(pBufHeader->nFilledLen == 0) { sleep(5); }
*/
// wait for end of stream events
int ret =
ilclient_wait_for_event(decoder->imageDecoder->component,
OMX_EventBufferFlag,
decoder->imageDecoder->outPort, 1,
OMX_BUFFERFLAG_EOS, 1,
0, 2);
if (ret != 0) {
fprintf(stderr, "No EOS event on image decoder %d\n", ret);
}
ret = ilclient_wait_for_event(decoder->imageResizer->component,
OMX_EventBufferFlag,
decoder->imageResizer->outPort, 1,
OMX_BUFFERFLAG_EOS, 1, 0, 2);
if (ret != 0) {
fprintf(stderr, "No EOS event on image resizer %d\n", ret);
}
return OMXJPEG_OK;
}
void MenuSettings::on_btnOk_clicked()
{
// Port settings
if( settings->value( "bitsPerSecond" ).toString() != ui->cmbBps->currentText() ||
settings->value( "dataBits" ).toString() != ui->cmbDataBits->currentText() ||
settings->value( "parity" ).toString() != ui->cmbParity->currentText() ||
settings->value( "stopBits" ).toString() != ui->cmbStopBits->currentText() ||
settings->value( "flowControl" ).toString() != ui->cmbFlowControl->currentText() )
{
settings->setValue( "bitsPerSecond", ui->cmbBps->currentText() );
settings->setValue( "dataBits", ui->cmbDataBits->currentText() );
settings->setValue( "parity", ui->cmbParity->currentText() );
settings->setValue( "stopBits", ui->cmbStopBits->currentText() );
settings->setValue( "flowControl", ui->cmbFlowControl->currentText() );
emit portSettingsChanged();
}
// CONNECTION SETTINGS
bool changed = false;
// connect all or single
if( group.checkedButton() == ui->radioAll )
{
if( settings->value( "port" ).toString() != "ALL" )
{
settings->setValue( "port", "ALL" );
changed = true;
}
}
else if( group.checkedButton() == ui->radioSingle )
{
if( settings->value( "port" ).toString() != ui->cmbPorts->currentText() )
{
settings->setValue( "port", ui->cmbPorts->currentText() );
changed = true;
}
}
// auto connect
if( settings->value( "autoConnect").toBool() != ui->chkAutoConnect->isChecked() )
{
if( ui->chkAutoConnect->isChecked() ) // checked
settings->setValue( "autoConnect", true );
else // unchecked
settings->setValue( "autoConnect", false );
changed = true;
}
// did the connection settings change
if( changed )
emit connectionSettingsChanged();
// VALIDATION SETTINGS
if( settings->value( "validationManualCommand" ).toBool() != ui->chkVerifManCom->isChecked() ||
settings->value( "validationSequence" ).toBool() != ui->chkVerifSeq->isChecked() )
{
// validation: manual command
if( ui->chkVerifManCom->isChecked() ) // checked
settings->setValue( "validationManualCommand", true );
else // unchecked
settings->setValue( "validationManualCommand", false );
// validation: sequence
if( ui->chkVerifSeq->isChecked() ) // checked
settings->setValue( "validationSequence", true );
else // unchecked
settings->setValue( "validationSequence", false );
emit validationSettingsChanged();
}
this->close();
}
