bool Engine::initialize() { bool result = false; QAudioFormat format = m_format; if (selectFormat()) { if (m_format != format) { resetAudioDevices(); if (m_file) { emit bufferLengthChanged(bufferLength()); emit dataLengthChanged(dataLength()); emit bufferChanged(0, 0, m_buffer); setRecordPosition(bufferLength()); result = true; } else { m_bufferLength = audioLength(m_format, BufferDurationUs); m_buffer.resize(m_bufferLength); m_buffer.fill(0); emit bufferLengthChanged(bufferLength()); if (m_generateTone) { if (0 == m_tone.endFreq) { const qreal nyquist = nyquistFrequency(m_format); m_tone.endFreq = qMin(qreal(SpectrumHighFreq), nyquist); } // Call function defined in utils.h, at global scope ::generateTone(m_tone, m_format, m_buffer); m_dataLength = m_bufferLength; emit dataLengthChanged(dataLength()); emit bufferChanged(0, m_dataLength, m_buffer); setRecordPosition(m_bufferLength); result = true; } else { emit bufferChanged(0, 0, m_buffer); m_audioInput = new QAudioInput(m_audioInputDevice, m_format, this); m_audioInput->setNotifyInterval(NotifyIntervalMs); result = true; } } m_audioOutput = new QAudioOutput(m_audioOutputDevice, m_format, this); m_audioOutput->setNotifyInterval(NotifyIntervalMs); } } else { if (m_file) emit errorMessage(tr("Audio format not supported"), formatToString(m_format)); else if (m_generateTone) emit errorMessage(tr("No suitable format found"), ""); else emit errorMessage(tr("No common input / output format found"), ""); } ENGINE_DEBUG << "Engine::initialize" << "m_bufferLength" << m_bufferLength; ENGINE_DEBUG << "Engine::initialize" << "m_dataLength" << m_dataLength; ENGINE_DEBUG << "Engine::initialize" << "format" << m_format; return result; }
PppConfOption* PppConfPacket::optionAt (const int optIdx) { ACE_TRACE("PppConfPacket::optionAt"); int optNum = 0; if (codeVal() != Configure_Request && codeVal() != Configure_Ack && codeVal() != Configure_Nak) throw std::runtime_error("No options in this type of packet."); ACE_UINT8 optType, bufLen; ACE_UINT8* optPtr; int optPos = 0; do { optType = *(dataPtr() + optPos); bufLen = *(dataPtr() + optPos + 1) - 2; optPtr = dataPtr() + optPos + 2; optPos += bufLen + 2; } while ( optPos < dataLength() && optNum++ <= optIdx ); if ( optNum != optIdx ) throw std::runtime_error("Could not reach specified option index."); // TODO: use an auto_ptr here so there's no worry about deleting later return new PppConfOption(optType, bufLen, optPtr); }
EXPORT_C TInt CDosExtensionBase::ExecuteMessageL(const RMessage2& aMessage) { API_TRACE_( "[DOSSERVER] CDosExtensionBase::ExecuteMessageL(...)" ); __ASSERT_DEBUG(aMessage.Function() == ECallFunction, PanicClient(aMessage,EPanicIllegalFunction)); TInt retVal(KErrNone); TBool parameterModifiedByDSY(EFalse); // Get data from RMessage TExtensionParPckg extPars; aMessage.ReadL(0, extPars); TInt dataLength(extPars().iParLength); if (dataLength >= 0) { HBufC8* dataBuffer = HBufC8::NewMaxLC( dataLength ); TPtr8 dataPtr = dataBuffer->Des(); aMessage.ReadL( 1, dataPtr ); // Check autocomplete flag TUint autoCompl(aMessage.Int2()); if (autoCompl == KAutoComplete) { COM_TRACE_4( "[DOSSERVER] MDosExtensionBaseDSY::CallFunctionL(0x%x,0x%x,0x%x,0x%x)" ,extPars().iFunc ,dataPtr.Ptr() ,dataPtr.Length() ,autoCompl ); retVal = CallFunctionL(extPars().iFunc, const_cast<TUint8*>(dataPtr.Ptr()), dataPtr.Length(), parameterModifiedByDSY); if((retVal == KErrNone) && parameterModifiedByDSY) { // Write over client's parameters retVal = aMessage.Write(1, dataPtr); } } else { COM_TRACE_3( "[DOSSERVER] MDosExtensionBaseDSY::CallFunctionAndCompleteL(0x%x,0x%x,0x%x)" ,extPars().iFunc ,dataPtr.Ptr() ,dataPtr.Length() ); CallFunctionAndCompleteL(extPars().iFunc, const_cast<TUint8*>(dataPtr.Ptr()), dataPtr.Length(), aMessage); } CleanupStack::PopAndDestroy(); // dataBuffer } else { // Client passed negative parameter length retVal = KErrGeneral; } return retVal; }
unsigned PppConfPacket::countOpts() { unsigned optNum = 0; for (int optPos = 0; optPos < dataLength(); optNum++ ) { ACE_UINT8 bufLen = *(dataPtr() + optPos + 1) - 2; optPos += bufLen + 2; } return optNum; }
/** * Return (malloc'ed) copy of entry data. * @param type entry data type * @param p entry data * @param c entry item count * @retval lengthPtr no. bytes in returned data * @return (malloc'ed) copy of entry data, NULL on error */ static void * grabData(rpm_tagtype_t type, rpm_constdata_t p, rpm_count_t c, int * lengthPtr) { rpm_data_t data = NULL; int length; length = dataLength(type, p, c, 0, NULL); if (length > 0) { data = xmalloc(length); copyData(type, data, p, c, length); } if (lengthPtr) *lengthPtr = length; return data; }
StaticSet(const CONTAINER_t & container) { const uint16_t listSize(container.size()); uint32_t offsets[listSize + 1]; uint32_t dataLength(0); const typename CONTAINER_t::const_iterator begin(container.begin()), end(container.end()); typename CONTAINER_t::const_iterator iterator; uint16_t index; offsets[0] = 0; for (iterator = begin, index = 1; iterator != end; iterator++, index += 1) { offsets[index] = dataLength += iterator->size(); } /* * DEBUG std::cerr << "listSize: " << listSize << ", dataLength: " << dataLength << std::endl; */ StaticSetData< uint16_t, uint32_t, typename DATA_t::TYPE > data(listSize, dataLength); memcpy(const_cast< uint32_t * >(data.offsets), offsets, (listSize + 1) * sizeof(offsets[0])); /* * DEBUG std::cerr << "size: " << *data.size << std::endl; for (int i(0); i <= *data.size; i++) { std::cerr << "offset[" << i << "]: " << data.offsets[i] << std::endl; } */ for (iterator = begin, index = 0; iterator != end; iterator++, index += 1) { iterator->copy(data.data + offsets[index]); } this->data.swap(data); }
void Engine::audioDataReady() { Q_ASSERT(0 == m_bufferPosition); const qint64 bytesReady = m_audioInput->bytesReady(); const qint64 bytesSpace = m_buffer.size() - m_dataLength; const qint64 bytesToRead = qMin(bytesReady, bytesSpace); const qint64 bytesRead = m_audioInputIODevice->read( m_buffer.data() + m_dataLength, bytesToRead); if (bytesRead) { m_dataLength += bytesRead; emit dataLengthChanged(dataLength()); } if (m_buffer.size() == m_dataLength) stopRecording(); }
static const uint32_t calculateSize(const CONTAINER_t & container) { uint32_t dataLength(0); const uint16_t offsetsLength(container.size() + 1); const typename CONTAINER_t::const_iterator end(container.end()); typename CONTAINER_t::const_iterator iterator(container.begin()); uint16_t index(1); for (; iterator != end; iterator++, index += 1) { dataLength += iterator->size(); } const uint32_t TOTAL_SIZE_SIZE(sizeof(STATIC_SET_DATA_TYPE::SIZE_TYPE)), TOTAL_OFFSETS_SIZE(offsetsLength * sizeof(STATIC_SET_DATA_TYPE::OFFSETS_TYPE)), TOTAL_DATA_SIZE(dataLength * sizeof(STATIC_SET_DATA_TYPE::DATA_TYPE)); return TOTAL_SIZE_SIZE + TOTAL_OFFSETS_SIZE + TOTAL_DATA_SIZE; }
static int intAppendEntry(Header h, rpmtd td) { indexEntry entry; int length; if (td->type == RPM_STRING_TYPE || td->type == RPM_I18NSTRING_TYPE) { /* we can't do this */ return 0; } /* Find the tag entry in the header. */ entry = findEntry(h, td->tag, td->type); if (!entry) return 0; length = dataLength(td->type, td->data, td->count, 0, NULL); if (length < 0) return 0; if (ENTRY_IN_REGION(entry)) { char * t = xmalloc(entry->length + length); memcpy(t, entry->data, entry->length); entry->data = t; entry->info.offset = 0; } else entry->data = xrealloc(entry->data, entry->length + length); copyData(td->type, ((char *) entry->data) + entry->length, td->data, td->count, length); entry->length += length; entry->info.count += td->count; return 1; }
/** \ingroup header * Swap int32_t and int16_t arrays within header region. * * If a header region tag is in the set to be swabbed, as the data for a * a header region is located after all other tag data. * * @param entry header entry * @param il no. of entries * @param dl start no. bytes of data * @param pe header physical entry pointer (swapped) * @param dataStart header data start * @param dataEnd header data end * @param regionid region offset * @param fast use offsets for data sizes if possible * @return no. bytes of data in region, -1 on error */ static int regionSwab(indexEntry entry, int il, int dl, entryInfo pe, unsigned char * dataStart, const unsigned char * dataEnd, int regionid, int fast) { if ((entry != NULL && regionid >= 0) || (entry == NULL && regionid != 0)) return -1; for (; il > 0; il--, pe++) { struct indexEntry_s ie; ie.info.tag = ntohl(pe->tag); ie.info.type = ntohl(pe->type); ie.info.count = ntohl(pe->count); ie.info.offset = ntohl(pe->offset); if (hdrchkType(ie.info.type)) return -1; if (hdrchkData(ie.info.count)) return -1; if (hdrchkData(ie.info.offset)) return -1; if (hdrchkAlign(ie.info.type, ie.info.offset)) return -1; ie.data = dataStart + ie.info.offset; if (dataEnd && (unsigned char *)ie.data >= dataEnd) return -1; if (fast && il > 1) { ie.length = ntohl(pe[1].offset) - ie.info.offset; } else { ie.length = dataLength(ie.info.type, ie.data, ie.info.count, 1, dataEnd); } if (ie.length < 0 || hdrchkData(ie.length)) return -1; ie.rdlen = 0; if (entry) { ie.info.offset = regionid; *entry = ie; /* structure assignment */ entry++; } /* Alignment */ dl += alignDiff(ie.info.type, dl); /* Perform endian conversions */ switch (ntohl(pe->type)) { case RPM_INT64_TYPE: { uint64_t * it = ie.data; for (; ie.info.count > 0; ie.info.count--, it += 1) { if (dataEnd && ((unsigned char *)it) >= dataEnd) return -1; *it = htonll(*it); } } break; case RPM_INT32_TYPE: { int32_t * it = ie.data; for (; ie.info.count > 0; ie.info.count--, it += 1) { if (dataEnd && ((unsigned char *)it) >= dataEnd) return -1; *it = htonl(*it); } } break; case RPM_INT16_TYPE: { int16_t * it = ie.data; for (; ie.info.count > 0; ie.info.count--, it += 1) { if (dataEnd && ((unsigned char *)it) >= dataEnd) return -1; *it = htons(*it); } } break; } dl += ie.length; } return dl; }
/** \ingroup header * Swap int32_t and int16_t arrays within header region. * * If a header region tag is in the set to be swabbed, as the data for a * a header region is located after all other tag data. * * @param entry header entry * @param il no. of entries * @param dl start no. bytes of data * @param pe header physical entry pointer (swapped) * @param dataStart header data start * @param dataEnd header data end * @param regionid region offset * @return no. bytes of data in region, -1 on error */ static int regionSwab(indexEntry entry, int il, int dl, entryInfo pe, unsigned char * dataStart, const unsigned char * dataEnd, int regionid) { for (; il > 0; il--, pe++) { struct indexEntry_s ie; rpmTagType type; ie.info.tag = ntohl(pe->tag); ie.info.type = ntohl(pe->type); ie.info.count = ntohl(pe->count); ie.info.offset = ntohl(pe->offset); if (hdrchkType(ie.info.type)) return -1; if (hdrchkData(ie.info.count)) return -1; if (hdrchkData(ie.info.offset)) return -1; if (hdrchkAlign(ie.info.type, ie.info.offset)) return -1; ie.data = dataStart + ie.info.offset; if (dataEnd && (unsigned char *)ie.data >= dataEnd) return -1; ie.length = dataLength(ie.info.type, ie.data, ie.info.count, 1, dataEnd); if (ie.length < 0 || hdrchkData(ie.length)) return -1; ie.rdlen = 0; if (entry) { ie.info.offset = regionid; *entry = ie; /* structure assignment */ entry++; } /* Alignment */ type = ie.info.type; if (typeSizes[type] > 1) { unsigned diff = typeSizes[type] - (dl % typeSizes[type]); if (diff != typeSizes[type]) { dl += diff; } } /* Perform endian conversions */ switch (ntohl(pe->type)) { case RPM_INT64_TYPE: { uint64_t * it = ie.data; for (; ie.info.count > 0; ie.info.count--, it += 1) { if (dataEnd && ((unsigned char *)it) >= dataEnd) return -1; *it = htonll(*it); } } break; case RPM_INT32_TYPE: { int32_t * it = ie.data; for (; ie.info.count > 0; ie.info.count--, it += 1) { if (dataEnd && ((unsigned char *)it) >= dataEnd) return -1; *it = htonl(*it); } } break; case RPM_INT16_TYPE: { int16_t * it = ie.data; for (; ie.info.count > 0; ie.info.count--, it += 1) { if (dataEnd && ((unsigned char *)it) >= dataEnd) return -1; *it = htons(*it); } } break; } dl += ie.length; } return dl; }
int main(int argc, char *argv[]) { FILE *fp; char c; time_t start = time(NULL), end; if ((argc < 3) || (argc > 4)) { printf("Usage:\n%s /dev/port /path/to.hex [q]\n", argv[0]); return 1; } // Open HEX File if ((fp = fopen(argv[2], "r")) == NULL) { printf("Could not open file %s\n", argv[2]); return 1; } // Read it's contents if (readHex(fp) != 0) { printf("Could not parse HEX file %s\n", argv[2]); fclose(fp); return 1; } fclose(fp); if (!isValid()) { printf("HEX-File not valid!\n"); freeHex(); return 1; } uint32_t min = minAddress(); uint32_t max = maxAddress(); uint32_t length = dataLength(); printf("Hex File Path : %s\n", argv[2]); printf("Minimum Address : 0x%X\n", min); printf("Maximum Address : 0x%X\n", max); printf("Data payload : %i bytes\n\n", length); uint8_t *d = (uint8_t *)malloc(length * sizeof(uint8_t)); if (d == NULL) { fprintf(stderr, "Not enough memory (%lu bytes)!\n", length * sizeof(uint8_t)); freeHex(); return 1; } parseData(d); freeHex(); // Open serial port if ((fd = serialOpen(argv[1], 38400, 1)) == -1) { printf("Could not open port %s\n", argv[1]); free(d); return 1; } signal(SIGINT, intHandler); signal(SIGQUIT, intHandler); ping: printf("Pinging bootloader... Stop with CTRL+C\n"); if (argc > 3) { c = argv[3][0]; } else { c = 'f'; } serialWriteChar(fd, c); usleep(PINGDELAY * 1000); if ((serialReadRaw(fd, &c, 1) != 1) || (c != OKAY)) { goto ping; } printf("Got response... Acknowledging...\n"); serialWriteChar(fd, CONFIRM); serialReadChar(fd, &c); if (c != ACK) { printf("Invalid acknowledge! Trying again...\n", c, c); goto ping; } printf("Connection established successfully!\n"); printf("Sending target address...\n"); serialWriteChar(fd, (min & 0xFF000000) >> 24); serialWriteChar(fd, (min & 0x00FF0000) >> 16); serialWriteChar(fd, (min & 0x0000FF00) >> 8); serialWriteChar(fd, min & 0x000000FF); serialReadChar(fd, &c); if (c != OKAY) { printf("Invalid acknowledge from YASAB!\n", c, c); free(d); serialClose(fd); return 1; } printf("Sending data length...\n"); serialWriteChar(fd, (length & 0xFF000000) >> 24); serialWriteChar(fd, (length & 0x00FF0000) >> 16); serialWriteChar(fd, (length & 0x0000FF00) >> 8); serialWriteChar(fd, length & 0x000000FF); serialReadChar(fd, &c); if (c != OKAY) { printf("Invalid acknowledge from YASAB (%x)!\n", c, c); free(d); serialClose(fd); return 1; } printf("\n\n"); for (uint32_t i = 0; i < length; i++) { serialWriteChar(fd, d[i]); if (serialHasChar(fd)) { serialReadChar(fd, &c); if (c == OKAY) { printNextPage(); } else if (c == ERROR) { printf("YASAB aborted the connection!\n"); free(d); serialClose(fd); return 1; } else { printf("Unknown answer from YASAB (%x)!\n", c, c); } } printProgress(i + 1, length); } end = time(NULL); printf("\n\nUpload finished after %3.1f seconds.\n", difftime(end, start)); printf("YASAB - Yet another simple AVR Bootloader\n"); printf("By xythobuz - Visit www.xythobuz.org\n"); free(d); serialClose(fd); return 0; }