## ffmpeg / libavutil / intfloat_readwrite.c @ 617d56ca

History | View | Annotate | Download (2.86 KB)

1 | c11c2bc2 | Alexander Strasser | ```
/*
``` |
---|---|---|---|

2 | ```
* portable IEEE float/double read/write functions
``` |
||

3 | ```
*
``` |
||

4 | ```
* Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
``` |
||

5 | ```
*
``` |
||

6 | b78e7197 | Diego Biurrun | ```
* This file is part of FFmpeg.
``` |

7 | ```
*
``` |
||

8 | ```
* FFmpeg is free software; you can redistribute it and/or
``` |
||

9 | c11c2bc2 | Alexander Strasser | ```
* modify it under the terms of the GNU Lesser General Public
``` |

10 | ```
* License as published by the Free Software Foundation; either
``` |
||

11 | b78e7197 | Diego Biurrun | ```
* version 2.1 of the License, or (at your option) any later version.
``` |

12 | c11c2bc2 | Alexander Strasser | ```
*
``` |

13 | b78e7197 | Diego Biurrun | ```
* FFmpeg is distributed in the hope that it will be useful,
``` |

14 | c11c2bc2 | Alexander Strasser | ```
* but WITHOUT ANY WARRANTY; without even the implied warranty of
``` |

15 | ```
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
``` |
||

16 | ```
* Lesser General Public License for more details.
``` |
||

17 | ```
*
``` |
||

18 | ```
* You should have received a copy of the GNU Lesser General Public
``` |
||

19 | b78e7197 | Diego Biurrun | ```
* License along with FFmpeg; if not, write to the Free Software
``` |

20 | 5509bffa | Diego Biurrun | ```
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
``` |

21 | c11c2bc2 | Alexander Strasser | ```
*/
``` |

22 | 115329f1 | Diego Biurrun | |

23 | c11c2bc2 | Alexander Strasser | ```
/**
``` |

24 | ba87f080 | Diego Biurrun | ```
* @file
``` |

25 | 89c9ff50 | Diego Biurrun | ```
* portable IEEE float/double read/write functions
``` |

26 | c11c2bc2 | Alexander Strasser | ```
*/
``` |

27 | 115329f1 | Diego Biurrun | |

28 | 2ed6f399 | Måns Rullgård | #include <stdint.h> |

29 | #include <math.h> |
||

30 | a851b8e8 | Dieter | #include "intfloat_readwrite.h" |

31 | c11c2bc2 | Alexander Strasser | |

32 | ```
double av_int2dbl(int64_t v){
``` |
||

33 | 1ce83a36 | Baptiste Coudurier | if(v+v > 0xFFEULL<<52) |

34 | c11c2bc2 | Alexander Strasser | return 0.0/0.0; |

35 | bf4e3bd2 | Måns Rullgård | return ldexp(((v&((1LL<<52)-1)) + (1LL<<52)) * (v>>63|1), (v>>52&0x7FF)-1075); |

36 | c11c2bc2 | Alexander Strasser | } |

37 | |||

38 | ```
float av_int2flt(int32_t v){
``` |
||

39 | if(v+v > 0xFF000000U) |
||

40 | return 0.0/0.0; |
||

41 | return ldexp(((v&0x7FFFFF) + (1<<23)) * (v>>31|1), (v>>23&0xFF)-150); |
||

42 | } |
||

43 | |||

44 | f11288da | Michael Niedermayer | double av_ext2dbl(const AVExtFloat ext){ |

45 | ```
uint64_t m = 0;
``` |
||

46 | ```
int e, i;
``` |
||

47 | |||

48 | for (i = 0; i < 8; i++) |
||

49 | 767aeb11 | Michael Niedermayer | ```
m = (m<<8) + ext.mantissa[i];
``` |

50 | f11288da | Michael Niedermayer | e = (((int)ext.exponent[0]&0x7f)<<8) | ext.exponent[1]; |

51 | if (e == 0x7fff && m) |
||

52 | return 0.0/0.0; |
||

53 | e -= 16383 + 63; /* In IEEE 80 bits, the whole (i.e. 1.xxxx) |
||

54 | ```
* mantissa bit is written as opposed to the
``` |
||

55 | 89c9ff50 | Diego Biurrun | ```
* single and double precision formats. */
``` |

56 | f11288da | Michael Niedermayer | if (ext.exponent[0]&0x80) |

57 | 767aeb11 | Michael Niedermayer | m= -m; |

58 | f11288da | Michael Niedermayer | ```
return ldexp(m, e);
``` |

59 | } |
||

60 | |||

61 | c11c2bc2 | Alexander Strasser | ```
int64_t av_dbl2int(double d){
``` |

62 | ```
int e;
``` |
||

63 | if ( !d) return 0; |
||

64 | else if(d-d) return 0x7FF0000000000000LL + ((int64_t)(d<0)<<63) + (d!=d); |
||

65 | d= frexp(d, &e); |
||

66 | return (int64_t)(d<0)<<63 | (e+1022LL)<<52 | (int64_t)((fabs(d)-0.5)*(1LL<<53)); |
||

67 | } |
||

68 | |||

69 | ```
int32_t av_flt2int(float d){
``` |
||

70 | ```
int e;
``` |
||

71 | if ( !d) return 0; |
||

72 | else if(d-d) return 0x7F800000 + ((d<0)<<31) + (d!=d); |
||

73 | d= frexp(d, &e); |
||

74 | return (d<0)<<31 | (e+126)<<23 | (int64_t)((fabs(d)-0.5)*(1<<24)); |
||

75 | } |
||

76 | f11288da | Michael Niedermayer | |

77 | ```
AVExtFloat av_dbl2ext(double d){
``` |
||

78 | 767aeb11 | Michael Niedermayer | struct AVExtFloat ext= {{0}}; |

79 | f11288da | Michael Niedermayer | int e, i; double f; uint64_t m; |

80 | |||

81 | f = fabs(frexp(d, &e)); |
||

82 | if (f >= 0.5 && f < 1) { |
||

83 | ```
e += 16382;
``` |
||

84 | ext.exponent[0] = e>>8; |
||

85 | ```
ext.exponent[1] = e;
``` |
||

86 | ```
m = (uint64_t)ldexp(f, 64);
``` |
||

87 | for (i=0; i < 8; i++) |
||

88 | ext.mantissa[i] = m>>(56-(i<<3)); |
||

89 | 767aeb11 | Michael Niedermayer | } else if (f != 0.0) { |

90 | f11288da | Michael Niedermayer | ext.exponent[0] = 0x7f; ext.exponent[1] = 0xff; |

91 | if (f != 1/0.0) |
||

92 | ext.mantissa[0] = ~0; |
||

93 | } |
||

94 | if (d < 0) |
||

95 | ext.exponent[0] |= 0x80; |
||

96 | ```
return ext;
``` |
||

97 | } |