libav*: create a new avcommon_compat.h file for backward compatibility

[vlc] / modules / codec / araw.c

diff --git a/modules/codec/araw.c b/modules/codec/araw.c
index b0ee2eccb1c33327ee6ab436279f81fdcf102945..34e4b4c6c95614e0da9bf4711291d597c4fb3a48 100644 (file)
--- a/modules/codec/araw.c
+++ b/modules/codec/araw.c
@@ -87,10 +87,17 @@ static void U16BDecode( void *, const uint8_t *, unsigned );
 static void U16LDecode( void *, const uint8_t *, unsigned );
 static void S16IDecode( void *, const uint8_t *, unsigned );
 static void S20BDecode( void *, const uint8_t *, unsigned );
+static void U24BDecode( void *, const uint8_t *, unsigned );
+static void U24LDecode( void *, const uint8_t *, unsigned );
+static void S24BDecode( void *, const uint8_t *, unsigned );
+static void S24LDecode( void *, const uint8_t *, unsigned );
+static void S24B32Decode( void *, const uint8_t *, unsigned );
+static void S24L32Decode( void *, const uint8_t *, unsigned );
 static void U32BDecode( void *, const uint8_t *, unsigned );
 static void U32LDecode( void *, const uint8_t *, unsigned );
-static void Swap32Decode( void *, const uint8_t *, unsigned );
-static void Swap64Decode( void *, const uint8_t *, unsigned );
+static void S32IDecode( void *, const uint8_t *, unsigned );
+static void F32IDecode( void *, const uint8_t *, unsigned );
+static void F64IDecode( void *, const uint8_t *, unsigned );
 static void DAT12Decode( void *, const uint8_t *, unsigned );
 
 /*****************************************************************************
@@ -132,7 +139,7 @@ static int DecoderOpen( vlc_object_t *p_this )
     case VLC_CODEC_F64B:
 #endif
         format = VLC_CODEC_FL64;
-        decode = Swap64Decode;
+        decode = F64IDecode;
     case VLC_CODEC_FL64:
         bits = 64;
         break;
@@ -142,7 +149,7 @@ static int DecoderOpen( vlc_object_t *p_this )
     case VLC_CODEC_F32B:
 #endif
         format = VLC_CODEC_FL32;
-        decode = Swap32Decode;
+        decode = F32IDecode;
     case VLC_CODEC_FL32:
         bits = 32;
         break;
@@ -158,12 +165,38 @@ static int DecoderOpen( vlc_object_t *p_this )
         break;
     case VLC_CODEC_S32I:
         format = VLC_CODEC_S32N;
-        decode = Swap32Decode;
-     case VLC_CODEC_S32N:
+        decode = S32IDecode;
+    case VLC_CODEC_S32N:
         bits = 32;
         break;
-    case VLC_CODEC_S24L:
+    case VLC_CODEC_S24B32:
+        format = VLC_CODEC_S32N;
+        decode = S24B32Decode;
+        bits = 32;
+        break;
+    case VLC_CODEC_S24L32:
+        format = VLC_CODEC_S32N;
+        decode = S24L32Decode;
+        bits = 32;
+        break;
+    case VLC_CODEC_U24B:
+        format = VLC_CODEC_S32N;
+        decode = U24BDecode;
+        bits = 24;
+        break;
+    case VLC_CODEC_U24L:
+        format = VLC_CODEC_S32N;
+        decode = U24LDecode;
+        bits = 24;
+        break;
     case VLC_CODEC_S24B:
+        format = VLC_CODEC_S32N;
+        decode = S24BDecode;
+        bits = 24;
+        break;
+    case VLC_CODEC_S24L:
+        format = VLC_CODEC_S32N;
+        decode = S24LDecode;
         bits = 24;
         break;
     case VLC_CODEC_S20B:
@@ -373,6 +406,76 @@ static void S20BDecode( void *outp, const uint8_t *in, unsigned samples )
         *(out++) = (U16_AT(in) << 16) | ((in[2] & 0xF0) << 8);
 }
 
+static void U24BDecode( void *outp, const uint8_t *in, unsigned samples )
+{
+    uint32_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = ((in[0] << 24) | (in[1] << 16) | (in[2] << 8)) - 0x80000000;
+        *(out++) = s;
+        in += 3;
+    }
+}
+
+static void U24LDecode( void *outp, const uint8_t *in, unsigned samples )
+{
+    uint32_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = ((in[2] << 24) | (in[1] << 16) | (in[0] << 8)) - 0x80000000;
+        *(out++) = s;
+        in += 3;
+    }
+}
+
+static void S24BDecode( void *outp, const uint8_t *in, unsigned samples )
+{
+    uint32_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = ((in[0] << 24) | (in[1] << 16) | (in[2] << 8));
+        *(out++) = s;
+        in += 3;
+    }
+}
+
+static void S24LDecode( void *outp, const uint8_t *in, unsigned samples )
+{
+    uint32_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = ((in[2] << 24) | (in[1] << 16) | (in[0] << 8));
+        *(out++) = s;
+        in += 3;
+    }
+}
+
+static void S24B32Decode( void *outp, const uint8_t *in, unsigned samples )
+{
+    uint32_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        *(out++) = GetDWBE( in ) << 8;
+        in += 4;
+    }
+}
+
+static void S24L32Decode( void *outp, const uint8_t *in, unsigned samples )
+{
+    uint32_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        *(out++) = GetDWLE( in ) << 8;
+        in += 4;
+    }
+}
+
 static void U32BDecode( void *outp, const uint8_t *in, unsigned samples )
 {
     uint32_t *out = outp;
@@ -395,7 +498,7 @@ static void U32LDecode( void *outp, const uint8_t *in, unsigned samples )
     }
 }
 
-static void Swap32Decode( void *outp, const uint8_t *in, unsigned samples )
+static void S32IDecode( void *outp, const uint8_t *in, unsigned samples )
 {
     int32_t *out = outp;
 
@@ -410,17 +513,38 @@ static void Swap32Decode( void *outp, const uint8_t *in, unsigned samples )
     }
 }
 
-static void Swap64Decode( void *outp, const uint8_t *in, unsigned samples )
+static void F32IDecode( void *outp, const uint8_t *in, unsigned samples )
 {
-    int64_t *out = outp;
+    float *out = outp;
 
     for( size_t i = 0; i < samples; i++ )
     {
+        union { float f; uint32_t u; } s;
+
 #ifdef WORDS_BIGENDIAN
-        *(out++) = GetQWLE( in );
+        s.u = GetDWLE( in );
 #else
-        *(out++) = GetQWBE( in );
+        s.u = GetDWBE( in );
 #endif
+        *(out++) = s.f;
+        in += 4;
+    }
+}
+
+static void F64IDecode( void *outp, const uint8_t *in, unsigned samples )
+{
+    double *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        union { double d; uint64_t u; } s;
+
+#ifdef WORDS_BIGENDIAN
+        s.u = GetQWLE( in );
+#else
+        s.u = GetQWBE( in );
+#endif
+        *(out++) = s.d;
         in += 8;
     }
 }
@@ -486,6 +610,62 @@ static void U16NEncode( void *outp, const uint8_t *inp, unsigned samples )
         *(out++) =  *(in++) + 0x8000;
 }
 
+static void U24BEncode( void *outp, const uint8_t *inp, unsigned samples )
+{
+    const uint32_t *in = (const uint32_t *)inp;
+    uint8_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = *(in++);
+        *(out++) = (s >> 24) + 0x80;
+        *(out++) = (s >> 16);
+        *(out++) = (s >>  8);
+    }
+}
+
+static void U24LEncode( void *outp, const uint8_t *inp, unsigned samples )
+{
+    const uint32_t *in = (const uint32_t *)inp;
+    uint8_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = *(in++);
+        *(out++) = (s >>  8);
+        *(out++) = (s >> 16);
+        *(out++) = (s >> 24) + 0x80;
+    }
+}
+
+static void S24BEncode( void *outp, const uint8_t *inp, unsigned samples )
+{
+    const uint32_t *in = (const uint32_t *)inp;
+    uint8_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = *(in++);
+        *(out++) = (s >> 24);
+        *(out++) = (s >> 16);
+        *(out++) = (s >>  8);
+    }
+}
+
+static void S24LEncode( void *outp, const uint8_t *inp, unsigned samples )
+{
+    const uint32_t *in = (const uint32_t *)inp;
+    uint8_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        uint32_t s = *(in++);
+        *(out++) = (s >>  8);
+        *(out++) = (s >> 16);
+        *(out++) = (s >> 24);
+    }
+}
+
 static void U32IEncode( void *outp, const uint8_t *inp, unsigned samples )
 {
     const uint32_t *in = (const uint32_t *)inp;
@@ -504,7 +684,7 @@ static void U32NEncode( void *outp, const uint8_t *inp, unsigned samples )
         *(out++) =  *(in++) + 0x80000000;
 }
 
-static void Swap32Encode( void *outp, const uint8_t *inp, unsigned samples )
+static void S32IEncode( void *outp, const uint8_t *inp, unsigned samples )
 {
     const int32_t *in = (const int32_t *)inp;
     int32_t *out = outp;
@@ -513,13 +693,36 @@ static void Swap32Encode( void *outp, const uint8_t *inp, unsigned samples )
         *(out++) = bswap32( *(in++) );
 }
 
-static void Swap64Encode( void *outp, const uint8_t *inp, unsigned samples )
+static void F32IEncode( void *outp, const uint8_t *inp, unsigned samples )
 {
-    const int64_t *in = (const int64_t *)inp;
-    int64_t *out = outp;
+    const float *in = (const float *)inp;
+    uint8_t *out = outp;
 
     for( size_t i = 0; i < samples; i++ )
-        *(out++) = bswap64( *(in++) );
+    {
+        union { float f; uint32_t u; char b[4]; } s;
+
+        s.f = *(in++);
+        s.u = bswap32( s.u );
+        memcpy( out, s.b, 4 );
+        out += 4;
+    }
+}
+
+static void F64IEncode( void *outp, const uint8_t *inp, unsigned samples )
+{
+    const double *in = (const double *)inp;
+    uint8_t *out = outp;
+
+    for( size_t i = 0; i < samples; i++ )
+    {
+        union { double d; uint64_t u; char b[8]; } s;
+
+        s.d = *(in++);
+        s.u = bswap64( s.u );
+        memcpy( out, s.b, 8 );
+        out += 8;
+    }
 }
 
 static block_t *Encode( encoder_t *enc, block_t *in )
@@ -580,10 +783,24 @@ static int EncoderOpen( vlc_object_t *p_this )
         p_enc->fmt_in.i_codec = VLC_CODEC_S16N;
         p_enc->fmt_out.audio.i_bitspersample = 16;
         break;
-    case VLC_CODEC_U24L:
     case VLC_CODEC_U24B:
-    case VLC_CODEC_S24L:
+        encode = U24BEncode;
+        p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
+        p_enc->fmt_out.audio.i_bitspersample = 24;
+        break;
+    case VLC_CODEC_U24L:
+        encode = U24LEncode;
+        p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
+        p_enc->fmt_out.audio.i_bitspersample = 24;
+        break;
     case VLC_CODEC_S24B:
+        encode = S24BEncode;
+        p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
+        p_enc->fmt_out.audio.i_bitspersample = 24;
+        break;
+    case VLC_CODEC_S24L:
+        encode = S24LEncode;
+        p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
         p_enc->fmt_out.audio.i_bitspersample = 24;
         break;
     case VLC_CODEC_U32I:
@@ -597,7 +814,7 @@ static int EncoderOpen( vlc_object_t *p_this )
         p_enc->fmt_out.audio.i_bitspersample = 32;
         break;
     case VLC_CODEC_S32I:
-        encode = Swap32Encode;
+        encode = S32IEncode;
     case VLC_CODEC_S32N:
         p_enc->fmt_in.i_codec = VLC_CODEC_S32N;
         p_enc->fmt_out.audio.i_bitspersample = 32;
@@ -607,7 +824,7 @@ static int EncoderOpen( vlc_object_t *p_this )
 #else
     case VLC_CODEC_F32B:
 #endif
-        encode = Swap32Encode;
+        encode = F32IEncode;
     case VLC_CODEC_FL32:
         p_enc->fmt_in.i_codec = VLC_CODEC_FL32;
         p_enc->fmt_out.audio.i_bitspersample = 32;
@@ -617,7 +834,7 @@ static int EncoderOpen( vlc_object_t *p_this )
 #else
     case VLC_CODEC_F64B:
 #endif
-        encode = Swap64Encode;
+        encode = F64IEncode;
     case VLC_CODEC_FL64:
         p_enc->fmt_in.i_codec = VLC_CODEC_FL64;
         p_enc->fmt_out.audio.i_bitspersample = 64;