2023-12-01 09:17:09 +00:00
|
|
|
#include "data.h"
|
|
|
|
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
2023-12-09 10:21:05 +00:00
|
|
|
#if OS_WIN
|
2023-12-01 09:17:09 +00:00
|
|
|
#else
|
|
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <unistd.h>
|
2023-12-09 10:21:05 +00:00
|
|
|
#include <sys/mman.h>
|
2023-12-01 09:17:09 +00:00
|
|
|
#endif
|
|
|
|
|
2023-12-12 01:36:06 +00:00
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
packet_data_base::packet_data_base() : pack_cmd_(0), pack_id_(0)
|
|
|
|
{
|
2023-12-16 07:27:40 +00:00
|
|
|
set_progress_notify();
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
2023-12-16 07:27:40 +00:00
|
|
|
packet_data_base::~packet_data_base()
|
2024-01-27 09:43:13 +00:00
|
|
|
{
|
|
|
|
notify_progress(FINAL_NOTIFY, FINAL_NOTIFY, 0);
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
void packet_data_base::set_packet_param(uint32_t cmd, uint32_t id)
|
|
|
|
{
|
|
|
|
pack_cmd_ = cmd;
|
|
|
|
pack_id_ = id;
|
|
|
|
}
|
2023-12-02 02:15:44 +00:00
|
|
|
void packet_data_base::set_session_id(uint32_t session_id)
|
|
|
|
{
|
|
|
|
session_id_ = session_id;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
int packet_data_base::get_packet_command(void)
|
|
|
|
{
|
|
|
|
return pack_cmd_;
|
|
|
|
}
|
|
|
|
int packet_data_base::get_packet_id(void)
|
|
|
|
{
|
|
|
|
return pack_id_;
|
|
|
|
}
|
2023-12-02 02:15:44 +00:00
|
|
|
uint32_t packet_data_base::get_session_id(void)
|
|
|
|
{
|
|
|
|
return session_id_;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
void packet_data_base::set_progress_notify(PROGRESS_NOTIFYER notify, void* param)
|
|
|
|
{
|
2023-12-16 07:27:40 +00:00
|
|
|
auto empty_notifyer = [&](uint64_t, uint64_t, uint32_t, void*) -> int
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
progress_notify_ = notify ? notify : empty_notifyer;
|
2023-12-01 09:17:09 +00:00
|
|
|
user_data_ = param;
|
|
|
|
}
|
2023-12-16 07:27:40 +00:00
|
|
|
int packet_data_base::notify_progress(uint64_t total, uint64_t cur_size, uint32_t err)
|
|
|
|
{
|
|
|
|
return progress_notify_(total, cur_size, err, user_data_);
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
data_holder::data_holder()
|
|
|
|
{}
|
|
|
|
data_holder::~data_holder()
|
|
|
|
{}
|
|
|
|
|
2023-12-02 02:15:44 +00:00
|
|
|
void data_holder::cancel(void)
|
|
|
|
{}
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
mem_holder::mem_holder(size_t size) : space_(size)
|
|
|
|
{
|
|
|
|
buf_ = (uint8_t*)malloc(size);
|
|
|
|
if (buf_)
|
|
|
|
memset(buf_, 0, size);
|
|
|
|
}
|
|
|
|
mem_holder::~mem_holder()
|
|
|
|
{
|
|
|
|
if (buf_)
|
|
|
|
free(buf_);
|
|
|
|
buf_ = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
int mem_holder::put_data(const void* data, uint32_t* size)
|
|
|
|
{
|
|
|
|
if (*size > space_ - wpos_)
|
|
|
|
*size = space_ - wpos_;
|
|
|
|
|
|
|
|
memcpy(buf_ + wpos_, data, *size);
|
|
|
|
wpos_ += *size;
|
2024-01-17 08:54:06 +00:00
|
|
|
notify_progress(space_, wpos_, 0);
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
bool mem_holder::is_complete(void)
|
|
|
|
{
|
|
|
|
return wpos_ >= space_;
|
|
|
|
}
|
|
|
|
uint32_t mem_holder::get_required(void)
|
|
|
|
{
|
|
|
|
if (wpos_ >= space_)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return space_ - wpos_;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t mem_holder::data_length(void)
|
|
|
|
{
|
|
|
|
return wpos_;
|
|
|
|
}
|
|
|
|
uint8_t* mem_holder::data(void)
|
|
|
|
{
|
|
|
|
return buf_;
|
|
|
|
}
|
|
|
|
|
2024-01-17 08:54:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// image_holder
|
|
|
|
image_holder::image_holder(LPPACKIMAGE head) : mem_holder(head->info_size + head->data_size), head_(*head)
|
|
|
|
{}
|
|
|
|
image_holder::~image_holder()
|
|
|
|
{}
|
|
|
|
|
|
|
|
void image_holder::set_info(LPPACKIMAGE head)
|
|
|
|
{
|
|
|
|
head_ = *head;
|
|
|
|
}
|
|
|
|
LPPACKIMAGE image_holder::get_info(void)
|
|
|
|
{
|
|
|
|
return &head_;
|
|
|
|
}
|
|
|
|
int image_holder::save_2_file(const char* root_dir, const char* alg)
|
|
|
|
{
|
|
|
|
std::string file(root_dir);
|
|
|
|
FILE* dst = nullptr;
|
|
|
|
int err = ENOTSUP;
|
|
|
|
char buf[80] = { 0 };
|
|
|
|
|
|
|
|
file += PATH_SEPARATOR;
|
|
|
|
sprintf(buf, "%04d", head_.pos.paper_ind);
|
|
|
|
file += buf;
|
|
|
|
if (head_.pos.paper_side == PAPER_SIDE_FRONT)
|
|
|
|
file += "_Front";
|
|
|
|
else if (head_.pos.paper_side == PAPER_SIDE_BACK)
|
|
|
|
file += "_Back";
|
|
|
|
else
|
|
|
|
file += "_Comp";
|
|
|
|
sprintf(buf, "_%x", head_.pos.split_ind);
|
|
|
|
file += buf;
|
|
|
|
if (alg && *alg)
|
|
|
|
file += std::string("_") + alg;
|
|
|
|
if (head_.format == IMG_FMT_BMP)
|
|
|
|
{
|
|
|
|
std::string bih(utils::bitmap_info_header(head_.width, head_.height, head_.bpp * head_.channels, head_.resolution_x, head_.resolution_y)),
|
|
|
|
bfh(utils::bitmap_file_header((BITMAPINFOHEADER*)&bih[0]));
|
|
|
|
file += ".bmp";
|
|
|
|
dst = fopen(file.c_str(), "wb");
|
|
|
|
if (dst)
|
|
|
|
{
|
|
|
|
fwrite(bfh.c_str(), 1, bfh.length(), dst);
|
|
|
|
fwrite(bih.c_str(), 1, bih.length(), dst);
|
2024-01-24 09:40:41 +00:00
|
|
|
if(head_.data_size == ((LPBITMAPINFOHEADER)&bih[0])->biSizeImage)
|
|
|
|
fwrite(data() + head_.info_size, 1, head_.data_size, dst);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int l = BMP_LINE_BYTES(head_.width * head_.bpp * head_.channels),
|
|
|
|
dif = l - (head_.width * head_.bpp * head_.channels + 7) / 8;
|
|
|
|
char pad[4] = { 0 };
|
|
|
|
uint8_t *ptr = data() + head_.info_size;
|
|
|
|
for (int i = 0; i < head_.height; ++i)
|
|
|
|
{
|
|
|
|
fwrite(ptr, 1, l - dif, dst);
|
|
|
|
fwrite(pad, 1, dif, dst);
|
|
|
|
ptr += l - dif;
|
|
|
|
}
|
|
|
|
}
|
2024-01-17 08:54:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dst)
|
|
|
|
fclose(dst);
|
2024-01-27 09:43:13 +00:00
|
|
|
utils::to_log(LOG_LEVEL_ALL, "Image-Process of file '%s' is %ums.\n", file.c_str(), head_.prc_time);
|
2024-01-17 08:54:06 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
empty_holer::empty_holer(uint64_t size) : size_(size), put_(0)
|
|
|
|
{}
|
|
|
|
empty_holer::~empty_holer()
|
|
|
|
{}
|
|
|
|
|
|
|
|
int empty_holer::put_data(const void* data, uint32_t* size)
|
|
|
|
{
|
|
|
|
if (*size >= size_ - put_)
|
|
|
|
{
|
|
|
|
*size -= size_ - put_;
|
|
|
|
put_ = size_;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
put_ += *size;
|
|
|
|
}
|
|
|
|
notify_progress(size_, put_, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
bool empty_holer::is_complete(void)
|
|
|
|
{
|
|
|
|
return size_ == put_;
|
|
|
|
}
|
|
|
|
uint32_t empty_holer::get_required(void)
|
|
|
|
{
|
|
|
|
return size_ - put_;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
file_saver::file_saver(void) : size_(0), wrote_(0), path_(""), check_(""), dst_(nullptr), pack_cmd_(0), pack_id_(0)
|
|
|
|
{}
|
|
|
|
file_saver::~file_saver()
|
|
|
|
{
|
2023-12-13 06:57:08 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Wrote over of file(%s) at(%llu/%llu).\n", path_.c_str(), wrote_, size_);
|
2023-12-01 09:17:09 +00:00
|
|
|
close();
|
|
|
|
}
|
|
|
|
|
|
|
|
void file_saver::close(void)
|
|
|
|
{
|
2023-12-09 10:21:05 +00:00
|
|
|
if (map_)
|
|
|
|
map_->release();
|
|
|
|
map_ = nullptr;
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
if(dst_)
|
|
|
|
fclose(dst_);
|
|
|
|
dst_ = nullptr;
|
|
|
|
|
|
|
|
size_ = wrote_ = pack_cmd_ = pack_id_ = 0;
|
|
|
|
path_ = check_ = "";
|
|
|
|
}
|
|
|
|
|
2023-12-09 10:21:05 +00:00
|
|
|
int file_saver::set_verify_data(const char* data, size_t len)
|
|
|
|
{
|
|
|
|
if (data)
|
|
|
|
check_ = std::string(data, len);
|
|
|
|
else
|
|
|
|
check_ = "";
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2023-12-13 06:57:08 +00:00
|
|
|
const char* file_saver::path_file(void)
|
|
|
|
{
|
|
|
|
return path_.c_str();
|
|
|
|
}
|
2023-12-09 10:21:05 +00:00
|
|
|
int file_saver::open(const char* path, uint64_t size, bool in_mem, size_t off)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
close();
|
2023-12-09 10:21:05 +00:00
|
|
|
wrote_ = off;
|
|
|
|
path_ = path;
|
|
|
|
size_ = size;
|
|
|
|
|
|
|
|
if (in_mem)
|
|
|
|
{
|
|
|
|
map_ = new file_map();
|
|
|
|
err = map_->open(path, size, false);
|
|
|
|
if (err || !map_->map())
|
|
|
|
{
|
|
|
|
map_->release();
|
|
|
|
map_ = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = utils::make_file_size(path, wrote_);
|
|
|
|
dst_ = fopen(path, "ab+");
|
|
|
|
if (dst_)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
unsigned long long space = 0;
|
2023-12-09 10:21:05 +00:00
|
|
|
std::string dir(path);
|
|
|
|
size_t pos = dir.rfind(PATH_SEPARATOR[0]);
|
2023-12-01 09:17:09 +00:00
|
|
|
|
2023-12-09 10:21:05 +00:00
|
|
|
if (pos != std::string::npos)
|
|
|
|
dir.erase(pos);
|
|
|
|
err = utils::get_disk_space(dir.c_str(), nullptr, &space, nullptr);
|
2023-12-01 09:17:09 +00:00
|
|
|
if (err || space < size * 1.5)
|
|
|
|
{
|
|
|
|
fclose(dst_);
|
|
|
|
dst_ = nullptr;
|
|
|
|
remove(path);
|
|
|
|
if (err == 0)
|
|
|
|
err = ENOSPC;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
err = errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int file_saver::put_data(const void* data, uint32_t* size/*[in] - total bytes of data; [out] - used bytes*/)
|
|
|
|
{
|
2023-12-09 10:21:05 +00:00
|
|
|
if (!dst_)
|
|
|
|
{
|
|
|
|
if (map_)
|
|
|
|
{
|
|
|
|
// fix me: we consider whole file is all mapped in memory
|
|
|
|
int w = *size > size_ - wrote_ ? size_ - wrote_ : *size;
|
|
|
|
memcpy(map_->buffer() + wrote_, data, w);
|
|
|
|
*size = w;
|
|
|
|
wrote_ += w;
|
|
|
|
notify_progress(size_, wrote_, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
return ENOENT;
|
2023-12-09 10:21:05 +00:00
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
int w = *size > size_ - wrote_ ? size_ - wrote_ : *size,
|
|
|
|
real_w = fwrite(data, 1, w, dst_), // should handle error here !
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
*size = real_w;
|
|
|
|
wrote_ += real_w;
|
|
|
|
if(wrote_ >= size_)
|
|
|
|
{
|
|
|
|
fclose(dst_);
|
|
|
|
dst_ = nullptr;
|
|
|
|
}
|
|
|
|
else if (real_w < w) // what happens ?
|
|
|
|
{
|
|
|
|
err = ferror(dst_);
|
|
|
|
}
|
|
|
|
notify_progress(size_, wrote_, err);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
bool file_saver::is_complete(void)
|
|
|
|
{
|
|
|
|
return wrote_ >= size_;
|
|
|
|
}
|
|
|
|
uint32_t file_saver::get_required(void)
|
|
|
|
{
|
|
|
|
return size_ - wrote_;
|
|
|
|
}
|
2023-12-02 02:15:44 +00:00
|
|
|
void file_saver::cancel(void)
|
|
|
|
{
|
2023-12-09 10:21:05 +00:00
|
|
|
std::string discard(path_);
|
|
|
|
|
2023-12-02 02:15:44 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Discard receiving file (%u/%u): '%s'.\n", wrote_, size_, path_.c_str());
|
|
|
|
close();
|
2023-12-09 10:21:05 +00:00
|
|
|
remove(discard.c_str());
|
2023-12-02 02:15:44 +00:00
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
data_source::data_source()
|
|
|
|
{}
|
|
|
|
data_source::~data_source()
|
|
|
|
{}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// dyn_mem
|
2024-01-03 09:39:16 +00:00
|
|
|
#ifdef STAT_MEM
|
2023-12-01 09:17:09 +00:00
|
|
|
uint64_t dyn_mem::mem_used_bytes_ = 0;
|
|
|
|
MUTEX dyn_mem::mem_lock_;
|
2024-01-03 09:39:16 +00:00
|
|
|
#endif
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
dyn_mem::dyn_mem(size_t size) : buf_(nullptr), len_(0), space_(ALIGN_TO(size, 16))
|
|
|
|
{
|
|
|
|
buf_ = (uint8_t*)malloc(space_);
|
|
|
|
if (buf_)
|
|
|
|
{
|
2024-01-03 09:39:16 +00:00
|
|
|
#ifdef STAT_MEM
|
|
|
|
{
|
|
|
|
SIMPLE_LOCK(dyn_mem::mem_lock_);
|
|
|
|
dyn_mem::mem_used_bytes_ += space_;
|
|
|
|
}
|
|
|
|
#endif
|
2023-12-01 09:17:09 +00:00
|
|
|
memset(buf_, 0, space_);
|
|
|
|
}
|
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
dyn_mem::dyn_mem(void* buf, size_t size)
|
|
|
|
: buf_((uint8_t*)buf), space_(size), len_(size)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
dyn_mem::~dyn_mem()
|
|
|
|
{
|
|
|
|
if (buf_)
|
|
|
|
{
|
|
|
|
free(buf_);
|
2024-01-03 09:39:16 +00:00
|
|
|
#ifdef STAT_MEM
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
SIMPLE_LOCK(dyn_mem::mem_lock_);
|
|
|
|
dyn_mem::mem_used_bytes_ -= space_;
|
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
#endif
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-03 09:39:16 +00:00
|
|
|
#ifdef STAT_MEM
|
2023-12-01 09:17:09 +00:00
|
|
|
uint64_t dyn_mem::mem_used(void)
|
|
|
|
{
|
|
|
|
return dyn_mem::mem_used_bytes_;
|
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
#endif
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
dyn_mem_ptr dyn_mem::memory(size_t size)
|
|
|
|
{
|
|
|
|
return new dyn_mem(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t dyn_mem::space(void)
|
|
|
|
{
|
|
|
|
return space_;
|
|
|
|
}
|
|
|
|
bool dyn_mem::set_len(size_t len)
|
|
|
|
{
|
|
|
|
if (len > space_)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
len_ = len;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
int dyn_mem::put(const void* data, int len)
|
|
|
|
{
|
|
|
|
if (len + len_ > space_)
|
|
|
|
len = space_ - len;
|
|
|
|
|
|
|
|
if (len > 0)
|
|
|
|
{
|
|
|
|
memcpy(buf_ + len_, data, len);
|
|
|
|
len_ += len;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
len = 0;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
void* dyn_mem::detach(size_t* size)
|
|
|
|
{
|
|
|
|
void* buf = buf_;
|
|
|
|
|
|
|
|
if (size)
|
|
|
|
*size = space_;
|
|
|
|
space_ = len_ = 0;
|
|
|
|
buf_ = nullptr;
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t dyn_mem::used(size_t len)
|
|
|
|
{
|
|
|
|
if (len >= len_)
|
|
|
|
{
|
|
|
|
len_ = 0;
|
|
|
|
}
|
|
|
|
else if (len)
|
|
|
|
{
|
|
|
|
memcpy(buf_, buf_ + len, len_ - len);
|
|
|
|
len_ -= len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len_;
|
|
|
|
}
|
|
|
|
dyn_mem& dyn_mem::operator+=(dyn_mem& r)
|
|
|
|
{
|
|
|
|
if (len_ + r.get_rest() > space_)
|
|
|
|
{
|
|
|
|
size_t size = ALIGN_TO(len_ + r.get_rest(), 16);
|
|
|
|
uint8_t* buf = (uint8_t*)malloc(size);
|
|
|
|
memcpy(buf, buf_, len_);
|
|
|
|
free(buf_);
|
|
|
|
buf_ = buf;
|
2024-01-03 09:39:16 +00:00
|
|
|
#ifdef STAT_MEM
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
SIMPLE_LOCK(dyn_mem::mem_lock_);
|
|
|
|
dyn_mem::mem_used_bytes_ += size - space_;
|
|
|
|
}
|
2024-01-03 09:39:16 +00:00
|
|
|
#endif
|
2023-12-01 09:17:09 +00:00
|
|
|
space_ = size;
|
|
|
|
}
|
|
|
|
memcpy(buf_ + len_, r.buf_, r.get_rest());
|
|
|
|
len_ += r.get_rest();
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
2023-12-12 01:36:06 +00:00
|
|
|
void dyn_mem::clear_data(void)
|
|
|
|
{
|
|
|
|
len_ = 0;
|
|
|
|
set_packet_param(0, 0);
|
|
|
|
set_session_id(0);
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
bool dyn_mem::is_memory_block(void)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
uint32_t dyn_mem::get_rest(void)
|
|
|
|
{
|
|
|
|
return len_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// following API valid when is_memory_block() return true
|
|
|
|
uint8_t* dyn_mem::ptr(void)
|
|
|
|
{
|
|
|
|
return buf_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// following API valid when is_memory_block() return false
|
|
|
|
int dyn_mem::fetch_data(void* buf, uint32_t* size)
|
|
|
|
{
|
|
|
|
if (*size >= len_)
|
|
|
|
{
|
|
|
|
memcpy(buf, buf_, len_);
|
|
|
|
*size = len_;
|
|
|
|
len_ = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy(buf, buf_, *size);
|
|
|
|
used(*size);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2024-01-03 09:39:16 +00:00
|
|
|
//
|
|
|
|
dyn_mem_shared::dyn_mem_shared(void* buf, size_t size, BEFORE_DESTROY_FUNC destroy, void* param)
|
|
|
|
: dyn_mem(buf, size), destroy_(destroy), param_(param)
|
|
|
|
{}
|
|
|
|
dyn_mem_shared::~dyn_mem_shared()
|
|
|
|
{
|
|
|
|
if(destroy_)
|
|
|
|
destroy_(this, param_);
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2023-12-01 09:17:09 +00:00
|
|
|
//
|
|
|
|
file_reader::file_reader() : len_(0), src_(nullptr), path_(""), consume_(0)
|
|
|
|
{}
|
|
|
|
file_reader::~file_reader()
|
|
|
|
{
|
|
|
|
if(src_)
|
|
|
|
fclose(src_);
|
2023-12-09 10:21:05 +00:00
|
|
|
if (map_)
|
|
|
|
map_->release();
|
2023-12-12 01:36:06 +00:00
|
|
|
notify_progress(len_, len_, 0); // ensure 100%
|
2023-12-26 05:50:23 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Read over of file(%s) at(%llu/%llu).\n", path_.c_str(), consume_, len_);
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
|
2023-12-09 10:21:05 +00:00
|
|
|
int file_reader::open(const char* file, bool in_mem, size_t off)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
if(src_)
|
|
|
|
fclose(src_);
|
2023-12-09 10:21:05 +00:00
|
|
|
src_ = nullptr;
|
|
|
|
consume_ = off;
|
|
|
|
|
|
|
|
if (in_mem)
|
|
|
|
{
|
|
|
|
map_ = new file_map();
|
|
|
|
if (map_->open(file, 0, true) || !map_->map())
|
|
|
|
{
|
|
|
|
map_->release();
|
|
|
|
map_ = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (map_->total_size() <= off)
|
|
|
|
{
|
|
|
|
map_->release();
|
|
|
|
map_ = nullptr;
|
|
|
|
|
|
|
|
return EOVERFLOW;
|
|
|
|
}
|
|
|
|
path_ = file;
|
|
|
|
len_ = map_->total_size();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
src_ = fopen(file, "rb");
|
|
|
|
if(!src_)
|
|
|
|
return errno;
|
|
|
|
|
|
|
|
FSEEK(src_, 0, SEEK_END);
|
|
|
|
len_ = FTELL(src_);
|
2023-12-09 10:21:05 +00:00
|
|
|
FSEEK(src_, consume_, SEEK_SET);
|
2023-12-01 09:17:09 +00:00
|
|
|
path_ = file;
|
2023-12-09 10:21:05 +00:00
|
|
|
if (len_ <= consume_)
|
|
|
|
{
|
|
|
|
fclose(src_);
|
|
|
|
src_ = nullptr;
|
|
|
|
|
|
|
|
return EOVERFLOW;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int file_reader::attach(FILE* f)
|
|
|
|
{
|
|
|
|
if (src_)
|
|
|
|
{
|
|
|
|
fclose(src_);
|
|
|
|
src_ = nullptr;
|
|
|
|
}
|
2023-12-09 10:21:05 +00:00
|
|
|
if (map_)
|
|
|
|
{
|
|
|
|
map_->release();
|
|
|
|
map_ = nullptr;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
uint64_t cur = FTELL(f);
|
|
|
|
|
|
|
|
FSEEK(f, 0, SEEK_END);
|
|
|
|
len_ = FTELL(f);
|
|
|
|
FSEEK(f, cur, SEEK_SET);
|
|
|
|
if (len_ <= cur)
|
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
src_ = f;
|
|
|
|
len_ -= cur;
|
|
|
|
consume_ = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
FILE* file_reader::detach(void)
|
|
|
|
{
|
|
|
|
FILE* ret = src_;
|
|
|
|
|
|
|
|
src_ = nullptr;
|
|
|
|
len_ = 0;
|
|
|
|
path_ = "";
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2023-12-13 06:57:08 +00:00
|
|
|
const char* file_reader::path_file(void)
|
|
|
|
{
|
|
|
|
return path_.c_str();
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
bool file_reader::is_memory_block(void)
|
|
|
|
{
|
2023-12-09 10:21:05 +00:00
|
|
|
return map_ != nullptr;
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
uint32_t file_reader::get_rest(void)
|
|
|
|
{
|
|
|
|
return len_ - consume_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// following API valid when is_memory_block() return true
|
|
|
|
uint8_t* file_reader::ptr(void)
|
|
|
|
{
|
2023-12-09 10:21:05 +00:00
|
|
|
return map_ ? map_->buffer() : nullptr;
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// following API valid when is_memory_block() return false
|
|
|
|
int file_reader::fetch_data(void* buf, uint32_t* size)
|
|
|
|
{
|
|
|
|
if (!src_)
|
2023-12-09 10:21:05 +00:00
|
|
|
{
|
|
|
|
if (map_)
|
|
|
|
{
|
|
|
|
if (*size + consume_ >= len_)
|
|
|
|
*size = len_ - consume_;
|
|
|
|
memcpy(buf, map_->buffer() + consume_, *size);
|
|
|
|
consume_ += *size;
|
|
|
|
notify_progress(len_, consume_, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
return ENODATA;
|
2023-12-09 10:21:05 +00:00
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
size_t r = fread(buf, 1, *size, src_); // fix me if ERROR occurs !!!
|
|
|
|
|
|
|
|
consume_ += r;
|
|
|
|
*size = r;
|
|
|
|
if (consume_ >= len_)
|
|
|
|
{
|
|
|
|
fclose(src_);
|
|
|
|
src_ = nullptr;
|
|
|
|
}
|
|
|
|
notify_progress(len_, consume_, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2023-12-09 10:21:05 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
file_map::file_map()
|
|
|
|
{
|
|
|
|
utils::get_page_size(&os_map_size_);
|
|
|
|
}
|
|
|
|
file_map::~file_map()
|
|
|
|
{
|
|
|
|
close();
|
|
|
|
}
|
|
|
|
|
|
|
|
void file_map::unmap(void)
|
|
|
|
{
|
|
|
|
if (buf_)
|
|
|
|
#if OS_WIN
|
|
|
|
UnmapViewOfFile(buf_);
|
|
|
|
#else
|
|
|
|
munmap(buf_, map_size_);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
buf_ = nullptr;
|
|
|
|
map_off_ = map_size_ = off_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int file_map::open(const char* file, uint64_t size, bool readonly)
|
|
|
|
{
|
|
|
|
close();
|
|
|
|
|
|
|
|
std::string oper(readonly ? "open" : "create");
|
|
|
|
|
|
|
|
#if OS_WIN
|
|
|
|
HANDLE h = INVALID_HANDLE_VALUE;
|
|
|
|
DWORD access = PAGE_READONLY;
|
|
|
|
if (readonly)
|
|
|
|
{
|
|
|
|
h = CreateFileA(file, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
access = PAGE_READWRITE;
|
|
|
|
h = CreateFileA(file, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
}
|
|
|
|
if (h == INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "FileMapping: %s '%s' failed: %d\n", oper.c_str(), file, GetLastError());
|
|
|
|
return EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (readonly)
|
|
|
|
{
|
|
|
|
DWORD* hi = (DWORD*)&size + 1,
|
|
|
|
* lo = (DWORD*)&size;
|
|
|
|
*lo = GetFileSize(h, hi);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LONG lo = size & 0x0ffffffff,
|
|
|
|
hi = size >> 32;
|
|
|
|
DWORD ret = SetFilePointer(h, lo, &hi, FILE_BEGIN);
|
|
|
|
if (ret == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
|
|
|
|
{
|
|
|
|
CloseHandle(h);
|
|
|
|
remove(file);
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "FileMapping: no space(%ld) for '%s'.\n", size, file);
|
|
|
|
|
|
|
|
return ENOSPC;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// write a byte to ensure map success
|
|
|
|
SetFilePointer(h, -1, NULL, FILE_CURRENT);
|
|
|
|
lo = 0;
|
|
|
|
WriteFile(h, &lo, 1, &ret, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
map_ = CreateFileMappingA(h, NULL, access, 0, 0, NULL);
|
|
|
|
access = GetLastError();
|
|
|
|
CloseHandle(h);
|
|
|
|
if (!map_)
|
|
|
|
{
|
|
|
|
remove(file);
|
|
|
|
map_ = INVALID_HANDLE_VALUE;
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "FileMapping: create mapping object for '%s' failed: %d.\n", file, access);
|
|
|
|
|
|
|
|
return EFAULT;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (readonly)
|
|
|
|
map_ = (HANDLE)::open(file, O_RDONLY, 0644);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int err = utils::make_file_size(file, size);
|
|
|
|
if(err)
|
|
|
|
{
|
|
|
|
utils::to_log(LOG_LEVEL_FATAL, "FileMapping: make file(%s) size(%ld) = %d\n", file, size, err);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
map_ = (HANDLE)::open(file, O_RDWR, 0666);
|
|
|
|
}
|
|
|
|
if (map_ == INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
int err = errno;
|
|
|
|
|
|
|
|
if(!readonly)
|
|
|
|
remove(file);
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "FileMapping: create mapping object for '%s' failed: %d.\n", file, err);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
path_file_ = file;
|
|
|
|
total_ = size;
|
|
|
|
read_only_ = readonly;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int file_map::close(void)
|
|
|
|
{
|
|
|
|
unmap();
|
|
|
|
|
|
|
|
if (map_ != INVALID_HANDLE_VALUE)
|
|
|
|
#if OS_WIN
|
|
|
|
CloseHandle(map_);
|
|
|
|
#else
|
|
|
|
::close((int)(long)map_);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
map_ = INVALID_HANDLE_VALUE;
|
|
|
|
total_ = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
uint64_t file_map::total_size(void)
|
|
|
|
{
|
|
|
|
return total_;
|
|
|
|
}
|
|
|
|
uint8_t* file_map::map(uint64_t off, uint32_t* size)
|
|
|
|
{
|
|
|
|
uint32_t len = 0;
|
|
|
|
|
|
|
|
unmap();
|
|
|
|
|
|
|
|
if (!size)
|
|
|
|
size = &len;
|
|
|
|
|
|
|
|
if (off < total_)
|
|
|
|
{
|
|
|
|
DWORD hi = 0,
|
|
|
|
lo = 0,
|
|
|
|
cnt = 0;
|
|
|
|
|
|
|
|
map_off_ = off / os_map_size_ * os_map_size_;
|
|
|
|
off_ = off - map_off_;
|
|
|
|
hi = map_off_ >> 32;
|
|
|
|
lo = map_off_;
|
|
|
|
cnt = total_ - map_off_;
|
|
|
|
if (cnt - off > *size && *size)
|
|
|
|
{
|
|
|
|
cnt = ALIGN_TO(*size + off, os_map_size_);
|
|
|
|
if(cnt > total_ - map_off_)
|
|
|
|
cnt = total_ - map_off_;
|
|
|
|
}
|
|
|
|
map_size_ = cnt;
|
|
|
|
#if OS_WIN
|
|
|
|
buf_ = (uint8_t*)MapViewOfFile(map_, read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE, hi, lo, map_size_);
|
|
|
|
#else
|
|
|
|
int priv = PROT_READ, prot = MAP_PRIVATE;
|
|
|
|
if (!read_only_)
|
|
|
|
{
|
|
|
|
priv |= PROT_WRITE;
|
|
|
|
prot = MAP_SHARED;
|
|
|
|
}
|
|
|
|
buf_ = (uint8_t*)mmap(nullptr, map_size_, priv, prot, (int)(long)map_, map_off_);
|
|
|
|
if(buf_ == INVALID_HANDLE_VALUE)
|
|
|
|
buf_ = nullptr;
|
|
|
|
#endif
|
|
|
|
if (!buf_)
|
|
|
|
{
|
2023-12-13 06:57:08 +00:00
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "FileMapping: request map(%llu + %u), real map(%llu + %u) failed: %d\n"
|
2023-12-09 10:21:05 +00:00
|
|
|
, off, *size, map_off_, map_size_, GetLastError());
|
|
|
|
*size = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*size = cnt - off;
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf_ ? buf_ + off_ : nullptr;
|
|
|
|
}
|
|
|
|
uint8_t* file_map::buffer(void)
|
|
|
|
{
|
|
|
|
return buf_ ? buf_ + off_ : nullptr;
|
|
|
|
}
|
2023-12-13 06:57:08 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2024-01-16 09:51:34 +00:00
|
|
|
// image_packet
|
2024-01-17 08:54:06 +00:00
|
|
|
image_packet::image_packet(LPPACKIMAGE head, dyn_mem_ptr img, uint32_t scanid
|
|
|
|
, const void* info, size_t info_size)
|
2024-01-16 09:51:34 +00:00
|
|
|
: img_(img), offset_(0), info_over_(false)
|
|
|
|
{
|
|
|
|
LPPACK_BASE pack = nullptr;
|
|
|
|
LPPACKIMAGE pimg = nullptr;
|
|
|
|
|
|
|
|
paper_ind_ = head->pos.paper_ind;
|
|
|
|
img->add_ref();
|
|
|
|
if(info && info_size)
|
|
|
|
info_ = std::string((const char*)info, info_size);
|
|
|
|
else
|
|
|
|
info_ = "";
|
|
|
|
|
|
|
|
head_ = dyn_mem::memory(sizeof(PACK_BASE) + sizeof(PACKIMAGE));
|
|
|
|
pack = (LPPACK_BASE)head_->ptr();
|
|
|
|
pimg = (LPPACKIMAGE)pack->payload;
|
|
|
|
BASE_PACKET_REPLY(*pack, PACK_CMD_SCAN_IMG_ROGER, scanid, 0);
|
|
|
|
pack->payload_len = sizeof(PACKIMAGE);
|
|
|
|
|
|
|
|
memcpy(pimg, head, sizeof(*pimg));
|
|
|
|
pimg->data_size = img->get_rest();
|
|
|
|
pimg->info_size = info_size;
|
|
|
|
|
|
|
|
head_->set_len(sizeof(PACK_BASE) + sizeof(PACKIMAGE));
|
|
|
|
info_over_ = info_.empty();
|
|
|
|
|
|
|
|
char buf[128] = {0};
|
|
|
|
|
|
|
|
sprintf(buf, "Image-%04u", head->pos.paper_ind);
|
|
|
|
pos_str_ = buf;
|
|
|
|
if(head->pos.paper_side == PAPER_SIDE_FRONT)
|
|
|
|
pos_str_ += "F_";
|
|
|
|
else if(head->pos.paper_side == PAPER_SIDE_BACK)
|
|
|
|
pos_str_ += "B_";
|
|
|
|
else
|
|
|
|
pos_str_ += "C_";
|
|
|
|
pos_str_ += std::to_string(head->pos.split_ind);
|
|
|
|
}
|
|
|
|
image_packet::~image_packet()
|
|
|
|
{
|
|
|
|
head_->release();
|
|
|
|
img_->release();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool image_packet::is_memory_block(void)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
uint32_t image_packet::get_rest(void)
|
|
|
|
{
|
|
|
|
return head_->get_rest() + info_.length() + img_->get_rest() - offset_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// following API valid when is_memory_block() return true
|
|
|
|
uint8_t* image_packet::ptr(void)
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
// following API valid when is_memory_block() return false. return error code
|
|
|
|
int image_packet::fetch_data(void* buf, uint32_t* size)
|
|
|
|
{
|
|
|
|
if(head_->get_rest())
|
|
|
|
{
|
|
|
|
if(*size < head_->get_rest())
|
|
|
|
{
|
|
|
|
memcpy(buf, head_->ptr(), *size);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy(buf, head_->ptr(), head_->get_rest());
|
|
|
|
*size = head_->get_rest();
|
|
|
|
}
|
|
|
|
head_->used(*size);
|
|
|
|
}
|
|
|
|
else if(!info_over_)
|
|
|
|
{
|
|
|
|
if(*size < info_.length() - offset_)
|
|
|
|
{
|
|
|
|
memcpy(buf, info_.c_str() + offset_, *size);
|
|
|
|
offset_ += *size;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy(buf, info_.c_str() + offset_, info_.length() - offset_);
|
|
|
|
*size = info_.length() - offset_;
|
|
|
|
|
|
|
|
info_over_ = true;
|
|
|
|
info_ = "";
|
|
|
|
offset_ = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(*size + offset_ >= img_->get_rest())
|
|
|
|
{
|
|
|
|
memcpy(buf, img_->ptr() + offset_, img_->get_rest() - offset_);
|
|
|
|
*size = img_->get_rest() - offset_;
|
|
|
|
offset_ = img_->get_rest();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy(buf, img_->ptr() + offset_, *size);
|
|
|
|
offset_ += *size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t image_packet::get_paper_index(void)
|
|
|
|
{
|
|
|
|
return paper_ind_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// dyn_mem_pool
|
2023-12-13 06:57:08 +00:00
|
|
|
dyn_mem_pool::dyn_mem_pool(uint32_t cnt, uint32_t unit) : count_(cnt), unit_(unit)
|
|
|
|
{
|
|
|
|
pool_ = (dyn_mem_ptr*)malloc(cnt * sizeof(dyn_mem_ptr));
|
|
|
|
for(uint32_t i = 0; i < cnt; ++i)
|
|
|
|
{
|
|
|
|
pool_[i] = dyn_mem::memory(unit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dyn_mem_pool::~dyn_mem_pool()
|
|
|
|
{
|
|
|
|
if(pool_)
|
|
|
|
{
|
|
|
|
for(uint32_t i = 0; i < count_; ++i)
|
|
|
|
{
|
|
|
|
if(pool_[i])
|
|
|
|
{
|
|
|
|
pool_[i]->release();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(pool_);
|
|
|
|
}
|
|
|
|
|
|
|
|
pool_ = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
dyn_mem_ptr dyn_mem_pool::take(void)
|
|
|
|
{
|
|
|
|
dyn_mem_ptr buf = nullptr;
|
|
|
|
|
|
|
|
if(!pool_[rpos_])
|
|
|
|
{
|
2023-12-16 07:27:40 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "memory pool pointer = %u.\n", wpos_);
|
2023-12-13 06:57:08 +00:00
|
|
|
chronograph watch;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
|
|
} while (run_ && !pool_[rpos_]);
|
2023-12-16 07:27:40 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Waiting for taking memory pool took %ums at %u (write pos = %u).\n", watch.elapse_ms(), rpos_, wpos_);
|
2023-12-13 06:57:08 +00:00
|
|
|
}
|
|
|
|
if(pool_[rpos_])
|
|
|
|
{
|
|
|
|
buf = pool_[rpos_];
|
|
|
|
pool_[rpos_++] = nullptr;
|
|
|
|
if(rpos_ >= count_)
|
|
|
|
rpos_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
void dyn_mem_pool::put(dyn_mem_ptr buf)
|
|
|
|
{
|
|
|
|
if(pool_[wpos_])
|
|
|
|
{
|
|
|
|
chronograph watch;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
|
|
} while (run_ && pool_[wpos_]);
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Waiting for putting memory pool took %ums at %u.\n", watch.elapse_ms(), wpos_);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(pool_[wpos_])
|
|
|
|
{
|
|
|
|
buf->release();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pool_[wpos_++] = buf;
|
|
|
|
if(wpos_ >= count_)
|
|
|
|
wpos_ = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void dyn_mem_pool::stop(void)
|
|
|
|
{
|
|
|
|
run_ = false;
|
|
|
|
}
|
|
|
|
uint32_t dyn_mem_pool::count(void)
|
|
|
|
{
|
|
|
|
return count_;
|
|
|
|
}
|
|
|
|
uint32_t dyn_mem_pool::unit(void)
|
|
|
|
{
|
|
|
|
return unit_;
|
|
|
|
}
|
|
|
|
uint32_t dyn_mem_pool::take_pos(void)
|
|
|
|
{
|
|
|
|
return rpos_;
|
|
|
|
}
|