* src/extras/libc.c: shut up compiler warnings.

[vlc] / src / extras / libc.c

diff --git a/src/extras/libc.c b/src/extras/libc.c
index 9ed82925015d6e73418dfcf813403d3227656f5c..74090cda43d30d3b0a3bbe5eeed8599bb8d9e4ec 100644 (file)
--- a/src/extras/libc.c
+++ b/src/extras/libc.c
@@ -6,6 +6,7 @@
  *
  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
  *          Samuel Hocevar <sam@zoy.org>
+ *          Gildas Bazin <gbazin@videolan.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,6 +24,7 @@
  *****************************************************************************/
 #include <string.h>                                              /* strdup() */
 #include <stdlib.h>
+#include <ctype.h>
 
 #include <vlc/vlc.h>
 
@@ -143,16 +145,16 @@ int vlc_strncasecmp( const char *s1, const char *s2, size_t n )
 #if !defined( HAVE_STRCASESTR ) && !defined( HAVE_STRISTR )
 char * vlc_strcasestr( const char *psz_big, const char *psz_little )
 {
-    char *p_pos = psz_big;
+    char *p_pos = (char *)psz_big;
 
-    if( !psz_big || !psz_little || !*psz_little ) return psz_big;
+    if( !psz_big || !psz_little || !*psz_little ) return p_pos;
  
     while( *p_pos ) 
     {
         if( toupper( *p_pos ) == toupper( *psz_little ) )
         {
             char * psz_cur1 = p_pos + 1;
-            char * psz_cur2 = psz_little + 1;
+            char * psz_cur2 = (char *)psz_little + 1;
             while( *psz_cur1 && *psz_cur2 &&
                    toupper( *psz_cur1 ) == toupper( *psz_cur2 ) )
             {
@@ -250,28 +252,87 @@ double vlc_atof( const char *nptr )
 #endif
 
 /*****************************************************************************
- * atoll: convert a string to a 64 bits int.
+ * strtoll: convert a string to a 64 bits int.
  *****************************************************************************/
-#if !defined( HAVE_ATOLL )
-int64_t vlc_atoll( const char *str )
+#if !defined( HAVE_STRTOLL )
+int64_t vlc_strtoll( const char *nptr, char **endptr, int base )
 {
     int64_t i_value = 0;
-    int sign = 1;
+    int sign = 1, newbase = base ? base : 10;
 
-    if( *str == '-' )
+    while( isspace(*nptr) ) nptr++;
+
+    if( *nptr == '-' )
     {
         sign = -1;
+        nptr++;
+    }
+
+    /* Try to detect base */
+    if( *nptr == '0' )
+    {
+        newbase = 8;
+        nptr++;
+
+        if( *nptr == 'x' )
+        {
+            newbase = 16;
+            nptr++;
+        }
     }
 
-    while( *str >= '0' && *str <= '9' )
+    if( base && newbase != base )
     {
-        i_value = i_value * 10 + ( *str++ - '0' );
+        if( endptr ) *endptr = (char *)nptr;
+        return i_value;
+    }
+
+    switch( newbase )
+    {
+        case 10:
+            while( *nptr >= '0' && *nptr <= '9' )
+            {
+                i_value *= 10;
+                i_value += ( *nptr++ - '0' );
+            }
+            if( endptr ) *endptr = (char *)nptr;
+            break;
+
+        case 16:
+            while( (*nptr >= '0' && *nptr <= '9') ||
+                   (*nptr >= 'a' && *nptr <= 'f') ||
+                   (*nptr >= 'A' && *nptr <= 'F') )
+            {
+                int i_valc = 0;
+                if(*nptr >= '0' && *nptr <= '9') i_valc = *nptr - '0';
+                else if(*nptr >= 'a' && *nptr <= 'f') i_valc = *nptr - 'a' +10;
+                else if(*nptr >= 'A' && *nptr <= 'F') i_valc = *nptr - 'A' +10;
+                i_value *= 16;
+                i_value += i_valc;
+                nptr++;
+            }
+            if( endptr ) *endptr = (char *)nptr;
+            break;
+
+        default:
+            i_value = strtol( nptr, endptr, newbase );
+            break;
     }
 
     return i_value * sign;
 }
 #endif
 
+/*****************************************************************************
+ * atoll: convert a string to a 64 bits int.
+ *****************************************************************************/
+#if !defined( HAVE_ATOLL )
+int64_t vlc_atoll( const char *nptr )
+{
+    return strtoll( nptr, (char **)NULL, 10 );
+}
+#endif
+
 /*****************************************************************************
  * lseek: reposition read/write file offset.
  *****************************************************************************
@@ -402,7 +463,7 @@ size_t vlc_iconv( vlc_iconv_t cd, char **inbuf, size_t *inbytesleft,
 #if defined(HAVE_ICONV)
     return iconv( cd, inbuf, inbytesleft, outbuf, outbytesleft );
 #else
-    int i_bytes = __MIN(inbytesleft, outbytesleft);
+    int i_bytes = __MIN(*inbytesleft, *outbytesleft);
     if( !inbuf || !outbuf || !i_bytes ) return (size_t)(-1);
     memcpy( *outbuf, *inbuf, i_bytes );
     inbuf += i_bytes;
@@ -421,3 +482,70 @@ int vlc_iconv_close( vlc_iconv_t cd )
     return 0;
 #endif
 }
+
+/*****************************************************************************
+ * reduce a fraction
+ *   (adapted from libavcodec, author Michael Niedermayer <michaelni@gmx.at>)
+ *****************************************************************************/
+vlc_bool_t vlc_reduce( int *pi_dst_nom, int *pi_dst_den,
+                       int64_t i_nom, int64_t i_den, int64_t i_max )
+{
+    vlc_bool_t b_exact = 1, b_sign = 0;
+    int64_t i_gcd;
+
+    if( i_den == 0 )
+    {
+        *pi_dst_nom = 0;
+        *pi_dst_den = 1;
+        return 1;
+    }
+
+    if( i_den < 0 )
+    {
+        i_den = - i_den;
+        i_nom = - i_nom;
+    }
+
+    if( i_nom < 0 )
+    {
+        i_nom = - i_nom;
+        b_sign = 1;
+    }
+
+    i_gcd = GCD( i_nom, i_den );
+    i_nom /= i_gcd;
+    i_den /= i_gcd;
+
+    if( i_max == 0 ) i_max = I64C(0xFFFFFFFF);
+
+    if( i_nom > i_max || i_den > i_max )
+    {
+        int i_a0_num = 0, i_a0_den = 1, i_a1_num = 1, i_a1_den = 0;
+        b_exact = 0;
+
+        for( ; ; )
+        {
+            int64_t i_x = i_nom / i_den;
+            int64_t i_a2n = i_x * i_a1_num + i_a0_num;
+            int64_t i_a2d = i_x * i_a1_den + i_a0_den;
+
+            if( i_a2n > i_max || i_a2d > i_max ) break;
+
+            i_nom %= i_den;
+
+            i_a0_num = i_a1_num; i_a0_den = i_a1_den;
+            i_a1_num = i_a2n; i_a1_den = i_a2d;
+            if( i_nom == 0 ) break;
+            i_x = i_nom; i_nom = i_den; i_den = i_x;
+        }
+        i_nom = i_a1_num;
+        i_den = i_a1_den;
+    }
+
+    if( b_sign ) i_nom = - i_nom;
+
+    *pi_dst_nom = i_nom;
+    *pi_dst_den = i_den;
+
+    return b_exact;
+}