print a big warning if we mess up and run out of space ...

[ffmpeg] / libavcodec / mem.c

diff --git a/libavcodec/mem.c b/libavcodec/mem.c
index c5ca166d337d4ae324557c7e407a7d5470d13554..24d75e9483d17c4c77a9e146feadd2653703fe1a 100644 (file)
--- a/libavcodec/mem.c
+++ b/libavcodec/mem.c
@@ -14,14 +14,14 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
- 
+
 /**
  * @file mem.c
  * default memory allocator for libavcodec.
  */
- 
+
 #include "avcodec.h"
 
 /* here we can use OS dependant allocation functions */
@@ -37,7 +37,7 @@
    memory allocator. You do not need to suppress this file because the
    linker will do it automatically */
 
-/** 
+/**
  * Memory allocation of size byte with alignment suitable for all
  * memory accesses (including vectors if available on the
  * CPU). av_malloc(0) must return a non NULL pointer.
@@ -45,15 +45,27 @@
 void *av_malloc(unsigned int size)
 {
     void *ptr;
-    
-#if defined (HAVE_MEMALIGN)
+#ifdef MEMALIGN_HACK
+    long diff;
+#endif
+
+    /* lets disallow possible ambiguous cases */
+    if(size > INT_MAX)
+        return NULL;
+
+#ifdef MEMALIGN_HACK
+    ptr = malloc(size+16+1);
+    diff= ((-(long)ptr - 1)&15) + 1;
+    ptr += diff;
+    ((char*)ptr)[-1]= diff;
+#elif defined (HAVE_MEMALIGN)
     ptr = memalign(16,size);
-    /* Why 64? 
+    /* Why 64?
        Indeed, we should align it:
          on 4 for 386
          on 16 for 486
-        on 32 for 586, PPro - k6-III
-        on 64 for K7 (maybe for P3 too).
+         on 32 for 586, PPro - k6-III
+         on 64 for K7 (maybe for P3 too).
        Because L1 and L2 caches are aligned on those values.
        But I don't want to code such logic here!
      */
@@ -64,14 +76,14 @@ void *av_malloc(unsigned int size)
         Why not larger? because i didnt see a difference in benchmarks ...
      */
      /* benchmarks with p3
-        memalign(64)+1         3071,3051,3032
-        memalign(64)+2         3051,3032,3041
-        memalign(64)+4         2911,2896,2915
-        memalign(64)+8         2545,2554,2550
-        memalign(64)+16                2543,2572,2563
-        memalign(64)+32                2546,2545,2571
-        memalign(64)+64                2570,2533,2558
-        
+        memalign(64)+1          3071,3051,3032
+        memalign(64)+2          3051,3032,3041
+        memalign(64)+4          2911,2896,2915
+        memalign(64)+8          2545,2554,2550
+        memalign(64)+16         2543,2572,2563
+        memalign(64)+32         2546,2545,2571
+        memalign(64)+64         2570,2533,2558
+
         btw, malloc seems to do 8 byte alignment by default here
      */
 #else
@@ -83,18 +95,41 @@ void *av_malloc(unsigned int size)
 /**
  * av_realloc semantics (same as glibc): if ptr is NULL and size > 0,
  * identical to malloc(size). If size is zero, it is identical to
- * free(ptr) and NULL is returned.  
+ * free(ptr) and NULL is returned.
  */
 void *av_realloc(void *ptr, unsigned int size)
 {
+#ifdef MEMALIGN_HACK
+    int diff;
+#endif
+
+    /* lets disallow possible ambiguous cases */
+    if(size > INT_MAX)
+        return NULL;
+
+#ifdef MEMALIGN_HACK
+    //FIXME this isnt aligned correctly though it probably isnt needed
+    if(!ptr) return av_malloc(size);
+    diff= ((char*)ptr)[-1];
+    return realloc(ptr - diff, size + diff) + diff;
+#else
     return realloc(ptr, size);
+#endif
 }
 
-/* NOTE: ptr = NULL is explicetly allowed */
+/**
+ * Free memory which has been allocated with av_malloc(z)() or av_realloc().
+ * NOTE: ptr = NULL is explicetly allowed
+ * Note2: it is recommanded that you use av_freep() instead
+ */
 void av_free(void *ptr)
 {
     /* XXX: this test should not be needed on most libcs */
     if (ptr)
+#ifdef MEMALIGN_HACK
+        free(ptr - ((char*)ptr)[-1]);
+#else
         free(ptr);
+#endif
 }