void save_chunk_logic(uint8_t *data, uint64_t data_len, int unitsize) { static uint8_t *buf = NULL; static int buf_len = 0; static int last_unitsize = 0; int max; if (!buf) buf = g_malloc(SAVE_CHUNK_SIZE); if (buf_len + data_len > SAVE_CHUNK_SIZE) { max = (SAVE_CHUNK_SIZE - buf_len) / unitsize * unitsize; memcpy(buf + buf_len, data, max); sr_session_append(opt_output_file, buf, unitsize, (buf_len + max) / unitsize); memcpy(buf, data + max, data_len - max); buf_len = data_len - max; } else if (data_len == 0 && last_unitsize != 0) { /* End of data, flush the buffer out. */ sr_session_append(opt_output_file, buf, last_unitsize, buf_len / last_unitsize); } else { /* Buffer chunk. */ memcpy(buf + buf_len, data, data_len); buf_len += data_len; } last_unitsize = unitsize; }
void StoreSession::store_proc(shared_ptr<data::LogicSnapshot> snapshot) { assert(snapshot); uint64_t start_sample = 0; /// TODO: Wrap this in a std::unique_ptr when we transition to C++11 uint8_t *data = NULL; //uint8_t *const data = new uint8_t[BlockSize]; //assert(data); const int unit_size = snapshot->unit_size(); assert(unit_size != 0); { lock_guard<mutex> lock(_mutex); _unit_count = snapshot->get_sample_count(); } const unsigned int samples_per_block = BlockSize / unit_size; while (!boost::this_thread::interruption_requested() && start_sample < _unit_count) { progress_updated(); const uint64_t end_sample = min( start_sample + samples_per_block, _unit_count); data = snapshot->get_samples(start_sample, end_sample); if(sr_session_append(_file_name.c_str(), data, unit_size, end_sample - start_sample) != SR_OK) { _error = tr("Error while saving."); break; } start_sample = end_sample; { lock_guard<mutex> lock(_mutex); _units_stored = start_sample; } } progress_updated(); //delete[] data; }
/** * Save a session to the specified file. * * @param session The session to save to the specified file. Must not be NULL. * @param filename The name of the filename to save the session as. * Must not be NULL. * @param sdi The device instance from which the data was captured. * @param buf The data to be saved. * @param unitsize The number of bytes per sample. * @param units The number of samples. * * @retval SR_OK Success * @retval SR_ERR_ARG Invalid arguments * @retval SR_ERR Other errors * * @since 0.2.0 */ SR_API int sr_session_save(struct sr_session *session, const char *filename, const struct sr_dev_inst *sdi, unsigned char *buf, int unitsize, int units) { struct sr_channel *ch; GSList *l; GVariant *gvar; uint64_t samplerate; int cnt, ret; char **channel_names; samplerate = 0; if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) { if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE, &gvar) == SR_OK) { samplerate = g_variant_get_uint64(gvar); g_variant_unref(gvar); } } channel_names = g_malloc0(sizeof(char *) * (g_slist_length(sdi->channels) + 1)); cnt = 0; for (l = sdi->channels; l; l = l->next) { ch = l->data; if (ch->type != SR_CHANNEL_LOGIC) continue; if (ch->enabled != TRUE) continue; if (!ch->name) continue; /* Just borrowing the ptr. */ channel_names[cnt++] = ch->name; } if ((ret = sr_session_save_init(session, filename, samplerate, channel_names)) != SR_OK) return ret; ret = sr_session_append(session, filename, buf, unitsize, units); return ret; }