void tst_CTelegramStream::testEncode() { const QStringList dataList = { QStringLiteral("1"), QStringLiteral("02"), QStringLiteral("003"), QStringLiteral("0004"), QStringLiteral("00005"), QStringLiteral("000006"), QStringLiteral("0000007"), QStringLiteral("00000008") }; for (const QString &s : dataList) { CTelegramStream stream(CTelegramStream::WriteOnly); stream << s; const int writtenBytes = stream.getData().size(); if (writtenBytes != getValueEncodedSize(s)) { qWarning() << "A problem with" << s; } QCOMPARE(writtenBytes, getValueEncodedSize(s)); } for (const QString &s : dataList) { CTelegramStream stream(CTelegramStream::WriteOnly); stream << s; const QByteArray encodedStr = encodeData(s); const QByteArray streamedStr = stream.getData(); if (streamedStr != encodedStr) { qWarning() << "A problem with" << s; } QCOMPARE(streamedStr.toHex(), encodedStr.toHex()); } { const TLValue testValue = TLValue::AccountChangePhone; const QByteArray encoded = encodeData(testValue); CTelegramStream stream(encoded); TLValue readValue; stream >> readValue; QCOMPARE(testValue, readValue); } { const TLValue testValue = TLValue::AccountChangePhone; const QString phoneNumber = QStringLiteral("myPhone"); // size = 7 const QString phoneCodeHash = QStringLiteral("7531"); // size = 4 const QByteArray encoded = encodeData(testValue, phoneNumber, phoneCodeHash); CTelegramStream stream(encoded); TLValue readValue; QString readPhoneNumber; QString readPhoneCodeHash; // QString readPhoneCode; stream >> readValue; stream >> readPhoneNumber; stream >> readPhoneCodeHash; QCOMPARE(testValue, readValue); QCOMPARE(readPhoneNumber, phoneNumber); QCOMPARE(readPhoneCodeHash, phoneCodeHash); } }
bool SNMPPdu::encode(unsigned char *buf,int buflen,int pklen) { // int pklen = getPDUBerLength(); // int buflen = pklen+1+ getLengthBerLength(pklen); // buf = new unsigned char[buflen]; // *len = buflen; return encodeData(buf,buflen,pklen); }
void QPpsObjectPrivate::encodeObject(pps_encoder_t *encoder, const QVariantMap &data, bool *ok) { for (QVariantMap::const_iterator it = data.constBegin(); it != data.constEnd(); ++it) { encodeData(encoder, it.key().toUtf8().constData(), it.value(), ok); if (!(*ok)) return; } // if the passed data is empty, nothing went wrong and ok is set to true *ok = true; }
void QPpsObjectPrivate::encodeArray(pps_encoder_t *encoder, const QVariantList &data, bool *ok) { for (QVariantList::const_iterator it = data.constBegin(); it != data.constEnd(); ++it) { encodeData(encoder, 0, *it, ok); if (!(*ok)) return; } // if the passed data is empty, nothing went wrong and ok is set to true *ok = true; }
/// Return the size of the data plus header. size_t size() const { if (!_data) return 0; SimpleBuffer buf; // The header comprises 2 bytes and a length field of 4 bytes. if (encodeData(_name, *_data, buf)) { return buf.size() + 6; } return 0; }
void compress(istream& input, obitstream& output) { map<int, int> freqTable = buildFrequencyTable(input); HuffmanNode* encodingTree = buildEncodingTree(freqTable); map<int, string> encodingMap = buildEncodingMap(encodingTree); writeHeader(encodingTree, output); input.clear(); input.seekg(0, ios::beg); encodeData(input, encodingMap, output); freeTree(encodingTree); }
static int encodeDisplayAndSave(mm_camera_super_buf_t* recvd_frame, int enqueued, mm_camera_app_obj_t *pme) { int ret = -1; #if 0 CDBG("%s: Send frame for encoding", __func__); ret = encodeData(recvd_frame, pme->snapshot_buf.frame_len, enqueued, pme); if (!ret) { CDBG_ERROR("%s: Failure configuring JPEG encoder", __func__); } LOGD("%s: X", __func__); #endif return ret; }
//Komprimerar headern genom att se om det finns tal i frekvenstabellen som är större än en byte (255) //Om så är fallet läggs den in i ouputen på samma sätt med en 1 först i filen för att markera det //Annars sätts 0 först i filen samt storleken på frekvenstabellen, alla karaktärer och frekvenser //Skrivs till ouput med .put() //Exempel för example.txt 08322973983991 EOF lägg inte in eftersom den är större än en byte void compress(istream& input, obitstream& output) { map<int, int> freqTable = buildFrequencyTable(input); HuffmanNode* priorityTree = buildEncodingTree(freqTable); map<int, string> encodingMap = buildEncodingMap(priorityTree); bool containsBiggerThanByte = false; vector<char> vectorForFreqTable; for(map<int,int>::iterator it = freqTable.begin(); it != freqTable.end(); ++it){ if(it->first == PSEUDO_EOF){ //Lägg inte till PSEUDO_EOF än break; } else if(!(it->first > PSEUDO_EOF) && !(it->second > PSEUDO_EOF)){ //Om frekvensen och karaktären tar mindre än en byte vectorForFreqTable.push_back(it->first); vectorForFreqTable.push_back(it->second); }else{ containsBiggerThanByte = true; break; } } if(containsBiggerThanByte){ output.put('1'); //Tal större än en byte finns addBiggerThanByte(freqTable,output); }else{ output.put('0'); //Inget tal större än en byte int freqTableSize = vectorForFreqTable.size(); output.put(freqTableSize); //tabellens storlek kommer användas för inmatningen for(int i = 0; i < freqTableSize; ++i){ int tempNum = vectorForFreqTable.at(i); output.put(tempNum); } } input.clear(); input.seekg(0, ios::beg); encodeData(input, encodingMap, output); freeTree(priorityTree); }
static void snapshot_yuv_cb(mm_camera_super_buf_t *bufs, void *user_data) { int rc; int i = 0; mm_camera_buf_def_t *main_frame = NULL; mm_camera_buf_def_t *thumb_frame = NULL; mm_camera_app_obj_t *pme = NULL; char* cmd = "This is a private cmd from test app"; CDBG("%s: BEGIN\n", __func__); pme = (mm_camera_app_obj_t *)user_data; CDBG("%s: send private ioctl here", __func__); pme->cam->ops->send_command(bufs->camera_handle, MM_CAMERA_CMD_TYPE_PRIVATE, 0, strlen(cmd) + 1, (void *)cmd); /* start jpeg encoding job */ rc = encodeData(pme, bufs); /* buf done rcvd frames in error case */ if ( 0 != rc ) { for (i=0; i<bufs->num_bufs; i++) { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, bufs->bufs[i])) { CDBG_ERROR("%s: Failed in Qbuf\n", __func__); } mm_stream_invalid_cache(pme,bufs->bufs[i]); } } #ifdef TEST_ABORT_JPEG_ENCODE else { if (aborted_flag) { aborted_flag = 0; /* abort the job */ CDBG("%s: abort jpeg encode job here", __func__); rc = pme->jpeg_ops.abort_job(pme->jpeg_hdl, pme->current_job_id); if (NULL != pme->current_job_frames) { free(pme->current_job_frames); pme->current_job_frames = NULL; } CDBG("%s: abort jpeg encode job returns %d", __func__, rc); for (i=0; i<bufs->num_bufs; i++) { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, bufs->bufs[i])) { CDBG_ERROR("%s: Failed in Qbuf\n", __func__); } mm_stream_invalid_cache(pme,bufs->bufs[i]); } /* signal snapshot is done */ mm_app_snapshot_done(); } } #endif CDBG("%s: END\n", __func__); }
QString QJson::encodeData(const QVariant &data, EncodeOptions options, QString *errorMessage, int indentation, QString currentLinePrefix) { QString indentedLinePrefix = options.testFlag(Compact) ? QString::fromLatin1("") : (currentLinePrefix + QString::fromLatin1(" ").repeated(indentation)); QString optionalNewLine = options.testFlag(Compact) ? QString::fromLatin1("") : (QString::fromLatin1("\n") + currentLinePrefix); QString optionalIndentedNewLine = options.testFlag(Compact) ? QString::fromLatin1("") : (QString::fromLatin1("\n") + indentedLinePrefix); QString encoded; switch (data.type()) { case(QVariant::Bool) : encoded += QString::fromLatin1(data.toBool() ? "true" : "false"); break; case(QVariant::Int) : case(QVariant::UInt) : case(QVariant::LongLong) : case(QVariant::ULongLong) : Q_ASSERT(data.canConvert(QVariant::String)); encoded = data.toString(); break; case(QVariant::Double) : encoded = QString::number(data.toDouble(), 'g', 16); if (!encoded.contains(QString::fromLatin1(".")) && !encoded.contains(QString::fromLatin1("e"))) encoded += ".0"; break; case(QVariant::String) : encoded = encodeString(data.toString()); break; case(QVariant::ByteArray) : encoded = encodeByteArray(data.toByteArray()); break; case(QVariant::List) : { encoded = QString::fromLatin1("[") + optionalIndentedNewLine; QVariantList list = data.toList(); for (int i = 0; i < list.count(); ++i) { if (i) encoded += QString::fromLatin1(",") + optionalIndentedNewLine; encoded += encodeData(list.at(i), options, errorMessage, indentation, indentedLinePrefix); if (errorMessage && !errorMessage->isNull()) return QString(); } encoded += optionalNewLine + QString::fromLatin1("]"); } break; case(QVariant::StringList) : { encoded = QString::fromLatin1("[") + optionalIndentedNewLine; QStringList list = data.toStringList(); for (int i = 0; i < list.count(); ++i) { if (i) encoded += QString::fromLatin1(",") + optionalIndentedNewLine; encoded += encodeData(list.at(i), options, errorMessage, indentation, indentedLinePrefix); if (errorMessage && !errorMessage->isNull()) return QString(); } encoded += optionalNewLine + QString::fromLatin1("]"); } break; case(QVariant::Map) : { encoded = QString::fromLatin1("{") + optionalIndentedNewLine; QVariantMap map = data.toMap(); QVariantMap::iterator i; bool first = true; for (i = map.begin(); i != map.end(); ++i) { if (!first) encoded += QString::fromLatin1(",") + optionalIndentedNewLine; first = false; encoded += encodeString(i.key()); encoded += options.testFlag(Compact) ? QString::fromLatin1(":") : QString::fromLatin1(" : "); encoded += encodeData(i.value(), options, errorMessage, indentation, indentedLinePrefix); if (errorMessage && !errorMessage->isNull()) return QString(); } encoded += optionalNewLine + QString::fromLatin1("}"); } break; case(QVariant::Hash) : { encoded = QString::fromLatin1("{") + optionalIndentedNewLine; QVariantHash hash = data.toHash(); QVariantHash::iterator i; bool first = true; for (i = hash.begin(); i != hash.end(); ++i) { if (!first) encoded += QString::fromLatin1(",") + optionalIndentedNewLine; first = false; encoded += encodeString(i.key()); encoded += options.testFlag(Compact) ? QString::fromLatin1(":") : QString::fromLatin1(" : "); encoded += encodeData(i.value(), options, errorMessage, indentation, indentedLinePrefix); if (errorMessage && !errorMessage->isNull()) return QString(); } encoded += optionalNewLine + QString::fromLatin1("}"); } break; case(QVariant::Invalid) : encoded = QString::fromLatin1("null"); break; default: if (!options.testFlag(EncodeUnknownTypesAsNull)) { if (errorMessage) *errorMessage = QString::fromLatin1("Can't encode this type of data to JSON: %1") .arg(data.typeName()); return QString(); } encoded = QString::fromLatin1("null"); break; } return encoded; }
QString QJson::encode(const QVariant &data, EncodeOptions options, QString *errorMessage, int indentation) { return encodeData(data, options, errorMessage, indentation, QString()); }
/// Returns false if the data cannot be written to file. // /// If there is no data, the file is removed and the function returns true. bool SharedObject_as::flush(int space) const { /// This is called on on destruction of the SharedObject, or (allegedly) /// on a call to SharedObject.data, so _data is not guaranteed to exist. // /// The function should never be called from SharedObject.flush() when /// _data is 0. if (!_data) return false; if (space > 0) { log_unimpl("SharedObject.flush() called with a minimum disk space " "argument (%d), which is currently ignored", space); } const std::string& filespec = getFilespec(); if (!mkdirRecursive(filespec)) { log_error("Couldn't create dir for flushing SharedObject %s", filespec); return false; } #ifdef USE_SOL_READONLY log_debug(_("SharedObject %s not flushed (compiled as read-only mode)"), filespec); return false; #endif if (rcfile.getSOLReadOnly()) { log_security("Attempting to write object %s when it's SOL " "Read Only is set! Refusing...", filespec); return false; } // Open file std::ofstream ofs(filespec.c_str(), std::ios::binary); if (!ofs) { log_error("SharedObject::flush(): Failed opening file '%s' in " "binary mode", filespec.c_str()); return false; } // Encode data part. SimpleBuffer buf; if (!encodeData(_name, *_data, buf)) { std::remove(filespec.c_str()); return true; } // Encode header part. SimpleBuffer header; encodeHeader(buf.size(), header); // Write header ofs.write(reinterpret_cast<const char*>(header.data()), header.size()); if (!ofs) { log_error("Error writing SOL header"); return false; } // Write AMF data ofs.write(reinterpret_cast<const char*>(buf.data()), buf.size()); if (!ofs) { log_error("Error writing %d bytes to output file %s", buf.size(), filespec.c_str()); return false; } ofs.close(); log_security("SharedObject '%s' written to filesystem.", filespec); return true; }
static void timeoutInterrupt() { #ifdef COMPENSATION_DELAY_US // hold interrupts until the "real" timeout time has been reached while(TCNT3 < timeout_target) { ; } #endif #ifndef ENHANCEDPRECISION // simple reset of the timer // (not accounting for past time) TCNT3 = 0; #endif // "clear" interrupt flag (by setting it) sbi(TIFR3,OCF3A); // disable timeout interrupt cbi(TIMSK3,OCIE3A); #ifdef ENHANCEDPRECISION // account for the time spent since the interrupt occurred TCNT3 = TCNT3 - timeout_target; #endif switch(state) { case inactive: // nothing to do here break; case idle: // check if bus appears "ready" (high) // /* if(ADBDATA == 0) { debug_pulse(); // bus not ready. // try later on. setTimeout(50); break; } */ // begin attention adb_forcelow(); setTimeout(ATTENTION_TIME_US); state = attention; break; case attention: // begin sync adb_highimpedance(); setTimeout(SYNC_TIME_US); initEncodeByte(itsAdbPacket->headerRawByte); state = sync; break; case sync: state = header; // fall through header state case header: { ErrorStatus status = encodeByte(); if(status == success) { // begin header stop // TODO: handle SRQs: (probably not needed) adb_forcelow(); setTimeout(BIT_0_LOW_TIME_US); state = header_stop; break; } else if(status == failure) { restartAdbTransaction(); } break; } case header_stop: { adb_highimpedance(); // release bus if(itsAdbPacket->command == ADB_COMMAND_TALK) { // prepare for reading: // wait till the end of the stop bit // before starting probing the bus setTimeout(BIT_0_HIGH_TIME_US); // wait a little before switching on the input capture state = header_stop_high_in; break; } else { // start outputting (encoding) data bytes setTimeout(STOP2START_TIME_US); state = stop_to_start_out; break; } } case stop_to_start_out: { // begin start bit adb_forcelow(); setTimeout(BIT_1_LOW_TIME_US); state = start_out; break; } case start_out: // continue start bit adb_highimpedance(); setTimeout(BIT_1_HIGH_TIME_US); initEncodeData(); state = data_out; break; case data_out: { ErrorStatus status = encodeData(); if(status == success) { // begin stop bit adb_forcelow(); setTimeout(BIT_0_LOW_TIME_US); state = stop_out; } else if(status == failure) { restartAdbTransaction(); } break; } case stop_out: { adb_highimpedance(); setTimeout(BIT_0_HIGH_TIME_US); state = finished; break; } case finished: { state = inactive; trigFinished(); break; } // ======================================= // "_in" states: reading bits from device // or more specifically inactivity timeouts // ======================================= case header_stop_high_in: //--------------------------- // Turn on the Input Capture //--------------------------- // setup to trig on the next falling edge cbi(TCCR3B, ICES3); waitingOn = FALLING_EDGE; // clear Input Capture Flag by setting it sbi(TIFR3, ICF3); // enable input capture interrupt sbi(TIMSK3, ICIE3); setTimeout(STOP2START_TIME_MAX_US); state = stop_to_start_in; break; case stop_to_start_in: // it appears that there is no response from the device trigFinished(); break; case data_in: // this is called essentially after the stop bit without // any activity afterwards. This denotes the end of a packet if(itsAdbPacket->datalen > 0 && decodeBitNumber == 8) { // all ok trigFinished(); } else { // error condition errorAndResetDecoder(20); // no activity timeout while receiving data } state = inactive; // reset timer value break; default: state = idle; break; } }
/** * Encode data and return the encoding. * @param data The Data object to encode. * @return A Blob containing the encoding. * @throws logic_error for unimplemented if the derived class does not override. */ Blob encodeData(const Data& data) { size_t dummyBeginOffset, dummyEndOffset; return encodeData(data, &dummyBeginOffset, &dummyEndOffset); }
static void mm_app_snapshot_notify_cb(mm_camera_super_buf_t *bufs, void *user_data) { int rc = 0; int i = 0; mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data; mm_camera_channel_t *channel = NULL; mm_camera_stream_t *p_stream = NULL; mm_camera_stream_t *m_stream = NULL; mm_camera_buf_def_t *p_frame = NULL; mm_camera_buf_def_t *m_frame = NULL; CDBG("%s: BEGIN\n", __func__); /* find channel */ for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) { if (pme->channels[i].ch_id == bufs->ch_id) { channel = &pme->channels[i]; break; } } if (NULL == channel) { CDBG_ERROR("%s: Wrong channel id (%d)", __func__, bufs->ch_id); rc = -1; goto error; } /* find snapshot stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_SNAPSHOT) { m_stream = &channel->streams[i]; break; } } if (NULL == m_stream) { CDBG_ERROR("%s: cannot find snapshot stream", __func__); rc = -1; goto error; } /* find snapshot frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == m_stream->s_id) { m_frame = bufs->bufs[i]; break; } } if (NULL == m_frame) { CDBG_ERROR("%s: main frame is NULL", __func__); rc = -1; goto error; } mm_app_dump_frame(m_frame, "main", "yuv", m_frame->frame_idx); /* find postview stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_POSTVIEW) { p_stream = &channel->streams[i]; break; } } if (NULL != p_stream) { /* find preview frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == p_stream->s_id) { p_frame = bufs->bufs[i]; break; } } if (NULL != p_frame) { mm_app_dump_frame(p_frame, "postview", "yuv", p_frame->frame_idx); } } mm_app_cache_ops((mm_camera_app_meminfo_t *)m_frame->mem_info, ION_IOC_CLEAN_INV_CACHES); pme->jpeg_buf.buf.buffer = (uint8_t *)malloc(m_frame->frame_len); if ( NULL == pme->jpeg_buf.buf.buffer ) { CDBG_ERROR("%s: error allocating jpeg output buffer", __func__); goto error; } pme->jpeg_buf.buf.frame_len = m_frame->frame_len; /* create a new jpeg encoding session */ rc = createEncodingSession(pme, m_stream, m_frame); if (0 != rc) { CDBG_ERROR("%s: error creating jpeg session", __func__); free(pme->jpeg_buf.buf.buffer); goto error; } /* start jpeg encoding job */ rc = encodeData(pme, bufs, m_stream); if (0 != rc) { CDBG_ERROR("%s: error creating jpeg session", __func__); free(pme->jpeg_buf.buf.buffer); goto error; } error: /* buf done rcvd frames in error case */ if ( 0 != rc ) { for (i=0; i<bufs->num_bufs; i++) { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, bufs->bufs[i])) { CDBG_ERROR("%s: Failed in Qbuf\n", __func__); } mm_app_cache_ops((mm_camera_app_meminfo_t *)bufs->bufs[i]->mem_info, ION_IOC_INV_CACHES); } } CDBG("%s: END\n", __func__); }
static void mm_app_reprocess_notify_cb(mm_camera_super_buf_t *bufs, void *user_data) { mm_camera_buf_def_t *frame = bufs->bufs[0]; mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data; mm_camera_channel_t *channel = NULL; mm_camera_stream_t *m_stream = NULL; mm_camera_buf_def_t *m_frame = NULL; mm_camera_super_buf_t *src_frame; int i = 0; int rc = 0; CDBG_ERROR("%s: BEGIN - length=%d, frame idx = %d\n", __func__, frame->frame_len, frame->frame_idx); /* find channel */ for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) { if (pme->channels[i].ch_id == bufs->ch_id) { channel = &pme->channels[i]; break; } } if (NULL == channel) { CDBG_ERROR("%s: Wrong channel id (%d)", __func__, bufs->ch_id); return; } // We have only one stream and buffer // in the reprocess channel. m_stream = &channel->streams[0]; m_frame = bufs->bufs[0]; if ( pme->encodeJpeg ) { pme->jpeg_buf.buf.buffer = (uint8_t *)malloc(m_frame->frame_len); if ( NULL == pme->jpeg_buf.buf.buffer ) { CDBG_ERROR("%s: error allocating jpeg output buffer", __func__); goto exit; } pme->jpeg_buf.buf.frame_len = m_frame->frame_len; /* create a new jpeg encoding session */ rc = createEncodingSession(pme, m_stream, m_frame); if (0 != rc) { CDBG_ERROR("%s: error creating jpeg session", __func__); free(pme->jpeg_buf.buf.buffer); goto exit; } /* start jpeg encoding job */ CDBG_ERROR("Encoding reprocessed frame!!"); rc = encodeData(pme, bufs, m_stream); pme->encodeJpeg = 0; } else { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, frame)) { CDBG_ERROR("%s: Failed in Reprocess Qbuf\n", __func__); } mm_app_cache_ops((mm_camera_app_meminfo_t *)frame->mem_info, ION_IOC_INV_CACHES); } exit: // Release source frame src_frame = ( mm_camera_super_buf_t * ) mm_qcamera_queue_dequeue(&pme->pp_frames, 1); if ( NULL != src_frame ) { mm_app_release_ppinput((void *) src_frame, (void *) pme); } CDBG_ERROR("%s: END\n", __func__); }
// Converts one old savegame file to the new format... bool CSaveGameController::convertOldFormat(size_t slot) { // TODO: Old CG 0.3.0.4 Code Handle with care std::string fname; int version; fname = "ep"; fname += itoa(m_Episode); fname += "save"; fname += itoa(slot); fname += ".dat"; if ( ((version = getOldSGVersion(fname)) == 0) ) return false; size_t newslot = slot; while(Fileexists(newslot)) newslot++; prepareSaveGame(newslot, "oldsave"+itoa(slot)); if(alreadyExits()) { g_pLogFile->textOut("You already have \""+m_statefilename+"\". If you want to export an old savegame erase it, or erase the old savegame if it's already exported!" ); return false; } if(version == 5) { OldSaveGameFormatV5 old; if(!loadSaveGameVersion5(fname, old)) return false; // Rename the old save game to the extension bak, so it won't be converted again std::string newfname = fname.substr(0,fname.size()-3) + "bak"; Rename(fname, newfname); // // Now let's save it into a new format // /// Save the Game in the CSaveGameController object // store the episode, level and difficulty encodeData(old.LevelControl.episode); encodeData(old.LevelControl.curlevel); encodeData(old.LevelControl.hardmode ? 2 : 1); // Also the last checkpoint is stored. This is the level entered from map // in Commander Keen games encodeData(false); // No checkpoint set encodeData(0); // Checkpoint X set to zero encodeData(0); // Checkpoint Y set to zero encodeData(old.LevelControl.dark); // Save number of Players encodeData(1); // Now save the inventory of every player encodeData(old.Player.x); encodeData(old.Player.y); encodeData(old.Player.blockedd); encodeData(old.Player.blockedu); encodeData(old.Player.blockedl); encodeData(old.Player.blockedr); encodeData(old.Player.inventory); // save the number of objects on screen. encodeData(0); // Save the map_data as it is left encodeData(old.map.xsize); encodeData(old.map.ysize); word *mapdata = new word[old.map.xsize*old.map.ysize]; for( size_t x=0 ; x<old.map.xsize ; x++ ) { for( size_t y=0 ; y<old.map.ysize ; y++ ) { mapdata[y*old.map.xsize+x] = old.map.mapdata[x][y]; } } addData( (byte*)(mapdata), 2*old.map.xsize*old.map.ysize ); delete [] mapdata; // store completed levels addData( (byte*)(old.LevelControl.levels_completed), MAX_LEVELS_VORTICON ); g_pLogFile->ftextOut("Structures restored: map size: %d,%d and saved\n", old.map.xsize, old.map.ysize); } else if(version == 4) { OldSaveGameFormatV4 old; if(!loadSaveGameVersion4(fname, old)) return false; // Rename the old save game to the extension bak, so it won't be converted again std::string newfname = fname.substr(0,fname.size()-3) + "bak"; Rename(fname, newfname); // // Now let's save it into a new format // /// Save the Game in the CSaveGameController object // store the episode, level and difficulty encodeData(old.LevelControl.episode); encodeData(old.LevelControl.curlevel); encodeData(old.LevelControl.hardmode ? 2 : 1); // Also the last checkpoint is stored. This is the level entered from map // in Commander Keen games encodeData(false); // No checkpoint set encodeData(0); // Checkpoint X set to zero encodeData(0); // Checkpoint Y set to zero encodeData(old.LevelControl.dark); // Save number of Players encodeData(1); // Now save the inventory of every player encodeData(old.Player.x); encodeData(old.Player.y); encodeData(old.Player.blockedd); encodeData(old.Player.blockedu); encodeData(old.Player.blockedl); encodeData(old.Player.blockedr); encodeData(old.Player.inventory); // save the number of objects on screen. encodeData(0); // Save the map_data as it is left encodeData(old.map.xsize); encodeData(old.map.ysize); word *mapdata = new word[old.map.xsize*old.map.ysize]; for( size_t x=0 ; x<old.map.xsize ; x++ ) { for( size_t y=0 ; y<old.map.ysize ; y++ ) { mapdata[y*old.map.xsize+x] = old.map.mapdata[x][y]; } } addData( (byte*)(mapdata), 2*old.map.xsize*old.map.ysize ); delete [] mapdata; // store completed levels addData( (byte*)(old.LevelControl.levels_completed), MAX_LEVELS_VORTICON ); g_pLogFile->ftextOut("Structures restored: map size: %d,%d and saved\n", old.map.xsize, old.map.ysize); } else { g_pLogFile->ftextOut("Sorry, but the old save game format is unknown\n"); return false; } save(); g_pLogFile->ftextOut("The old savegame has been converted successfully OK\n"); return true; }
static void mm_app_snapshot_notify_cb(mm_camera_super_buf_t *bufs, void *user_data) { int rc = 0; uint32_t i = 0; mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data; mm_camera_channel_t *channel = NULL; mm_camera_stream_t *p_stream = NULL; mm_camera_stream_t *m_stream = NULL; mm_camera_buf_def_t *p_frame = NULL; mm_camera_buf_def_t *m_frame = NULL; /* find channel */ for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) { if (pme->channels[i].ch_id == bufs->ch_id) { channel = &pme->channels[i]; break; } } if (NULL == channel) { LOGE(" Wrong channel id (%d)", bufs->ch_id); rc = -1; goto error; } /* find snapshot stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_SNAPSHOT) { m_stream = &channel->streams[i]; break; } } if (NULL == m_stream) { LOGE(" cannot find snapshot stream"); rc = -1; goto error; } /* find snapshot frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == m_stream->s_id) { m_frame = bufs->bufs[i]; break; } } if (NULL == m_frame) { LOGE(" main frame is NULL"); rc = -1; goto error; } mm_app_dump_frame(m_frame, "main", "yuv", m_frame->frame_idx); /* find postview stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_POSTVIEW) { p_stream = &channel->streams[i]; break; } } if (NULL != p_stream) { /* find preview frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == p_stream->s_id) { p_frame = bufs->bufs[i]; break; } } if (NULL != p_frame) { mm_app_dump_frame(p_frame, "postview", "yuv", p_frame->frame_idx); } } mm_app_cache_ops((mm_camera_app_meminfo_t *)m_frame->mem_info, ION_IOC_CLEAN_INV_CACHES); pme->jpeg_buf.mem_info.size = m_frame->frame_len; mm_app_allocate_ion_memory(&pme->jpeg_buf, (0x1 << CAMERA_ION_FALLBACK_HEAP_ID)); /* create a new jpeg encoding session */ rc = createEncodingSession(pme, m_stream, m_frame); if (0 != rc) { LOGE(" error creating jpeg session"); mm_app_deallocate_ion_memory(&pme->jpeg_buf); goto error; } /* start jpeg encoding job */ rc = encodeData(pme, bufs, m_stream); if (0 != rc) { LOGE(" error creating jpeg session"); mm_app_deallocate_ion_memory(&pme->jpeg_buf); goto error; } error: /* buf done rcvd frames in error case */ if ( 0 != rc ) { for (i=0; i<bufs->num_bufs; i++) { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, bufs->bufs[i])) { LOGE(" Failed in Qbuf\n"); } mm_app_cache_ops((mm_camera_app_meminfo_t *)bufs->bufs[i]->mem_info, ION_IOC_INV_CACHES); } } LOGD(" END\n"); }
static void mm_app_zsl_notify_cb(mm_camera_super_buf_t *bufs, void *user_data) { int rc = 0; int i = 0; mm_camera_test_obj_t *pme = (mm_camera_test_obj_t *)user_data; mm_camera_channel_t *channel = NULL; mm_camera_stream_t *p_stream = NULL; mm_camera_stream_t *m_stream = NULL; mm_camera_stream_t *md_stream = NULL; mm_camera_buf_def_t *p_frame = NULL; mm_camera_buf_def_t *m_frame = NULL; mm_camera_buf_def_t *md_frame = NULL; CDBG("%s: BEGIN\n", __func__); if (NULL == bufs || NULL == user_data) { CDBG_ERROR("%s: bufs or user_data are not valid ", __func__); return; } /* find channel */ for (i = 0; i < MM_CHANNEL_TYPE_MAX; i++) { if (pme->channels[i].ch_id == bufs->ch_id) { channel = &pme->channels[i]; break; } } if (NULL == channel) { CDBG_ERROR("%s: Wrong channel id (%d)", __func__, bufs->ch_id); return; } /* find preview stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_PREVIEW) { p_stream = &channel->streams[i]; break; } } if (NULL == p_stream) { CDBG_ERROR("%s: cannot find preview stream", __func__); return; } /* find snapshot stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_SNAPSHOT) { m_stream = &channel->streams[i]; break; } } if (NULL == m_stream) { CDBG_ERROR("%s: cannot find snapshot stream", __func__); return; } /* find metadata stream */ for (i = 0; i < channel->num_streams; i++) { if (channel->streams[i].s_config.stream_info->stream_type == CAM_STREAM_TYPE_METADATA) { md_stream = &channel->streams[i]; break; } } if (NULL == md_stream) { CDBG_ERROR("%s: cannot find metadata stream", __func__); } /* find preview frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == p_stream->s_id) { p_frame = bufs->bufs[i]; break; } } if(md_stream) { /* find metadata frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == md_stream->s_id) { md_frame = bufs->bufs[i]; break; } } if (!pme->metadata) { /* App will free the metadata */ pme->metadata = malloc(sizeof(metadata_buffer_t)); } memcpy(pme->metadata , md_frame->buffer, sizeof(metadata_buffer_t)); } /* find snapshot frame */ for (i = 0; i < bufs->num_bufs; i++) { if (bufs->bufs[i]->stream_id == m_stream->s_id) { m_frame = bufs->bufs[i]; break; } } if (!m_frame || !p_frame) { CDBG_ERROR("%s: cannot find preview/snapshot frame", __func__); return; } CDBG("%s: ZSL CB with fb_fd = %d, m_frame = 0x%x, p_frame = 0x%x \n", __func__, pme->fb_fd, (uint32_t )m_frame, (uint32_t )p_frame); if ( 0 < pme->fb_fd ) { mm_app_overlay_display(pme, p_frame->fd); }/* else { mm_app_dump_frame(p_frame, "zsl_preview", "yuv", p_frame->frame_idx); mm_app_dump_frame(m_frame, "zsl_main", "yuv", m_frame->frame_idx); }*/ if ( pme->enable_reproc && ( NULL != pme->reproc_stream ) ) { rc = mm_app_do_reprocess(pme, m_frame, md_frame->buf_idx, bufs, md_stream); if (MM_CAMERA_OK != rc ) { CDBG_ERROR("%s: reprocess failed rc = %d", __func__, rc); } return; } if ( pme->encodeJpeg ) { pme->jpeg_buf.buf.buffer = (uint8_t *)malloc(m_frame->frame_len); if ( NULL == pme->jpeg_buf.buf.buffer ) { CDBG_ERROR("%s: error allocating jpeg output buffer", __func__); goto exit; } pme->jpeg_buf.buf.frame_len = m_frame->frame_len; /* create a new jpeg encoding session */ rc = createEncodingSession(pme, m_stream, m_frame); if (0 != rc) { CDBG_ERROR("%s: error creating jpeg session", __func__); free(pme->jpeg_buf.buf.buffer); goto exit; } /* start jpeg encoding job */ rc = encodeData(pme, bufs, m_stream); pme->encodeJpeg = 0; } else { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, m_frame)) { CDBG_ERROR("%s: Failed in main Qbuf\n", __func__); } mm_app_cache_ops((mm_camera_app_meminfo_t *)m_frame->mem_info, ION_IOC_INV_CACHES); } exit: if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, p_frame)) { CDBG_ERROR("%s: Failed in preview Qbuf\n", __func__); } mm_app_cache_ops((mm_camera_app_meminfo_t *)p_frame->mem_info, ION_IOC_INV_CACHES); if(md_frame) { if (MM_CAMERA_OK != pme->cam->ops->qbuf(bufs->camera_handle, bufs->ch_id, md_frame)) { CDBG_ERROR("%s: Failed in metadata Qbuf\n", __func__); } mm_app_cache_ops((mm_camera_app_meminfo_t *)md_frame->mem_info, ION_IOC_INV_CACHES); } CDBG("%s: END\n", __func__); }
eCodes WsEncoder::encodePlainPacket() { eCodes code = eCodes::ST_Ok; switch (_writeState) { case eWriteState::None: { computeLength(); _writeState = eWriteState::Header; _firstPacket = true; _encodedLen = 0; } // No break; case eWriteState::Header: { if ((_sendVecEndPtr - _currPtr) < _headerLen) { // Left space is not enough. return eCodes::ST_BufferFull; } bool fin = true; if (_fragmented) { if (_totalLen - _encodedLen <= _payloadLen) { // The last packet. fin should be true. _payloadLen = _totalLen - _encodedLen; } else { fin = false; } } writeHeader(_firstPacket, fin); // Reset mask function related variables. _maskKeyIdx = 0; _maskBeginPtr = _currPtr; if (_firstPacket) { _firstPacket = false; getMetaData(ePayloadItem::SysJson, _sysJsonStr.size()); _writeState = eWriteState::SysJsonMeta; _srcPtr = &(*_metaData.begin()); _srcEndPtr = &(*_metaData.end()); } else { _writeState = _prevWriteState; return encodePlainPacket(); } } // No break; case eWriteState::SysJsonMeta: { code = encodeMeta(); if (code == eCodes::ST_BufferFull) { return code; } } // no break; case eWriteState::SysJson: { code = encodeData(); if (code == eCodes::ST_BufferFull || code == eCodes::ST_Complete) { return code; } } // no break; case eWriteState::JsonMeta: { code = encodeMeta(); if (code == eCodes::ST_BufferFull) { return code; } } // no break; case eWriteState::Json: { code = encodeData(); if (code == eCodes::ST_BufferFull || code == eCodes::ST_Complete) { return code; } } // no break; case eWriteState::BinaryMeta: { code = encodeMeta(); if (code == eCodes::ST_BufferFull) { return code; } } // no break; case eWriteState::Binary: { code = encodeData(); if (code == eCodes::ST_BufferFull || code == eCodes::ST_Complete) { return code; } } break; default: { PARROT_ASSERT(false); } } return code; }