void GLPixelBuffer::unlockImpl(void)
{
if (mCurrentLockOptions != GBL_READ_ONLY)
{
// From buffer to card, only upload if was locked for writing
upload(mCurrentLock, mLockedBox);
}
freeBuffer();
}
/** Uploads a filename, and if necessary, uploads the data as well.
*
* @param name The named file to be uploaded (of the form "meerkat:///somefile.texture")
* @param hashContext The location to upload the data to (usually "mhash:")
* @param toUpload Data to be uploaded. Will only be uploaded if necessary.
* @param listener An EventListener to receive a UploadEventPtr with the retrieved data.
* @param forceIfExists Upload the data even if the file already exists on all known CDN services.
*/
inline void upload(const URI &name,
const URIContext &hashContext,
const DenseDataPtr &toUpload,
const EventListener &listener,
bool forceIfExists) {
RemoteFileId rfid(
Fingerprint::computeDigest(toUpload->data(), toUpload->length()),
hashContext);
upload(name, rfid, toUpload, listener, forceIfExists);
}
static int put(void)
{
res = ne_concat(i_path, "lockme", NULL);
res2 = ne_concat(i_path, "notlocked", NULL);
//res3 = ne_concat(i_path,"not-existing",NULL);
CALL(upload_foo("lockme"));
CALL(upload("notlocked", "./htdocs/bar"));
return OK;
}
IndexBufferImpl::IndexBufferImpl(uint length, uint fmt, const void* data, LPDIRECT3DDEVICE9 device) {
D3DFORMAT table[] = {D3DFMT_INDEX16, D3DFMT_INDEX32};
assert(("Unknown format", fmt <= 1));
if (FAILED(device->CreateIndexBuffer(length, 0, table[fmt], D3DPOOL_DEFAULT, &ib, 0)))
throw Exception("Failed to allocate VertexBuffer");
if (data != nullptr)
upload(data, 0, length);
}
void Uploader::onUploadButton()
{
QFileInfo fi(browseEdit->text());
if(!fi.exists())
return mainWindow->message( tr("%1 can't be found.").arg(fi.fileName()), MsgType::Error, tr("Uploader") );
if( uploader.state() != QProcess::NotRunning )
return mainWindow->message( tr("Uploader is currently busy...give it a second, then try again"), MsgType::Error, tr("Uploader") );
upload(fi.filePath());
}
void GL3PlusHardwarePixelBuffer::unlockImpl(void)
{
if (mCurrentLockOptions != HardwareBuffer::HBL_READ_ONLY)
{
// From buffer to card, only upload if was locked for writing.
upload(mCurrentLock, mLockedBox);
}
freeBuffer();
mBuffer = PixelBox( mWidth, mHeight, mDepth, mFormat, mBuffer.data );
}
void Quad::draw() const {
// upload to GPU if neccessary
if (!verts_) {
upload();
}
rectangle_->Bind();
ogl::Context::DrawArrays(oglplus::PrimitiveType::TriangleStrip, 0, 4);
oglplus::NoVertexArray().Bind();
}
void Quad::draw(unsigned instance_count) const {
// upload to GPU if neccessary
if (!verts_) {
upload();
}
rectangle_->Bind();
ogl::Context::DrawArraysInstanced(oglplus::PrimitiveType::TriangleStrip, 0, 4, instance_count);
oglplus::NoVertexArray().Bind();
}
MainWindow::MainWindow() {
int row = 0;
qRegisterMetaType<Buttons>("Buttons");
connect(&worker, SIGNAL(status(QString)), this, SLOT(status(QString)));
connect(&worker, SIGNAL(progress(int)), this, SLOT(progress(int)));
connect(&worker, SIGNAL(buttons(Buttons)), this, SLOT(buttons(Buttons)));
refreshButton.setText("Refresh");
grid.addWidget(&refreshButton, row++, 0);
fileListBox.setSizeConstraint(QLayout::SetFixedSize);
fileListWidget.setLayout(&fileListBox);
fileListArea.setWidgetResizable(true);
fileListArea.setWidget(&fileListWidget);
fileListAreaBox.setContentsMargins(1, 0, 1, 3);
fileListAreaBox.addWidget(&fileListArea);
fileListAreaWidget.setFixedHeight(192);
fileListAreaWidget.setLayout(&fileListAreaBox);
grid.addWidget(&fileListAreaWidget, row++, 0);
progressBar.setMinimum(0);
progressBar.setMaximum(10000);
progressBarBox.setContentsMargins(1, 0, 0, 0);
progressBarBox.addWidget(&progressBar, 0);
progressBarWidget.setLayout(&progressBarBox);
grid.addWidget(&progressBarWidget, row++, 0);
uploadButton.setText("Upload");
grid.addWidget(&uploadButton, row++, 0);
verifyButton.setText("Verify");
grid.addWidget(&verifyButton, row++, 0);
widget.setParent(this);
widget.setLayout(&grid);
setCentralWidget(&widget);
setWindowTitle("WAV uploader");
statusBar()->setSizeGripEnabled(false);
setFixedSize(384, minimumSizeHint().height());
setWindowFlags(Qt::MSWindowsFixedSizeDialogHint);
connect(&refreshButton, SIGNAL(clicked()), this, SLOT(refresh()));
connect(&uploadButton, SIGNAL(clicked()), this, SLOT(upload()));
connect(&verifyButton, SIGNAL(clicked()), this, SLOT(verify()));
buttons(Buttons::Step1);
progress();
status();
refresh();
show();
}
eIndexBufferDx9::eIndexBufferDx9(IDirect3DDevice9 *d3dDev, eU32 count, eBool dynamic) :
m_d3dDev(d3dDev),
m_count(count),
m_locked(eFALSE),
m_dynamic(dynamic),
m_d3dIb(eNULL)
{
eASSERT(d3dDev != eNULL);
eASSERT(count > 0);
upload();
}
// custom drawing
void VAO::begin(GLuint vertexSize, GLsizei vertices, const GLvoid* data, GLenum usage)
{
this->isCreating = true;
// create VAO & VBO
if (vao == 0)
{
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
}
upload(vertexSize, vertices, data, usage);
}
bool qt_dempak::init(QString file) {
int inlen = 0;
int stage = 0;
char inbuf[16384],outbuf[16384];
z_stream stream;
FILE *fp;
if (!(fp = fopen(file.toAscii(),"rb"))) {
errorString=QString("Error opening file %1").arg(file);
return(false);
}
// read and check header
fseek(fp, 0, SEEK_SET);
fread (inbuf,1,4,fp);
inbuf[4]='\0';
if ( strcmp("MPAK",inbuf) ) {
errorString=QString("%1 not valid MPAK file").arg(file);
return(false);
}
// zstream start
fseek(fp, 21, SEEK_SET);
memset(&stream,0,sizeof(z_stream));
inflateInit(&stream);
while (!feof(fp) || inlen > 0) {
int rc=0;
inlen += fread(inbuf + inlen, 1, sizeof(inbuf) - inlen, fp);
stream.next_in = (unsigned char *)inbuf;
stream.avail_in = inlen;
stream.next_out = (unsigned char *)outbuf;
stream.avail_out = sizeof(outbuf);
rc = inflate(&stream, 0);
if (rc != Z_STREAM_END && rc != Z_OK) {
errorString=QString("inflate returned %d").arg(rc);
return(false);
}
if ((char*)stream.next_out > outbuf)
upload(stage, outbuf, (char*)stream.next_out - outbuf);
if ((char*)stream.next_in > inbuf) {
memmove(inbuf, stream.next_in, stream.avail_in);
inlen = stream.avail_in;
}
if (rc == Z_STREAM_END) {
++stage;
inflateEnd(&stream);
inflateInit(&stream);
}
}
inflateEnd(&stream);
fclose(fp);
return(true);
}
void GLPixelBuffer::unlock()
{
assert(mIsLocked && "Cannot unlock this buffer, it is not locked!");
if (mCurrentLockOptions != GBL_READ_ONLY)
{
// From buffer to card, only upload if was locked for writing
upload(mCurrentLock, mLockedBox);
}
freeBuffer();
mIsLocked = false;
}
int main(int c, char **argv) {
CURL *curlhandle = NULL;
curl_global_init(CURL_GLOBAL_ALL);
curlhandle = curl_easy_init();
upload(curlhandle, "ftp://*****:*****@host/path/file", "C:\\file", 0, 3);
curl_easy_cleanup(curlhandle);
curl_global_cleanup();
return 0;
}
static void
generate_data(const struct fmt_test *test)
{
unsigned pixels = piglit_width * piglit_height;
void *data = malloc(pixels * test->bpp);
char *p = data;
for (unsigned i = 0; i < pixels; i++, p += test->bpp)
value_for_format(test, p);
upload(test, data);
free(data);
}
QString takeScreenshot(QRect area) {
QPixmap shot = grabEntireScreen();
if (area.isValid())
shot = shot.copy(area);
PuushFile file = compressImage("ss", shot);
if (settings.onPuushActions & Settings::SaveToDisk)
writeFileToDisk(file);
return upload(file);
}
void GLES2HardwarePixelBuffer::blitFromMemory(const PixelBox &src, const Image::Box &dstBox)
{
if (!mBuffer.contains(dstBox))
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Destination box out of range",
"GLES2HardwarePixelBuffer::blitFromMemory");
}
PixelBox scaled;
if (src.getWidth() != dstBox.getWidth() ||
src.getHeight() != dstBox.getHeight() ||
src.getDepth() != dstBox.getDepth())
{
// Scale to destination size.
// This also does pixel format conversion if needed
allocateBuffer();
scaled = mBuffer.getSubVolume(dstBox);
Image::scale(src, scaled, Image::FILTER_BILINEAR);
}
else if ((src.format != mFormat) ||
((GLES2PixelUtil::getGLOriginFormat(src.format) == 0) && (src.format != PF_R8G8B8)))
{
// Extents match, but format is not accepted as valid source format for GL
// do conversion in temporary buffer
allocateBuffer();
scaled = mBuffer.getSubVolume(dstBox);
PixelUtil::bulkPixelConversion(src, scaled);
if(mFormat == PF_A4R4G4B4)
{
// ARGB->BGRA
GLES2PixelUtil::convertToGLformat(scaled, scaled);
}
}
else
{
allocateBuffer();
scaled = src;
if (src.format == PF_R8G8B8)
{
scaled.format = PF_B8G8R8;
PixelUtil::bulkPixelConversion(src, scaled);
}
}
upload(scaled, dstBox);
freeBuffer();
}
bool LKTracker::trackf2f(const GpuMat& gImg1, const GpuMat& gImg2, GpuMat &gPoints1, GpuMat &gPoints2) {
//计算正反光流
gFlow->sparse(gImg1, gImg2, gPoints1, gPoints2, gStatus); // compute gPoints2
gFlow->sparse(gImg2, gImg1, gPoints2, gPointsFB, gFBStatus); //compute gPointsFB
vector<Point2f> points1, points2;
download(gPoints1, points1);
download(gPoints2, points2);
//Compute the real FB-error
FB_error.clear();
for (int i = 0; i < points1.size(); ++i)
{
FB_error.push_back(norm(pointsFB[i] - points1[i]));
}
//Filter out points with FB_error[i] > mean(FB_error) && points with sim_error[i] > mean(sim_error)
normCrossCorrelation(gImg1, gImg2, gPoints1, gPoints2, points1, points2);
bool retVal = filterPts(points1, points2);
//更新gpu数据
upload(points1, gPoints1);
upload(points2, gPoints2);
return retVal;
}
eVertexBufferDx9::eVertexBufferDx9(IDirect3DDevice9 *d3dDev, IDirect3DVertexDeclaration9 * const d3dVDecls[], eU32 byteSize, eBool dynamic) :
m_d3dVb(eNULL),
m_d3dDev(d3dDev),
m_d3dVDecls(d3dVDecls),
m_byteSize(byteSize),
m_dynamic(dynamic),
m_locked(eFALSE)
{
eASSERT(d3dDev != eNULL);
eASSERT(d3dVDecls != eNULL);
eASSERT(byteSize > 0);
upload();
}
int main(int argc, char** argv) {
xdl::IPXdevLCore core = xdl::createCore();
core->plug(xdl::XdevLPluginName("XdevLComputeDeviceCL"), xdl::XdevLVersion(0,1,0));
auto computeDevice = xdl::createModule<xdl::IPXdevLComputeDevice>(core, xdl::XdevLModuleName("XdevLComputeDevice"), xdl::XdevLID("MyComputeDevice"));
// We need a context.
auto context = computeDevice->createContext();
// We need a command queue to run commands.
auto commandQueue = context->createCommandQueue();
auto program = context->createProgram();
auto inBuffer = context->createBuffer(xdl::XDEVL_COMPUTE_BUFFER_READ_ONLY, sizeof(float) * 10);
auto outBuffer = context->createBuffer(xdl::XDEVL_COMPUTE_BUFFER_WRITE_ONLY, sizeof(float) * 10);
//
// Load and build the kernel.
//
auto kernel = program->compileFromFile(xdl::XdevLFileName("compute_device_demo.cl"), xdl::XdevLString("calculate_sqrt"));
for(int a = 0; a < 100; a++) {
kernel->setArgumentBuffer(0, inBuffer);
kernel->setArgumentBuffer(1, outBuffer);
kernel->setArgumentFloat(2, 2);
inBuffer->upload(commandQueue.get(), sizeof(float) * 10, (xdl::xdl_uint8*)data);
xdl::XdevLComputeExecuteParameter para(commandQueue.get(), kernel.get(), {32});
program->execute(para);
// std::cout << "Before: " << std::endl;
// for(auto item : data) {
// std::cout << item << " : ";
// }
// std::cout << std::endl;
outBuffer->download(commandQueue.get(), sizeof(float) * 10, (xdl::xdl_uint8*)data);
std::cout << "After: " << std::endl;
for(auto item : data) {
std::cout << item << " : ";
}
std::cout << std::endl;
}
xdl::destroyCore(core);
}
int main(int c,char *argv[])
{
char *hostname="sinastorage.com";
char *project="sandbox";
char *remotepath="/ty/test1.c";
char *localpath="new1.c";
char *kid="SYS0000000000SANDBOX";
char *secretkey="1111111111111111111111111111111111111111";
int timeout=1800;
int connecttimeout=2;
upload(hostname,project,remotepath,localpath,kid,secretkey,timeout,connecttimeout);
return 0;
}
void FontTexture::reload()
{
if (!id)
{
FontData *data;
FontAtlas *atlas;
tie(data, atlas) = FontManager::fetchFontDataAndAtlas(inputSource); // CAN THROW
delete data; // WE'RE ONLY INTERESTED IN THE FontAtlas
upload(atlas);
delete atlas;
}
}
bool nTexture::TextureInternal::makeValid(bool force, uint slot) const {
if(!handle) {
handle = new TextureHandle();
modified = true;
}
if(modified) {
if(force || !data) {
upload(slot);
} else {
uploadASync();
}
}
return handle && !modified;
}
int FTPsUPLOAD(BYTE * id,BYTE *pw,BYTE *ip,BYTE * file ,BYTE *RemoName)
{
CURL *curlhandle = NULL;
BYTE str[128];
curl_global_init(CURL_GLOBAL_ALL);
curlhandle = curl_easy_init();
sprintf(str,"ftp://%s:%s@%s/%s",id,pw,ip,RemoName);
upload(curlhandle,str, file, 0, 3);
curl_easy_cleanup(curlhandle);
curl_global_cleanup();
}
void Upload::processQueue()
{
if (m_queue.isEmpty()) {
return;
}
Package const package = m_queue.takeFirst();
if (upload(package)) {
QString const message = QString("File %1 (%2) successfully created and uploaded").arg(package.file.fileName()).arg(Region::fileSize(package.file));
Logger::instance().setStatus(package.region.id(), package.region.name(), "finished", message);
}
deleteFile(package.file);
processQueue();
}
Texture::Texture(const Texture &other)
{
// Copy data
m_width = other.m_width;
m_height = other.m_height;
m_pixels = new unsigned char[3 * m_width * m_height];
m_texIndex = other.m_texIndex;
for(int i = 0; i < 3 * m_width * m_height; i++)
{
m_pixels[i] = other.m_pixels[i];
}
// Upload texture
upload();
}
static GLuint
create_and_bind_fbo(const struct fmt_test *test, GLuint *tex)
{
GLuint fbo;
GLuint fbo_tex = create_and_bind_empty_texture(test);
upload(test, NULL);
*tex = fbo_tex;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, fbo_tex, 0);
return fbo;
}
void Camera::change_look_at_pos(int xrel, int y, int width, int height)
{
if(y==0) {
y = 1;
}
x += xrel;
float fi = ((float)x)/width*2*M_PI;
float theta = ((float)y)/height*M_PI;
look_at_pos.x = -sin(theta)*sin(fi) + position.x;
look_at_pos.y = cos(theta) + position.y;
look_at_pos.z = sin(theta)*cos(fi) + position.z;
*matrix = glm::lookAt(position, look_at_pos, up);
upload();
}
void SshKeyController::upload_key(std::map<int, EnvsSelectState> key_with_selected_envs) {
std::vector<SshKey> tmp = m_keys;
int total = static_cast<int>(key_with_selected_envs.size());
int count = 1;
for (auto state : key_with_selected_envs) {
SshKey key;
size_t index = static_cast<size_t>(state.first);
if (tmp.size() > index)
key = tmp.at(index);
QStringList env_ids;
// get selected environment
for (auto st : state.second.states) {
if (st.second && !key.env_ids.contains(st.first))
env_ids << st.first;
}
qDebug() << "SSH UPLOAD ENV ids:"
<< key.file_name
<< env_ids;
emit progress_ssh_key_rest(count++, total);
if (!env_ids.empty()) {
QThread* thread = new QThread;
Worker* worker = new Worker(key.file_name,
key.content,
env_ids);
worker->moveToThread(thread);
connect(thread, SIGNAL (started()), worker, SLOT (upload()));
connect(worker, &Worker::finished, [env_ids, this]() {
// clean up m_envs
this->clean_environment_list(env_ids);
});
connect(worker, SIGNAL (finished()), thread, SLOT (quit()));
connect(worker, SIGNAL (finished()), worker, SLOT (deleteLater()));
connect(thread, SIGNAL (finished()), thread, SLOT (deleteLater()));
thread->start();
}
}
emit ssh_key_send_finished();
check_key_with_envs();
}
void Camera::rotate(char direction, float angle)
{
switch (direction) {
case 'x':
look_at_pos = glm::rotate(look_at_pos, angle, glm::vec3(1,0,0));
break;
case 'y':
look_at_pos = glm::rotate(look_at_pos, angle, glm::vec3(0,1,0));
break;
case 'z':
look_at_pos = glm::rotate(look_at_pos, angle, glm::vec3(0,0,1));
break;
}
*matrix = glm::lookAt(position, look_at_pos, up);
upload();
}
