## ffmpeg / libavcodec / bswap.h @ cb231c48

History | View | Annotate | Download (2.58 KB)

1 | 983e3246 | Michael Niedermayer | ```
/**
``` |
---|---|---|---|

2 | ```
* @file bswap.h
``` |
||

3 | ```
* byte swap.
``` |
||

4 | ```
*/
``` |
||

5 | |||

6 | a9b3f630 | Nick Kurshev | ```
#ifndef __BSWAP_H__
``` |

7 | ```
#define __BSWAP_H__
``` |
||

8 | |||

9 | ```
#ifdef HAVE_BYTESWAP_H
``` |
||

10 | #include <byteswap.h> |
||

11 | ```
#else
``` |
||

12 | |||

13 | ```
#ifdef ARCH_X86
``` |
||

14 | 669e5093 | Alex Beregszaszi | static inline unsigned short ByteSwap16(unsigned short x) |

15 | a9b3f630 | Nick Kurshev | { |

16 | ```
__asm("xchgb %b0,%h0" :
``` |
||

17 | ```
"=q" (x) :
``` |
||

18 | ```
"0" (x));
``` |
||

19 | ```
return x;
``` |
||

20 | } |
||

21 | ```
#define bswap_16(x) ByteSwap16(x)
``` |
||

22 | |||

23 | 669e5093 | Alex Beregszaszi | static inline unsigned int ByteSwap32(unsigned int x) |

24 | a9b3f630 | Nick Kurshev | { |

25 | #if __CPU__ > 386 |
||

26 | ```
__asm("bswap %0":
``` |
||

27 | ```
"=r" (x) :
``` |
||

28 | ```
#else
``` |
||

29 | ```
__asm("xchgb %b0,%h0\n"
``` |
||

30 | ```
" rorl $16,%0\n"
``` |
||

31 | ```
" xchgb %b0,%h0":
``` |
||

32 | ```
"=q" (x) :
``` |
||

33 | ```
#endif
``` |
||

34 | ```
"0" (x));
``` |
||

35 | ```
return x;
``` |
||

36 | } |
||

37 | ```
#define bswap_32(x) ByteSwap32(x)
``` |
||

38 | |||

39 | 669e5093 | Alex Beregszaszi | static inline unsigned long long int ByteSwap64(unsigned long long int x) |

40 | a9b3f630 | Nick Kurshev | { |

41 | 74fc9989 | Fabrice Bellard | register union { __extension__ uint64_t __ll; |

42 | ```
uint32_t __l[2]; } __x;
``` |
||

43 | a9b3f630 | Nick Kurshev | asm("xchgl %0,%1": |

44 | "=r"(__x.__l[0]),"=r"(__x.__l[1]): |
||

45 | "0"(bswap_32((unsigned long)x)),"1"(bswap_32((unsigned long)(x>>32)))); |
||

46 | ```
return __x.__ll;
``` |
||

47 | } |
||

48 | ```
#define bswap_64(x) ByteSwap64(x)
``` |
||

49 | |||

50 | 0c6bd2ea | BERO | ```
#elif defined(ARCH_SH4)
``` |

51 | |||

52 | static inline uint16_t ByteSwap16(uint16_t x) { |
||

53 | __asm__("swap.b %0,%0":"=r"(x):"0"(x)); |
||

54 | ```
return x;
``` |
||

55 | } |
||

56 | |||

57 | static inline uint32_t ByteSwap32(uint32_t x) { |
||

58 | __asm__( |
||

59 | ```
"swap.b %0,%0\n"
``` |
||

60 | ```
"swap.w %0,%0\n"
``` |
||

61 | ```
"swap.b %0,%0\n"
``` |
||

62 | :"=r"(x):"0"(x)); |
||

63 | ```
return x;
``` |
||

64 | } |
||

65 | |||

66 | ```
#define bswap_16(x) ByteSwap16(x)
``` |
||

67 | ```
#define bswap_32(x) ByteSwap32(x)
``` |
||

68 | |||

69 | 669e5093 | Alex Beregszaszi | static inline uint64_t ByteSwap64(uint64_t x) |

70 | 0c6bd2ea | BERO | { |

71 | ```
union {
``` |
||

72 | uint64_t ll; |
||

73 | ```
struct {
``` |
||

74 | uint32_t l,h; |
||

75 | } l; |
||

76 | } r; |
||

77 | r.l.l = bswap_32 (x); |
||

78 | ```
r.l.h = bswap_32 (x>>32);
``` |
||

79 | ```
return r.ll;
``` |
||

80 | } |
||

81 | ```
#define bswap_64(x) ByteSwap64(x)
``` |
||

82 | |||

83 | a9b3f630 | Nick Kurshev | ```
#else
``` |

84 | |||

85 | #define bswap_16(x) (((x) & 0x00ff) << 8 | ((x) & 0xff00) >> 8) |
||

86 | |||

87 | |||

88 | ```
// code from bits/byteswap.h (C) 1997, 1998 Free Software Foundation, Inc.
``` |
||

89 | ```
#define bswap_32(x) \
``` |
||

90 | ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ |
||

91 | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)) |
||

92 | |||

93 | 669e5093 | Alex Beregszaszi | static inline uint64_t ByteSwap64(uint64_t x) |

94 | 74fc9989 | Fabrice Bellard | { |

95 | ```
union {
``` |
||

96 | uint64_t ll; |
||

97 | ```
uint32_t l[2];
``` |
||

98 | } w, r; |
||

99 | w.ll = x; |
||

100 | r.l[0] = bswap_32 (w.l[1]); |
||

101 | r.l[1] = bswap_32 (w.l[0]); |
||

102 | ```
return r.ll;
``` |
||

103 | } |
||

104 | ```
#define bswap_64(x) ByteSwap64(x)
``` |
||

105 | |||

106 | a9b3f630 | Nick Kurshev | #endif /* !ARCH_X86 */ |

107 | |||

108 | #endif /* !HAVE_BYTESWAP_H */ |
||

109 | |||

110 | ```
// be2me ... BigEndian to MachineEndian
``` |
||

111 | ```
// le2me ... LittleEndian to MachineEndian
``` |
||

112 | |||

113 | ```
#ifdef WORDS_BIGENDIAN
``` |
||

114 | ```
#define be2me_16(x) (x)
``` |
||

115 | ```
#define be2me_32(x) (x)
``` |
||

116 | ```
#define be2me_64(x) (x)
``` |
||

117 | ```
#define le2me_16(x) bswap_16(x)
``` |
||

118 | ```
#define le2me_32(x) bswap_32(x)
``` |
||

119 | ```
#define le2me_64(x) bswap_64(x)
``` |
||

120 | ```
#else
``` |
||

121 | ```
#define be2me_16(x) bswap_16(x)
``` |
||

122 | ```
#define be2me_32(x) bswap_32(x)
``` |
||

123 | ```
#define be2me_64(x) bswap_64(x)
``` |
||

124 | ```
#define le2me_16(x) (x)
``` |
||

125 | ```
#define le2me_32(x) (x)
``` |
||

126 | ```
#define le2me_64(x) (x)
``` |
||

127 | ```
#endif
``` |
||

128 | |||

129 | b17c92d1 | Fabrice Bellard | #endif /* __BSWAP_H__ */ |