byteptr encodeArray(Codec const& codec, byteptr p, byteptr end, Uint const* xs, unsigned n) {
if (codec.k_max_bytes * n + p > end)
for (unsigned i = 0; i < n; ++i) p = codec.encode(p, end, xs[i]);
else
for (unsigned i = 0; i < n; ++i) p = codec.encode(p, xs[i]);
return p;
}
//---------------------------------------------------------------------
DataStreamPtr Image::encode(const String& formatextension)
{
if( !mBuffer )
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "No image data loaded",
"Image::encode");
}
Codec * pCodec = Codec::getCodec(formatextension);
if( !pCodec )
OGRE_EXCEPT(
Exception::ERR_INVALIDPARAMS,
"Unable to encode image data as '" + formatextension + "' - invalid extension.",
"Image::encode" );
ImageCodec::ImageData* imgData = OGRE_NEW ImageCodec::ImageData();
imgData->format = mFormat;
imgData->height = mHeight;
imgData->width = mWidth;
imgData->depth = mDepth;
// Wrap in CodecDataPtr, this will delete
Codec::CodecDataPtr codeDataPtr(imgData);
// Wrap memory, be sure not to delete when stream destroyed
MemoryDataStreamPtr wrapper(OGRE_NEW MemoryDataStream(mBuffer, mBufSize, false));
return pCodec->encode(wrapper, codeDataPtr);
}
void Codec::taskFunc(void *objArg, void *arg)
{
Codec *codec = (Codec *)objArg;
TaskFuncArg *taskFuncArg = (TaskFuncArg *)arg;
void *resMsg = NULL;
int resLen = 0;
resMsg = codec->messageCallback_(codec->objArg_, taskFuncArg->msg, taskFuncArg->length, &resLen);
delete (char *)taskFuncArg->msg;
assert(resLen != 0);
int type;
memcpy(&type, resMsg, 4);
LOG_TRACE << "----------------Type " << type;
resMsg = codec->encode(resMsg, &resLen);
assert(resLen != 0);
{
MutexLockGuard lockGuard(codec->sendLock_);
LOG_TRACE << "In thread func " << resLen;
int type;
memcpy(&type, (char *)resMsg + 4, 4);
LOG_TRACE << "----------------Type " << *(int *)((char *)resMsg + 4);
taskFuncArg->con->sendMsg(resMsg, resLen);
}
}
void test()
{
for(int i=0;i<Codec::factoryCount();i++)
{
Codec::Factory * pFactory = Codec::factory( i );
// generate random data
byte data[ CODEC_DATA_SIZE ];
for(int i=0;i<sizeof(data);i++)
data[i] = (i & 0xff); //rand() & 0xff;
// create the codec
Codec * pCodec = pFactory->create();
Test( pCodec != NULL );
byte encoded[ CODEC_DATA_SIZE * 3 ];
int nBytes = pCodec->encode( data, sizeof(data), encoded, sizeof(encoded), Codec::CL_NORMAL );
Test( nBytes >= 0 );
delete pCodec;
printf("Codec %s, %d bytes encoded into %d bytes - %d%% Compression\n",
pFactory->name(), CODEC_DATA_SIZE, nBytes, ((nBytes * 100) / CODEC_DATA_SIZE) );
pCodec = pFactory->create();
Test( pCodec != NULL );
int nDecodedBytes = pCodec->decode( encoded, nBytes, data, sizeof(data) );
Test( nDecodedBytes == CODEC_DATA_SIZE );
for(int j=0;j<sizeof(data);j++)
Test( data[j] == (j & 0xff) );
delete pCodec;
}
}
Bytes
encode(const Unicode& ustring,
const Bytes& encoding)
{
Codec* codec = lookup(encoding);
Bytes bstring = codec->encode(bstring);
delete codec;
return bstring;
}
int main(void) {
Codec codec;
vector<string> strs = {"", "vn"};
string encoded_string = codec.encode(strs);
vector<string> strs2 = codec.decode(encoded_string);
assert(strs.size() == strs2.size());
for (size_t i = 0; i < strs.size(); i++) assert(strs[i] == strs2[i]);
cout << "\nPassed All\n";
return 0;
}
// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.decode(codec.encode(strs));
//
int main() {
Codec codec;
vector<string> strs;
strs.push_back("hello");
strs.push_back("");
strs.push_back("gaobo");
string coded_str = codec.encode(strs);
cout << "coded str: " << coded_str << endl;
vector<string> decoded_strs = codec.decode(coded_str);
for (int i = 0; i < decoded_strs.size(); i++) {
cout << decoded_strs[i] << endl;
}
return 0;
}
