void Writer::writeMessage(const protocol::Message &msg)
{
Q_ASSERT(m_file->isOpen());
if(msg.isRecordable()) {
// Write Interval message if sufficient time has passed since last message was written
if(m_minInterval>0) {
qint64 now = QDateTime::currentMSecsSinceEpoch();
qint64 interval = now - m_interval;
if(interval >= m_minInterval) {
protocol::Interval imsg(0, qMin(qint64(0xffff), interval));
QVarLengthArray<char> ibuf(imsg.length());
int ilen = imsg.serialize(ibuf.data());
m_file->write(ibuf.data(), ilen);
}
m_interval = now;
}
// Write the actual message
QVarLengthArray<char> buf(msg.length());
int len = msg.serialize(buf.data());
Q_ASSERT(len == buf.length());
m_file->write(buf.data(), len);
}
}
int main() {
/*Declarations instead of command line args*/
std::ifstream source("source.txt", std::ios::in);
std::ofstream result("result_07.txt", std::ios::out);
istring from = "%Tag%";
istring to = "John";
std::string buf;
size_t pos;
while (getline(source, buf)) {
istring ibuf(buf.begin(), buf.end());
pos = ibuf.find(from);
while (pos != std::string::npos) {
ibuf.replace(pos, from.size(), to);
pos = ibuf.find(from, pos);
}
result << ibuf << '\n';
}
return 0;
}
void Painter::DrawPolyPolyPolygonOp(const Point *vertices, int vertex_count,
const int *subpolygon_counts, int scc, const int *disjunct_polygon_counts,
int dpcc, Color color, int width, Color outline, uint64 pattern, Color doxor)
{
Image fill_img;
if(pattern && !IsNull(color)) {
ImageBuffer ibuf(8, 8);
RGBA r[2] = { color, RGBAZero() };
for(RGBA *out = ibuf, *end = out + 64; out < end; pattern >>= 1)
*out++ = r[(byte)pattern & 1];
fill_img = ibuf;
}
static bool test(const char* in, bool once, const char* name)
{
acl::json json;
const char* ptr = NULL, *p1 = in;
char buf[2];
if (once)
ptr = json.update(p1);
else
{
while (*p1)
{
buf[0] = *p1;
buf[1] = 0;
ptr = json.update(buf);
p1++;
}
}
printf("------------------ input json ------------------------\r\n");
printf("%s\r\n", in);
printf("-------------------------------------------------------\r\n");
printf("json finish: %s, left: |%s|, len: %d\r\n",
json.finish() ? "yes" : "no", ptr, (int) strlen(ptr));
printf("------------------ rebuild json -----------------------\r\n");
printf("%s\r\n", json.to_string().c_str());
printf("-------------------------------------------------------\r\n");
acl::string ibuf(in);
ibuf.trim_space().trim_right_line();
acl::string obuf = json.to_string();
obuf.trim_space();
if (ibuf == obuf)
printf("\r\n-----OK----\r\n\r\n");
else
printf("\r\n-----Error----\r\n\r\n");
if (name && *name)
test_type(json, name);
return true;
}
virtual V m_bang()
{
if(!ref.Ok() || !ref.Check()) {
/*
if(!frms)
post("%s - No length defined!",thisName());
else
*/
{
ImmBuf ibuf(frms,zero);
Vasp ret(frms,Vasp::Ref(ibuf));
ToOutVasp(0,ret);
}
}
else if(ref.Vectors() > 1)
post("%s - More than one vector in vasp!",thisName());
else {
VBuffer *buf = ref.Buffer(0);
const I len = buf->Length(),chns = buf->Channels();
// size of memory reservation (at least frms samples)
const I rlen = frms > len?frms:len;
ImmBuf imm(rlen,false);
BS *dst = imm.Pointer();
const BS *src = buf->Pointer();
// post("!copy: src: %p,%i,%i -> dst: %p,%i",src,len,chns,dst,rlen);
register int i;
_DE_LOOP(i,len, ( dst[i] = *src,src += chns ) )
if(zero && rlen > len) ZeroSamples(dst+len,rlen-len);
Vasp::Ref vr(imm);
// post("!vr: %s,%i",vr.Ok()?vr.Symbol().Name():"***",vr.Offset());
Vasp ret(len,vr);
ToOutVasp(0,ret);
delete buf;
}
}
CPLErr MSGRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void * pImage )
{
MSGDataset *poGDS = (MSGDataset *) poDS;
int iBytesPerPixel = 1;
if (eDataType == GDT_UInt16)
iBytesPerPixel = 2;
else if (eDataType == GDT_Float32)
iBytesPerPixel = 4;
/* -------------------------------------------------------------------- */
/* Calculate the correct input file name based on nBlockYOff */
/* -------------------------------------------------------------------- */
int strip_number;
int iChannel = poGDS->command.iChannel(1 + ((nBand - 1) % poGDS->command.iNrChannels()));
if (fScanNorth)
strip_number = nBlockYOff + 1;
else
strip_number = poGDS->command.iNrStrips(iChannel) - nBlockYOff;
std::string strip_input_file = poGDS->command.sFileName(iSatellite, nBand, strip_number);
/* -------------------------------------------------------------------- */
/* Open the input file */
/* -------------------------------------------------------------------- */
if (access(strip_input_file.c_str(), 0) == 0) // does it exist?
{
std::ifstream i_file (strip_input_file.c_str(), std::ios::in|std::ios::binary);
if (i_file.good())
{
XRITHeaderParser xhp (i_file);
if (xhp.isValid())
{
std::vector <short> QualityInfo;
unsigned short chunck_height = xhp.nrRows();
unsigned short chunck_bpp = xhp.nrBitsPerPixel();
unsigned short chunck_width = xhp.nrColumns();
unsigned __int8 NR = (unsigned __int8)chunck_bpp;
unsigned int nb_ibytes = xhp.dataSize();
int iShift = 0;
bool fSplitStrip = false; // in the split strip the "shift" only happens before the split "row"
int iSplitRow = 0;
if (iChannel == 12)
{
iSplitRow = iSplitLine % xhp.nrRows();
int iSplitBlock = iSplitLine / xhp.nrRows();
fSplitStrip = (nBlockYOff == iSplitBlock); // in the split strip the "shift" only happens before the split "row"
// When iLowerShift > 0, the lower HRV image is shifted to the right
// When iLowerShift < 0, the lower HRV image is shifted to the left
// The available raster may be wider than needed, so that time series don't fall outside the raster.
if (nBlockYOff <= iSplitBlock)
iShift = -iLowerShift;
// iShift < 0 means upper image moves to the left
// iShift > 0 means upper image moves to the right
}
std::auto_ptr< unsigned char > ibuf( new unsigned char[nb_ibytes]);
if (ibuf.get() == 0)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Not enough memory to perform wavelet decompression\n");
return CE_Failure;
}
i_file.read( (char *)(ibuf.get()), nb_ibytes);
Util::CDataFieldCompressedImage img_compressed(ibuf.release(),
nb_ibytes*8,
(unsigned char)chunck_bpp,
chunck_width,
chunck_height );
Util::CDataFieldUncompressedImage img_uncompressed;
//****************************************************
//*** Here comes the wavelets decompression routine
COMP::DecompressWT(img_compressed, NR, img_uncompressed, QualityInfo);
//****************************************************
// convert:
// Depth:
// 8 bits -> 8 bits
// 10 bits -> 16 bits (img_uncompressed contains the 10 bits data in packed form)
// Geometry:
// chunck_width x chunck_height to nBlockXSize x nBlockYSize
// cases:
// combination of the following:
// - scan direction can be north or south
// - eDataType can be GDT_Byte, GDT_UInt16 or GDT_Float32
// - nBlockXSize == chunck_width or nBlockXSize > chunck_width
// - when nBlockXSize > chunck_width, fSplitStrip can be true or false
// we won't distinguish the following cases:
// - NR can be == 8 or != 8
// - when nBlockXSize > chunck_width, iShift iMinCOff-iMaxCOff <= iShift <= 0
int nBlockSize = nBlockXSize * nBlockYSize;
int y = chunck_width * chunck_height;
int iStep = -1;
if (fScanNorth) // image is the other way around
{
y = -1; // See how y is used below: += happens first, the result is used in the []
iStep = 1;
}
COMP::CImage cimg (img_uncompressed); // unpack
if (eDataType == GDT_Byte)
{
if (nBlockXSize == chunck_width) // optimized version
{
if (poGDS->command.cDataConversion == 'B')
{
for( int i = 0; i < nBlockSize; ++i )
((GByte *)pImage)[i] = cimg.Get()[y+=iStep] / 4;
}
else
{
for( int i = 0; i < nBlockSize; ++i )
((GByte *)pImage)[i] = cimg.Get()[y+=iStep];
}
}
else
{
// initialize to 0's (so that it does not have to be done in an 'else' statement <performance>)
memset(pImage, 0, nBlockXSize * nBlockYSize * iBytesPerPixel);
if (poGDS->command.cDataConversion == 'B')
{
for( int j = 0; j < chunck_height; ++j ) // assumption: nBlockYSize == chunck_height
{
int iXOffset = j * nBlockXSize + iShift;
iXOffset += nBlockXSize - iLowerWestColumnPlanned - 1; // Position the HRV part in the frame; -1 to compensate the pre-increment in the for-loop
if (fSplitStrip && (j >= iSplitRow)) // In splitstrip, below splitline, thus do not shift!!
iXOffset -= iShift;
for (int i = 0; i < chunck_width; ++i)
((GByte *)pImage)[++iXOffset] = cimg.Get()[y+=iStep] / 4;
}
}
else
{
for( int j = 0; j < chunck_height; ++j ) // assumption: nBlockYSize == chunck_height
{
int iXOffset = j * nBlockXSize + iShift;
iXOffset += nBlockXSize - iLowerWestColumnPlanned - 1; // Position the HRV part in the frame; -1 to compensate the pre-increment in the for-loop
if (fSplitStrip && (j >= iSplitRow)) // In splitstrip, below splitline, thus do not shift!!
iXOffset -= iShift;
for (int i = 0; i < chunck_width; ++i)
((GByte *)pImage)[++iXOffset] = cimg.Get()[y+=iStep];
}
}
}
}
else if (eDataType == GDT_UInt16) // this is our "normal case" if scan direction is South: 10 bit MSG data became 2 bytes per pixel
{
if (nBlockXSize == chunck_width) // optimized version
{
for( int i = 0; i < nBlockSize; ++i )
((GUInt16 *)pImage)[i] = cimg.Get()[y+=iStep];
}
else
{
// initialize to 0's (so that it does not have to be done in an 'else' statement <performance>)
memset(pImage, 0, nBlockXSize * nBlockYSize * iBytesPerPixel);
for( int j = 0; j < chunck_height; ++j ) // assumption: nBlockYSize == chunck_height
{
int iXOffset = j * nBlockXSize + iShift;
iXOffset += nBlockXSize - iLowerWestColumnPlanned - 1; // Position the HRV part in the frame; -1 to compensate the pre-increment in the for-loop
if (fSplitStrip && (j >= iSplitRow)) // In splitstrip, below splitline, thus do not shift!!
iXOffset -= iShift;
for (int i = 0; i < chunck_width; ++i)
((GUInt16 *)pImage)[++iXOffset] = cimg.Get()[y+=iStep];
}
}
}
else if (eDataType == GDT_Float32) // radiometric calibration is requested
{
if (nBlockXSize == chunck_width) // optimized version
{
for( int i = 0; i < nBlockSize; ++i )
((float *)pImage)[i] = (float)rRadiometricCorrection(cimg.Get()[y+=iStep], iChannel, nBlockYOff * nBlockYSize + i / nBlockXSize, i % nBlockXSize, poGDS);
}
else
{
// initialize to 0's (so that it does not have to be done in an 'else' statement <performance>)
memset(pImage, 0, nBlockXSize * nBlockYSize * iBytesPerPixel);
for( int j = 0; j < chunck_height; ++j ) // assumption: nBlockYSize == chunck_height
{
int iXOffset = j * nBlockXSize + iShift;
iXOffset += nBlockXSize - iLowerWestColumnPlanned - 1; // Position the HRV part in the frame; -1 to compensate the pre-increment in the for-loop
if (fSplitStrip && (j >= iSplitRow)) // In splitstrip, below splitline, thus do not shift!!
iXOffset -= iShift;
int iXFrom = nBlockXSize - iLowerWestColumnPlanned + iShift; // i is used as the iCol parameter in rRadiometricCorrection
int iXTo = nBlockXSize - iLowerWestColumnPlanned + chunck_width + iShift;
for (int i = iXFrom; i < iXTo; ++i) // range always equal to chunck_width .. this is to utilize i to get iCol
((float *)pImage)[++iXOffset] = (float)rRadiometricCorrection(cimg.Get()[y+=iStep], iChannel, nBlockYOff * nBlockYSize + j, (fSplitStrip && (j >= iSplitRow))?(i - iShift):i, poGDS);
}
}
}
}
else // header could not be opened .. make sure block contains 0's
memset(pImage, 0, nBlockXSize * nBlockYSize * iBytesPerPixel);
}
else // file could not be opened .. make sure block contains 0's
memset(pImage, 0, nBlockXSize * nBlockYSize * iBytesPerPixel);
i_file.close();
}
else // file does not exist .. make sure block contains 0's
memset(pImage, 0, nBlockXSize * nBlockYSize * iBytesPerPixel);
return CE_None;
}
template<class T> static bool copyout( T& t, adfs::folium& f ) {
detail::cpio ibuf( f.size() );
std::istream is( &ibuf );
return f.read( ibuf.size(), ibuf.get() ) && archive_type::restore( is, t );
}
std::wstring load_text_file(const std::wstring &path, uint32_t codepage)
{
struct F {
static void release(IUnknown *x) { x->Release(); }
};
IStream *stream;
HRESULT hr = SHCreateStreamOnFileW(path.c_str(),
STGM_READ | STGM_SHARE_DENY_WRITE,
&stream);
if (FAILED(hr)) win32::throw_error(path, hr);
std::shared_ptr<IStream> streamPtr(stream, F::release);
LARGE_INTEGER li = { 0 };
ULARGE_INTEGER ui;
HR(stream->Seek(li, STREAM_SEEK_END, &ui));
if (ui.QuadPart > 0x100000) {
throw std::runtime_error(strutil::w2us(path + L": file too big"));
}
size_t fileSize = ui.LowPart;
HR(stream->Seek(li, STREAM_SEEK_SET, &ui));
IMultiLanguage2 *mlang;
HR(CoCreateInstance(CLSID_CMultiLanguage, 0, CLSCTX_INPROC_SERVER,
IID_IMultiLanguage2, (void**)(&mlang)));
std::shared_ptr<IMultiLanguage2> mlangPtr(mlang, F::release);
if (!codepage) {
DetectEncodingInfo encoding[5];
INT nscores = 5;
HR(mlang->DetectCodepageInIStream(0, GetACP(),
stream, encoding, &nscores));
/*
* Usually DetectCodepageInIStream() puts the most appropriate choice
* in the first place.
* However, it tends to pick 8bit locale charset for the first place,
* even if it is really an UTF-8 encoded file.
*/
codepage = encoding[0].nCodePage;
for (size_t i = 0; i < nscores; ++i)
if (encoding[i].nCodePage == 65001) {
codepage = 65001;
break;
}
HR(stream->Seek(li, STREAM_SEEK_SET, &ui));
}
std::vector<char> ibuf(fileSize);
ULONG nread;
HR(stream->Read(&ibuf[0], ibuf.size(), &nread));
DWORD ctx = 0;
UINT size = ibuf.size(), cnt;
HR(mlang->ConvertStringToUnicode(&ctx, codepage,
&ibuf[0], &size, 0, &cnt));
std::vector<wchar_t> obuf(cnt);
size = ibuf.size();
HR(mlang->ConvertStringToUnicode(&ctx, codepage,
&ibuf[0], &size, &obuf[0], &cnt));
obuf.push_back(0);
// chop off BOM
size_t bom = obuf.size() && obuf[0] == 0xfeff;
return strutil::normalize_crlf(&obuf[bom], L"\n");
}
int main()
try {
// -------------------------------------------------------------------------
std::cout << "Read standard Ifd from data buffer\n";
const long len = 77;
Exiv2::byte buf[]
= { 0xff, // Filler
// No
0x00,0x04,
// Tag Type Components Offset/Data
0x00,0x01, 0x00,0x02, 0x00,0x00,0x00,0x04, 'T', 'h', 'e', '\0',
0x00,0x02, 0x00,0x02, 0x00,0x00,0x00,0x06, 0x00,0x00,0x00,0x37,
0x00,0x03, 0x00,0x02, 0x00,0x00,0x00,0x07, 0x00,0x00,0x00,0x3d,
0x00,0x04, 0x00,0x02, 0x00,0x00,0x00,0x09, 0x00,0x00,0x00,0x44,
// Next
0x00,0x00,0x00,0x00,
// Data
'K', 'u', 'a', 'l', 'a', '\0',
'L', 'u', 'm', 'p', 'u', 'r', '\0',
'M', 'a', 'l', 'a', 'y', 's', 'i', 'a', '\0'
};
Exiv2::Ifd ifd(Exiv2::ifd0Id, 0, false);
int rc = ifd.read(buf, len, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (1) failed, rc = " << rc << "\n";
return rc;
}
ifd.print(std::cout);
Exiv2::Ifd::iterator pos = ifd.findTag(0x0004);
if (pos == ifd.end()) {
std::cout << "Tag not found!\n";
return 1;
}
Exiv2::byte data[] = { 'T', 'H', 'R', 'E', 'E', '\0' };
std::cout << "Setting value of entry 3...\n";
pos->setValue(2, 6, data, 6);
Exiv2::DataBuf db(1024);
rc = ifd.copy(db.pData_ + 1, Exiv2::bigEndian);
std::cout << "Wrote " << rc << " characters to data buffer\n";
rc = ifd.read(db.pData_, len, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (1a) failed, rc = " << rc << "\n";
return rc;
}
ifd.print(std::cout);
// -------------------------------------------------------------------------
std::cout << "\nRead non-standard Ifd from data buffer\n";
const long len2 = 76;
Exiv2::byte buf2[]
= { // Data
'K', 'u', 'a', 'l', 'a', '\0',
'L', 'u', 'm', 'p', 'u', 'r', '\0',
'M', 'a', 'l', 'a', 'y', 's', 'i', 'a', '\0',
// No
0x00,0x04,
// Tag Type Components Offset/Data
0x00,0x01, 0x00,0x02, 0x00,0x00,0x00,0x04, 'T', 'h', 'e', '\0',
0x00,0x02, 0x00,0x02, 0x00,0x00,0x00,0x06, 0x00,0x00,0x00,0x00,
0x00,0x03, 0x00,0x02, 0x00,0x00,0x00,0x07, 0x00,0x00,0x00,0x06,
0x00,0x04, 0x00,0x02, 0x00,0x00,0x00,0x09, 0x00,0x00,0x00,0x0d,
// Next
0x00,0x00,0x00,0x00
};
Exiv2::Ifd ifd2(Exiv2::ifd0Id, 0, false);
rc = ifd2.read(buf2, len2, 22, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (2) failed, rc = " << rc << "\n";
return rc;
}
ifd2.print(std::cout);
pos = ifd2.findTag(0x0004);
if (pos == ifd2.end()) {
std::cout << "Tag not found!\n";
return 1;
}
Exiv2::byte data2[] = { 'T', 'H', 'R', 'E', 'E', '\0' };
std::cout << "Setting value of entry 3...\n";
pos->setValue(2, 6, data2, 6);
ifd2.print(std::cout);
// -------------------------------------------------------------------------
std::cout << "\nTest boundary checks, the following reads should generate warnings or errors\n";
std::cout << "--- read (3)" << std::endl;
rc = ifd.read(buf, len-1, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (3) failed, rc = " << rc << "\n";
}
std::cout << "--- read (4)" << std::endl;
rc = ifd.read(buf, len-17, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (4) failed, rc = " << rc << "\n";
}
std::cout << "--- read (5)" << std::endl;
rc = ifd.read(buf, len-16, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (5) failed, rc = " << rc << "\n";
}
std::cout << "--- read (6)" << std::endl;
rc = ifd.read(buf, len-23, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (6) failed, rc = " << rc << "\n";
}
std::cout << "--- read (7)" << std::endl;
rc = ifd2.read(buf2, len2-1, 22, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (7) failed, rc = " << rc << "\n";
}
// -------------------------------------------------------------------------
std::cout << "\nCreate Ifd from scratch\n";
Exiv2::Ifd ifd3(Exiv2::ifd0Id);
Exiv2::Entry e;
e.setIfdId(Exiv2::ifd0Id);
e.setIdx(0);
e.setTag(0x0001);
e.setOffset(0); // will be calculated when the IFD is written
Exiv2::byte data0x01[] = { 'T', 'h', 'e', '\0' };
e.setValue(2, 4, data0x01, 4);
ifd3.add(e);
e.setTag(0x0002);
e.setOffset(0); // will be calculated when the IFD is written
Exiv2::byte data0x02[] = { 'K', 'u', 'a', 'l', 'a', '\0' };
e.setValue(2, 6, data0x02, 6);
ifd3.add(e);
e.setTag(0x0003);
e.setOffset(0); // will be calculated when the IFD is written
Exiv2::byte data0x03[] = { 'L', 'u', 'm', 'p', 'u', 'r', '\0' };
e.setValue(2, 7, data0x03, 7);
ifd3.add(e);
e.setTag(0x0004);
e.setOffset(0); // will be calculated when the IFD is written
Exiv2::byte data0x04[] = { 'M', 'a', 'l', 'a', 'y', 's', 'i', 'a', '\0' };
e.setValue(2, 9, data0x04, 9);
ifd3.add(e);
Exiv2::DataBuf ibuf(256);
long len3 = ifd3.copy(ibuf.pData_, Exiv2::bigEndian);
Exiv2::Ifd ifd4(Exiv2::ifd0Id, 0, false);
rc = ifd4.read(ibuf.pData_, len3, 0, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (8) failed, rc = " << rc << "\n";
}
ifd4.print(std::cout);
// -------------------------------------------------------------------------
std::cout << "\nMove data buffer\n";
Exiv2::Ifd ifd5(Exiv2::ifd0Id, 0, false);
rc = ifd5.read(buf, len, 1, Exiv2::bigEndian);
if (rc) {
std::cout << "Ifd::read (1) failed, rc = " << rc << "\n";
return rc;
}
ifd5.print(std::cout);
Exiv2::byte* newBuf = new Exiv2::byte[len];
std::memset(newBuf, 0x00, len);
std::memcpy(newBuf, buf, len);
std::memset(buf, 0x0, len);
ifd5.updateBase(newBuf);
ifd5.print(std::cout);
delete[] newBuf;
return 0;
}
catch (const Exiv2::AnyError& e) {
std::cout << "Caught Exiv2 exception '" << e << "'\n";
return 1;
}
