Exemple #1
0
void cStream::allocateArrays()
{
  if( mArraysAreAllocated )
  {
#ifdef vs2005
    a = (double*)_aligned_realloc( a, N * sizeof(double), 16 );
    b = (double*)_aligned_realloc( b, N * sizeof(double), 16 );
    c = (double*)_aligned_realloc( c, N * sizeof(double), 16 );
#else
    free( a );
    free( b );
    free( c );
  #ifdef windowos
    a = (double*)malloc( N * sizeof(double) );
    b = (double*)malloc( N * sizeof(double) );
    c = (double*)malloc( N * sizeof(double) );
  #else
    a = (double*)valloc( N * sizeof(double) );
    b = (double*)valloc( N * sizeof(double) );
    c = (double*)valloc( N * sizeof(double) );
  #endif
#endif
  } else
  {
#ifdef vs2005
    // allocate memory from heap for arrays
    a = (double*)_aligned_malloc( N * sizeof(double), 16 );
    b = (double*)_aligned_malloc( N * sizeof(double), 16 );
    c = (double*)_aligned_malloc( N * sizeof(double), 16 );
    bytes = (double*)_aligned_malloc( 4 * sizeof(double), 16 );
#else
    // obtain clock update frequency:
    freq = CLOCKS_PER_SEC;
    // allocate memory from heap for arrays
    #ifdef windowsos
     a = (double*)malloc( N * sizeof(double) );
     b = (double*)malloc( N * sizeof(double) );
     c = (double*)malloc( N * sizeof(double) );
     bytes = (double*)_malloc( 4 * sizeof(double) );
    #else
     a = (double*)valloc( N * sizeof(double) );
     b = (double*)valloc( N * sizeof(double) );
     c = (double*)valloc( N * sizeof(double) );
     bytes = (double*)valloc( 4 * sizeof(double) );
    #endif
#endif
  }
  bytes[ eCopy  ] = 2 * sizeof(double) * N;
  bytes[ eScale ] = 2 * sizeof(double) * N;
  bytes[ eAdd   ] = 3 * sizeof(double) * N;
  bytes[ eTriad ] = 3 * sizeof(double) * N;
  mArraysAreAllocated = true;
} // void cStream::allocateArrays()
Exemple #2
0
//! \brief Reallocates \a sz bytes of memory on a 16 byte boundary, optionally tracking the allocation
void* xsAlignedRealloc(void* ptr, size_t sz)
{
#ifdef TRACK_ALLOCS
	lastFreeIdx = (lastAlignedFreeIdx + 1) & (TRACK_ALLOCS-1);
	lastAlignedFrees[lastAlignedFreeIdx] = ptr;

	ptr = _aligned_realloc(ptr, sz, 16);
	lastAlignedAllocIdx = (lastAlignedAllocIdx + 1) & (TRACK_ALLOCS-1);
	lastAlignedAllocs[lastAlignedAllocIdx] = ptr;
	return ptr;
#else
	return _aligned_realloc(ptr, sz, 16);
#endif
}
Exemple #3
0
void wf_Bitmap_Decompress(wfContext* wfc, rdpBitmap* bitmap,
		BYTE* data, int width, int height, int bpp, int length, BOOL compressed, int codecId)
{
	int status;
	UINT16 size;
	BYTE* pSrcData;
	BYTE* pDstData;
	UINT32 SrcSize;
	UINT32 SrcFormat;
	UINT32 bytesPerPixel;

	bytesPerPixel = (bpp + 7) / 8;
	size = width * height * 4;

	if (!bitmap->data)
		bitmap->data = (BYTE*) _aligned_malloc(size, 16);
	else
		bitmap->data = (BYTE*) _aligned_realloc(bitmap->data, size, 16);

	pSrcData = data;
	SrcSize = (UINT32) length;
	pDstData = bitmap->data;

	if (compressed)
	{
		if (bpp < 32)
		{
			if (!freerdp_client_codecs_prepare(wfc->codecs, FREERDP_CODEC_INTERLEAVED))
				return;

			status = interleaved_decompress(wfc->codecs->interleaved, pSrcData, SrcSize, bpp,
					&pDstData, PIXEL_FORMAT_XRGB32, width * 4, 0, 0, width, height, NULL);
		}
		else
		{
			if (!freerdp_client_codecs_prepare(wfc->codecs, FREERDP_CODEC_PLANAR))
				return;

			status = planar_decompress(wfc->codecs->planar, pSrcData, SrcSize, &pDstData,
					PIXEL_FORMAT_XRGB32, width * 4, 0, 0, width, height, TRUE);
		}

		if (status < 0)
		{
			WLog_ERR(TAG, "Bitmap Decompression Failed");
			return;
		}
	}
	else
	{
		SrcFormat = gdi_get_pixel_format(bpp, TRUE);

		status = freerdp_image_copy(pDstData, PIXEL_FORMAT_XRGB32, width * 4, 0, 0,
				width, height, pSrcData, SrcFormat, width * bytesPerPixel, 0, 0, NULL);
	}

	bitmap->compressed = FALSE;
	bitmap->length = size;
	bitmap->bpp = 32;
}
void *rax_realloc(void *p, size_t size, boolean needsMemoryAlignment) 
{  
  //it's actually not that easy to implement an aligned realloc
  //because we need to know the size of the array pointed to by 
  //the pointer passed as argument
  //hence I added this boolean flag that should increase programmer 
  //awareness about this issue
  void 
    *ptr = (void *)NULL;

  if(needsMemoryAlignment)
    {
      assert(0);
      return (void*)NULL;
    }
  else
    {
#ifndef WIN32      
      ptr = realloc(p, size);
#else
      ptr = _aligned_realloc(p, size, BYTE_ALIGNMENT);
#endif
    }

  if(ptr == (void*)NULL) 
    {
      outOfMemory();
      assert(0);
    }

  return ptr;
}
Exemple #5
0
void *av_realloc(void *ptr, size_t size)
{
#if CONFIG_MEMALIGN_HACK
    int diff;
#endif

    /* let's disallow possibly ambiguous cases */
    if (size > (max_alloc_size - 32))
        return NULL;

#if CONFIG_MEMALIGN_HACK
    //FIXME this isn't aligned correctly, though it probably isn't needed
    if (!ptr)
        return av_malloc(size);
    diff = ((char *)ptr)[-1];
    av_assert0(diff>0 && diff<=ALIGN);
    ptr = realloc((char *)ptr - diff, size + diff);
    if (ptr)
        ptr = (char *)ptr + diff;
    return ptr;
#elif HAVE_ALIGNED_MALLOC
    return _aligned_realloc(ptr, size + !size, ALIGN);
#else
    return realloc(ptr, size + !size);
#endif
}
static void* _memory_reallocate_malloc( void* p, uint64_t size, unsigned int align )
{
	align = _memory_get_align( align );
#if FOUNDATION_PLATFORM_WINDOWS
	return _aligned_realloc( p, (size_t)size, align );
#else
	if( align )
	{
		//No realloc aligned available
		void* memory = aligned_alloc( align, (size_t)size );
		if( !memory )
		{
			log_panicf( ERROR_OUT_OF_MEMORY, "Unable to reallocate memory: %s", system_error_message( 0 ) );
			return 0;
		}
		if( p )
		{
			size_t prev_size = malloc_usable_size( p );
			memcpy( memory, p, ( size < prev_size ) ? size : prev_size );
		}
		return memory;
	}
	return realloc( p, (size_t)size );
#endif
}
Exemple #7
0
void wf_Bitmap_Decompress(wfContext* wfc, rdpBitmap* bitmap,
		BYTE* data, int width, int height, int bpp, int length, BOOL compressed, int codec_id)
{
	UINT16 size;

	size = width * height * (bpp / 8);

	if (!bitmap->data)
		bitmap->data = (BYTE*) _aligned_malloc(size, 16);
	else
		bitmap->data = (BYTE*) _aligned_realloc(bitmap->data, size, 16);

	if (compressed)
	{
		BOOL status;

		status = bitmap_decompress(data, bitmap->data, width, height, length, bpp, bpp);

		if (status != TRUE)
		{
			fprintf(stderr, "Bitmap Decompression Failed\n");
		}
	}
	else
	{
		freerdp_image_flip(data, bitmap->data, width, height, bpp);
	}

	bitmap->compressed = FALSE;
	bitmap->length = size;
	bitmap->bpp = bpp;
}
Exemple #8
0
void *jl_gc_managed_realloc(void *d, size_t sz, size_t oldsz, int isaligned)
{
    if (allocd_bytes > collect_interval)
        jl_gc_collect();
    sz = (sz+15) & -16;
    void *b;
#ifdef _P64
    b = realloc(d, sz);
#elif defined(_OS_WINDOWS_)
    if (isaligned)
        b = _aligned_realloc(d, sz, 16);
    else
        b = realloc(d, sz);
#elif defined(__APPLE__)
    b = realloc(d, sz);
#else
    // TODO better aligned realloc here
    b = malloc_a16(sz);
    if (b != NULL) {
        memcpy(b, d, oldsz);
        if (isaligned) free_a16(d);
        else free(d);
    }
#endif
    if (b == NULL)
        jl_throw(jl_memory_exception);
    allocd_bytes += sz;
    return b;
}
Exemple #9
0
  //============================================================================
  inline byte* reallocate ( byte* ptr
                          , std::size_t nbytes
                          , std::size_t obytes
                          , std::size_t align
                          )
  {
    byte* result(ptr);

    if( (obytes < nbytes) || !is_aligned(ptr,align) )
    {
      #if defined(BOOST_MSVC)
      //========================================================================
      // MSVC systems use _aligned_realloc
      //========================================================================
      if( !(  result
           =  reinterpret_cast<byte*>(_aligned_realloc(ptr, nbytes, align))
           )
        )
      {
        BOOST_THROW_EXCEPTION( std::bad_alloc() );
        result = 0;
      }
      #else
      //========================================================================
      // Other systems allocate/copy/deallocate
      //========================================================================
      byte* tmp = allocate(nbytes, align);
      std::memcpy(tmp,ptr,obytes);
      deallocate(ptr,obytes,align);
      result = tmp;
      #endif
    }

    return result;
  }
void *__cilkrts_realloc(void *ptr, size_t size)
{
#ifdef _WIN32
    return _aligned_realloc(ptr, size, PREFERRED_ALIGNMENT);
#else
    return realloc(ptr, size);
#endif
}
Exemple #11
0
void* Aligned_Realloc(void* ptr, size_t size, size_t align)
{
#ifdef __GNUC__
	return posix_memalign(ptr, align, size);
#else
	return _aligned_realloc(ptr, size, align);
#endif
}
Exemple #12
0
void* tsk_realloc_aligned(void * ptr, tsk_size_t size, tsk_size_t alignment)
{
#if TSK_UNDER_WINDOWS && !TSK_UNDER_WINDOWS_CE && !TSK_UNDER_WINDOWS_RT
	return _aligned_realloc(ptr, size, alignment);
#else
	tsk_free_aligned(ptr);
	return tsk_malloc_aligned(size, alignment);
#endif
}
      bool aligned_reallocate(block &b, size_t n) noexcept
      {
        block reallocatedBlock{ _aligned_realloc(b.ptr, n, alignment), n };

        if (reallocatedBlock) {
          b = reallocatedBlock;
          return true;
        }
        return false;
      }
Exemple #14
0
void *av_realloc(void *ptr, unsigned int size)
{
    /* let's disallow possible ambiguous cases */
    if(size > (INT_MAX-16) )
        return NULL;

#ifndef __GNUC__
    return _aligned_realloc(ptr, size,16);
#else
    return __mingw_aligned_realloc(ptr, size,16);
#endif
}
Exemple #15
0
void    FCDECL  exaligned_mrealloc (void** p,
                 size_t blocksize, size_t blockalign,
                 size_t memset_start, size_t memset_stop)
{
    void* pp = *p;

    if (blocksize)
    {
        while (blocksize > EXCALCBLOCKSIZE_MAX - blockalign ||
              (pp = _aligned_realloc (*p, blocksize, blockalign))
              == NULL)
        {
            void (*pvf) (void) = set_exalloc_handler (NULL);
            set_exalloc_handler (pvf);
            if (pvf != NULL) { (*pvf)(); continue; }

            (*exalloc_status.size_handler)();
            exalloc_status.nBlocksFailed++;
            return;
        }

        if (((size_t)pp & (blockalign - 1)) != 0) {}

        if (pp != NULL)
        {
            exalloc_status.nBlocksAllocated++;
        }

        if (memset_stop > memset_start)
        {
             memset ((char*)pp + memset_start, 0,
                   memset_stop - memset_start);
        }

        if (exalloc_status.pMinAlloc - 1 >= (char*) pp)
        {
            exalloc_status.pMinAlloc = (char*)pp;
        }
        if (exalloc_status.pMaxAlloc < (char*)pp + blocksize)
        {
            exalloc_status.pMaxAlloc = (char*)pp + blocksize;
        }
    }

    else if (pp)
    {
        _aligned_free (pp); pp = NULL;
        exalloc_status.nBlocksAllocated--;
    }

    *p = pp;
}
Exemple #16
0
void* FF_aligned_realloc(void *ptr,size_t size,size_t alignment)
{
	if (!ptr)
		return FF_aligned_malloc(size,alignment);
	else
		if (size==0)
		{
			FF_aligned_free(ptr);
			return NULL;
		}
		else
			return _aligned_realloc(ptr,size,alignment);
}
N1527MALLOCNOALIASATTR N1527MALLOCPTRATTR void *n1527_aligned_realloc(void *ptr, size_t alignment, size_t size)
{
#ifdef _MSC_VER
  return _aligned_realloc(ptr, size, alignment);
#else
  /* Sadly no standard POSIX choice here */
  void *temp;
  size_t oldsize=malloc_usable_size(ptr);
  if(!(temp=memalign(alignment, size))) return 0;
  memcpy(temp, ptr, (oldsize<size) ? oldsize : size);
  free(ptr);
  return temp;
#endif
}
Exemple #18
0
	void* DefaultAllocator::realloc(void* _ptr, size_t _size, size_t _align, const char* _file, uint32_t _line)
	{
		if (0 == _size)
		{
			if (NULL != _ptr)
			{
				if (BX_CONFIG_ALLOCATOR_NATURAL_ALIGNMENT >= _align)
				{
					::free(_ptr);
					return NULL;
				}

#	if BX_COMPILER_MSVC
				BX_UNUSED(_file, _line);
				_aligned_free(_ptr);
#	else
				bx::alignedFree(this, _ptr, _align, _file, _line);
#	endif // BX_
			}

			return NULL;
		}
		else if (NULL == _ptr)
		{
			if (BX_CONFIG_ALLOCATOR_NATURAL_ALIGNMENT >= _align)
			{
				return ::malloc(_size);
			}

#	if BX_COMPILER_MSVC
			BX_UNUSED(_file, _line);
			return _aligned_malloc(_size, _align);
#	else
			return bx::alignedAlloc(this, _size, _align, _file, _line);
#	endif // BX_
		}

		if (BX_CONFIG_ALLOCATOR_NATURAL_ALIGNMENT >= _align)
		{
			return ::realloc(_ptr, _size);
		}

#	if BX_COMPILER_MSVC
		BX_UNUSED(_file, _line);
		return _aligned_realloc(_ptr, _size, _align);
#	else
		return bx::alignedRealloc(this, _ptr, _size, _align, _file, _line);
#	endif // BX_
	}
Exemple #19
0
void ff::SmallDict::Reserve(size_t newAllocated, bool allowEmptySpace)
{
	size_t oldAllocated = Allocated();
	if (newAllocated > oldAllocated)
	{
		if (allowEmptySpace)
		{
			newAllocated = std::max<size_t>(NearestPowerOfTwo(newAllocated), 4);
		}

		size_t byteSize = sizeof(Data) + newAllocated * sizeof(Entry) - sizeof(Entry);
		_data = (Data *)_aligned_realloc(_data, byteSize, __alignof(Data));
		_data->allocated = newAllocated;
		_data->size = oldAllocated ? _data->size : 0;
		_data->atomizer = oldAllocated ? _data->atomizer : &ProcessGlobals::Get()->GetStringCache();
	}
}
Exemple #20
0
static void *a_realloc(void *ptr, size_t size)
{
#ifdef ALIGNED_MALLOC
	return _aligned_realloc(ptr, size, ALIGNMENT);
#elif ALIGNMENT_HACK
	long diff;

	if (!ptr)
		return a_malloc(size);
	diff = ((char *)ptr)[-1];
	ptr = realloc((char*)ptr - diff, size + diff);
	if (ptr)
		ptr = (char *)ptr + diff;
	return ptr;
#else
	return realloc(ptr, size);
#endif
}
Exemple #21
0
void CAEBuffer::ReAlloc(const size_t size)
{
#if defined(TARGET_WINDOWS)
    m_buffer = (uint8_t*)_aligned_realloc(m_buffer, size, 16);
#else
    uint8_t* tmp = (uint8_t*)_aligned_malloc(size, 16);
    if (m_buffer)
    {
        size_t copy = std::min(size, m_bufferSize);
        memcpy(tmp, m_buffer, copy);
        _aligned_free(m_buffer);
    }
    m_buffer = tmp;
#endif

    m_bufferSize = size;
    m_bufferPos  = std::min(m_bufferPos, m_bufferSize);
}
Exemple #22
0
void allocAlignedRealloc(bool bFree)
{
    void* leaked = _aligned_offset_malloc(64, 16, 1);
    int* leaked_memory = (int*)_aligned_malloc(64, 16);
    int* leaked_memory_dbg = (int*)_aligned_malloc_dbg(32, 16, __FILE__, __LINE__);
    leaked = (int*)_aligned_offset_realloc(leaked, 48, 16, 2);
    leaked_memory = (int*)_aligned_realloc(leaked_memory, 128, 16);
    leaked_memory_dbg = (int*)_aligned_realloc_dbg(leaked_memory_dbg, 48, 16, __FILE__, __LINE__);
    leaked = (int*)_aligned_offset_recalloc(leaked, 1, 52, 16, 2);
    leaked_memory = (int*)_aligned_recalloc(leaked_memory, 1, 132, 16);
    leaked_memory_dbg = (int*)_aligned_recalloc_dbg(leaked_memory_dbg, 1, 64, 16, __FILE__, __LINE__);
    if (bFree)
    {
        _aligned_free(leaked);
        _aligned_free(leaked_memory);
        _aligned_free_dbg(leaked_memory_dbg);
    }
}
/**
 * Reallocate memory, with alignment.
 */
void *
_mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,
                    unsigned long alignment)
{
#if defined(_WIN32) && defined(_MSC_VER)
   (void) oldSize;
   return _aligned_realloc(oldBuffer, newSize, alignment);
#else
   const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
   void *newBuf = _mesa_align_malloc(newSize, alignment);
   if (newBuf && oldBuffer && copySize > 0) {
      memcpy(newBuf, oldBuffer, copySize);
   }
   if (oldBuffer)
      _mesa_align_free(oldBuffer);
   return newBuf;
#endif
}
Exemple #24
0
    void* MemDefaultAllocator::ReallocAligned(void* pOldPtr, size_t size, size_t alignment, const char* tag, const char* pFile, unsigned int Line)
    {
        BEHAVIAC_UNUSED_VAR(alignment);
        BEHAVIAC_UNUSED_VAR(tag);
        BEHAVIAC_UNUSED_VAR(pFile);
        BEHAVIAC_UNUSED_VAR(Line);

        if (pOldPtr)
        {
#if BEHAVIAC_DEBUG_MEMORY_STATS

            if (m_bEnablePtrSizeRegister)
            {
                ScopedInt_t scopedInt(GetThreadInt());

                if (scopedInt.equal(1))
                {
                    GetPtrSizeRegister().UnRegisterPtr(pOldPtr);
                }
            }

#endif
        }

#if BEHAVIAC_COMPILER_MSVC
        void* p = _aligned_realloc(pOldPtr, size, alignment);
#else
        void* p = realloc(pOldPtr, size);
#endif//BEHAVIAC_COMPILER_MSVC
#if BEHAVIAC_DEBUG_MEMORY_STATS

        if (m_bEnablePtrSizeRegister)
        {
            ScopedInt_t scopedInt(GetThreadInt());

            if (scopedInt.equal(1))
            {
                GetPtrSizeRegister().RegisterPtrSize(p, size);
            }
        }

#endif
        return p;
    }
Exemple #25
0
void *av_realloc(void *ptr, size_t size)
{
#if CONFIG_MEMALIGN_HACK
    int diff;
#endif

    /* let's disallow possibly ambiguous cases */
    if (size > (max_alloc_size - 32))
        return NULL;

#if CONFIG_MEMALIGN_HACK
    //FIXME this isn't aligned correctly, though it probably isn't needed
    if (!ptr)
        return av_malloc(size);
    diff = ((char *)ptr)[-1];
    av_assert0(diff>0 && diff<=ALIGN);
    ptr = realloc((char *)ptr - diff, size + diff);
    if (ptr)
        ptr = (char *)ptr + diff;
    return ptr;
#elif HAVE_ALIGNED_MALLOC
    return _aligned_realloc(ptr, size + !size, ALIGN);
#else
#ifdef USE_MEM_STATS
    if (ptr) 
        mem_cur -= malloc_usable_size(ptr);
    printf("realloc(%p, %ld)\n", ptr, size);
    ptr = realloc(ptr, size + !size);
    if (ptr) {
        mem_cur += malloc_usable_size(ptr);
        if (mem_cur > mem_max) {
            mem_max = mem_cur;
            printf("mem_max=%d\n", mem_max);
        }
    }
    return ptr;
#else
    return realloc(ptr, size + !size);
#endif
#endif
}
Exemple #26
0
void *av_realloc(void *ptr, size_t size)
{
#if CONFIG_MEMALIGN_HACK
    int diff;
#endif

    /* let's disallow possible ambiguous cases */
    if(size > (INT_MAX-16) )
        return NULL;

#if CONFIG_MEMALIGN_HACK
    //FIXME this isn't aligned correctly, though it probably isn't needed
    if(!ptr) return av_malloc(size);
    diff= ((char*)ptr)[-1];
    return (char*)realloc((char*)ptr - diff, size + diff) + diff;
#elif HAVE_ALIGNED_MALLOC
    return _aligned_realloc(ptr, size, 32);
#else
    return realloc(ptr, size);
#endif
}
Exemple #27
0
void* MikMod_realloc(void *data, size_t size)
{
    if (data)
    {
#if defined __MACH__ || defined __QNXNTO__
        void *d = realloc(data, size);
        if(!d) {
            _mm_errno = MMERR_OUT_OF_MEMORY;
            if(_mm_errorhandler) {
                _mm_errorhandler();
            }
        }
        return d;
#elif (defined _WIN32 || defined _WIN64) && !defined(_WIN32_WCE)
        return _aligned_realloc(data, size, ALIGN_STRIDE);
#else
        unsigned char *newPtr = (unsigned char *)realloc(get_pointer(data), size + ALIGN_STRIDE + sizeof(void*));
        return align_pointer((char*)newPtr, ALIGN_STRIDE);
#endif
    }
    return MikMod_malloc(size);
}
 /**
  * Reallocate a block of memory with a new size, with the start address 
  * being aligned to a multiple of \p align bytes.
  * \remarks The returned block of memory must be freed with AlignedFree.
  * \warning The alignment must be the same as initially passed to 
  *   AlignedMalloc.
  */
 void* AlignedRealloc (void* ptr, size_t size, 
   size_t align)
 {
 #if !defined(CS_NO_PTMALLOC)
   void* newPtr = ptmalloc_::ptrealloc (ptr, size);
   if ((newPtr != ptr)
     && ((((uintptr_t)newPtr) / align * align) != (uintptr_t)newPtr))
   {
     // Bah, alignment borked. Need to alloc again :(
     void* newPtrAligned = ptmalloc_::ptmemalign (align, size);
     memcpy (newPtrAligned, newPtr, size);
     ptfree (newPtr);
     newPtr = newPtrAligned;
   }
   return newPtr;
 #elif defined(CS_HAVE__ALIGNED_MALLOC)
   return _aligned_realloc (ptr, size, align);
 #else
   void* orgPtr = *(((void**)ptr) - 1);
   uintptr_t offsetToData = (uintptr_t)ptr - (uintptr_t)orgPtr;
   void* newPtr = cs_realloc (orgPtr, size + align + sizeof(void*));
   
   uintptr_t ptrInt = (intptr_t)newPtr;
   ptrInt = (ptrInt + align + sizeof(void*)) / align * align;
   uintptr_t newOffsetToData = ptrInt - (uintptr_t)newPtr;
   if (newOffsetToData != offsetToData)
   {
     // Ensure realloced data is aligned again
     memmove ((void*)(ptrInt), (void*)((uintptr_t)newPtr + offsetToData),
       size);
   }
   
   *(((void**)ptrInt) - 1) = newPtr;
   return (void*)ptrInt;
 #endif
 }
Exemple #29
0
void* MikMod_realloc(void *data, size_t size)
{
	return realloc(data, size);
	
#if 0
	if (data)
	{
#if defined __MACH__
		void *d = realloc(data, size);
		if (d)
		{
			return d;
		}
		return 0;
#elif (defined _WIN32 || defined _WIN64) && !defined(_WIN32_WCE)
		return _aligned_realloc(data, size, ALIGN_STRIDE);
#else
		unsigned char *newPtr = (unsigned char *)realloc(get_pointer(data), size + ALIGN_STRIDE + sizeof(void*));
		return align_pointer(newPtr, ALIGN_STRIDE);
#endif
	}
	return MikMod_malloc(size);
#endif
}
Exemple #30
0
void *av_realloc(void *ptr, FF_INTERNAL_MEM_TYPE size)
{
#if CONFIG_MEMALIGN_HACK
    int diff;
#endif

    /* let's disallow possible ambiguous cases */
    if(size > (INT_MAX-16) )
        return NULL;

#if CONFIG_MEMALIGN_HACK
    //FIXME this isn't aligned correctly, though it probably isn't needed
    if(!ptr) return av_malloc(size);
    diff= ((char*)ptr)[-1];
    return (char*)realloc((char*)ptr - diff, size + diff) + diff;
#else
// RJVB
#   if defined(_MSC_VER) || defined(__MINGW32__)
    return _aligned_realloc(ptr, size, 16);
#   else
    return realloc(ptr, size);
#   endif
#endif
}