// initialize image data
void ImageBase::init (short width, short height)
{
	// if image has to be scaled
	if (m_scale)
	{
		// recalc sizes of image
		width = calcSize(width);
		height = calcSize(height);
	}
	// if sizes differ
	if (width != m_size[0] || height != m_size[1])
	{
		if (m_exports > 0)
			THRWEXCP(ImageHasExports,S_OK);

		// new buffer size
		unsigned int newSize = width * height;
		// if new buffer is larger than previous
		if (newSize > m_imgSize)
		{
			// set new buffer size
			m_imgSize = newSize;
			// release previous and create new buffer
			if (m_image)
				delete [] m_image;
			m_image = new unsigned int[m_imgSize];
		}
		// new image size
		m_size[0] = width;
		m_size[1] = height;
		// scale was processed
		m_scaleChange = false;
	}
}

int32_t C2DColorConverter::getBuffReq(int32_t port, C2DBuffReq *req) {
    if (!req) return -1;

    if (port != C2D_INPUT && port != C2D_OUTPUT) return -1;

    memset(req, 0, sizeof(C2DBuffReq));
    if (port == C2D_INPUT) {
        req->width = mSrcWidth;
        req->height = mSrcHeight;
        req->stride = calcStride(mSrcFormat, mSrcWidth);
        req->sliceHeight = mSrcHeight;
        req->lumaAlign = calcLumaAlign(mSrcFormat);
        req->sizeAlign = calcSizeAlign(mSrcFormat);
        req->size = calcSize(mSrcFormat, mSrcWidth, mSrcHeight);
        //add bpp?
        ALOGV("input req->size = %d\n", req->size);
    } else if (port == C2D_OUTPUT) {
        req->width = mDstWidth;
        req->height = mDstHeight;
        req->stride = calcStride(mDstFormat, mDstWidth);
        req->sliceHeight = mDstHeight;
        req->lumaAlign = calcLumaAlign(mDstFormat);
        req->sizeAlign = calcSizeAlign(mDstFormat);
        req->size = calcSize(mDstFormat, mDstWidth, mDstHeight);
        ALOGV("output req->size = %d\n", req->size);
    }
    return 0;
}

void CanvasNavigator::createCanvasBox()
{
    QRect crect = m_canvas->contentsRect();
    QRect mapped = m_canvas->mapDev(crect);
    QRectF real(calcSize(mapped.x()), 0, calcSize(mapped.width()), 80);
    m_canvasBox = m_scene->addRect(real);
    m_canvasBox->setZValue(124000.0f);
    updateCanvasBoxColor();
}

C2DColorConverter::C2DColorConverter(size_t srcWidth, size_t srcHeight, size_t dstWidth, size_t dstHeight, ColorConvertFormat srcFormat, ColorConvertFormat dstFormat, int32_t flags, size_t stride)
{
     mError = 0;
     mC2DLibHandle = dlopen("libC2D2.so", RTLD_NOW);
     if (!mC2DLibHandle) {
         ALOGE("FATAL ERROR: could not dlopen libc2d2.so: %s", dlerror());
         mError = -1;
         return;
     }
     mC2DCreateSurface = (LINK_c2dCreateSurface)dlsym(mC2DLibHandle, "c2dCreateSurface");
     mC2DUpdateSurface = (LINK_c2dUpdateSurface)dlsym(mC2DLibHandle, "c2dUpdateSurface");
     mC2DReadSurface = (LINK_c2dReadSurface)dlsym(mC2DLibHandle, "c2dReadSurface");
     mC2DDraw = (LINK_c2dDraw)dlsym(mC2DLibHandle, "c2dDraw");
     mC2DFlush = (LINK_c2dFlush)dlsym(mC2DLibHandle, "c2dFlush");
     mC2DFinish = (LINK_c2dFinish)dlsym(mC2DLibHandle, "c2dFinish");
     mC2DWaitTimestamp = (LINK_c2dWaitTimestamp)dlsym(mC2DLibHandle, "c2dWaitTimestamp");
     mC2DDestroySurface = (LINK_c2dDestroySurface)dlsym(mC2DLibHandle, "c2dDestroySurface");
     mC2DMapAddr = (LINK_c2dMapAddr)dlsym(mC2DLibHandle, "c2dMapAddr");
     mC2DUnMapAddr = (LINK_c2dUnMapAddr)dlsym(mC2DLibHandle, "c2dUnMapAddr");

     if (!mC2DCreateSurface || !mC2DUpdateSurface || !mC2DReadSurface
        || !mC2DDraw || !mC2DFlush || !mC2DFinish || !mC2DWaitTimestamp
        || !mC2DDestroySurface || !mC2DMapAddr || !mC2DUnMapAddr) {
         ALOGE("%s: dlsym ERROR", __FUNCTION__);
         mError = -1;
         return;
     }

    mSrcWidth = srcWidth;
    mSrcHeight = srcHeight;
    mDstWidth = dstWidth;
    mDstHeight = dstHeight;
    mSrcFormat = srcFormat;
    mDstFormat = dstFormat;
    mSrcSize = calcSize(srcFormat, srcWidth, srcHeight);
    mDstSize = calcSize(dstFormat, dstWidth, dstHeight);
    mSrcYSize = calcYSize(srcFormat, srcWidth, srcHeight);
    mDstYSize = calcYSize(dstFormat, dstWidth, dstHeight);
    mStride = stride;
    mFlags = flags; // can be used for rotation

    mSrcSurfaceDef = getDummySurfaceDef(srcFormat, srcWidth, srcHeight, true);
    mDstSurfaceDef = getDummySurfaceDef(dstFormat, dstWidth, dstHeight, false);

    memset((void*)&mBlit,0,sizeof(C2D_OBJECT));
    mBlit.source_rect.x = 0 << 16;
    mBlit.source_rect.y = 0 << 16;
    mBlit.source_rect.width = srcWidth << 16;
    mBlit.source_rect.height = srcHeight << 16;
    mBlit.target_rect.x = 0 << 16;
    mBlit.target_rect.y = 0 << 16;
    mBlit.target_rect.width = dstWidth << 16;
    mBlit.target_rect.height = dstHeight << 16;
    mBlit.config_mask = C2D_ALPHA_BLEND_NONE | C2D_NO_BILINEAR_BIT | C2D_NO_ANTIALIASING_BIT | C2D_TARGET_RECT_BIT;
    mBlit.surface_id = mSrcSurface;
}

void CanvasNavigator::updateLoopRange()
{
    if(m_punchIn)
    {
        double lpos = calcSize(song->lpos());
        m_punchIn->setPos(QPointF(lpos, 0.0));
        m_punchIn->setVisible(song->loop() || song->punchin());
    }
    if(m_punchOut)
    {
        double rpos = calcSize(song->rpos());
        m_punchOut->setPos(QPointF(rpos, 0.0));
        m_punchOut->setVisible(song->loop() || song->punchout());
    }
}

bool SaveContainer::writePart(uint32 partN, const SavePart *part) {
	// Sanity checks
	if (!part)
		return false;
	if (partN >= _partCount)
		return false;

	Part *&p = _parts[partN];

	delete p;
	// Create the part
	p = new Part(part->getSize());

	Common::WriteStream *pStream = p->createWriteStream();

	// Write
	if (!part->write(*pStream)) {
		delete p;
		p = 0;

		delete pStream;
		return false;
	}

	delete pStream;

	// Update size
	_header.setSize(calcSize());

	return true;
}

/**
 * Read the file and form the HTML -> MOVE TO UTILS
 **/
char* formHTML(struct fileInfo informator) {
	int len = calcSize(informator);
	if ((informator.fd = fopen(informator.filename, "rt")) != NULL ) {
		printf("> File Open Success \n");
		// get information regarding the img file
		if ((strcmp(informator.Context, "Content-Type: image/jpeg\r\n") == 0)
				|| (strcmp(informator.Context, "Content-Type: image/gif\r\n")
						== 0)) {
			printf("The size is [%d] \n", len);
			char* contents = (char*) malloc((sizeof(char) * len) + 1);
			contents[len + 1] = '\0';
			size_t bytes = fread(contents, sizeof(char), len, informator.fd);
			fclose(informator.fd);
			return contents;
		} else {
			// get info regarding the txt file
			printf("The size is [%d] \n", len);
			char* contents = (char*) malloc((sizeof(char) * len) + 2);
			size_t bytes = fread(contents, sizeof(char), len, informator.fd);
			contents[len + 2] = '\0';
			contents[len + 1] = '\n';
			contents[len] = '\r';
			fclose(informator.fd);
			return contents;
		}
	} else {
		printf("file open NOT A SUCCESS \n");
		return "";
	}
}

void IntelHexImage::open(bool read)
{

	if (read)
	{
		/* NOTE: "t" mode do nothing on non-Windows platform!!! See also  IntelHexImage::read() */
		_file = fopen(_name.c_str(), "rt");
		if (_file == NULL)
			throw DEFileOpenFailed(_name, read);
		_size = calcSize();
	}
	else
	{
		/* NOTE: "t" mode do nothing on non-Windows platform!!! See also  IntelHexImage::write() */
		_file = fopen(_name.c_str(), "wt");
		if (_file == NULL)
			throw DEFileOpenFailed(_name, read);
		_size = 0;
	}
	_read = read;
	_readCurrent = 0;
	_readAddr = 0;
	_writeAddr = 0;
	_linAddr = 1; // LOW 16 bit MUST be nonzero at first time write() called
	_record.clear();
}

typename P::Value
cache<P>::read(const K & key)
{
    {
        vespalib::LockGuard guard(_hashLock);
        if (Lru::hasKey(key)) {
            _hit++;
            return (*this)[key];
        } else {
            _miss++;
        }
    }

    vespalib::LockGuard storeGuard(getLock(key));
    {
        vespalib::LockGuard guard(_hashLock);
        if (Lru::hasKey(key)) {
            // Somebody else just fetched it ahead of me.
            _race++;
            return (*this)[key];
        }
    }
    V value;
    if (_store.read(key, value)) {
        vespalib::LockGuard guard(_hashLock);
        Lru::insert(key, value);
        _sizeBytes += calcSize(key, value);
        _insert++;
    } else {
        _noneExisting.fetch_add(1);
    }
    return value;
}

void TextPreview::setWins(const QList<FF8Window> &windows, bool update)
{
	ff8Windows = windows;
	if(update)
		calcSize();
	//qDebug() << "type" << window.type << "x" << window.x << "y" << window.y << "u1" << window.u1;
}

////////////////////////////
// kernel caller definitions
bool SURF_OCL::calcLayerDetAndTrace(int octave, int c_layer_rows)
{
    int nOctaveLayers = params->nOctaveLayers;
    const int min_size = calcSize(octave, 0);
    const int max_samples_i = 1 + ((img_rows - min_size) >> octave);
    const int max_samples_j = 1 + ((img_cols - min_size) >> octave);

    size_t localThreads[]  = {16, 16};
    size_t globalThreads[] =
    {
        divUp(max_samples_j, (int)localThreads[0]) * localThreads[0],
        divUp(max_samples_i, (int)localThreads[1]) * localThreads[1] * (nOctaveLayers + 2)
    };
    ocl::Kernel kerCalcDetTrace("SURF_calcLayerDetAndTrace", ocl::xfeatures2d::surf_oclsrc, kerOpts);
    if(haveImageSupport)
    {
        kerCalcDetTrace.args(sumTex,
                             img_rows, img_cols, nOctaveLayers,
                             octave, c_layer_rows,
                             ocl::KernelArg::WriteOnlyNoSize(det),
                             ocl::KernelArg::WriteOnlyNoSize(trace));
    }
    else
    {
        kerCalcDetTrace.args(ocl::KernelArg::ReadOnlyNoSize(sum),
                             img_rows, img_cols, nOctaveLayers,
                             octave, c_layer_rows,
                             ocl::KernelArg::WriteOnlyNoSize(det),
                             ocl::KernelArg::WriteOnlyNoSize(trace));
    }
    return kerCalcDetTrace.run(2, globalThreads, localThreads, true);
}

void Text::setText(String text) {
	XOJ_CHECK_TYPE(Text);

	this->text = text;

	calcSize();
}

EXPORT int  mongo_gridfs_store(struct gridfs_* gfs, mxArray* data, char* remoteName, char* contentType) {
    uint64_t size;
    void* p;
    if (mxIsComplex(data))
        mexErrMsgTxt("GridFS:store - Complex values not supported");
    p = calcSize(data, &size);
    return (gridfs_store_buffer((gridfs*)gfs, (char*)p, size, remoteName, contentType) == MONGO_OK);
}

	float TextField2::getMeasuredHeight()
	{
		if (mDirty)
		{
			calcSize();
		}
		return mMeasuredHeight;
	}

bool
cache<P>::removeOldest(const value_type & v) {
    bool remove(Lru::removeOldest(v) || (sizeBytes() >= capacityBytes()));
    if (remove) {
        _sizeBytes -= calcSize(v.first, v.second._value);
    }
    return remove;
}

// capture image from viewport
void ImageViewport::calcImage (unsigned int texId)
{
	// if scale was changed
	if (m_scaleChange)
		// reset image
		init(m_capSize[0], m_capSize[1]);
	// if texture wasn't initialized
	if (!m_texInit)
	{
		// initialize it
		loadTexture(texId, m_image, m_size);
		m_texInit = true;
	}
	// if texture can be directly created
	if (texId != 0 && m_pyfilter == NULL && m_capSize[0] == calcSize(m_capSize[0])
		&& m_capSize[1] == calcSize(m_capSize[1]) && !m_flip)
	{
		// just copy current viewport to texture
	    glBindTexture(GL_TEXTURE_2D, texId);
	    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1]);
	    // image is not available
	    m_avail = false;
	}
	// otherwise copy viewport to buffer, if image is not available
	else if (!m_avail)
	{
		// get frame buffer data
        if (m_alpha)
        {
    		glReadPixels(m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1], GL_RGBA,
			    GL_UNSIGNED_BYTE, m_viewportImage);
		    // filter loaded data
		    FilterRGBA32 filt;
		    filterImage(filt, m_viewportImage, m_capSize);
        } 
        else
        {
    		glReadPixels(m_upLeft[0], m_upLeft[1], (GLsizei)m_capSize[0], (GLsizei)m_capSize[1], GL_RGB,
	    		GL_UNSIGNED_BYTE, m_viewportImage);
    		// filter loaded data
		    FilterRGB24 filt;
		    filterImage(filt, m_viewportImage, m_capSize);
        }
	}
}

void
RangeSensorWidget::setGroup(CORBA::UShort _group)
{
  group_ = _group;
  scan_ = sensor_->getGroup(group_);
  calcSize();
  if (!timer_)
    timer_ = startTimer(40);  
  calcCaption();
}

void Area::insert(size_t dimOrdinal, const Set* elems, bool calc) {
  if (dimOrdinal >= area.size()) {
    throw ErrorException(ErrorException::ERROR_INTERNAL,
                         "Area::insert invalid dimOrdinal");
  }
  area[dimOrdinal] = elems;
  if (calc) {
    calcSize();
  }
}

void ScaleBar::pointerButtonDown(GLMotif::Event& event)
	{
	Scalar newScale=currentScale;
	
	/* Check if the event happened in the left or right corner: */
	float relEventPos=(event.getWidgetPoint().getPoint()[0]-getInterior().origin[0])/getInterior().size[0];
	if(relEventPos<=0.333f)
		{
		/* Calculate the next smaller quasi-binary scale factor: */
		newScale=Scalar(getSmallerQuasiBinary(currentScale));
		}
	else if(relEventPos>=0.667f)
		{
		/* Calculate the next bigger quasi-binary scale factor: */
		newScale=Scalar(getBiggerQuasiBinary(currentScale));
		}
	
	if(newScale!=currentScale&&activateNavigationTool(reinterpret_cast<const Tool*>(this)))
		{
		/* Adjust the navigation transformation: */
		Scalar newNavScale;
		const Geometry::LinearUnit& unit=getCoordinateManager()->getUnit();
		if(unit.isImperial())
			{
			/* Calculate scale factor through imperial units: */
			newNavScale=getInchFactor()*newScale/unit.getInchFactor();
			}
		else
			{
			/* Calculate scale factor through metric units: */
			newNavScale=getMeterFactor()*newScale/unit.getMeterFactor();
			}
		
		/* Get the current navigation transformation and calculate the display center position in navigation coordinates: */
		const NavTransform& nav=getNavigationTransformation();
		Point center=nav.inverseTransform(getDisplayCenter());
		
		/* Create the new navigation transformation: */
		NavTransform newNav=NavTransform(nav.getTranslation(),nav.getRotation(),newNavScale);
		newNav.leftMultiply(NavTransform::translate(getDisplayCenter()-newNav.transform(center)));
		setNavigationTransformation(newNav);
		
		deactivateNavigationTool(reinterpret_cast<const Tool*>(this));
		currentScale=newScale;
		
		/* Update the scale bar: */
		calcSize(newNav);
		
		/* Resize the widget so that the clicked point stays in the same place: */
		GLMotif::Vector newSize=calcNaturalSize();
		GLfloat newInteriorWidth=newSize[0]-2.0f*getBorderWidth();
		GLfloat newOrigin=event.getWidgetPoint().getPoint()[0]-newInteriorWidth*relEventPos-getBorderWidth();
		resize(GLMotif::Box(GLMotif::Vector(newOrigin,0.0f,0.0f),newSize));
		}
	}

double Element::getY()
{
	XOJ_CHECK_TYPE(Element);

	if (!this->sizeCalculated)
	{
		this->sizeCalculated = true;
		calcSize();
	}
	return y;
}