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