コード例 #1
0
ファイル: heap_agent.c プロジェクト: levenkov/olver
static TACommandVerdict posix_memalign_cmd(TAThread thread,TAInputStream stream)
{
    void *memptr;
    size_t alignment;
    size_t size;
    int res;

    // Prepare
    alignment = readSize(&stream);
    size = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = posix_memalign(&memptr, alignment, size);

    END_TARGET_OPERATION(thread);

    // Response
    if (res)
    {
        memptr = NULL;
    }
    
    writePointer(thread, memptr);
    writeInt(thread, res); 
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #2
0
ファイル: heap_agent.c プロジェクト: levenkov/olver
static TACommandVerdict calloc_cmd(TAThread thread,TAInputStream stream)
{
    size_t nelem;
    size_t elsize;
    void* res;

    // Prepare
    nelem = readSize(&stream);
    elsize = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = calloc(nelem, elsize);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    writeInt(thread, errno); 
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #3
0
ファイル: kptydevice.cpp プロジェクト: vasi/kdelibs
    void free(int bytes)
    {
        totalSize -= bytes;
        Q_ASSERT(totalSize >= 0);

        forever {
            int nbs = readSize();

            if (bytes < nbs) {
                head += bytes;
                if (head == tail && buffers.count() == 1) {
                    buffers.first().resize(CHUNKSIZE);
                    head = tail = 0;
                }
                break;
            }

            bytes -= nbs;
            if (buffers.count() == 1) {
                buffers.first().resize(CHUNKSIZE);
                head = tail = 0;
                break;
            }

            buffers.removeFirst();
            head = 0;
        }
    }
コード例 #4
0
ファイル: fifo_agent.c プロジェクト: levenkov/olver
static TACommandVerdict read_fifo_cmd(TAThread thread,TAInputStream stream)
{
    int fildes;
    void* buf;
    size_t nbyte;

    ssize_t res;

    // Prepare
    fildes = readInt(&stream);
    buf    = readPointer(&stream);
    nbyte  = readSize(&stream);

    BEFORE_BLOCKED_TARGET_OPERATION(thread);

    writeString(thread,"Ok");
    sendResponse(thread);
    errno = 0;


    START_TARGET_OPERATION(thread);
    res = read(fildes, buf, nbyte);
    END_TARGET_OPERATION(thread);


    writeDeferredReaction(thread, "read_fifo_return");

    // Response
    writeSSize(thread, res);
    writeInt(thread, errno);
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #5
0
ファイル: wcasecmp_agent.c プロジェクト: levenkov/olver
static TACommandVerdict wcsncasecmp_cmd(TAThread thread,TAInputStream stream)
{
    int res;
    wchar_t *s1;
    wchar_t *s2;
    size_t n;
    
    // Prepare

    s1 = ta_wcsalign(readWString(&stream)); //align on copy
    s2 = ta_wcsalign(readWString(&stream)); //align on copy    
    n = readSize(&stream);
    
    START_TARGET_OPERATION(thread);
    res = wcsncasecmp(s1, s2, n); 
    END_TARGET_OPERATION(thread);
    
    // Response
    
    writeInt(thread,res);
    sendResponse(thread);
    
    ta_dealloc_memory(s1);
    ta_dealloc_memory(s2);

    return taDefaultVerdict;
}
コード例 #6
0
ファイル: sysconf_agent.c プロジェクト: levenkov/olver
static TACommandVerdict confstr_cmd(TAThread thread,TAInputStream stream)
{
    int name;
    size_t res;
    char * buf;
    size_t len;

    /* Prepare */
    name = readInt(&stream);
    buf = (char*)readPointer(&stream);
    len = readSize(&stream);

    /* [ Set errno ] */
    errno = readInt(&stream);

    START_TARGET_OPERATION(thread);

    /* Execute */
    res = confstr(name,buf,len);

    END_TARGET_OPERATION(thread);

    /* Response */
    writeSize(thread, res);
    writeInt(thread, errno);

    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #7
0
ファイル: wstr_agent.c プロジェクト: levenkov/olver
static TACommandVerdict wcsncpy_cmd(TAThread thread, TAInputStream stream)
{
    wchar_t* ws1;
    wchar_t* ws2;
    size_t n;
    wchar_t* res;

    // Prepare
    ws1 = (wchar_t*)readPointer(&stream);
    ws2 = (wchar_t*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = wcsncpy(ws1, ws2, n);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #8
0
ファイル: BasicStream.cpp プロジェクト: wuhua988/icm
bool BasicStream::readDoubleSeq(std::vector<double>& v)
{
  ULong sz;
  readSize(sz);
  if (sz > 0) {
    //checkFixedSeq(sz, static_cast<int> (sizeof(double)));
    Container::iterator begin = i;
    i += sz * static_cast<int> (sizeof(double));
    v.resize(sz);
#ifdef ACE_BIG_ENDIAN
    const Byte* src = &(*begin);
    Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(double) - 1;
    for(int j = 0; j < sz; ++j)
    {
      *dest-- = *src++;
      *dest-- = *src++;
      *dest-- = *src++;
      *dest-- = *src++;
      *dest-- = *src++;
      *dest-- = *src++;
      *dest-- = *src++;
      *dest-- = *src++;
      dest += 2 * sizeof(double);
    }
#else
    std::copy(begin, i, reinterpret_cast<Byte*> (&v[0]));
#endif
  } else {
    v.clear();
  }
  return true;
}
コード例 #9
0
ファイル: str_agent.c プロジェクト: levenkov/olver
static TACommandVerdict strncpy_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t n;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strncpy(s1, s2, n);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #10
0
ファイル: str_agent.c プロジェクト: levenkov/olver
static TACommandVerdict strndup_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    size_t n;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    n = readSize(&stream);
    
   START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = strndup(s,n);

    END_TARGET_OPERATION(thread);
    // Execute

    // Response
    writePointer(thread, res);
    writeInt(thread, errno);
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #11
0
ファイル: wstr_agent.c プロジェクト: levenkov/olver
static TACommandVerdict wcpncpy_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* dest;
    wchar_t* src;
    size_t n;
    wchar_t* res;

    // Prepare
    dest = (wchar_t*)readPointer(&stream);
    src = (wchar_t*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = wcpncpy(dest, src, n);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #12
0
offset_t CThorContiguousRowBuffer::beginNested()
{
    size32_t len = readSize();
    //Currently nested datasets are readahead by skipping the number of bytes in the datasets, rather than calling
    //beginNested(). If this function was ever called from readAhead() then it would need to call noteStartChild()
    //so that the self pointer is correct for the child rows
    return len+readOffset;
}
コード例 #13
0
ファイル: vstpresetfile.cpp プロジェクト: Fooway/ChuckDelay
//------------------------------------------------------------------------
bool PresetFile::readChunkList ()
{
	seekTo (0);
	entryCount = 0;

	char8 classString[kClassIDSize + 1] = {0};

	// Read header
	int32 version = 0;
	TSize listOffset = 0;
	if (!(readEqualID (getChunkID (kHeader)) &&
		 readInt32 (version) &&
		 verify (stream->read (classString, kClassIDSize)) &&
		 readSize (listOffset) &&
		 listOffset > 0 &&
		 seekTo (listOffset)))
		return false;

	classID.fromString (classString);

	// Read list
	int32 count = 0;
	if (!readEqualID (getChunkID (kChunkList)))
		return false;
	if (!readInt32 (count))
		return false;

	if (count > kMaxEntries)
		count = kMaxEntries;

	for (int32 i = 0; i < count; i++)
	{
		Entry& e = entries[i];
		if (!(readID (e.id) &&
			 readSize (e.offset) &&
			 readSize (e.size)))
			break;

		entryCount++;
	}

	return entryCount > 0;
}
コード例 #14
0
ファイル: kptydevice.cpp プロジェクト: vasi/kdelibs
 int read(char *data, int maxLength)
 {
     int bytesToRead = qMin(size(), maxLength);
     int readSoFar = 0;
     while (readSoFar < bytesToRead) {
         const char *ptr = readPointer();
         int bs = qMin(bytesToRead - readSoFar, readSize());
         memcpy(data + readSoFar, ptr, bs);
         readSoFar += bs;
         free(bs);
     }
     return readSoFar;
 }
コード例 #15
0
ファイル: BasicStream.cpp プロジェクト: wuhua988/icm
bool BasicStream::readByteSeq(std::vector<Byte>& v)
{
  ULong sz;
  readSize(sz);
  if(sz > 0) {
    //vector<Byte> (i, i + sz).swap(v);
    i += sz;
  } else {
    v.clear();
  }

  return true;
}
コード例 #16
0
ファイル: wcollate_agent.c プロジェクト: levenkov/olver
static TACommandVerdict wcsxfrm_cmd(TAThread thread, TAInputStream stream)
{
    wchar_t* ws1;
    wchar_t* ws2;
    wchar_t* xxx = L"";
    size_t n;
    size_t res;
    int save_errno;
    int overflow = 0;
    int i;

    // Prepare
    ws2 = ta_wcsalign(readWString(&stream)); //align on copy
    n = readSize(&stream);
    ws1 = ta_alloc_memory((n + BUFFER_TAIL) * sizeof(wchar_t));
    for (i=0; i<BUFFER_TAIL; ++i)
        ws1[n + i] = (wchar_t)0xDDDDDDDD;

    START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = wcsxfrm(ws1, ws2, n);
    save_errno = errno;

    END_TARGET_OPERATION(thread);

    for (i=0; i<BUFFER_TAIL; ++i)
        overflow |= (ws1[n + i] != (wchar_t)0xDDDDDDDD);

    if (overflow)
    {
        sendException(thread, "wcsxfrm.02 failed: writing outside of buffer limits occured!");
        return taDefaultVerdict;
    }

    // Response
    if (res >= n)
        writeWString(thread, xxx);
    else
        writeWString(thread, ws1);
    writeSize(thread, res);
    writeInt(thread, save_errno);

    sendResponse(thread);

    ta_dealloc_memory(ws1);
    ta_dealloc_memory(ws2);

    return taDefaultVerdict;
}
コード例 #17
0
ファイル: iconv_agent.c プロジェクト: levenkov/olver
static TACommandVerdict iconv_cmd(TAThread thread, TAInputStream stream)
{
    iconv_t cd;
    char* inbuf;
    char* outbuf;
    size_t inbytesleft;
    size_t outbytesleft;
    size_t res;
    int save_errno;

    // Prepare
    cd = (iconv_t)readPointer(&stream);
    inbuf = (char*)readPointer(&stream);
    inbytesleft = readSize(&stream);
    outbuf = (char*)readPointer(&stream);
    outbytesleft = readSize(&stream);

	errno = 0;

    START_TARGET_OPERATION(thread);

    // Execute
    res = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
    save_errno = errno;

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    writePointer(thread, inbuf);
    writeSize(thread, inbytesleft);
    writePointer(thread, outbuf);
    writeSize(thread, outbytesleft);
    writeInt(thread, save_errno);
    sendResponse(thread);

    return taDefaultVerdict;
}
コード例 #18
0
ファイル: BasicStream.cpp プロジェクト: wuhua988/icm
bool BasicStream::readBoolSeq(std::vector<bool> &v)
{
  ULong sz;
  readSize(sz);
  if(sz > 0) {
    v.resize(sz);
    copy(i, i + sz, v.begin());
    i += sz;
  } else {
    v.clear();
  }

  return true;
}
コード例 #19
0
ファイル: group_agent.c プロジェクト: levenkov/olver
static TACommandVerdict getgrgid_r_cmd(TAThread thread,TAInputStream stream)
{
    int res;
    gid_t gid;
    struct group *grp;
    char *buffer;
    size_t bufsize;
    struct group *result;
    int i=0;
    
    gid = readInt(&stream);
    grp = (struct group *)readPointer(&stream);
    bufsize = readSize(&stream);
    buffer=(char *) ta_alloc_memory(bufsize*sizeof(char));
    
    errno = 0;

    START_TARGET_OPERATION_WHICH_MAY_CONTAIN_CANCELPOINT(thread);
    res = getgrgid_r(gid, grp, buffer, bufsize, &result); 
    
    END_TARGET_OPERATION_WHICH_MAY_CONTAIN_CANCELPOINT(thread);
    
    writeInt(thread, res);
    writeInt(thread,errno);
    writePointer(thread,(void*)result);
    
    if(result)
    {
        writeString(thread, result->gr_name);
        writeInt(thread, result->gr_gid);
        while ((result->gr_mem)[i]!=NULL)
        {
            i++;
        }
        writeInt(thread, i);
        i=0;
        while ((result->gr_mem)[i]!=NULL)
        {
            writeString(thread, (result->gr_mem)[i]);
            i++;
        }
    } 
    
    
    sendResponse(thread);
    ta_dealloc_memory(buffer);
    return taDefaultVerdict;

}
コード例 #20
0
ファイル: fifo_agent.c プロジェクト: levenkov/olver
static TACommandVerdict writev_fifo_cmd(TAThread thread,TAInputStream stream)
{
    int fildes;
    int size;
    int i=0;
    void* curPointer;
    size_t curSize;
    struct iovec *iov;
    ssize_t res;


    // Prepare
    fildes = readInt(&stream);
    size = readInt(&stream);

    iov=(struct iovec *)ta_alloc_memory(size*sizeof(struct iovec));

    for (i=0;i<size;i++)
    {
        curPointer=readPointer(&stream);
        curSize=readSize(&stream);
        iov[i].iov_base=curPointer;
        iov[i].iov_len=curSize;
    }

    BEFORE_BLOCKED_TARGET_OPERATION(thread);

    writeString(thread,"Ok");
    sendResponse(thread);
    errno = 0;


    START_TARGET_OPERATION(thread);
    res = writev(fildes, iov, size);
    END_TARGET_OPERATION(thread);


    writeDeferredReaction(thread, "writev_fifo_return");

    // Response
    writeSSize(thread,res);
    writeInt(thread,errno);
    sendResponse(thread);

    ta_dealloc_memory(iov);

    return taDefaultVerdict;
}
コード例 #21
0
ファイル: SoundBuffer.cpp プロジェクト: agudpp/CordobaZombie
long long int
StreamWAVSoundBuffer::filler(ALBuffer& buf, size_t size, bool repeat)
{
	std::streamsize readSize(0);

	/* Try to read 'size' bytes into temp. array */
	if (file->eof()) {
		if (repeat) {
			file->seekg(dataStart);
			ASSERT(file->good() && !file->eof());
		} else {
			return 0ll;
		}
	}
	file->read(pcmData, size);

	/* EOF? */
	readSize = file->gcount();
	if (readSize >= 0 && readSize < size && repeat) {

		/* Must repeat: continue loading from the beginning. */
		file->seekg(dataStart);
		ASSERT(file->good() && !file->eof());

		file->read(&pcmData[readSize], size-readSize);
		if (readSize + file->gcount() < size) {
			debug("Couldn't extract %zu bytes from file.\n", size);
		}

		if (file->gcount() < 0) {
			debugERROR("Problems reading data from file.%s", "\n");
			return -1ll;
		} else {
			readSize += file->gcount();
		}
	} else if (readSize < 0) {
		debugERROR("Problems reading data from file.%s", "\n");
		return -1ll;
	}

	alBufferData(buf, format, pcmData, readSize, freq);

	if (alGetError() != AL_NO_ERROR) {
		return -1ll;
	}
	return ((long long int)readSize);
}
コード例 #22
0
ファイル: BasicStream.cpp プロジェクト: wuhua988/icm
bool BasicStream::readString(std::string& v)
{
  ULong sz;
  readSize(sz);
  if (sz > 0) {
    if (b.end() - i < (int)sz) {
      //throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
      return false;
    }
    //string(reinterpret_cast<const char*> (&*i), reinterpret_cast<const char*> (&*i) + sz).swap(v);
    //	v.assign(reinterpret_cast<const char*>(&(*i)), sz);
    i += sz;
  } else {
    v.clear();
  }
  return true;
}
コード例 #23
0
ファイル: BasicStream.cpp プロジェクト: wuhua988/icm
bool BasicStream::readStringSeq(std::vector<std::string>& v)
{
  ULong sz;
  readSize(sz);
  if (sz > 0) {
    //startSeq(sz, 1);
    v.resize(sz);
    for (ULong i = 0; i < sz; ++i) {
      readString(v[i]);
      //checkSeq();
      //endElement();
    }
    //endSeq(sz);
  } else {
    v.clear();
  }
  return true;
}
コード例 #24
0
ファイル: main.c プロジェクト: rodrigocarlos2/DBWithC
int main() {
	
	int *vector, size;
	
	readSize(&size);
	
	vector = (int *)malloc(size*sizeof(int));
	
	if(vector==NULL){
		exit(1);
	}
	
	readVector(vector, size);
	
	bubble_sort(vector, size);
	
	showVector(vector, size);
	
	free(vector);
	
	return 0;
}
コード例 #25
0
ファイル: wmem_agent.c プロジェクト: levenkov/olver
static TACommandVerdict wmemchr_cmd(TAThread thread,TAInputStream stream)
{
    wchar_t* s;
    wchar_t c;
    size_t n;
    wchar_t* res;
    
    // Prepare
    s = readPointer(&stream);
    c = readWChar(&stream);
    n = readSize(&stream);
    
    // Execute
    START_TARGET_OPERATION(thread);
    res = wmemchr( s, c, n );
    END_TARGET_OPERATION(thread);
    
    // Response
    writePointer(thread,res);
    sendResponse(thread);
    
    return taDefaultVerdict;
}
コード例 #26
0
void
CopyableCanvasLayer::UpdateSurface(gfxASurface* aDestSurface, Layer* aMaskLayer)
{
  if (!IsDirty())
    return;
  Painted();

  if (mDrawTarget) {
    mDrawTarget->Flush();
    if (mDrawTarget->GetType() == BACKEND_COREGRAPHICS_ACCELERATED) {
      // We have an accelerated CG context which has changed, unlike a bitmap surface
      // where we can alias the bits on initializing the mDrawTarget, we need to readback
      // and copy the accelerated surface each frame. We want to support this for quick
      // thumbnail but if we're going to be doing this every frame it likely is better
      // to use a non accelerated (bitmap) canvas.
      mSurface = gfxPlatform::GetPlatform()->GetThebesSurfaceForDrawTarget(mDrawTarget);
    }
  }

  if (!mGLContext && aDestSurface) {
    nsRefPtr<gfxContext> tmpCtx = new gfxContext(aDestSurface);
    tmpCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
    CopyableCanvasLayer::PaintWithOpacity(tmpCtx, 1.0f, aMaskLayer);
    return;
  }

  if (mGLContext) {
    if (aDestSurface && aDestSurface->GetType() != gfxASurface::SurfaceTypeImage) {
      MOZ_ASSERT(false, "Destination surface must be ImageSurface type.");
      return;
    }

    nsRefPtr<gfxImageSurface> readSurf;
    nsRefPtr<gfxImageSurface> resultSurf;

    SharedSurface* sharedSurf = mGLContext->RequestFrame();
    if (!sharedSurf) {
      NS_WARNING("Null frame received.");
      return;
    }

    gfxIntSize readSize(sharedSurf->Size());
    gfxImageFormat format = (GetContentFlags() & CONTENT_OPAQUE)
                            ? gfxASurface::ImageFormatRGB24
                            : gfxASurface::ImageFormatARGB32;

    if (aDestSurface) {
      resultSurf = static_cast<gfxImageSurface*>(aDestSurface);
    } else {
      resultSurf = GetTempSurface(readSize, format);
    }
    MOZ_ASSERT(resultSurf);
    if (resultSurf->CairoStatus() != 0) {
      MOZ_ASSERT(false, "Bad resultSurf->CairoStatus().");
      return;
    }

    MOZ_ASSERT(sharedSurf->APIType() == APITypeT::OpenGL);
    SharedSurface_GL* surfGL = SharedSurface_GL::Cast(sharedSurf);

    if (surfGL->Type() == SharedSurfaceType::Basic) {
      SharedSurface_Basic* sharedSurf_Basic = SharedSurface_Basic::Cast(surfGL);
      readSurf = sharedSurf_Basic->GetData();
    } else {
      if (resultSurf->Format() == format &&
          resultSurf->GetSize() == readSize)
      {
        readSurf = resultSurf;
      } else {
        readSurf = GetTempSurface(readSize, format);
      }

      // Readback handles Flush/MarkDirty.
      mGLContext->Screen()->Readback(surfGL, readSurf);
    }
    MOZ_ASSERT(readSurf);

    bool needsPremult = surfGL->HasAlpha() && !mIsGLAlphaPremult;
    if (needsPremult) {
      gfxImageSurface* sizedReadSurf = nullptr;
      if (readSurf->Format()  == resultSurf->Format() &&
          readSurf->GetSize() == resultSurf->GetSize())
      {
        sizedReadSurf = readSurf;
      } else {
        readSurf->Flush();
        nsRefPtr<gfxContext> ctx = new gfxContext(resultSurf);
        ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
        ctx->SetSource(readSurf);
        ctx->Paint();

        sizedReadSurf = resultSurf;
      }
      MOZ_ASSERT(sizedReadSurf);

      readSurf->Flush();
      resultSurf->Flush();
      gfxUtils::PremultiplyImageSurface(readSurf, resultSurf);
      resultSurf->MarkDirty();
    } else if (resultSurf != readSurf) {
      // Didn't need premult, but we do need to blit to resultSurf
      readSurf->Flush();
      nsRefPtr<gfxContext> ctx = new gfxContext(resultSurf);
      ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
      ctx->SetSource(readSurf);
      ctx->Paint();
    }

    // stick our surface into mSurface, so that the Paint() path is the same
    if (!aDestSurface) {
      mSurface = resultSurf;
    }
  }
}
コード例 #27
0
    void RPIImageDecoder::decode(bool onlySize)
    {
        unsigned int width, height;

        if (failed())
            return;

        // make sure we have all the data before doing anything
        if (!isAllDataReceived())
            return;

        if (onlySize)
        {
            if (readSize(width, height));
            {
                setSize(width, height);
            }
            return;
        }
        else
        {
            readSize(width, height);

            clock_t start = clock();

            ImageFrame& buffer = m_frameBufferCache[0];

            if (m_frameBufferCache.isEmpty())
            {
                log("decode : frameBuffercache is empty");
                setFailed();
                return;
            }

            if (buffer.status() == ImageFrame::FrameEmpty)
            {
                if (!buffer.setSize(width, height))
                {
                    log("decode : could not define buffer size");
                    setFailed();
                    return;
                }

                // The buffer is transparent outside the decoded area while the image is
                // loading. The completed image will be marked fully opaque in jpegComplete().
                buffer.setHasAlpha(false);
            }

            // lock the mutex so that we only process once at a time
            pthread_mutex_lock(&decode_mutex);

            // setup decoder request information
            BRCMIMAGE_REQUEST_T* dec_request = getDecoderRequest();
            BRCMIMAGE_T *decoder = getDecoder();

            memset(dec_request, 0, sizeof(BRCMIMAGE_REQUEST_T));
            dec_request->input = (unsigned char*)m_data->data();
            dec_request->input_size = m_data->size();
            dec_request->output = (unsigned char*)buffer.getAddr(0, 0);
            dec_request->output_alloc_size = width * height * 4;
            dec_request->output_handle = 0;
            dec_request->pixel_format = PIXEL_FORMAT_RGBA;
            dec_request->buffer_width = 0;
            dec_request->buffer_height = 0;

            brcmimage_acquire(decoder);
            BRCMIMAGE_STATUS_T status = brcmimage_process(decoder, dec_request);

            if (status == BRCMIMAGE_SUCCESS)
            {
                clock_t copy = clock();

                unsigned char *ptr = (unsigned char *)buffer.getAddr(0, 0);
                for (unsigned int i = 0; i < dec_request->height * dec_request->width; i++)
                {
                    // we swap RGBA -> BGRA
                    unsigned char tmp = *ptr;
                    *ptr = ptr[2];
                    ptr[2] = tmp;
                    ptr += 4;
                }

                brcmimage_release(decoder);

                buffer.setPixelsChanged(true);
                buffer.setStatus(ImageFrame::FrameComplete);
                buffer.setHasAlpha(m_hasAlpha);

                clock_t end = clock();
                unsigned long millis = (end - start) * 1000 / CLOCKS_PER_SEC;
                unsigned long copymillis = (end - copy) * 1000 / CLOCKS_PER_SEC;

                log("decode : image (%d x %d)(Alpha=%d) decoded in %d ms (copy in %d ms), source size = %d bytes", width, height, m_hasAlpha, millis, copymillis, m_data->size());

            }
            else
            {
                log("decode : Decoding failed with status %d", status);
            }

            pthread_mutex_unlock(&decode_mutex);
        }


    }
コード例 #28
0
ファイル: asn_sequence.cpp プロジェクト: macklo/PROI_ASN
int asn_sequence::readAll(std::istream& istr){
	if(!checkTag(istr))
		return -1;
	if(!readSize(istr))
		return -1;
	int readOctets = 2;
	int charleft = size;
	if(elements.empty()){
		while (charleft > 0){
			int tmptag = read(istr), x;
			if (tmptag < 0) {
				istr.clear();
				istr.seekg(0);
				writeable = 0;
				return -1;
			}
			istr.unget();
			istr.unget();
			if(tmptag==2){
				asn_int *tmpi = new asn_int;
				x = tmpi->readAll(istr);
				if(x <0) return -1;
				charleft = charleft-x;
				readOctets += x;
				addElement(tmpi);
			}
			else if(tmptag==19){
				asn_string *tmps = new asn_string;
				x = tmps->readAll(istr);
				if(x <0) return -1;
				charleft = charleft-x;
				readOctets += x;
				addElement(tmps);
			}
			else if(tmptag==48){
				asn_sequence *tmpss = new asn_sequence;
				x = tmpss->readAll(istr);
				if(x <0) return -1;
				charleft =charleft-x;
				readOctets += x;
				addElement(tmpss);
			}
			else{
				istr.clear();
				istr.seekg(0);
				writeable = 0;
				return -1;
			}
		}
		writeable = 1;
		return readOctets;
	}
	else{
		for (std::vector<asn_object*>::iterator it = elements.begin() ; it != elements.end(); ++it){
			int x = (*it)->readAll(istr);
			if (x<0){
				istr.clear();
				istr.seekg(0);
				/*
				for(int i = 0; i<readOctets; i++){
					istr.unget();
					istr.unget();
				}*/
				return -1;
			}
			readOctets += x;
		}
		writeable = 1;
		return readOctets;
	}
}
コード例 #29
0
bool
ShareableCanvasRenderer::UpdateTarget(DrawTarget* aDestTarget)
{
  MOZ_ASSERT(aDestTarget);
  if (!aDestTarget) {
    return false;
  }

  RefPtr<SourceSurface> surface;

  if (!mGLContext) {
    AutoReturnSnapshot autoReturn;

    if (mAsyncRenderer) {
      surface = mAsyncRenderer->GetSurface();
    } else if (mBufferProvider) {
      surface = mBufferProvider->BorrowSnapshot();
      autoReturn.mSnapshot = &surface;
      autoReturn.mBufferProvider = mBufferProvider;
    }

    MOZ_ASSERT(surface);
    if (!surface) {
      return false;
    }

    aDestTarget->CopySurface(surface,
                             IntRect(0, 0, mSize.width, mSize.height),
                             IntPoint(0, 0));
    return true;
  }

  gl::SharedSurface* frontbuffer = nullptr;
  if (mGLFrontbuffer) {
    frontbuffer = mGLFrontbuffer.get();
  } else {
    gl::GLScreenBuffer* screen = mGLContext->Screen();
    const auto& front = screen->Front();
    if (front) {
      frontbuffer = front->Surf();
    }
  }

  if (!frontbuffer) {
    NS_WARNING("Null frame received.");
    return false;
  }

  IntSize readSize(frontbuffer->mSize);
  SurfaceFormat format =
    mOpaque ? SurfaceFormat::B8G8R8X8 : SurfaceFormat::B8G8R8A8;
  bool needsPremult = frontbuffer->mHasAlpha && !mIsAlphaPremultiplied;

  // Try to read back directly into aDestTarget's output buffer
  uint8_t* destData;
  IntSize destSize;
  int32_t destStride;
  SurfaceFormat destFormat;
  if (aDestTarget->LockBits(&destData, &destSize, &destStride, &destFormat)) {
    if (destSize == readSize && destFormat == format) {
      RefPtr<DataSourceSurface> data =
        Factory::CreateWrappingDataSourceSurface(destData, destStride, destSize, destFormat);
      if (!mGLContext->Readback(frontbuffer, data)) {
        aDestTarget->ReleaseBits(destData);
        return false;
      }
      if (needsPremult) {
        gfxUtils::PremultiplyDataSurface(data, data);
      }
      aDestTarget->ReleaseBits(destData);
      return true;
    }
    aDestTarget->ReleaseBits(destData);
  }

  RefPtr<DataSourceSurface> resultSurf = GetTempSurface(readSize, format);
  // There will already be a warning from inside of GetTempSurface, but
  // it doesn't hurt to complain:
  if (NS_WARN_IF(!resultSurf)) {
    return false;
  }

  // Readback handles Flush/MarkDirty.
  if (!mGLContext->Readback(frontbuffer, resultSurf)) {
    return false;
  }
  if (needsPremult) {
    gfxUtils::PremultiplyDataSurface(resultSurf, resultSurf);
  }

  aDestTarget->CopySurface(resultSurf,
                           IntRect(0, 0, readSize.width, readSize.height),
                           IntPoint(0, 0));

  return true;
}
コード例 #30
0
ファイル: property.cpp プロジェクト: johey/MuseScore
QVariant getProperty(P_ID id, const QDomElement& e)
      {
      const QString& value(e.text());
      switch(propertyType(id)) {
            case T_BOOL:
                  return QVariant(bool(value.toInt()));
            case T_SUBTYPE:
            case T_INT:
                  return QVariant(value.toInt());
            case T_REAL:
            case T_SREAL:
                  return QVariant(value.toDouble());
            case T_FRACTION:
                  return QVariant::fromValue(readFraction(e));
            case T_COLOR:
                  return QVariant(readColor(e));
            case T_POINT:
                  return QVariant(readPoint(e));
            case T_SCALE:
            case T_SIZE:
                  return QVariant(readSize(e));
            case T_STRING:
                  return QVariant(value);
            case T_DIRECTION:
                  {
                  if (value == "up")
                        return QVariant(MScore::UP);
                  else if (value == "down")
                        return QVariant(MScore::DOWN);
                  else if (value == "auto")
                        return QVariant(MScore::AUTO);
                  }
                  break;
            case T_DIRECTION_H:
                  {
                  if (value == "left")
                        return QVariant(MScore::DH_LEFT);
                  else if (value == "right")
                        return QVariant(MScore::DH_RIGHT);
                  else if (value == "auto")
                        return QVariant(MScore::DH_AUTO);
                  }
                  break;
            case T_LAYOUT_BREAK:
                  if (value == "line")
                        return QVariant(int(LAYOUT_BREAK_LINE));
                  if (value == "page")
                        return QVariant(int(LAYOUT_BREAK_PAGE));
                  if (value == "section")
                        return QVariant(int(LAYOUT_BREAK_SECTION));
                  qDebug("getProperty: invalid T_LAYOUT_BREAK: <%s>", qPrintable(value));
                  break;
            case T_VALUE_TYPE:
                  if (value == "offset")
                        return QVariant(int(MScore::OFFSET_VAL));
                  else if (value == "user")
                        return QVariant(int(MScore::USER_VAL));
                  break;
            case T_BEAM_MODE:             // TODO
                  return QVariant(int(0));
            }
      return QVariant();
      }