int PeerCon::handleGetPeerMessage(const PeerPacket& reqpk){
int ret = 0;
TimeRecorder t("PeerCon::handleGetMessage");
//construct resp
PeerPacket resppk;
resppk.set_cmd(GET_PEER_MESSAGE_RESP);
GetPeerMessageResponse* gresp = resppk.mutable_get_peer_msg_resp();
const GetPeerMessageRequest& gmsgreq = reqpk.get_peer_msg_req();
//get message from db
const string& cid = gmsgreq.cid();
int64 start_msgid = gmsgreq.start_msgid();
int64 count = gmsgreq.count();
int64 lastmsgid = 0;
vector<Message> msgs;
std::stringstream os;
gresp->set_last_msgid(0);
if(!reqpk.has_get_peer_msg_req()){
FormatErrorLog(getPackSN(), "get_peer_message");
ret = INPUT_FORMAT_ERROR;
goto exit;
}
ret = getPeerMsg(cid, start_msgid, count, msgs, lastmsgid);
if(ret < 0){
PeerErrorLog(getPackSN(), "get_peer_message", cid, DB_ERROR);
ret = ret;
goto exit;
}
//construct resp
gresp->set_last_msgid(lastmsgid);
for(size_t i = 0; i < msgs.size(); ++i){
Message* pm = gresp->add_msgs();
*pm = msgs[i];
os << "<action:get_peer_message> <to:"
<< cid << "> <from:"
<< msgs[i].from() << "> <msgid:"
<< msgs[i].id() << "> <time:"
<< msgs[i].time() << "> <msg_sn:"
<< msgs[i].sn() << ">\n";
}
PLogTrace("PeerServer")
<< "<action:handle_get_peer_message> <cid:"
<< cid << "> <start_msgid:"
<< start_msgid << "> <count:"
<< count << "> <status:" << ret
<< "> <last_msgid:" << gresp->last_msgid() << "> <size:"
<< gresp->msgs_size() << "> <errstr:"
<< getErrStr(ret) << ">";
if(gresp->msgs_size())
PLogTrace("PeerServer") << os.str();
ret = 0;
exit:
std::string payload;
resppk.SerializeToString(&payload);
ret = sendServiceResponse(ret, payload);
return ret;
}
/*****************************
******* Image Reader ******
****************************/
ImageReader::ImageReader(const char * _base_name, const int _start, const int _end,
const float _fps, bool _use_DevIL, bool _info, const char * _pixel,
IScriptEnvironment* env)
: base_name(), start(_start), use_DevIL(_use_DevIL), info(_info), framecopies(0)
{
// Generate full name
if (IsAbsolutePath(_base_name))
{
base_name[0] = '\0';
strncat(base_name, _base_name, sizeof base_name);
}
else
{
char cwd[MAX_PATH + 1];
GetWorkingDir(cwd, sizeof cwd);
_snprintf(base_name, sizeof base_name, "%s%s", cwd, _base_name);
}
_snprintf(filename, sizeof filename, base_name, start);
memset(&vi, 0, sizeof(vi));
// Invariants
vi.num_frames = -start + _end + 1; // make sure each frame can be requested
vi.audio_samples_per_second = 0;
double num = _fps; // calculate fps as num/denom for vi
int denom = 1;
while (num < 16777216 && denom < 16777216) { num*=2; denom*=2; } // float mantissa is only 24 bits
vi.fps_numerator = int(num+0.5);
vi.fps_denominator = denom;
// undecorated filename means they want a single, static image
if( strcmp(filename, base_name) == 0 ) framecopies = vi.num_frames;
if (use_DevIL == false)
{
fileHeader.bfType = 0;
// Try to parse as bmp/ebmp
ifstream file(filename, ios::binary);
file.read( reinterpret_cast<char *> (&fileHeader), sizeof(fileHeader) );
file.read( reinterpret_cast<char *> (&infoHeader), sizeof(infoHeader) );
file.close();
if ( fileHeader.bfType == ('M' << 8) + 'B')
{
if (infoHeader.biCompression != 0)
// use_DevIL = true; // Not a type we know, give it to DevIL
env->ThrowError("ImageReader: EBMP reader cannot handle compressed images.");
vi.width = infoHeader.biWidth;
vi.height = infoHeader.biHeight;
if (infoHeader.biPlanes == 1) {
if (infoHeader.biBitCount == 32)
vi.pixel_type = VideoInfo::CS_BGR32;
else if (infoHeader.biBitCount == 24)
vi.pixel_type = VideoInfo::CS_BGR24;
else if (infoHeader.biBitCount == 16)
vi.pixel_type = VideoInfo::CS_YUY2;
else
// use_DevIL = true; // Not a type we know, give it to DevIL
// DevIL 1.6.6 has a major coronary with palletted BMP files so don't fail thru to it
env->ThrowError("ImageReader: %d bit BMP is unsupported.", infoHeader.biBitCount);
}
else if (infoHeader.biPlanes == 3) {
if (infoHeader.biBitCount == 12)
vi.pixel_type = VideoInfo::CS_YV12;
else
env->ThrowError("ImageReader: %d bit, 3 plane EBMP is unsupported.", infoHeader.biBitCount);
}
else
env->ThrowError("ImageReader: %d plane BMP is unsupported.", infoHeader.biPlanes);
if (infoHeader.biWidth <= 0)
// use_DevIL = true; // Not a type we know, give it to DevIL
env->ThrowError("ImageReader: Unsupported width %d", infoHeader.biWidth);
if (infoHeader.biHeight <= 0)
// use_DevIL = true; // Not a type we know, give it to DevIL
env->ThrowError("ImageReader: Unsupported height %d", infoHeader.biHeight);
}
else {
use_DevIL = true; // Not a BMP, give it to DevIL
}
}
if (use_DevIL == true) { // attempt to open via DevIL
ilInit();
ILuint myImage=0;
ilGenImages(1, &myImage);
ilBindImage(myImage);
ilLoadImage(filename);
vi.width = ilGetInteger(IL_IMAGE_WIDTH);
vi.height = ilGetInteger(IL_IMAGE_HEIGHT);
if (!lstrcmpi(_pixel, "rgb")) {
vi.pixel_type = VideoInfo::CS_BGR32;
}
else if (!lstrcmpi(_pixel, "rgb32")) {
vi.pixel_type = VideoInfo::CS_BGR32;
}
else if (!lstrcmpi(_pixel, "rgb24")) {
vi.pixel_type = VideoInfo::CS_BGR24;
}
else {
env->ThrowError("ImageReader: supports the following pixel types: RGB24 or RGB32");
}
// Get errors if any
// (note: inability to parse an (e)bmp will show up here as a DevIL error)
ILenum err = ilGetError();
ilDeleteImages(1, &myImage);
if (err != IL_NO_ERROR)
{
ostringstream ss;
ss << "ImageReader: error '" << getErrStr(err) << "' in DevIL library\n reading file " << filename;
env->ThrowError(ss.str().c_str());
}
// work around DevIL upside-down bug with compressed images
should_flip = false;
const char * ext = strrchr(_base_name, '.') + 1;
if ( !lstrcmpi(ext, "jpeg") || !lstrcmpi(ext, "jpg") || !lstrcmpi(ext, "jpe") || !lstrcmpi(ext, "dds") ||
!lstrcmpi(ext, "pal") || !lstrcmpi(ext, "pal") || !lstrcmpi(ext, "pcx") || !lstrcmpi(ext, "png") ||
!lstrcmpi(ext, "pbm") || !lstrcmpi(ext, "pgm") || !lstrcmpi(ext, "ppm") || !lstrcmpi(ext, "tga") )
{
should_flip = true;
}
}
}
PVideoFrame ImageReader::GetFrame(int n, IScriptEnvironment* env)
{
ILenum err = IL_NO_ERROR;
PVideoFrame frame = env->NewVideoFrame(vi);
BYTE * dstPtr = frame->GetWritePtr();
BYTE * const WritePtr = dstPtr;
const int pitch = frame->GetPitch();
const int row_size = frame->GetRowSize();
const int height = frame->GetHeight();
const int width = vi.width;
_snprintf(filename, sizeof filename, base_name, n+start);
if (use_DevIL) /* read using DevIL */
{
// Setup
ILuint myImage=0;
ilGenImages(1, &myImage);
ilBindImage(myImage);
if (ilLoadImage(filename) == IL_FALSE) {
// Get errors if any
err = ilGetError();
// Cleanup
ilDeleteImages(1, &myImage);
memset(WritePtr, 0, pitch * height); // Black frame
if ((info) || (err != IL_COULD_NOT_OPEN_FILE)) {
ostringstream ss;
ss << "ImageReader: error '" << getErrStr(err) << "' in DevIL library\n opening file \"" << filename << "\"";
ApplyMessage(&frame, vi, ss.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
}
return frame;
}
// Check some parameters
if ( ilGetInteger(IL_IMAGE_HEIGHT) != height)
{
// Cleanup
ilDeleteImages(1, &myImage);
memset(WritePtr, 0, pitch * height);
ApplyMessage(&frame, vi, "ImageReader: images must have identical heights", vi.width/4, TEXT_COLOR,0,0 , env);
return frame;
}
if ( ilGetInteger(IL_IMAGE_WIDTH) != width)
{
// Cleanup
ilDeleteImages(1, &myImage);
memset(WritePtr, 0, pitch * height);
ApplyMessage(&frame, vi, "ImageReader: images must have identical widths", vi.width/4, TEXT_COLOR,0,0 , env);
return frame;
}
const ILenum il_format = vi.IsRGB32() ? IL_BGRA : IL_BGR;
const ILenum linesize = width * (vi.IsRGB32() ? 4 : 3);
// Copy raster to AVS frame
////if (ilGetInteger(IL_ORIGIN_MODE) == IL_ORIGIN_UPPER_LEFT, IL_ORIGIN_LOWER_LEFT ???
if (should_flip)
{
// Copy upside down
for (int y=height-1; y>=0; --y)
{
if (ilCopyPixels(0, y, 0, width, 1, 1, il_format, IL_UNSIGNED_BYTE, dstPtr) > linesize)
break; // Try not to spew all over memory
dstPtr += pitch;
}
}
else {
// Copy right side up
for (int y=0; y<height; ++y)
{
if (ilCopyPixels(0, y, 0, width, 1, 1, il_format, IL_UNSIGNED_BYTE, dstPtr) > linesize)
break; // Try not to spew all over memory
dstPtr += pitch;
}
}
// Get errors if any
err = ilGetError();
// Cleanup
ilDeleteImages(1, &myImage);
if (err != IL_NO_ERROR)
{
memset(WritePtr, 0, pitch * height);
ostringstream ss;
ss << "ImageReader: error '" << getErrStr(err) << "' in DevIL library\n reading file \"" << filename << "\"";
ApplyMessage(&frame, vi, ss.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
return frame;
}
}
else { /* treat as ebmp */
// Open file, ensure it has the expected properties
ifstream file(filename, ios::binary);
if (!checkProperties(file, frame, env)) {
file.close();
return frame;
}
// Seek past padding
file.seekg (fileHeader.bfOffBits, ios::beg);
// Read in raster
if (0) // (vi.IsY8())
{
// read upside down
BYTE * endPtr = dstPtr + pitch * (height-1);
fileRead(file, endPtr, -pitch, row_size, height);
}
else
{
fileRead(file, dstPtr, pitch, row_size, height);
if (vi.IsPlanar())
{
dstPtr = frame->GetWritePtr(PLANAR_U);
const int pitchUV = frame->GetPitch(PLANAR_U);
const int row_sizeUV = frame->GetRowSize(PLANAR_U);
const int heightUV = frame->GetHeight(PLANAR_U);
fileRead(file, dstPtr, pitchUV, row_sizeUV, heightUV);
dstPtr = frame->GetWritePtr(PLANAR_V);
fileRead(file, dstPtr, pitchUV, row_sizeUV, heightUV);
}
}
file.close();
}
if (info) {
// overlay on video output: progress indicator
ostringstream text;
text << "Frame " << n << ".\nRead from \"" << filename << "\"";
ApplyMessage(&frame, vi, text.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
}
return frame;
}
PVideoFrame ImageWriter::GetFrame(int n, IScriptEnvironment* env)
{
PVideoFrame frame = child->GetFrame(n, env);
// check bounds
if ((n<start)||(n>end))
{
if (info) {
ostringstream ss;
ss << "ImageWriter: frame " << n << " not in range";
env->MakeWritable(&frame);
ApplyMessage(&frame, vi, ss.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
}
return frame;
}
// construct filename
ostringstream fn_oss;
fn_oss << base_name << setfill('0') << setw(6) << n << '.' << ext;
string filename = fn_oss.str();
if (!lstrcmpi(ext, "ebmp")) /* Use internal 'ebmp' writer */
{
// initialize file object
ofstream file(filename.c_str(), ios::out | ios::trunc | ios::binary);
if (!file)
{
ostringstream ss;
ss << "ImageWriter: could not create file '" << filename << "'";
env->MakeWritable(&frame);
ApplyMessage(&frame, vi, ss.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
return frame;
}
// write headers
file.write(reinterpret_cast<const char *>( &fileHeader ), sizeof(BITMAPFILEHEADER));
file.write(reinterpret_cast<const char *>( &infoHeader ), sizeof(BITMAPINFOHEADER));
// write raster
const BYTE * srcPtr = frame->GetReadPtr();
int pitch = frame->GetPitch();
int row_size = frame->GetRowSize();
int height = frame->GetHeight();
if (0) // (vi.IsY8())
{
// write upside down
const BYTE * endPtr = srcPtr + pitch * (height-1);
fileWrite(file, endPtr, -pitch, row_size, height);
}
else
{
fileWrite(file, srcPtr, pitch, row_size, height);
if (vi.IsPlanar())
{
srcPtr = frame->GetReadPtr(PLANAR_U);
pitch = frame->GetPitch(PLANAR_U);
row_size = frame->GetRowSize(PLANAR_U);
height = frame->GetHeight(PLANAR_U);
fileWrite(file, srcPtr, pitch, row_size, height);
srcPtr = frame->GetReadPtr(PLANAR_V);
fileWrite(file, srcPtr, pitch, row_size, height);
}
}
// clean up
file.close();
}
else { /* Use DevIL library */
// Set up DevIL
ILuint myImage=0;
ilGenImages(1, &myImage); // Initialize 1 image structure
ilBindImage(myImage); // Set this as the current image
const ILenum il_format = vi.IsRGB32() ? IL_BGRA : IL_BGR;
// Set image parameters
if (IL_TRUE == ilTexImage(vi.width, vi.height, 1, vi.BitsPerPixel() / 8, il_format, IL_UNSIGNED_BYTE, NULL)) {
// Program actual image raster
const BYTE * srcPtr = frame->GetReadPtr();
int pitch = frame->GetPitch();
for (int y=0; y<vi.height; ++y)
{
ilSetPixels(0, y, 0, vi.width, 1, 1, il_format, IL_UNSIGNED_BYTE, (void*) srcPtr);
srcPtr += pitch;
}
// DevIL writer fails if the file exists, so delete first
DeleteFile(filename.c_str());
// Save to disk (format automatically inferred from extension)
ilSaveImage(const_cast<char * const> (filename.c_str()) );
}
// Get errors if any
ILenum err = ilGetError();
// Clean up
ilDeleteImages(1, &myImage);
if (err != IL_NO_ERROR)
{
ostringstream ss;
ss << "ImageWriter: error '" << getErrStr(err) << "' in DevIL library\n writing file " << filename;
env->MakeWritable(&frame);
ApplyMessage(&frame, vi, ss.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
return frame;
}
}
if (info) {
// overlay on video output: progress indicator
ostringstream text;
text << "Frame " << n << " written to: " << filename;
env->MakeWritable(&frame);
ApplyMessage(&frame, vi, text.str().c_str(), vi.width/4, TEXT_COLOR,0,0 , env);
}
return frame;
}
