void write_argument_value(tstring const& data)
{
// http://www.w3.org/TR/REC-xml/#NT-AttValue
// says that in att value, we escape " ' < and &
static const tstring patterns = "\"'<&";
static const tstring replacements[] = {
""", "'", "<", "&"
};
xml_content_encoder encoder(data, patterns, replacements);
while( encoder.has_next() ) {
tinfra::tstring chunk = encoder.next();
out_->write(chunk.data(), chunk.size());
}
}
const std::string createHeader()
{
// TODO: Some sane code to represent JSON objects
std::string header = "{\"alg\":\""+_alg+"\",\"typ\":\""+_typ+"\"}";
Log::info("JWT Header: " + header);
std::ostringstream ostr;
Poco::OutputLineEndingConverter lineEndingConv(ostr, "");
Poco::Base64Encoder encoder(lineEndingConv);
encoder << header;
encoder.close();
return ostr.str();
}
void ArchExecutor::EncodeFiles(Options* options)
{
int filesCount = options->Files->GetCount();
if (options->Stdin || filesCount == 0)
{
LzwEncoder encoder(stdin, stdout);
encoder.Encode("");
return;
}
for(int i = 0; i < filesCount; i++)
{
char* path = options->Files->GetElement(i);
FILE* inputFile = fopen(path, "rb");
if (IsCompressedFile(inputFile))
{
fclose(inputFile);
continue;
}
char* compressedPath = new char[PATH_MAX];
int pathLength = sprintf (compressedPath, "%s.ar", path);
if (pathLength >= PATH_MAX)
{
printf ("Path length has got too long.\n");
continue;
}
FILE* outputFile = fopen(compressedPath, "wb");
LzwEncoder encoder(inputFile, outputFile);
encoder.Encode(GetName(path));
fclose(inputFile);
remove(path);
}
}
void VlrCompressor::done()
{
// Close and clear the point encoder.
m_encoder->done();
m_encoder.reset();
newChunk();
// Save our current position. Go to the location where we need
// to write the chunk table offset at the beginning of the point data.
uint64_t chunkTablePos = htole64((uint64_t) m_stream.m_buf.size());
// We need to add the offset given a construction time since
// we did not use a stream to write the header and vlrs
uint64_t trueChunkTablePos = htole64((uint64_t) m_stream.m_buf.size() + m_offsetToData);
// Equivalent of stream.seekp(m_chunkInfoPos); stream << chunkTablePos
memcpy(&m_stream.m_buf[m_chunkInfoPos], (char*) &trueChunkTablePos, sizeof(uint64_t));
// Move to the start of the chunk table.
// Which in our case is the end of the m_stream vector
// Write the chunk table header in two steps
// 1. Push bytes into the stream
// 2. memcpy the data into the pushed bytes
unsigned char skip[2 * sizeof(uint32_t)] = {0};
m_stream.putBytes(skip, sizeof(skip));
uint32_t version = htole32(0);
uint32_t chunkTableSize = htole32((uint32_t) m_chunkTable.size());
memcpy(&m_stream.m_buf[chunkTablePos], &version, sizeof(uint32_t));
memcpy(&m_stream.m_buf[chunkTablePos + sizeof(uint32_t)], &chunkTableSize, sizeof(uint32_t));
// Encode and write the chunk table.
// OutputStream outputStream(m_stream);
TypedLazPerfBuf<uint8_t> outputStream(m_stream);
Encoder encoder(outputStream);
laszip::compressors::integer compressor(32, 2);
compressor.init();
uint32_t predictor = 0;
for (uint32_t chunkSize : m_chunkTable)
{
chunkSize = htole32(chunkSize);
compressor.compress(encoder, predictor, chunkSize, 1);
predictor = chunkSize;
}
encoder.done();
}
// -----------------------------------------------------------------------------
// CWimCertHandler::ParseCertPublicKeyL
// Parse public key from certificate.
// -----------------------------------------------------------------------------
//
void CWimCertHandler::ParseCertPublicKeyL(
const TDesC8& aCertData,
TDes8& aPublicKey,
const TUint8 aCertType ) const
{
_WIMTRACE2(_L("WIM | WIMServer | CWimPublicKeyHandler::ParseCertPublicKeyL | Begin, type %d"), aCertType);
CCertificate* certificate = NULL;
CRSAPublicKey* publicKey = NULL;
switch ( aCertType )
{
case WIMI_CT_WTLS:
{
certificate = CWTLSCertificate::NewLC( aCertData );
publicKey = CWTLSRSAPublicKey::NewLC( certificate->PublicKey().KeyData() );
break;
}
case WIMI_CT_X509:
{
certificate = CX509Certificate::NewLC( aCertData );
publicKey = CX509RSAPublicKey::NewLC( certificate->PublicKey().KeyData() );
break;
}
default:
{
_WIMTRACE2(_L("WIM|WIMServer|CWimCertHandler::ParseCertPublicKeyL, type %d not supported"), aCertType);
User::Leave( KErrNotSupported );
break;
}
}
TX509RSAKeyEncoder encoder( *publicKey, ESHA1 );
CASN1EncBase* encoded = encoder.EncodeKeyLC();
TUint pos = 0;
aPublicKey.SetLength( KPublicKeyLength );
// Check that Max. length is not exceeded
if ( encoded->LengthDER() > static_cast< TUint >( KPublicKeyLength ) )
{
_WIMTRACE(_L("WIM|WIMServer|CWimCertHandler::ParseCertPublicKeyL, too long public key"));
User::Leave( KErrBadDescriptor );
}
// Write encoded key to prealloced buffer
encoded->WriteDERL( aPublicKey, pos );
CleanupStack::PopAndDestroy( 3, certificate ); // encoded, publicKey, certificate
_WIMTRACE(_L("WIM | WIMServer | CWimPublicKeyHandler::ParseCertPublicKeyL | End"));
}
/*
encoder - decoder
cbr or cq
ppinloop
rebuild.yuv size.txt ssim.txt
*/
void run_codec_test(char argc, char** argv)
{
CX264Encoder e;
set_default_cmd();
parse_cmd_enc( argc, argv);
if(1==verfy_cmd())
{
cmd_help();
}
init_encoder( &e );
encoder( &e, &gCmd);
}
std::string lzwTest(const std::string& str) {
std::ostringstream oss;
LzwEncoder encoder(std::make_shared<Writer>(&oss));
for (auto c : str) {
encoder.encode(c);
}
encoder.flush();
std::istringstream iss(oss.str());
LzwDecoder decoder(std::make_shared<Reader>(&iss));
std::ostringstream result;
decoder.decode(result);
return result.str();
}
void URLEncoderTest::DecodeTest()
{
URLEncoder encoder("encoder");
String Request = "Dies%20ist%0A%20%22%25%26%3F%2F%5C%23%7B%7DeinTestString";
String Answer, expected;
encoder.DoDecode(Answer, Request);
expected = "Dies ist\n ";
expected.Append('"').Append("%&?/\\#{}einTestString");
assertEqual( expected, Answer );
Request = "Dies+ist%0A+%22%25%26%3F%2F%5C%23%7B%7Dein+Test+String";
encoder.DoDecode(Answer, Request);
expected = "Dies ist\n ";
expected.Append('"').Append("%&?/\\#{}ein Test String");
assertEqual( expected, Answer );
}
void write_content_bytes(tstring const& data)
{
// http://www.w3.org/TR/REC-xml/#dt-chardata
// says that only < and & are escaped
// in normal text
static const tstring patterns = "<&";
static const tstring replacements[] = {
"<", "&"
};
xml_content_encoder encoder(data, patterns, replacements);
while( encoder.has_next() ) {
tinfra::tstring chunk = encoder.next();
out_->write(chunk.data(), chunk.size());
}
}
void MailMessage::writeEncoded(std::istream& istr, std::ostream& ostr, ContentTransferEncoding encoding) const
{
switch (encoding)
{
case ENCODING_7BIT:
case ENCODING_8BIT:
StreamCopier::copyStream(istr, ostr);
break;
case ENCODING_QUOTED_PRINTABLE:
{
QuotedPrintableEncoder encoder(ostr);
StreamCopier::copyStream(istr, encoder);
encoder.close();
}
break;
case ENCODING_BASE64:
{
Base64Encoder encoder(ostr);
StreamCopier::copyStream(istr, encoder);
encoder.close();
}
break;
}
}
void compressAdaptive(std::istream& in, std::ostream& out) {
const char* header = "AC\x00";
out.write(header, 3);
ArithmeticEncoder encoder(std::make_shared<BitStreamWriter>(&out));
AdaptiveDataModel dataModel(NUM_SYMBOLS);
for (;;) {
int c = in.get();
if (c == std::char_traits<char>::eof()) {
encoder.encode(NUM_SYMBOLS - 1, &dataModel);
break;
}
encoder.encode(c, &dataModel);
}
}
static Block
makeBlock(uint32_t type, Iterator first, Iterator last)
{
EncodingEstimator estimator;
size_t valueLength = last - first;
size_t totalLength = valueLength;
totalLength += estimator.prependVarNumber(valueLength);
totalLength += estimator.prependVarNumber(type);
EncodingBuffer encoder(totalLength, 0);
encoder.prependRange(first, last);
encoder.prependVarNumber(valueLength);
encoder.prependVarNumber(type);
return encoder.block();
}
void main(int argc, char *argv[])
{
void encoder();
static void usage(char*);
if (argc != 3)
usage(argv[0]);
#ifdef __ADSP21000__
initx();
#else
ifile_name = argv[1];
xfile_name = argv[2];
#endif
ffase = -4;
encoder();
}
void saveImage (const unsigned char* pixels,const unsigned char* palette,size_t width,size_t height,size_t channels,const std::string& strFile)
{
std::auto_ptr<ImageEncoder> encoder ( getImageEncoder (strFile) );
if (!encoder.get())
throw std::runtime_error("Unsupported file format "+strFile);
encoder->setWidth (width);
encoder->setHeight (height);
encoder->setChannels (channels);
encoder->setPalette (palette);
encoder->write_open(strFile);
encoder->write_header();
encoder->write_data (pixels,palette);
encoder->write_close ();
}
const std::string createPayload()
{
std::time_t curtime = Poco::Timestamp().epochTime();
std::string exptime = std::to_string(curtime + 3600);
// TODO: Some sane code to represent JSON objects
std::string payload = "{\"iss\":\""+_iss+"\",\"sub\":\""+_sub+"\",\"aud\":\""+_aud+"\",\"nme\":\""+_name+"\",\"exp\":\""+exptime+"\"}";
Log::info("JWT Payload: " + payload);
std::ostringstream ostr;
Poco::OutputLineEndingConverter lineEndingConv(ostr, "");
Poco::Base64Encoder encoder(lineEndingConv);
encoder << payload;
encoder.close();
return ostr.str();
}
int main(void)
{
int i, sic, eic;
U16BIT I;
reset_encoder();
reset_decoder();
sic = __time / 2;
for (i = 0; i < sizeof(Input) / sizeof(U16BIT); i++)
decoder(encoder(Input[i]));
eic = __time / 2;
printf("\nInstruction cycles for transcoding a sample: %d\n",
(eic - sic) / (sizeof(Input) / sizeof(U16BIT)));
return (0);
}
//获取文件的MD5码
CString CProcessMgr::GetFileMD5(CString sFilePath)
{
std::string strFilePath = (LPCTSTR)sFilePath;
CryptoPP::Weak::MD5 md5;
CryptoPP::HashFilter filter(md5);
std::auto_ptr<CryptoPP::ChannelSwitch> channelSwitch(new CryptoPP::ChannelSwitch);
channelSwitch->AddDefaultRoute(filter);
std::wstring wstr = s2ws_1(strFilePath);
CryptoPP::FileSource(wstr.c_str(), true, channelSwitch.release());
std::stringstream result;
CryptoPP::HexEncoder encoder(new CryptoPP::FileSink(result), false);
filter.TransferTo(encoder);
std::string strResult = result.str();
CString sResult = strResult.c_str();
return sResult;
}
QList<MovieFormat> MovieCapture::availableFormats()
{
Q_D(MovieCapture);
static QList<MovieFormat> availableFormats;
if ( availableFormats.isEmpty() && checkToolsAvailability() ) {
QProcess encoder(this);
foreach ( MovieFormat format, m_supportedFormats ) {
QString type = format.type();
QStringList args;
args << "-h" << "muxer=" + type;
encoder.start( d->encoderExec, args );
encoder.waitForFinished();
QString output = encoder.readAll();
bool isFormatAvailable = !output.contains( "Unknown format" );
if( isFormatAvailable ) {
availableFormats << format;
}
}
TEST(invalidEncoder, CodecLibrary)
{
HBitmapEncoder encoder(new WindowsBitmapEncoder);
bool isInvalidEncoder = false;
try
{
std::ostringstream os(std::ios::binary);
encoder->encodeToStream(os);
}
catch (const InvalidEncoder&)
{
isInvalidEncoder = true;
}
CHECK(isInvalidEncoder);
}
void KDocumentTextBuffer::localTextInserted( KTextEditor::Document *document,
const KTextEditor::Range &range )
{
if ( m_aboutToClose ) return;
emit localChangedText(range, user(), false);
Q_UNUSED(document)
textOpPerformed();
if( m_user.isNull() ) {
kDebug() << "Could not insert text: No local user set.";
return;
}
unsigned int offset = cursorToOffset_kte(range.start());
kDebug() << "local text inserted" << kDocument() << "( range" << range << ")" << m_user << "offset:" << offset;
QInfinity::TextChunk chunk(encoding());
QString text = kDocument()->text(range);
#ifdef ENABLE_TAB_HACK
if ( text.contains('\t') ) {
text = text.replace('\t', " ");
kDocument()->blockSignals(true);
kDocument()->replaceText(range, text);
kDocument()->blockSignals(false);
}
#endif
Q_ASSERT(encoder());
if ( text.isEmpty() ) {
kDebug() << "Skipping empty insert.";
return;
}
QByteArray encodedText = codec()->fromUnicode( text );
if ( encodedText.size() == 0 ) {
kDebug() << "Got empty encoded text from non empty string "
"Skipping insertion";
}
else {
chunk.insertText( 0, encodedText, countUnicodeCharacters(text), m_user->id() );
blockRemoteInsert = true;
kDebug() << "inserting chunk of size" << chunk.length() << "into local buffer" << kDocument()->url();
insertChunk( offset, chunk, m_user );
kDebug() << "done inserting chunk";
checkConsistency();
}
}
int encoder_test(u32 k)
{
CEncoder encoder(k);
const u32 DATA_LEN = 1000;
u8 rndData[DATA_LEN];
for (int i = 0; i < 1000000; ++i)
{
for (int i = 0; i < DATA_LEN; ++i)
{
rndData[i] = rand();
}
CData data(rndData,DATA_LEN);
encoder.AddData(&data);
}
return 0;
}
void InitialState::encodeFile(string fileName){
if(ofFile::doesFileExist(fileName)){
ofFile file;
file.open(fileName, ofFile::ReadOnly);
ofBuffer buf = file.readToBuffer();
ostringstream ostr;
Poco::Base64Encoder encoder(ostr);
encoder << buf.getText();
encoder.close();
string outputStr = ostr.str();
string output = ofFilePath::getBaseName(fileName) + (ofToLower(ofFilePath::getFileExt(fileName)) == "vert" ? ".v" : ".f");
ofstream str;
str.open(output, ios_base::out | ios_base::trunc);
str << outputStr;
str.close();
}
}
void
WorldInputCmdProcessor::sendAttackCommand(const iXY &world_pos)
{
TerminalUnitCmdRequest comm_mesg;
UnitBase *target_ptr;
size_t id_list_index;
size_t id_list_size;
UnitBase *unit_ptr;
if ( working_list.isSelected() == true ) {
target_list.selectTarget( world_pos );
target_ptr = UnitInterface::getUnit( target_list.unit_list[0] );
id_list_size = working_list.unit_list.size();
if ( id_list_size == 0 )
return;
NetMessageEncoder encoder(true);
for( id_list_index = 0; id_list_index < id_list_size; id_list_index++ ) {
unit_ptr = UnitInterface::getUnit( working_list.unit_list[ id_list_index ] );
if ( unit_ptr != 0 ) {
if ( unit_ptr->unit_state.select == true ) {
comm_mesg.comm_request.setHeader(unit_ptr->id,
_umesg_flag_unique);
comm_mesg.comm_request.setTargetUnit(target_ptr->id);
encoder.encodeMessage(&comm_mesg,
sizeof(TerminalUnitCmdRequest));
}
}
}
encoder.sendEncodedMessage();
//sfx
sound->playSound("target");
}
}
/** @throw std::exception */
CrawlId LevCrawlDb::putData(const CrawlData& crawlData) {
CrawlId crawlId = ++mNextCrawlId;
string crawlId_str = std::to_string(crawlId);
ParcelAllocator allocator;
allocator.reserve(crawlData);
ParcelEncoder encoder(allocator);
encoder.encode(crawlData);
string serial(encoder.getData(), encoder.getSize());
auto ret = mDatabase->Put(leveldb::WriteOptions(), crawlId_str, serial);
if (!ret.ok()) {
throw std::runtime_error("Error encountered while inserting: " +
crawlId_str);
}
return crawlId;
}
Component
Component::fromNumberWithMarker(uint8_t marker, uint64_t number)
{
EncodingEstimator estimator;
size_t valueLength = estimator.prependNonNegativeInteger(number);
valueLength += estimator.prependByteArray(&marker, 1);
size_t totalLength = valueLength;
totalLength += estimator.prependVarNumber(valueLength);
totalLength += estimator.prependVarNumber(tlv::GenericNameComponent);
EncodingBuffer encoder(totalLength, 0);
encoder.prependNonNegativeInteger(number);
encoder.prependByteArray(&marker, 1);
encoder.prependVarNumber(valueLength);
encoder.prependVarNumber(tlv::GenericNameComponent);
return encoder.block();
}
void
WorldInputCmdProcessor::sendMoveCommand(const iXY& world_pos)
{
iXY map_pos;
PlacementMatrix matrix;
unsigned long id_list_index;
size_t id_list_size;
UnitBase *unit_ptr;
TerminalUnitCmdRequest comm_mesg;
id_list_size = working_list.unit_list.size();
if ( id_list_size == 0 )
return;
MapInterface::pointXYtoMapXY( world_pos, &map_pos );
matrix.reset( map_pos );
NetMessageEncoder encoder(true);
for( id_list_index = 0; id_list_index < id_list_size; id_list_index++ ) {
unit_ptr = UnitInterface::getUnit(working_list.unit_list[ id_list_index ]);
if ( unit_ptr != 0 ) {
if ( unit_ptr->unit_state.select == true ) {
matrix.getNextEmptyLoc( &map_pos );
comm_mesg.comm_request.setHeader(unit_ptr->id,
_umesg_flag_unique );
comm_mesg.comm_request.setMoveToLoc( map_pos );
encoder.encodeMessage(&comm_mesg,
sizeof(TerminalUnitCmdRequest));
}
}
}
encoder.sendEncodedMessage();
//sfx
sound->playUnitSound(working_list.getHeadUnitType() );
sound->playSound("move");
}
std::vector<std::shared_ptr<const X509_Certificate>> Certificate_Store_MacOS::find_all_certs(
const X509_DN& subject_dn,
const std::vector<uint8_t>& key_id) const
{
std::vector<uint8_t> dn_data;
DER_Encoder encoder(dn_data);
normalize(subject_dn).encode_into(encoder);
scoped_CFType<CFDataRef> dn_cfdata(createCFDataView(dn_data));
check_notnull(dn_cfdata, "create DN search object");
Certificate_Store_MacOS_Impl::Query query_params(
{
{kSecAttrSubject, dn_cfdata.get()}
});
scoped_CFType<CFDataRef> keyid_cfdata(createCFDataView(key_id));
check_notnull(keyid_cfdata, "create key ID search object");
if(!key_id.empty())
{
query_params.push_back({kSecAttrSubjectKeyID, keyid_cfdata.get()});
}
scoped_CFType<CFArrayRef> result(m_impl->search(std::move(query_params)));
if(!result)
{
return {}; // no certificates found
}
const auto count = CFArrayGetCount(result.get());
BOTAN_ASSERT(count > 0, "certificate result list contains data");
std::vector<std::shared_ptr<const X509_Certificate>> output;
output.reserve(count);
for(unsigned int i = 0; i < count; ++i)
{
auto cfCert = to_SecCertificateRef(CFArrayGetValueAtIndex(result.get(), i));
output.emplace_back(readCertificate(cfCert));
}
return output;
}
void *encoder_thread(void *arg) {
encoder_space::Encoder encoder(ENCODER_COM_PORT, ENCODER_BAUD_RATE);
encoder_space::EncoderData encoderData;
while (ros::ok()) {
/* Fetch data from Shaft Encoder and load it in local vars */
encoderData = encoder.fetchEncoderData();
pthread_mutex_lock(&pose_mutex);
/* Update the pose_data using the data in local vars */
pthread_mutex_unlock(&pose_mutex);
usleep(10);
}
return NULL;
}
void CSoundCardRepeaterTXThread::transmitNetworkHeader(CHeaderData& header)
{
wxLogMessage(wxT("Transmitting to - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X"), header.getMyCall1().c_str(), header.getMyCall2().c_str(), header.getYourCall().c_str(), header.getRptCall1().c_str(), header.getRptCall2().c_str(), header.getFlag1(), header.getFlag2(), header.getFlag3());
// Send the bit sync, 700 bits in 4 bit chunks
for (unsigned int i = 0U; i < 175U; i++)
m_networkBuffer.addData(BIT_SYNC_BITS, BIT_SYNC_LENGTH_BITS);
// Send the frame sync
m_networkBuffer.addData(FRAME_SYNC_BITS, FRAME_SYNC_LENGTH_BITS);
// Send the header
bool headerBits[FEC_SECTION_LENGTH_BITS];
CRadioHeaderEncoder encoder(header);
encoder.getRadioData(headerBits, FEC_SECTION_LENGTH_BITS);
m_networkBuffer.addData(headerBits, FEC_SECTION_LENGTH_BITS);
m_networkStarted = false;
m_networkRun = 0U;
}
static void
_json_BEAN_only(GString *gstr, GSList *l, gconstpointer selector,
gboolean extend, void (*encoder)(GString*,gpointer))
{
gboolean first = TRUE;
for (; l ;l=l->next) {
if (selector && DESCR(l->data) != selector)
continue;
if (!first)
g_string_append_c(gstr, ',');
first = FALSE;
g_string_append_c (gstr, '{');
if (extend)
g_string_append_printf (gstr, "\"type\":\"%s\",",
DESCR(l->data)->name);
encoder(gstr, l->data);
g_string_append_c (gstr, '}');
}
}
