static int guess_size (char * filename, ren_vid_format_t colorspace, int * w, int * h)
{
off_t size;
if ((size = filesize (filename)) == -1) {
return -1;
}
if (*w==-1 && *h==-1) {
/* Image size unspecified */
int nr_sizes = sizeof(sizes) / sizeof(sizes[0]);
int i;
for (i=0; i<nr_sizes; i++) {
if (size == imgsize(colorspace, sizes[i].w, sizes[i].h)) {
*w = sizes[i].w;
*h = sizes[i].h;
return 0;
}
}
}
return -1;
}
Point2i SamplingOpticalFlow( const Mat &fir,
const Mat &sec,
const Mat &mask,
vector<Point2f> &pt_src,
vector<Point2f> &flo)
{
bool useDense = USEDENSE;
double scalar = 1;
Mat src; cvtColor( fir, src, CV_RGB2GRAY);
Mat dst; cvtColor( sec, dst, CV_RGB2GRAY);
resize(src, src, Size((int)src.rows*scalar, (int)src.cols*scalar));
resize(dst, dst, Size((int)dst.rows*scalar, (int)dst.cols*scalar));
Point2i imgsize(src.cols, src.rows);
//
if (!useDense)
{
vector<Point2f> pt_dst; vector<uchar> status;vector<float>err;
pt_src.clear();
for ( int h = 0; h <src.rows; h+=2)
for ( int w = 0; w < src.cols; w+=2)
pt_src.push_back( Point2f(w,h));
pt_dst.reserve( pt_src.size());
flo.reserve( pt_src.size());
calcOpticalFlowPyrLK( src, dst, pt_src, pt_dst, status, err);
for ( uint n = 0; n < pt_src.size(); ++n)
{
flo.push_back(Point2f(pt_src[n].x - pt_dst[n].x, pt_src[n].y - pt_dst[n].y));
if(!status[n] || dist(Point( pt_src[n].x, pt_src[n].y), Point(pt_src[n].x + flo[n].x, pt_src[n].y + flo[n].y)) >= INITPSIZEW)
flo[n].x = flo[n].y = 0;
}
}
else
{
Mat floMat;
calcOpticalFlowFarneback( src, dst, floMat, 0.75, 3, 30, 10, 5, 1.5, OPTFLOW_FARNEBACK_GAUSSIAN);
for (int y = 0; y<floMat.rows; y++) {
for (int x = 0; x < floMat.cols; x++) {
if ( !mask.at<int>(y,x))
flo.push_back(Point2f(floMat.at<float>(y,2*x), floMat.at<float>(y,2*x+1)));
else
flo.push_back(Point2f(0.0f,0.0f));
}
}
}
return imgsize;
}
void QAlphaPaintEnginePrivate::drawAlphaImage(const QRectF &rect)
{
Q_Q(QAlphaPaintEngine);
qreal dpiX = qMax(m_pdev->logicalDpiX(), 300);
qreal dpiY = qMax(m_pdev->logicalDpiY(), 300);
qreal xscale = (dpiX / m_pdev->logicalDpiX());
qreal yscale = (dpiY / m_pdev->logicalDpiY());
QTransform picscale;
picscale.scale(xscale, yscale);
const int tileSize = 2048;
QSize size((int(rect.width() * xscale)), int(rect.height() * yscale));
int divw = (size.width() / tileSize);
int divh = (size.height() / tileSize);
divw += 1;
divh += 1;
int incx = int(rect.width() / divw);
int incy = int(rect.height() / divh);
for (int y=0; y<divh; ++y) {
int ypos = int((incy * y) + rect.y());
int height = int((y == (divh - 1)) ? (rect.height() - (incy * y)) : incy) + 1;
for (int x=0; x<divw; ++x) {
int xpos = int((incx * x) + rect.x());
int width = int((x == (divw - 1)) ? (rect.width() - (incx * x)) : incx) + 1;
QSize imgsize((int)(width * xscale), (int)(height * yscale));
QImage img(imgsize, QImage::Format_RGB32);
img.fill(0xffffffff);
QPainter imgpainter(&img);
imgpainter.setTransform(picscale);
QPointF picpos(qreal(-xpos), qreal(-ypos));
imgpainter.drawPicture(picpos, *m_pic);
imgpainter.end();
q->painter()->setTransform(QTransform());
QRect r(xpos, ypos, width, height);
q->painter()->drawImage(r, img);
}
}
}
bool CPhotoEngine::AddImageFile(LPCTSTR szPath, LPCTSTR szFileName)
{
const int maxsize = 800;
PHOTOINFO* pPhoto = new PHOTOINFO;
if( pPhoto == NULL ) return false;
pPhoto->sFilePath = szPath;
pPhoto->sFileName = szFileName;
size_t origsize = wcslen(szPath) + 1;
const size_t newsize = 1024;
size_t convertedChars = 0;
char nstring[newsize];
wcstombs_s(&convertedChars, nstring, newsize, szPath, _TRUNCATE);
cv::Mat image = cv::imread(nstring);
cv::Size imgsize(image.cols, image.rows);
if(imgsize.width > maxsize)
{
imgsize.height *= maxsize / (float)imgsize.width;
imgsize.width = maxsize;
}
if(imgsize.height > maxsize)
{
imgsize.width *= maxsize / (float)imgsize.height;
imgsize.height = maxsize;
}
cv::Mat image2;
cv::resize(image, image2, imgsize, 0, 0, cv::INTER_AREA);
if(imgsize.height > imgsize.width)
{
cv::transpose(image2, image2);
cv::flip(image2, image2, 0);
}
pPhoto->image = image2.clone();
pPhoto->Calculate();
photos.Add(pPhoto);
return true;
}
RID _add_body(Physics2DServer::ShapeType p_shape, const Matrix32& p_xform) {
VisualServer *vs = VisualServer::get_singleton();
Physics2DServer *ps = Physics2DServer::get_singleton();
RID body = ps->body_create();
ps->body_add_shape(body,body_shape_data[p_shape].shape);
ps->body_set_space(body,space);
ps->body_set_continuous_collision_detection_mode(body,Physics2DServer::CCD_MODE_CAST_SHAPE);
ps->body_set_state(body,Physics2DServer::BODY_STATE_TRANSFORM,p_xform);
// print_line("add body with xform: "+p_xform);
RID sprite = vs->canvas_item_create();
vs->canvas_item_set_parent(sprite,canvas);
vs->canvas_item_set_transform(sprite,p_xform);
Size2 imgsize( vs->texture_get_width(body_shape_data[p_shape].image),vs->texture_get_height(body_shape_data[p_shape].image) );
vs->canvas_item_add_texture_rect(sprite,Rect2(-imgsize/2.0,imgsize),body_shape_data[p_shape].image);
ps->body_set_force_integration_callback(body,this,"_body_moved",sprite);
// RID q = ps->query_create(this,"_body_moved",sprite);
// ps->query_body_state(q,body);
return body;
}
void Hud::drawItem(const ItemStack &item, const core::rect<s32>& rect, bool selected) {
if (selected) {
/* draw hihlighting around selected item */
if (use_hotbar_selected_image) {
core::rect<s32> imgrect2 = rect;
imgrect2.UpperLeftCorner.X -= (m_padding*2);
imgrect2.UpperLeftCorner.Y -= (m_padding*2);
imgrect2.LowerRightCorner.X += (m_padding*2);
imgrect2.LowerRightCorner.Y += (m_padding*2);
video::ITexture *texture = tsrc->getTexture(hotbar_selected_image);
core::dimension2di imgsize(texture->getOriginalSize());
driver->draw2DImage(texture, imgrect2,
core::rect<s32>(core::position2d<s32>(0,0), imgsize),
NULL, hbar_colors, true);
} else {
video::SColor c_outside(255,255,0,0);
//video::SColor c_outside(255,0,0,0);
//video::SColor c_inside(255,192,192,192);
s32 x1 = rect.UpperLeftCorner.X;
s32 y1 = rect.UpperLeftCorner.Y;
s32 x2 = rect.LowerRightCorner.X;
s32 y2 = rect.LowerRightCorner.Y;
// Black base borders
driver->draw2DRectangle(c_outside,
core::rect<s32>(
v2s32(x1 - m_padding, y1 - m_padding),
v2s32(x2 + m_padding, y1)
), NULL);
driver->draw2DRectangle(c_outside,
core::rect<s32>(
v2s32(x1 - m_padding, y2),
v2s32(x2 + m_padding, y2 + m_padding)
), NULL);
driver->draw2DRectangle(c_outside,
core::rect<s32>(
v2s32(x1 - m_padding, y1),
v2s32(x1, y2)
), NULL);
driver->draw2DRectangle(c_outside,
core::rect<s32>(
v2s32(x2, y1),
v2s32(x2 + m_padding, y2)
), NULL);
/*// Light inside borders
driver->draw2DRectangle(c_inside,
core::rect<s32>(
v2s32(x1 - padding/2, y1 - padding/2),
v2s32(x2 + padding/2, y1)
), NULL);
driver->draw2DRectangle(c_inside,
core::rect<s32>(
v2s32(x1 - padding/2, y2),
v2s32(x2 + padding/2, y2 + padding/2)
), NULL);
driver->draw2DRectangle(c_inside,
core::rect<s32>(
v2s32(x1 - padding/2, y1),
v2s32(x1, y2)
), NULL);
driver->draw2DRectangle(c_inside,
core::rect<s32>(
v2s32(x2, y1),
v2s32(x2 + padding/2, y2)
), NULL);
*/
}
}
video::SColor bgcolor2(128, 0, 0, 0);
if (!use_hotbar_image)
driver->draw2DRectangle(bgcolor2, rect, NULL);
drawItemStack(driver, g_fontengine->getFont(), item, rect, NULL, gamedef);
}
void Hud::drawLuaElements(v3s16 camera_offset) {
u32 text_height = g_fontengine->getTextHeight();
irr::gui::IGUIFont* font = g_fontengine->getFont();
for (size_t i = 0; i != player->maxHudId(); i++) {
HudElement *e = player->getHud(i);
if (!e)
continue;
v2s32 pos(floor(e->pos.X * (float) m_screensize.X + 0.5),
floor(e->pos.Y * (float) m_screensize.Y + 0.5));
switch (e->type) {
case HUD_ELEM_IMAGE: {
video::ITexture *texture = tsrc->getTexture(e->text);
if (!texture)
continue;
const video::SColor color(255, 255, 255, 255);
const video::SColor colors[] = {color, color, color, color};
core::dimension2di imgsize(texture->getOriginalSize());
v2s32 dstsize(imgsize.Width * e->scale.X,
imgsize.Height * e->scale.Y);
if (e->scale.X < 0)
dstsize.X = m_screensize.X * (e->scale.X * -0.01);
if (e->scale.Y < 0)
dstsize.Y = m_screensize.Y * (e->scale.Y * -0.01);
v2s32 offset((e->align.X - 1.0) * dstsize.X / 2,
(e->align.Y - 1.0) * dstsize.Y / 2);
core::rect<s32> rect(0, 0, dstsize.X, dstsize.Y);
rect += pos + offset + v2s32(e->offset.X, e->offset.Y);
driver->draw2DImage(texture, rect,
core::rect<s32>(core::position2d<s32>(0,0), imgsize),
NULL, colors, true);
break; }
case HUD_ELEM_TEXT: {
video::SColor color(255, (e->number >> 16) & 0xFF,
(e->number >> 8) & 0xFF,
(e->number >> 0) & 0xFF);
core::rect<s32> size(0, 0, e->scale.X, text_height * e->scale.Y);
std::wstring text = narrow_to_wide(e->text);
core::dimension2d<u32> textsize = font->getDimension(text.c_str());
v2s32 offset((e->align.X - 1.0) * (textsize.Width / 2),
(e->align.Y - 1.0) * (textsize.Height / 2));
v2s32 offs(e->offset.X, e->offset.Y);
font->draw(text.c_str(), size + pos + offset + offs, color);
break; }
case HUD_ELEM_STATBAR: {
v2s32 offs(e->offset.X, e->offset.Y);
drawStatbar(pos, HUD_CORNER_UPPER, e->dir, e->text, e->number, offs, e->size);
break; }
case HUD_ELEM_INVENTORY: {
InventoryList *inv = inventory->getList(e->text);
drawItems(pos, e->number, 0, inv, e->item, e->dir);
break; }
case HUD_ELEM_WAYPOINT: {
v3f p_pos = player->getPosition() / BS;
v3f w_pos = e->world_pos * BS;
float distance = floor(10 * p_pos.getDistanceFrom(e->world_pos)) / 10;
scene::ICameraSceneNode* camera = smgr->getActiveCamera();
w_pos -= intToFloat(camera_offset, BS);
core::matrix4 trans = camera->getProjectionMatrix();
trans *= camera->getViewMatrix();
f32 transformed_pos[4] = { w_pos.X, w_pos.Y, w_pos.Z, 1.0f };
trans.multiplyWith1x4Matrix(transformed_pos);
if (transformed_pos[3] < 0)
break;
f32 zDiv = transformed_pos[3] == 0.0f ? 1.0f :
core::reciprocal(transformed_pos[3]);
pos.X = m_screensize.X * (0.5 * transformed_pos[0] * zDiv + 0.5);
pos.Y = m_screensize.Y * (0.5 - transformed_pos[1] * zDiv * 0.5);
video::SColor color(255, (e->number >> 16) & 0xFF,
(e->number >> 8) & 0xFF,
(e->number >> 0) & 0xFF);
core::rect<s32> size(0, 0, 200, 2 * text_height);
std::wstring text = narrow_to_wide(e->name);
font->draw(text.c_str(), size + pos, color);
std::ostringstream os;
os<<distance<<e->text;
text = narrow_to_wide(os.str());
pos.Y += text_height;
font->draw(text.c_str(), size + pos, color);
break; }
default:
infostream << "Hud::drawLuaElements: ignoring drawform " << e->type <<
" of hud element ID " << i << " due to unrecognized type" << std::endl;
}
}
}
//NOTE: selectitem = 0 -> no selected; selectitem 1-based
void Hud::drawItems(v2s32 upperleftpos, s32 itemcount, s32 offset,
InventoryList *mainlist, u16 selectitem, u16 direction)
{
#ifdef HAVE_TOUCHSCREENGUI
if ( (g_touchscreengui) && (offset == 0))
g_touchscreengui->resetHud();
#endif
s32 height = m_hotbar_imagesize + m_padding * 2;
s32 width = (itemcount - offset) * (m_hotbar_imagesize + m_padding * 2);
if (direction == HUD_DIR_TOP_BOTTOM || direction == HUD_DIR_BOTTOM_TOP) {
width = m_hotbar_imagesize + m_padding * 2;
height = (itemcount - offset) * (m_hotbar_imagesize + m_padding * 2);
}
// Position of upper left corner of bar
v2s32 pos = upperleftpos;
if (hotbar_image != player->hotbar_image) {
hotbar_image = player->hotbar_image;
if (hotbar_image != "")
use_hotbar_image = tsrc->isKnownSourceImage(hotbar_image);
else
use_hotbar_image = false;
}
if (hotbar_selected_image != player->hotbar_selected_image) {
hotbar_selected_image = player->hotbar_selected_image;
if (hotbar_selected_image != "")
use_hotbar_selected_image = tsrc->isKnownSourceImage(hotbar_selected_image);
else
use_hotbar_selected_image = false;
}
/* draw customized item background */
if (use_hotbar_image) {
core::rect<s32> imgrect2(-m_padding/2, -m_padding/2,
width+m_padding/2, height+m_padding/2);
core::rect<s32> rect2 = imgrect2 + pos;
video::ITexture *texture = tsrc->getTexture(hotbar_image);
core::dimension2di imgsize(texture->getOriginalSize());
driver->draw2DImage(texture, rect2,
core::rect<s32>(core::position2d<s32>(0,0), imgsize),
NULL, hbar_colors, true);
}
for (s32 i = offset; i < itemcount && (size_t)i < mainlist->getSize(); i++)
{
v2s32 steppos;
s32 fullimglen = m_hotbar_imagesize + m_padding * 2;
core::rect<s32> imgrect(0, 0, m_hotbar_imagesize, m_hotbar_imagesize);
switch (direction) {
case HUD_DIR_RIGHT_LEFT:
steppos = v2s32(-(m_padding + (i - offset) * fullimglen), m_padding);
break;
case HUD_DIR_TOP_BOTTOM:
steppos = v2s32(m_padding, m_padding + (i - offset) * fullimglen);
break;
case HUD_DIR_BOTTOM_TOP:
steppos = v2s32(m_padding, -(m_padding + (i - offset) * fullimglen));
break;
default:
steppos = v2s32(m_padding + (i - offset) * fullimglen, m_padding);
break;
}
drawItem(mainlist->getItem(i), (imgrect + pos + steppos), (i +1) == selectitem );
#ifdef HAVE_TOUCHSCREENGUI
if (g_touchscreengui)
g_touchscreengui->registerHudItem(i, (imgrect + pos + steppos));
#endif
}
}
// /////////////////////////////////////////////////////////////////
//
// /////////////////////////////////////////////////////////////////
boost::optional<TexHandle> TextureManager::LoadRectangle(const std::string &imgnameRef, U32 &wRef, U32 &hRef, const GLenum wrapMode)
{
boost::optional<TexHandle> tHandle; // The texture handle.
// Check input parameters
if(imgnameRef.empty() || wrapMode == GL_REPEAT)
{
GF_LOG_TRACE_ERR("TextureManager::LoadRectangle()", "Invalid parameters");
return (tHandle);
}
// Check if we have already loaded a texture with this texture name.
tHandle = Find(imgnameRef);
if(tHandle.is_initialized())
{
// We loaded this texture already! So we will simply return the textures outside/public ID.
return (tHandle);
}
// Load the texture from the resource cache and initialize its data.
ImageResource imgRes(imgnameRef);
boost::shared_ptr<ImageResHandle> imgResHandle = boost::static_pointer_cast<ImageResHandle>(g_appPtr->GetResourceCache()->GetHandle(&imgRes));
if(!imgResHandle || !imgResHandle->VInitialize())
{
GF_LOG_TRACE_ERR("TextureManager::LoadRectangle()", std::string("Failed to retrieve and/or initialize the resource ") + imgnameRef);
return (tHandle);
}
wRef = imgResHandle->GetImageWidth();
hRef = imgResHandle->GetImageHeight();
// Check if we need to swap out old textures to make room.
if(m_maxSize != 0)
{
U32 imgsize(wRef * hRef);
if(imgsize > m_maxSize)
{
GF_LOG_TRACE_ERR("TextureManager::LoadRectangle()", "Cannot load image! It is bigger than the entire size of the TextureManagers memory budget!");
return (tHandle);
}
while(imgsize + m_currSize > m_maxSize)
{
UnloadLRUTexture();
}
}
// Ensure we have generated enough texture objects.
if(m_usedTextureCount >= m_glIdVec.size())
{
ResizeTextureVector();
}
GF_CLEAR_GL_ERROR();
// Bind to the next available texture object.
glBindTexture(GL_TEXTURE_RECTANGLE, m_glIdVec[m_usedTextureCount]);
GF_CHECK_GL_ERROR_TRC("TextureManager::LoadRectangle(): ");
bool pack = (FindImageTypeFromFile(imgnameRef) == IMAGE_TYPE_TGA);
// Set the textures filtering and wrap mode (basic filtering only for rectangle textures and no mipmaps).
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
GF_CHECK_GL_ERROR_TRC("TextureManager::LoadRectangle(): ");
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GF_CHECK_GL_ERROR_TRC("TextureManager::LoadRectangle(): ");
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, wrapMode);
GF_CHECK_GL_ERROR_TRC("TextureManager::LoadRectangle(): ");
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, wrapMode);
GF_CHECK_GL_ERROR_TRC("TextureManager::LoadRectangle(): ");
if(!LoadCommon2D(GL_TEXTURE_RECTANGLE, 0, imgResHandle->GetImageComponents(), wRef, hRef,\
0, imgResHandle->GetImageFormat(), GL_UNSIGNED_BYTE, const_cast<GLbyte *>(imgResHandle->GetImageBuffer()), pack))
{
return (tHandle);
}
// Set the public texture ID.
tHandle = m_usedTextureCount;
GLint unpackAlignment(1);
if(!pack)
{
glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpackAlignment);
GF_CHECK_GL_ERROR_TRC("TextureManager::LoadRectangle(): ");
}
// Fill out the data struct for the texture we have loaded onto the GPU.
TextureElement newTexElement;
newTexElement.m_id = *tHandle;
newTexElement.m_filename.assign(imgnameRef);
newTexElement.m_timestamp = static_cast<F32>(g_appPtr->GetCurrTime());
newTexElement.m_glTexId = m_glIdVec[*tHandle];
newTexElement.m_minFilter = GL_NEAREST;
newTexElement.m_magFilter = GL_NEAREST;
newTexElement.m_wrapMode = wrapMode;
newTexElement.m_glTarget = GL_TEXTURE_RECTANGLE;
newTexElement.m_width = wRef;
newTexElement.m_height = hRef;
newTexElement.m_imgFormat = imgResHandle->GetImageFormat();
newTexElement.m_imgType = GL_UNSIGNED_BYTE;
newTexElement.m_unpackAlignment = unpackAlignment;
// Append the struct to the map.
m_elementsMap[*tHandle] = newTexElement;
++m_usedTextureCount;
return (tHandle);
}
int main (int argc, char * argv[])
{
UIOMux * uiomux;
uiomux_resource_t uiores;
char * infilename[2] = {NULL, NULL}, * outfilename = NULL;
FILE * infile[2], * outfile = NULL;
size_t nread;
size_t input_size[2], output_size;
SHVIO *vio;
struct ren_vid_surface src[2];
const struct ren_vid_surface *srclist[2] = {
&src[0], &src[1]
};
struct ren_vid_surface dst;
void *inbuf[2], *outbuf;
int ret;
int frameno=0;
int show_version = 0;
int show_help = 0;
int show_list_vio = 0;
char * progname;
char * viodev = NULL;
int error = 0;
int c;
char * optstring = "hvo:O:c:s:C:S:f:u:l";
#ifdef HAVE_GETOPT_LONG
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"output", required_argument, 0, 'o'},
{"overlay", required_argument, 0, 'O'},
{"input-colorspace", required_argument, 0, 'c'},
{"input-size", required_argument, 0, 's'},
{"output-colorspace", required_argument, 0, 'C'},
{"output-size", required_argument, 0, 'S'},
{"filter", required_argument, 0, 'f'},
{"vio", required_argument, 0, 'u'},
{"list", no_argument, 0, 'l'},
{NULL,0,0,0}
};
#endif
#if defined(USE_MERAM_RA) || defined(USE_MERAM_WB)
#define ALIGN16(_x) (((_x) + 15) / 16 * 16)
#define ADJUST_PITCH(_p, _w) \
{ \
(_p) = ((_w) - 1) | 1023; \
(_p) = (_p) | ((_p) >> 1); \
(_p) = (_p) | ((_p) >> 2); \
(_p) += 1; \
}
unsigned long val;
MERAM *meram = meram_open();
MERAM_REG *regs = meram_lock_reg(meram);
size_t sz;
unsigned long mblock;
ICB *icbr, *icbw;
#endif /* defined(USE_MERAM_RA) || defined(USE_MERAM_WB) */
memset(src, 0, sizeof (src[0]) * 2);
src[0].w = -1;
src[0].h = -1;
dst.w = -1;
dst.h = -1;
src[0].format = REN_UNKNOWN;
dst.format = REN_UNKNOWN;
src[0].bpitchy = src[0].bpitchc = src[0].bpitcha = 0;
dst.bpitchy = dst.bpitchc = dst.bpitcha = 0;
memcpy((void *)&src[1], (void *)&src[0], sizeof(src[0]));
src[1].blend_out.x = 0;
src[1].blend_out.y = 0;
src[1].blend_out.w = 220;
src[1].blend_out.h = 440;
progname = argv[0];
if (argc < 2) {
usage (progname);
return (1);
}
while (1) {
#ifdef HAVE_GETOPT_LONG
c = getopt_long (argc, argv, optstring, long_options, NULL);
#else
c = getopt (argc, argv, optstring);
#endif
if (c == -1) break;
if (c == ':') {
usage (progname);
goto exit_err;
}
switch (c) {
case 'h': /* help */
show_help = 1;
break;
case 'v': /* version */
show_version = 1;
break;
case 'o': /* output */
outfilename = optarg;
break;
case 'O': /* ovalery */
infilename[1] = optarg;
break;
case 'c': /* input colorspace */
set_colorspace (optarg, &src[0].format);
break;
case 's': /* input size */
set_size (optarg, &src[0].w, &src[0].h);
break;
case 'C': /* output colorspace */
set_colorspace (optarg, &dst.format);
break;
case 'S': /* output size */
set_size (optarg, &dst.w, &dst.h);
break;
case 'f': /* filter mode */
rotation = strtoul(optarg, NULL, 0);
break;
case 'l':
show_list_vio = 1;
break;
case 'u':
viodev = optarg;
break;
default:
break;
}
}
if (show_version) {
printf ("%s version " VERSION "\n", progname);
}
if (show_help) {
usage (progname);
}
#if 0
if (show_list_vio) {
char **vio;
int i, n;
if (shvio_list_vio(&vio, &n) < 0) {
printf ("Can't get a list of VIO available...\n");
} else {
for(i = 0; i < n; i++)
printf("%s", vio[i]);
printf("Total: %d VIOs available.\n", n);
}
}
#endif
if (show_version || show_help || show_list_vio) {
goto exit_ok;
}
if (optind >= argc) {
usage (progname);
goto exit_err;
}
infilename[0] = argv[optind++];
if (optind < argc) {
outfilename = argv[optind++];
}
printf ("Input file: %s\n", infilename[0]);
if (infilename[1] != NULL)
printf ("Overlay file: %s\n", infilename[1]);
printf ("Output file: %s\n", outfilename);
guess_colorspace (infilename[0], &src[0].format);
if (infilename[1])
guess_colorspace (infilename[1], &src[1].format);
guess_colorspace (outfilename, &dst.format);
/* If the output colorspace isn't given and can't be guessed, then default to
* the input colorspace (ie. no colorspace conversion) */
if (dst.format == REN_UNKNOWN)
dst.format = src[0].format;
guess_size (infilename[0], src[0].format, &src[0].w, &src[0].h);
if (rotation & 0xF) {
/* Swap width/height for rotation */
dst.w = src[0].h;
dst.h = src[0].w;
} else if (dst.w == -1 && dst.h == -1) {
/* If the output size isn't given and can't be guessed, then default to
* the input size (ie. no rescaling) */
dst.w = src[0].w;
dst.h = src[0].h;
}
if (infilename[1])
guess_size (infilename[1], src[1].format, &src[1].w, &src[1].h);
/* Setup memory pitch */
src[0].pitch = src[0].w;
src[1].pitch = src[1].w;
dst.pitch = dst.w;
/* Check that all parameters are set */
if (src[0].format == REN_UNKNOWN) {
fprintf (stderr, "ERROR: Input colorspace unspecified\n");
error = 1;
}
if (src[0].w == -1) {
fprintf (stderr, "ERROR: Input width unspecified\n");
error = 1;
}
if (src[0].h == -1) {
fprintf (stderr, "ERROR: Input height unspecified\n");
error = 1;
}
if (dst.format == REN_UNKNOWN) {
fprintf (stderr, "ERROR: Output colorspace unspecified\n");
error = 1;
}
if (dst.w == -1) {
fprintf (stderr, "ERROR: Output width unspecified\n");
error = 1;
}
if (dst.h == -1) {
fprintf (stderr, "ERROR: Output height unspecified\n");
error = 1;
}
if (error) goto exit_err;
printf ("Input colorspace:\t%s\n", show_colorspace (src[0].format));
printf ("Input size:\t\t%dx%d %s\n", src[0].w, src[0].h, show_size (src[0].w, src[0].h));
printf ("Output colorspace:\t%s\n", show_colorspace (dst.format));
printf ("Output size:\t\t%dx%d %s\n", dst.w, dst.h, show_size (dst.w, dst.h));
printf ("Rotation:\t\t%s\n", show_rotation (rotation));
input_size[0] = imgsize (src[0].format, src[0].w, src[0].h);
if (infilename[1] != NULL)
input_size[1] = imgsize (src[1].format, src[1].w, src[1].h);
output_size = imgsize (dst.format, dst.w, dst.h);
if (/*viodev*/ 1) {
const char *blocks[2] = { "VPU5", NULL };
uiomux = uiomux_open_named(blocks);
uiores = 1 << 0;
} else {
uiomux = uiomux_open ();
uiores = UIOMUX_SH_VEU;
}
/* Set up memory buffers */
src[0].py = inbuf[0] = uiomux_malloc (uiomux, uiores, input_size[0], 32);
if (src[0].format == REN_RGB565) {
src[0].pc = 0;
} else if (src[0].format == REN_YV12) {
src[0].pc2 = src[0].py + (src[0].w * src[0].h); /* Cr(V) */
src[0].pc = src[0].pc2 + (src[0].w * src[0].h) / 4; /* Cb(U) */
} else if (src[0].format == REN_YV16) {
src[0].pc2 = src[0].py + (src[0].w * src[0].h); /* Cr(V) */
src[0].pc = src[0].pc2 + (src[0].w * src[0].h) / 2; /* Cb(U) */
} else {
src[0].pc = src[0].py + (src[0].w * src[0].h); /* CbCr(UV) */
}
if (infilename[1] != NULL) {
src[1].py = inbuf[1] = uiomux_malloc (uiomux, uiores, input_size[1], 32);
if (src[1].format == REN_RGB565) {
src[1].pc = 0;
} else if (src[1].format == REN_YV12) {
src[1].pc2 = src[1].py + (src[1].w * src[1].h); /* Cr(V) */
src[1].pc = src[1].pc2 + (src[1].w * src[1].h) / 4; /* Cb(U) */
} else if (src[1].format == REN_YV16) {
src[1].pc2 = src[1].py + (src[1].w * src[1].h); /* Cr(V) */
src[1].pc = src[1].pc2 + (src[1].w * src[1].h) / 2; /* Cb(U) */
} else {
src[1].pc = src[1].py + (src[1].w * src[1].h); /* CbCr(UV) */
}
}
dst.py = outbuf = uiomux_malloc (uiomux, uiores, output_size, 32);
if (dst.format == REN_RGB565) {
dst.pc = 0;
} else if (dst.format == REN_YV12) {
dst.pc2 = dst.py + (dst.w * dst.h); /* Cr(V) */
dst.pc = dst.pc2 + (dst.w * dst.h) / 4; /* Cb(U) */
} else if (dst.format == REN_YV16) {
dst.pc2 = dst.py + (dst.w * dst.h); /* Cr(V) */
dst.pc = dst.pc2 + (dst.w * dst.h) / 2; /* Cb(U) */
} else {
dst.pc = dst.py + (dst.w * dst.h); /* CbCr(UV) */
}
#if defined(USE_MERAM_RA) || defined(USE_MERAM_WB)
#error aaaa
meram_read_reg(meram, regs, MEVCR1, &val);
val |= 1 << 29; /* use 0xc0000000-0xdfffffff */
meram_write_reg(meram, regs, MEVCR1, val);
meram_unlock_reg(meram, regs);
#endif /* defined(USE_MERAM_RA) || defined(USE_MERAM_WB) */
#if defined(USE_MERAM_RA)
#error bbbb
/* calcurate byte-pitch */
src[0].bpitchy = size_y(src[0].format, src[0].pitch, 0);
/* set up read-ahead cache for input */
icbr = meram_lock_icb(meram, 0);
val = (3 << 24) | /* KRBNM: ((3+1) << 1) = 8 lines */
((16 - 1) << 16); /* BNM: 16 = KRBNM * 2 lines */
ADJUST_PITCH(sz, src[0].bpitchy);
sz *= 16; /* 16 lines */
if (src[0].format == REN_NV12) {
val |= 2 << 12; /* CPL: YCbCr420 */
sz = sz * 3 / 2;
} else if (src[0].format == REN_NV16) {
val |= 3 << 12; /* CPL: YCbCr422 */
sz = sz * 2;
}
meram_write_icb(meram, icbr, MExxMCNF, val);
sz = (sz + 1023) / 1024;
mblock = meram_alloc_icb_memory(meram, icbr,
(sz == 0) ? 1 : sz);
val = (1 << 28) | /* BSZ: 2^1 line/block */
(mblock << 16) | /* MSAR */
(3 << 9) | /* WD: (constant) */
(1 << 8) | /* WS: (constant) */
(1 << 3) | /* CM: address mode 1 */
1; /* MD: read buffer mode */
meram_write_icb(meram, icbr, MExxCTRL, val);
val = ((src[0].h - 1) << 16) | /* YSZM1 */
(src[0].bpitchy - 1); /* XSZM1 */
meram_write_icb(meram, icbr, MExxBSIZE, val);
val = ALIGN16(src[0].bpitchy); /* SBSIZE: 16 bytes aligned */
meram_write_icb(meram, icbr, MExxSBSIZE, val);
ADJUST_PITCH(src[0].bpitchy, src[0].bpitchy);
src[0].bpitchc = src[0].bpitcha = src[0].bpitchy;
val = uiomux_all_virt_to_phys(src[0].py);
meram_write_icb(meram, icbr, MExxSSARA, val);
src[0].py = (void *)meram_get_icb_address(meram, icbr, 0);
uiomux_register(src[0].py, (unsigned long)src[0].py, 8 << 20);
if (is_ycbcr(src[0].format)) {
val = uiomux_all_virt_to_phys(src[0].pc);
meram_write_icb(meram, icbr, MExxSSARB, val);
src[0].pc = (void *)meram_get_icb_address(meram, icbr, 1);
uiomux_register(src[0].pc, (unsigned long)src[0].pc, 8 << 20);
} else {
meram_write_icb(meram, icbr, MExxSSARB, 0);
}
#endif /* defined(USE_MERAM_RA) */
#if defined(USE_MERAM_WB)
/* calcurate byte-pitch */
dst.bpitchy = size_y(dst.format, dst.pitch, 0);
/* set up write-back cache for input */
icbw = meram_lock_icb(meram, 1);
val = (3 << 28) | /* KWBNM: ((3+1) << 1) = 8 lines */
((16 - 1) << 16); /* BNM: 16 = KWBNM * 2 lines */
ADJUST_PITCH(sz, dst.bpitchy);
sz *= 16; /* 16 lines */
if (dst.format == REN_NV12) {
val |= 2 << 12; /* CPL: YCbCr420 */
sz = sz * 3 / 2;
} else if (dst.format == REN_NV16) {
val |= 3 << 12; /* CPL: YCbCr422 */
sz = sz * 2;
}
meram_write_icb(meram, icbw, MExxMCNF, val);
sz = (sz + 1023) / 1024;
mblock = meram_alloc_icb_memory(meram, icbw,
(sz == 0) ? 1 : sz);
val = (1 << 28) | /* BSZ: 2^1 line/block */
(mblock << 16) | /* MSAR */
(3 << 9) | /* WD: (constant) */
(1 << 8) | /* WS: (constant) */
(1 << 3) | /* CM: address mode 1 */
2; /* MD: write buffer mode */
meram_write_icb(meram, icbw, MExxCTRL, val);
val = ((dst.h - 1) << 16) | /* YSZM1 */
(dst.bpitchy - 1); /* XSZM1 */
meram_write_icb(meram, icbw, MExxBSIZE, val);
val = ALIGN16(dst.bpitchy); /* SBSIZE: 16 bytes aligned */
meram_write_icb(meram, icbw, MExxSBSIZE, val);
ADJUST_PITCH(dst.bpitchy, dst.bpitchy);
dst.bpitchc = dst.bpitcha = dst.bpitchy;
val = uiomux_all_virt_to_phys(dst.py);
meram_write_icb(meram, icbw, MExxSSARA, val);
dst.py = (void *)meram_get_icb_address(meram, icbw, 0);
uiomux_register(dst.py, (unsigned long)dst.py, 8 << 20);
if (is_ycbcr(dst.format)) {
val = uiomux_all_virt_to_phys(dst.pc);
meram_write_icb(meram, icbw, MExxSSARB, val);
dst.pc = (void *)meram_get_icb_address(meram, icbw, 1);
uiomux_register(dst.pc, (unsigned long)dst.pc, 8 << 20);
} else {
meram_write_icb(meram, icbw, MExxSSARB, 0);
}
#endif /* defined(USE_MERAM_WB) */
if (strcmp (infilename[0], "-") == 0) {
infile[0] = stdin;
} else {
infile[0] = fopen (infilename[0], "rb");
if (infile[0] == NULL) {
fprintf (stderr, "%s: unable to open input file %s\n",
progname, infilename[0]);
goto exit_err;
}
}
if (infilename[1] != NULL) {
infile[1] = fopen (infilename[1], "rb");
if (infile[1] == NULL) {
fprintf (stderr, "%s: unable to open input file %s\n",
progname, infilename[1]);
goto exit_err;
}
}
if (outfilename != NULL) {
if (strcmp (outfilename, "-") == 0) {
outfile = stdout;
} else {
outfile = fopen (outfilename, "wb");
if (outfile == NULL) {
fprintf (stderr, "%s: unable to open output file %s\n",
progname, outfilename);
goto exit_err;
}
}
}
if (!viodev)
vio = shvio_open();
else
vio = shvio_open_named(viodev);
if (vio == 0) {
fprintf (stderr, "Error opening VIO\n");
goto exit_err;
}
while (1) {
#ifdef DEBUG
fprintf (stderr, "%s: Converting frame %d\n", progname, frameno);
#endif
/* Read input */
if ((nread = fread (inbuf[0], 1, input_size[0], infile[0])) != input_size[0]) {
if (nread == 0 && feof (infile[0])) {
break;
} else {
fprintf (stderr, "%p, %s: errors reading input file %s %d %d %d\n", inbuf[0],
progname, infilename[0], nread, input_size[0], ferror(infile[0]));
}
}
#if 1
if (infilename[1] != NULL) {
if ((nread = fread (inbuf[1], 1, input_size[1], infile[1])) != input_size[1]) {
if (nread == 0 && feof (infile[1])) {
break;
} else {
fprintf (stderr, "%s: error reading input file %s\n",
progname, infilename[1]);
}
}
printf("invoke shvio_setup_blend()...\n");
ret = shvio_setup_blend(vio, NULL, srclist, 2, &dst);
shvio_start(vio);
printf("shvio_start_blend() = %d\n", ret);
ret = shvio_wait(vio);
} else {
#endif
if (rotation) {
ret = shvio_rotate(vio, &src[0], &dst, rotation);
} else {
ret = shvio_resize(vio, &src[0], &dst);
}
}
#if defined(USE_MERAM_WB)
meram_read_icb(meram, icbw, MExxCTRL, &val);
val |= 1 << 5; /* WF: flush data */
meram_write_icb(meram, icbw, MExxCTRL, val);
#endif
#if defined(USE_MERAM_RA)
meram_read_icb(meram, icbr, MExxCTRL, &val);
val |= 1 << 4; /* RF: flush data */
meram_write_icb(meram, icbr, MExxCTRL, val);
#endif
/* Write output */
if (outfile && fwrite (outbuf, 1, output_size, outfile) != output_size) {
fprintf (stderr, "%s: error writing input file %s\n",
progname, outfilename);
}
frameno++;
}
shvio_close (vio);
#if defined(USE_MERAM_RA)
/* finialize the read-ahead cache */
uiomux_unregister(src[0].py);
if (is_ycbcr(src[0].format))
uiomux_unregister(src[0].pc);
meram_free_icb_memory(meram, icbr);
meram_unlock_icb(meram, icbr);
#endif
#if defined(USE_MERAM_WB)
/* finialize the write-back cache */
uiomux_unregister(dst.py);
if (is_ycbcr(dst.format))
uiomux_unregister(dst.pc);
meram_free_icb_memory(meram, icbw);
meram_unlock_icb(meram, icbw);
#endif
#if defined(USE_MERAM_RA) || defined(USE_MERAM_WB)
meram_close(meram);
#endif
uiomux_free (uiomux, uiores, src[0].py, input_size[0]);
if (infilename[1] != NULL)
uiomux_free (uiomux, uiores, src[1].py, input_size[1]);
uiomux_free (uiomux, uiores, dst.py, output_size);
uiomux_close (uiomux);
if (infile[0] != stdin) fclose (infile[0]);
if (infilename[1] != NULL)
fclose (infile[1]);
if (outfile == stdout) {
fflush (stdout);
} else if (outfile) {
fclose (outfile);
}
printf ("Frames:\t\t%d\n", frameno);
exit_ok:
exit (0);
exit_err:
exit (1);
}
void Mapper::drawMinimap()
{
video::ITexture *minimap_texture = getMinimapTexture();
if (!minimap_texture)
return;
updateActiveMarkers();
v2u32 screensize = porting::getWindowSize();
const u32 size = 0.25 * screensize.Y;
core::rect<s32> oldViewPort = driver->getViewPort();
core::matrix4 oldProjMat = driver->getTransform(video::ETS_PROJECTION);
core::matrix4 oldViewMat = driver->getTransform(video::ETS_VIEW);
driver->setViewPort(core::rect<s32>(
screensize.X - size - 10, 10,
screensize.X - 10, size + 10));
driver->setTransform(video::ETS_PROJECTION, core::matrix4());
driver->setTransform(video::ETS_VIEW, core::matrix4());
core::matrix4 matrix;
matrix.makeIdentity();
video::SMaterial &material = m_meshbuffer->getMaterial();
material.setFlag(video::EMF_TRILINEAR_FILTER, true);
material.Lighting = false;
material.TextureLayer[0].Texture = minimap_texture;
material.TextureLayer[1].Texture = data->heightmap_texture;
if (m_enable_shaders && !data->is_radar) {
u16 sid = m_shdrsrc->getShader("minimap_shader", 1, 1);
material.MaterialType = m_shdrsrc->getShaderInfo(sid).material;
} else {
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
}
if (data->minimap_shape_round)
matrix.setRotationDegrees(core::vector3df(0, 0, 360 - m_angle));
// Draw minimap
driver->setTransform(video::ETS_WORLD, matrix);
driver->setMaterial(material);
driver->drawMeshBuffer(m_meshbuffer);
// Draw overlay
video::ITexture *minimap_overlay = data->minimap_shape_round ?
data->minimap_overlay_round : data->minimap_overlay_square;
material.TextureLayer[0].Texture = minimap_overlay;
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
driver->setMaterial(material);
driver->drawMeshBuffer(m_meshbuffer);
// If round minimap, draw player marker
if (!data->minimap_shape_round) {
matrix.setRotationDegrees(core::vector3df(0, 0, m_angle));
material.TextureLayer[0].Texture = data->player_marker;
driver->setTransform(video::ETS_WORLD, matrix);
driver->setMaterial(material);
driver->drawMeshBuffer(m_meshbuffer);
}
// Reset transformations
driver->setTransform(video::ETS_VIEW, oldViewMat);
driver->setTransform(video::ETS_PROJECTION, oldProjMat);
driver->setViewPort(oldViewPort);
// Draw player markers
v2s32 s_pos(screensize.X - size - 10, 10);
core::dimension2di imgsize(data->object_marker_red->getOriginalSize());
core::rect<s32> img_rect(0, 0, imgsize.Width, imgsize.Height);
static const video::SColor col(255, 255, 255, 255);
static const video::SColor c[4] = {col, col, col, col};
f32 sin_angle = sin(m_angle * core::DEGTORAD);
f32 cos_angle = cos(m_angle * core::DEGTORAD);
s32 marker_size2 = 0.025 * (float)size;
for (std::list<v2f>::const_iterator
i = m_active_markers.begin();
i != m_active_markers.end(); ++i) {
v2f posf = *i;
if (data->minimap_shape_round) {
f32 t1 = posf.X * cos_angle - posf.Y * sin_angle;
f32 t2 = posf.X * sin_angle + posf.Y * cos_angle;
posf.X = t1;
posf.Y = t2;
}
posf.X = (posf.X + 0.5) * (float)size;
posf.Y = (posf.Y + 0.5) * (float)size;
core::rect<s32> dest_rect(
s_pos.X + posf.X - marker_size2,
s_pos.Y + posf.Y - marker_size2,
s_pos.X + posf.X + marker_size2,
s_pos.Y + posf.Y + marker_size2);
driver->draw2DImage(data->object_marker_red, dest_rect,
img_rect, &dest_rect, &c[0], true);
}
}
bool StyleBoxImageMask::test_mask(const Point2& p_point, const Rect2& p_rect) const {
if (image.empty())
return false;
if (p_rect.size.x<1)
return false;
if (p_rect.size.y<1)
return false;
Size2i imgsize(image.get_width(),image.get_height());
if (imgsize.x<=0 || imgsize.y<=0)
return false;
Point2i img_expand_size( imgsize.x - expand_margin[MARGIN_LEFT] - expand_margin[MARGIN_RIGHT], imgsize.y - expand_margin[MARGIN_TOP] - expand_margin[MARGIN_BOTTOM]);
Point2i rect_expand_size( p_rect.size.x - expand_margin[MARGIN_LEFT] - expand_margin[MARGIN_RIGHT], p_rect.size.y - expand_margin[MARGIN_TOP] - expand_margin[MARGIN_BOTTOM]);
if (rect_expand_size.x<1)
rect_expand_size.x=1;
if (rect_expand_size.y<1)
rect_expand_size.y=1;
Point2i click_pos;
//treat x
if (p_point.x<p_rect.pos.x)
click_pos.x=0;
else if (expand) {
if (p_point.x>=p_rect.pos.x+p_rect.size.x)
click_pos.x=imgsize.x-1;
else if ((p_point.x-p_rect.pos.x)<expand_margin[MARGIN_LEFT])
click_pos.x=p_point.x;
else if ((p_point.x-(p_rect.pos.x+p_rect.size.x))<expand_margin[MARGIN_RIGHT])
click_pos.x=imgsize.x-(p_point.x-(p_rect.pos.x+p_rect.size.x));
else //expand
click_pos.x=(p_point.x-p_rect.pos.x-expand_margin[MARGIN_LEFT])*img_expand_size.x/rect_expand_size.x;
} else if ((p_point.x-p_rect.pos.x) > imgsize.x)
click_pos.x=imgsize.x;
//treat y
if (p_point.y<p_rect.pos.y)
click_pos.y=0;
else if (expand) {
if (p_point.y>=p_rect.pos.y+p_rect.size.y)
click_pos.y=imgsize.y-1;
else if ((p_point.y-p_rect.pos.y)<expand_margin[MARGIN_TOP])
click_pos.y=p_point.y;
else if ((p_point.y-(p_rect.pos.y+p_rect.size.y))<expand_margin[MARGIN_BOTTOM])
click_pos.y=imgsize.y-(p_point.y-(p_rect.pos.y+p_rect.size.y));
else //expand
click_pos.y=(p_point.y-p_rect.pos.y-expand_margin[MARGIN_TOP])*img_expand_size.y/rect_expand_size.y;
} else if ((p_point.y-p_rect.pos.y) > imgsize.y)
click_pos.y=imgsize.y;
return image.get_pixel(click_pos.x,click_pos.y).gray()>0.5;
}
