falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
92476 Commits
32 Branches
1.0GB
Tree: 2de165a92b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2de165a92b'
${ noResults }
FFmpeg/libavutil/avsscanf.c

973 lines
25KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2005-2014 Rich Felker, et al.

  3.  *

  4.  * Permission is hereby granted, free of charge, to any person obtaining

  5.  * a copy of this software and associated documentation files (the

  6.  * "Software"), to deal in the Software without restriction, including

  7.  * without limitation the rights to use, copy, modify, merge, publish,

  8.  * distribute, sublicense, and/or sell copies of the Software, and to

  9.  * permit persons to whom the Software is furnished to do so, subject to

  10.  * the following conditions:

  11.  *

  12.  * The above copyright notice and this permission notice shall be

  13.  * included in all copies or substantial portions of the Software.

  14.  *

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  16.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  17.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

  18.  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

  19.  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

  20.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

  21.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  22.  */

  23. 

  24. #include <stdarg.h>

  25. #include <stdint.h>

  26. #include <stdio.h>

  27. #include <string.h>

  28. #include <float.h>

  29. 

  30. #include "config.h"

  31. #include "common.h"

  32. #include "mem.h"

  33. #include "avassert.h"

  34. #include "avstring.h"

  35. #include "bprint.h"

  36. 

  37. typedef struct FFFILE {

  38.     size_t buf_size;

  39.     unsigned char *buf;

  40.     unsigned char *rpos, *rend;

  41.     unsigned char *shend;

  42.     off_t shlim, shcnt;

  43.     void *cookie;

  44.     size_t (*read)(struct FFFILE *, unsigned char *, size_t);

  45. } FFFILE;

  46. 

  47. #define SIZE_hh -2

  48. #define SIZE_h  -1

  49. #define SIZE_def 0

  50. #define SIZE_l   1

  51. #define SIZE_L   2

  52. #define SIZE_ll  3

  53. 

  54. #define shcnt(f) ((f)->shcnt + ((f)->rpos - (f)->buf))

  55. 

  56. static int fftoread(FFFILE *f)

  57. {

  58.     f->rpos = f->rend = f->buf + f->buf_size;

  59.     return 0;

  60. }

  61. 

  62. static size_t ffstring_read(FFFILE *f, unsigned char *buf, size_t len)

  63. {

  64.     char *src = f->cookie;

  65.     size_t k = len+256;

  66.     char *end = memchr(src, 0, k);

  67. 

  68.     if (end) k = end-src;

  69.     if (k < len) len = k;

  70.     memcpy(buf, src, len);

  71.     f->rpos = (void *)(src+len);

  72.     f->rend = (void *)(src+k);

  73.     f->cookie = src+k;

  74. 

  75.     return len;

  76. }

  77. 

  78. static int ffuflow(FFFILE *f)

  79. {

  80.     unsigned char c;

  81.     if (!fftoread(f) && f->read(f, &c, 1)==1) return c;

  82.     return EOF;

  83. }

  84. 

  85. static void ffshlim(FFFILE *f, off_t lim)

  86. {

  87.     f->shlim = lim;

  88.     f->shcnt = f->buf - f->rpos;

  89.     /* If lim is nonzero, rend must be a valid pointer. */

  90.     if (lim && f->rend - f->rpos > lim)

  91.         f->shend = f->rpos + lim;

  92.     else

  93.         f->shend = f->rend;

  94. }

  95. 

  96. static int ffshgetc(FFFILE *f)

  97. {

  98.     int c;

  99.     off_t cnt = shcnt(f);

  100.     if (f->shlim && cnt >= f->shlim || (c=ffuflow(f)) < 0) {

  101.         f->shcnt = f->buf - f->rpos + cnt;

  102.         f->shend = 0;

  103.         return EOF;

  104.     }

  105.     cnt++;

  106.     if (f->shlim && f->rend - f->rpos > f->shlim - cnt)

  107.         f->shend = f->rpos + (f->shlim - cnt);

  108.     else

  109.         f->shend = f->rend;

  110.     f->shcnt = f->buf - f->rpos + cnt;

  111.     if (f->rpos[-1] != c) f->rpos[-1] = c;

  112.     return c;

  113. }

  114. 

  115. #define shlim(f, lim) ffshlim((f), (lim))

  116. #define shgetc(f) (((f)->rpos != (f)->shend) ? *(f)->rpos++ : ffshgetc(f))

  117. #define shunget(f) ((f)->shend ? (void)(f)->rpos-- : (void)0)

  118. 

  119. static const unsigned char table[] = { -1,

  120.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  121.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  122.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  123.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,

  124.     -1,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,

  125.     25,26,27,28,29,30,31,32,33,34,35,-1,-1,-1,-1,-1,

  126.     -1,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,

  127.     25,26,27,28,29,30,31,32,33,34,35,-1,-1,-1,-1,-1,

  128.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  129.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  130.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  131.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  132.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  133.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  134.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  135.     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,

  136. };

  137. 

  138. static unsigned long long ffintscan(FFFILE *f, unsigned base, int pok, unsigned long long lim)

  139. {

  140.     const unsigned char *val = table+1;

  141.     int c, neg=0;

  142.     unsigned x;

  143.     unsigned long long y;

  144.     if (base > 36 || base == 1) {

  145.         errno = EINVAL;

  146.         return 0;

  147.     }

  148.     while (av_isspace((c=shgetc(f))));

  149.     if (c=='+' || c=='-') {

  150.         neg = -(c=='-');

  151.         c = shgetc(f);

  152.     }

  153.     if ((base == 0 || base == 16) && c=='0') {

  154.         c = shgetc(f);

  155.         if ((c|32)=='x') {

  156.             c = shgetc(f);

  157.             if (val[c]>=16) {

  158.                 shunget(f);

  159.                 if (pok) shunget(f);

  160.                 else shlim(f, 0);

  161.                 return 0;

  162.             }

  163.             base = 16;

  164.         } else if (base == 0) {

  165.             base = 8;

  166.         }

  167.     } else {

  168.         if (base == 0) base = 10;

  169.         if (val[c] >= base) {

  170.             shunget(f);

  171.             shlim(f, 0);

  172.             errno = EINVAL;

  173.             return 0;

  174.         }

  175.     }

  176.     if (base == 10) {

  177.         for (x=0; c-'0'<10U && x<=UINT_MAX/10-1; c=shgetc(f))

  178.             x = x*10 + (c-'0');

  179.         for (y=x; c-'0'<10U && y<=ULLONG_MAX/10 && 10*y<=ULLONG_MAX-(c-'0'); c=shgetc(f))

  180.             y = y*10 + (c-'0');

  181.         if (c-'0'>=10U) goto done;

  182.     } else if (!(base & base-1)) {

  183.         int bs = "\0\1\2\4\7\3\6\5"[(0x17*base)>>5&7];

  184.         for (x=0; val[c]<base && x<=UINT_MAX/32; c=shgetc(f))

  185.             x = x<<bs | val[c];

  186.         for (y=x; val[c]<base && y<=ULLONG_MAX>>bs; c=shgetc(f))

  187.             y = y<<bs | val[c];

  188.     } else {

  189.         for (x=0; val[c]<base && x<=UINT_MAX/36-1; c=shgetc(f))

  190.             x = x*base + val[c];

  191.         for (y=x; val[c]<base && y<=ULLONG_MAX/base && base*y<=ULLONG_MAX-val[c]; c=shgetc(f))

  192.             y = y*base + val[c];

  193.     }

  194.     if (val[c]<base) {

  195.         for (; val[c]<base; c=shgetc(f));

  196.         errno = ERANGE;

  197.         y = lim;

  198.         if (lim&1) neg = 0;

  199.     }

  200. done:

  201.     shunget(f);

  202.     if (y>=lim) {

  203.         if (!(lim&1) && !neg) {

  204.             errno = ERANGE;

  205.             return lim-1;

  206.         } else if (y>lim) {

  207.             errno = ERANGE;

  208.             return lim;

  209.         }

  210.     }

  211.     return (y^neg)-neg;

  212. }

  213. 

  214. static long long scanexp(FFFILE *f, int pok)

  215. {

  216.     int c;

  217.     int x;

  218.     long long y;

  219.     int neg = 0;

  220. 

  221.     c = shgetc(f);

  222.     if (c=='+' || c=='-') {

  223.         neg = (c=='-');

  224.         c = shgetc(f);

  225.         if (c-'0'>=10U && pok) shunget(f);

  226.     }

  227.     if (c-'0'>=10U) {

  228.         shunget(f);

  229.         return LLONG_MIN;

  230.     }

  231.     for (x=0; c-'0'<10U && x<INT_MAX/10; c = shgetc(f))

  232.         x = 10*x + c-'0';

  233.     for (y=x; c-'0'<10U && y<LLONG_MAX/100; c = shgetc(f))

  234.         y = 10*y + c-'0';

  235.     for (; c-'0'<10U; c = shgetc(f));

  236.     shunget(f);

  237.     return neg ? -y : y;

  238. }

  239. 

  240. #define LD_B1B_DIG 2

  241. #define LD_B1B_MAX 9007199, 254740991

  242. #define KMAX 128

  243. #define MASK (KMAX-1)

  244. #define CONCAT2(x,y) x ## y

  245. #define CONCAT(x,y) CONCAT2(x,y)

  246. 

  247. static double decfloat(FFFILE *f, int c, int bits, int emin, int sign, int pok)

  248. {

  249.     uint32_t x[KMAX];

  250.     static const uint32_t th[] = { LD_B1B_MAX };

  251.     int i, j, k, a, z;

  252.     long long lrp=0, dc=0;

  253.     long long e10=0;

  254.     int lnz = 0;

  255.     int gotdig = 0, gotrad = 0;

  256.     int rp;

  257.     int e2;

  258.     int emax = -emin-bits+3;

  259.     int denormal = 0;

  260.     double y;

  261.     double frac=0;

  262.     double bias=0;

  263.     static const int p10s[] = { 10, 100, 1000, 10000,

  264.         100000, 1000000, 10000000, 100000000 };

  265. 

  266.     j=0;

  267.     k=0;

  268. 

  269.     /* Don't let leading zeros consume buffer space */

  270.     for (; c=='0'; c = shgetc(f)) gotdig=1;

  271.     if (c=='.') {

  272.         gotrad = 1;

  273.         for (c = shgetc(f); c=='0'; c = shgetc(f)) gotdig=1, lrp--;

  274.     }

  275. 

  276.     x[0] = 0;

  277.     for (; c-'0'<10U || c=='.'; c = shgetc(f)) {

  278.         if (c == '.') {

  279.             if (gotrad) break;

  280.             gotrad = 1;

  281.             lrp = dc;

  282.         } else if (k < KMAX-3) {

  283.             dc++;

  284.             if (c!='0') lnz = dc;

  285.             if (j) x[k] = x[k]*10 + c-'0';

  286.             else x[k] = c-'0';

  287.             if (++j==9) {

  288.                 k++;

  289.                 j=0;

  290.             }

  291.             gotdig=1;

  292.         } else {

  293.             dc++;

  294.             if (c!='0') {

  295.                 lnz = (KMAX-4)*9;

  296.                 x[KMAX-4] |= 1;

  297.             }

  298.         }

  299.     }

  300.     if (!gotrad) lrp=dc;

  301. 

  302.     if (gotdig && (c|32)=='e') {

  303.         e10 = scanexp(f, pok);

  304.         if (e10 == LLONG_MIN) {

  305.             if (pok) {

  306.                 shunget(f);

  307.             } else {

  308.                 shlim(f, 0);

  309.                 return 0;

  310.             }

  311.             e10 = 0;

  312.         }

  313.         lrp += e10;

  314.     } else if (c>=0) {

  315.         shunget(f);

  316.     }

  317.     if (!gotdig) {

  318.         errno = EINVAL;

  319.         shlim(f, 0);

  320.         return 0;

  321.     }

  322. 

  323.     /* Handle zero specially to avoid nasty special cases later */

  324.     if (!x[0]) return sign * 0.0;

  325. 

  326.     /* Optimize small integers (w/no exponent) and over/under-flow */

  327.     if (lrp==dc && dc<10 && (bits>30 || x[0]>>bits==0))

  328.         return sign * (double)x[0];

  329.     if (lrp > -emin/2) {

  330.         errno = ERANGE;

  331.         return sign * DBL_MAX * DBL_MAX;

  332.     }

  333.     if (lrp < emin-2*DBL_MANT_DIG) {

  334.         errno = ERANGE;

  335.         return sign * DBL_MIN * DBL_MIN;

  336.     }

  337. 

  338.     /* Align incomplete final B1B digit */

  339.     if (j) {

  340.         for (; j<9; j++) x[k]*=10;

  341.         k++;

  342.         j=0;

  343.     }

  344. 

  345.     a = 0;

  346.     z = k;

  347.     e2 = 0;

  348.     rp = lrp;

  349. 

  350.     /* Optimize small to mid-size integers (even in exp. notation) */

  351.     if (lnz<9 && lnz<=rp && rp < 18) {

  352.         int bitlim;

  353.         if (rp == 9) return sign * (double)x[0];

  354.         if (rp < 9) return sign * (double)x[0] / p10s[8-rp];

  355.         bitlim = bits-3*(int)(rp-9);

  356.         if (bitlim>30 || x[0]>>bitlim==0)

  357.             return sign * (double)x[0] * p10s[rp-10];

  358.     }

  359. 

  360.     /* Drop trailing zeros */

  361.     for (; !x[z-1]; z--);

  362. 

  363.     /* Align radix point to B1B digit boundary */

  364.     if (rp % 9) {

  365.         int rpm9 = rp>=0 ? rp%9 : rp%9+9;

  366.         int p10 = p10s[8-rpm9];

  367.         uint32_t carry = 0;

  368.         for (k=a; k!=z; k++) {

  369.             uint32_t tmp = x[k] % p10;

  370.             x[k] = x[k]/p10 + carry;

  371.             carry = 1000000000/p10 * tmp;

  372.             if (k==a && !x[k]) {

  373.                 a = (a+1 & MASK);

  374.                 rp -= 9;

  375.             }

  376.         }

  377.         if (carry) x[z++] = carry;

  378.         rp += 9-rpm9;

  379.     }

  380. 

  381.     /* Upscale until desired number of bits are left of radix point */

  382.     while (rp < 9*LD_B1B_DIG || (rp == 9*LD_B1B_DIG && x[a]<th[0])) {

  383.         uint32_t carry = 0;

  384.         e2 -= 29;

  385.         for (k=(z-1 & MASK); ; k=(k-1 & MASK)) {

  386.             uint64_t tmp = ((uint64_t)x[k] << 29) + carry;

  387.             if (tmp > 1000000000) {

  388.                 carry = tmp / 1000000000;

  389.                 x[k] = tmp % 1000000000;

  390.             } else {

  391.                 carry = 0;

  392.                 x[k] = tmp;

  393.             }

  394.             if (k==(z-1 & MASK) && k!=a && !x[k]) z = k;

  395.             if (k==a) break;

  396.         }

  397.         if (carry) {

  398.             rp += 9;

  399.             a = (a-1 & MASK);

  400.             if (a == z) {

  401.                 z = (z-1 & MASK);

  402.                 x[z-1 & MASK] |= x[z];

  403.             }

  404.             x[a] = carry;

  405.         }

  406.     }

  407. 

  408.     /* Downscale until exactly number of bits are left of radix point */

  409.     for (;;) {

  410.         uint32_t carry = 0;

  411.         int sh = 1;

  412.         for (i=0; i<LD_B1B_DIG; i++) {

  413.             k = (a+i & MASK);

  414.             if (k == z || x[k] < th[i]) {

  415.                 i=LD_B1B_DIG;

  416.                 break;

  417.             }

  418.             if (x[a+i & MASK] > th[i]) break;

  419.         }

  420.         if (i==LD_B1B_DIG && rp==9*LD_B1B_DIG) break;

  421.         /* FIXME: find a way to compute optimal sh */

  422.         if (rp > 9+9*LD_B1B_DIG) sh = 9;

  423.         e2 += sh;

  424.         for (k=a; k!=z; k=(k+1 & MASK)) {

  425.             uint32_t tmp = x[k] & (1<<sh)-1;

  426.             x[k] = (x[k]>>sh) + carry;

  427.             carry = (1000000000>>sh) * tmp;

  428.             if (k==a && !x[k]) {

  429.                 a = (a+1 & MASK);

  430.                 i--;

  431.                 rp -= 9;

  432.             }

  433.         }

  434.         if (carry) {

  435.             if ((z+1 & MASK) != a) {

  436.                 x[z] = carry;

  437.                 z = (z+1 & MASK);

  438.             } else x[z-1 & MASK] |= 1;

  439.         }

  440.     }

  441. 

  442.     /* Assemble desired bits into floating point variable */

  443.     for (y=i=0; i<LD_B1B_DIG; i++) {

  444.         if ((a+i & MASK)==z) x[(z=(z+1 & MASK))-1] = 0;

  445.         y = 1000000000.0L * y + x[a+i & MASK];

  446.     }

  447. 

  448.     y *= sign;

  449. 

  450.     /* Limit precision for denormal results */

  451.     if (bits > DBL_MANT_DIG+e2-emin) {

  452.         bits = DBL_MANT_DIG+e2-emin;

  453.         if (bits<0) bits=0;

  454.         denormal = 1;

  455.     }

  456. 

  457.     /* Calculate bias term to force rounding, move out lower bits */

  458.     if (bits < DBL_MANT_DIG) {

  459.         bias = copysignl(scalbn(1, 2*DBL_MANT_DIG-bits-1), y);

  460.         frac = fmodl(y, scalbn(1, DBL_MANT_DIG-bits));

  461.         y -= frac;

  462.         y += bias;

  463.     }

  464. 

  465.     /* Process tail of decimal input so it can affect rounding */

  466.     if ((a+i & MASK) != z) {

  467.         uint32_t t = x[a+i & MASK];

  468.         if (t < 500000000 && (t || (a+i+1 & MASK) != z))

  469.             frac += 0.25*sign;

  470.         else if (t > 500000000)

  471.             frac += 0.75*sign;

  472.         else if (t == 500000000) {

  473.             if ((a+i+1 & MASK) == z)

  474.                 frac += 0.5*sign;

  475.             else

  476.                 frac += 0.75*sign;

  477.         }

  478.         if (DBL_MANT_DIG-bits >= 2 && !fmodl(frac, 1))

  479.             frac++;

  480.     }

  481. 

  482.     y += frac;

  483.     y -= bias;

  484. 

  485.     if ((e2+DBL_MANT_DIG & INT_MAX) > emax-5) {

  486.         if (fabs(y) >= CONCAT(0x1p, DBL_MANT_DIG)) {

  487.             if (denormal && bits==DBL_MANT_DIG+e2-emin)

  488.                 denormal = 0;

  489.             y *= 0.5;

  490.             e2++;

  491.         }

  492.         if (e2+DBL_MANT_DIG>emax || (denormal && frac))

  493.             errno = ERANGE;

  494.     }

  495. 

  496.     return scalbnl(y, e2);

  497. }

  498. 

  499. static double hexfloat(FFFILE *f, int bits, int emin, int sign, int pok)

  500. {

  501.     uint32_t x = 0;

  502.     double y = 0;

  503.     double scale = 1;

  504.     double bias = 0;

  505.     int gottail = 0, gotrad = 0, gotdig = 0;

  506.     long long rp = 0;

  507.     long long dc = 0;

  508.     long long e2 = 0;

  509.     int d;

  510.     int c;

  511. 

  512.     c = shgetc(f);

  513. 

  514.     /* Skip leading zeros */

  515.     for (; c=='0'; c = shgetc(f))

  516.         gotdig = 1;

  517. 

  518.     if (c=='.') {

  519.         gotrad = 1;

  520.         c = shgetc(f);

  521.         /* Count zeros after the radix point before significand */

  522.         for (rp=0; c=='0'; c = shgetc(f), rp--) gotdig = 1;

  523.     }

  524. 

  525.     for (; c-'0'<10U || (c|32)-'a'<6U || c=='.'; c = shgetc(f)) {

  526.         if (c=='.') {

  527.             if (gotrad) break;

  528.             rp = dc;

  529.             gotrad = 1;

  530.         } else {

  531.             gotdig = 1;

  532.             if (c > '9') d = (c|32)+10-'a';

  533.             else d = c-'0';

  534.             if (dc<8) {

  535.                 x = x*16 + d;

  536.             } else if (dc < DBL_MANT_DIG/4+1) {

  537.                 y += d*(scale/=16);

  538.             } else if (d && !gottail) {

  539.                 y += 0.5*scale;

  540.                 gottail = 1;

  541.             }

  542.             dc++;

  543.         }

  544.     }

  545.     if (!gotdig) {

  546.         shunget(f);

  547.         if (pok) {

  548.             shunget(f);

  549.             if (gotrad) shunget(f);

  550.         } else {

  551.             shlim(f, 0);

  552.         }

  553.         return sign * 0.0;

  554.     }

  555.     if (!gotrad) rp = dc;

  556.     while (dc<8) x *= 16, dc++;

  557.     if ((c|32)=='p') {

  558.         e2 = scanexp(f, pok);

  559.         if (e2 == LLONG_MIN) {

  560.             if (pok) {

  561.                 shunget(f);

  562.             } else {

  563.                 shlim(f, 0);

  564.                 return 0;

  565.             }

  566.             e2 = 0;

  567.         }

  568.     } else {

  569.         shunget(f);

  570.     }

  571.     e2 += 4*rp - 32;

  572. 

  573.     if (!x) return sign * 0.0;

  574.     if (e2 > -emin) {

  575.         errno = ERANGE;

  576.         return sign * DBL_MAX * DBL_MAX;

  577.     }

  578.     if (e2 < emin-2*DBL_MANT_DIG) {

  579.         errno = ERANGE;

  580.         return sign * DBL_MIN * DBL_MIN;

  581.     }

  582. 

  583.     while (x < 0x80000000) {

  584.         if (y>=0.5) {

  585.             x += x + 1;

  586.             y += y - 1;

  587.         } else {

  588.             x += x;

  589.             y += y;

  590.         }

  591.         e2--;

  592.     }

  593. 

  594.     if (bits > 32+e2-emin) {

  595.         bits = 32+e2-emin;

  596.         if (bits<0) bits=0;

  597.     }

  598. 

  599.     if (bits < DBL_MANT_DIG)

  600.         bias = copysignl(scalbn(1, 32+DBL_MANT_DIG-bits-1), sign);

  601. 

  602.     if (bits<32 && y && !(x&1)) x++, y=0;

  603. 

  604.     y = bias + sign*(double)x + sign*y;

  605.     y -= bias;

  606. 

  607.     if (!y) errno = ERANGE;

  608. 

  609.     return scalbnl(y, e2);

  610. }

  611. 

  612. static double fffloatscan(FFFILE *f, int prec, int pok)

  613. {

  614.     int sign = 1;

  615.     size_t i;

  616.     int bits;

  617.     int emin;

  618.     int c;

  619. 

  620.     switch (prec) {

  621.     case 0:

  622.         bits = FLT_MANT_DIG;

  623.         emin = FLT_MIN_EXP-bits;

  624.         break;

  625.     case 1:

  626.         bits = DBL_MANT_DIG;

  627.         emin = DBL_MIN_EXP-bits;

  628.         break;

  629.     case 2:

  630.         bits = DBL_MANT_DIG;

  631.         emin = DBL_MIN_EXP-bits;

  632.         break;

  633.     default:

  634.         return 0;

  635.     }

  636. 

  637.     while (av_isspace((c = shgetc(f))));

  638. 

  639.     if (c=='+' || c=='-') {

  640.         sign -= 2*(c=='-');

  641.         c = shgetc(f);

  642.     }

  643. 

  644.     for (i=0; i<8 && (c|32)=="infinity"[i]; i++)

  645.         if (i<7) c = shgetc(f);

  646.     if (i==3 || i==8 || (i>3 && pok)) {

  647.         if (i!=8) {

  648.             shunget(f);

  649.             if (pok) for (; i>3; i--) shunget(f);

  650.         }

  651.         return sign * INFINITY;

  652.     }

  653.     if (!i) for (i=0; i<3 && (c|32)=="nan"[i]; i++)

  654.         if (i<2) c = shgetc(f);

  655.     if (i==3) {

  656.         if (shgetc(f) != '(') {

  657.             shunget(f);

  658.             return NAN;

  659.         }

  660.         for (i=1; ; i++) {

  661.             c = shgetc(f);

  662.             if (c-'0'<10U || c-'A'<26U || c-'a'<26U || c=='_')

  663.                 continue;

  664.             if (c==')') return NAN;

  665.             shunget(f);

  666.             if (!pok) {

  667.                 errno = EINVAL;

  668.                 shlim(f, 0);

  669.                 return 0;

  670.             }

  671.             while (i--) shunget(f);

  672.             return NAN;

  673.         }

  674.         return NAN;

  675.     }

  676. 

  677.     if (i) {

  678.         shunget(f);

  679.         errno = EINVAL;

  680.         shlim(f, 0);

  681.         return 0;

  682.     }

  683. 

  684.     if (c=='0') {

  685.         c = shgetc(f);

  686.         if ((c|32) == 'x')

  687.             return hexfloat(f, bits, emin, sign, pok);

  688.         shunget(f);

  689.         c = '0';

  690.     }

  691. 

  692.     return decfloat(f, c, bits, emin, sign, pok);

  693. }

  694. 

  695. static void *arg_n(va_list ap, unsigned int n)

  696. {

  697.     void *p;

  698.     unsigned int i;

  699.     va_list ap2;

  700.     va_copy(ap2, ap);

  701.     for (i=n; i>1; i--) va_arg(ap2, void *);

  702.     p = va_arg(ap2, void *);

  703.     va_end(ap2);

  704.     return p;

  705. }

  706. 

  707. static void store_int(void *dest, int size, unsigned long long i)

  708. {

  709.     if (!dest) return;

  710.     switch (size) {

  711.     case SIZE_hh:

  712.         *(char *)dest = i;

  713.         break;

  714.     case SIZE_h:

  715.         *(short *)dest = i;

  716.         break;

  717.     case SIZE_def:

  718.         *(int *)dest = i;

  719.         break;

  720.     case SIZE_l:

  721.         *(long *)dest = i;

  722.         break;

  723.     case SIZE_ll:

  724.         *(long long *)dest = i;

  725.         break;

  726.     }

  727. }

  728. 

  729. static int ff_vfscanf(FFFILE *f, const char *fmt, va_list ap)

  730. {

  731.     int width;

  732.     int size;

  733.     int base;

  734.     const unsigned char *p;

  735.     int c, t;

  736.     char *s;

  737.     void *dest=NULL;

  738.     int invert;

  739.     int matches=0;

  740.     unsigned long long x;

  741.     double y;

  742.     off_t pos = 0;

  743.     unsigned char scanset[257];

  744.     size_t i;

  745. 

  746.     for (p=(const unsigned char *)fmt; *p; p++) {

  747. 

  748.         if (av_isspace(*p)) {

  749.             while (av_isspace(p[1])) p++;

  750.             shlim(f, 0);

  751.             while (av_isspace(shgetc(f)));

  752.             shunget(f);

  753.             pos += shcnt(f);

  754.             continue;

  755.         }

  756.         if (*p != '%' || p[1] == '%') {

  757.             shlim(f, 0);

  758.             if (*p == '%') {

  759.                 p++;

  760.                 while (av_isspace((c=shgetc(f))));

  761.             } else {

  762.                 c = shgetc(f);

  763.             }

  764.             if (c!=*p) {

  765.                 shunget(f);

  766.                 if (c<0) goto input_fail;

  767.                 goto match_fail;

  768.             }

  769.             pos += shcnt(f);

  770.             continue;

  771.         }

  772. 

  773.         p++;

  774.         if (*p=='*') {

  775.             dest = 0; p++;

  776.         } else if (av_isdigit(*p) && p[1]=='$') {

  777.             dest = arg_n(ap, *p-'0'); p+=2;

  778.         } else {

  779.             dest = va_arg(ap, void *);

  780.         }

  781. 

  782.         for (width=0; av_isdigit(*p); p++) {

  783.             width = 10*width + *p - '0';

  784.         }

  785. 

  786.         if (*p=='m') {

  787.             s = 0;

  788.             p++;

  789.         }

  790. 

  791.         size = SIZE_def;

  792.         switch (*p++) {

  793.         case 'h':

  794.             if (*p == 'h') p++, size = SIZE_hh;

  795.             else size = SIZE_h;

  796.             break;

  797.         case 'l':

  798.             if (*p == 'l') p++, size = SIZE_ll;

  799.             else size = SIZE_l;

  800.             break;

  801.         case 'j':

  802.             size = SIZE_ll;

  803.             break;

  804.         case 'z':

  805.         case 't':

  806.             size = SIZE_l;

  807.             break;

  808.         case 'L':

  809.             size = SIZE_L;

  810.             break;

  811.         case 'd': case 'i': case 'o': case 'u': case 'x':

  812.         case 'a': case 'e': case 'f': case 'g':

  813.         case 'A': case 'E': case 'F': case 'G': case 'X':

  814.         case 's': case 'c': case '[':

  815.         case 'S': case 'C':

  816.         case 'p': case 'n':

  817.             p--;

  818.             break;

  819.         default:

  820.             goto fmt_fail;

  821.         }

  822. 

  823.         t = *p;

  824. 

  825.         /* C or S */

  826.         if ((t&0x2f) == 3) {

  827.             t |= 32;

  828.             size = SIZE_l;

  829.         }

  830. 

  831.         switch (t) {

  832.             case 'c':

  833.                 if (width < 1) width = 1;

  834.             case '[':

  835.                 break;

  836.             case 'n':

  837.                 store_int(dest, size, pos);

  838.                 /* do not increment match count, etc! */

  839.                 continue;

  840.             default:

  841.                 shlim(f, 0);

  842.                 while (av_isspace(shgetc(f)));

  843.                 shunget(f);

  844.                 pos += shcnt(f);

  845.         }

  846. 

  847.         shlim(f, width);

  848.         if (shgetc(f) < 0) goto input_fail;

  849.         shunget(f);

  850. 

  851.         switch (t) {

  852.             case 's':

  853.             case 'c':

  854.             case '[':

  855.                 if (t == 'c' || t == 's') {

  856.                     memset(scanset, -1, sizeof scanset);

  857.                     scanset[0] = 0;

  858.                     if (t == 's') {

  859.                         scanset[1 + '\t'] = 0;

  860.                         scanset[1 + '\n'] = 0;

  861.                         scanset[1 + '\v'] = 0;

  862.                         scanset[1 + '\f'] = 0;

  863.                         scanset[1 + '\r'] = 0;

  864.                         scanset[1 + ' ' ] = 0;

  865.                     }

  866.                 } else {

  867.                     if (*++p == '^') p++, invert = 1;

  868.                     else invert = 0;

  869.                     memset(scanset, invert, sizeof scanset);

  870.                     scanset[0] = 0;

  871.                     if (*p == '-') p++, scanset[1+'-'] = 1-invert;

  872.                     else if (*p == ']') p++, scanset[1+']'] = 1-invert;

  873.                     for (; *p != ']'; p++) {

  874.                         if (!*p) goto fmt_fail;

  875.                         if (*p=='-' && p[1] && p[1] != ']')

  876.                             for (c=p++[-1]; c<*p; c++)

  877.                                 scanset[1+c] = 1-invert;

  878.                         scanset[1+*p] = 1-invert;

  879.                     }

  880.                 }

  881.                 s = 0;

  882.                 i = 0;

  883.                 if ((s = dest)) {

  884.                     while (scanset[(c=shgetc(f))+1])

  885.                         s[i++] = c;

  886.                 } else {

  887.                     while (scanset[(c=shgetc(f))+1]);

  888.                 }

  889.                 shunget(f);

  890.                 if (!shcnt(f)) goto match_fail;

  891.                 if (t == 'c' && shcnt(f) != width) goto match_fail;

  892.                 if (t != 'c') {

  893.                     if (s) s[i] = 0;

  894.                 }

  895.                 break;

  896.             case 'p':

  897.             case 'X':

  898.             case 'x':

  899.                 base = 16;

  900.                 goto int_common;

  901.             case 'o':

  902.                 base = 8;

  903.                 goto int_common;

  904.             case 'd':

  905.             case 'u':

  906.                 base = 10;

  907.                 goto int_common;

  908.             case 'i':

  909.                 base = 0;

  910. int_common:

  911.                 x = ffintscan(f, base, 0, ULLONG_MAX);

  912.                 if (!shcnt(f))

  913.                     goto match_fail;

  914.                 if (t=='p' && dest)

  915.                     *(void **)dest = (void *)(uintptr_t)x;

  916.                 else

  917.                     store_int(dest, size, x);

  918.                 break;

  919.             case 'a': case 'A':

  920.             case 'e': case 'E':

  921.             case 'f': case 'F':

  922.             case 'g': case 'G':

  923.                 y = fffloatscan(f, size, 0);

  924.                 if (!shcnt(f))

  925.                     goto match_fail;

  926.                 if (dest) {

  927.                     switch (size) {

  928.                     case SIZE_def:

  929.                         *(float *)dest = y;

  930.                         break;

  931.                     case SIZE_l:

  932.                         *(double *)dest = y;

  933.                         break;

  934.                     case SIZE_L:

  935.                         *(double *)dest = y;

  936.                         break;

  937.                     }

  938.                 }

  939.                 break;

  940.         }

  941. 

  942.         pos += shcnt(f);

  943.         if (dest) matches++;

  944.     }

  945.     if (0) {

  946. fmt_fail:

  947. input_fail:

  948.         if (!matches) matches--;

  949.     }

  950. match_fail:

  951.     return matches;

  952. }

  953. 

  954. static int ff_vsscanf(const char *s, const char *fmt, va_list ap)

  955. {

  956.     FFFILE f = {

  957.         .buf = (void *)s, .cookie = (void *)s,

  958.         .read = ffstring_read,

  959.     };

  960. 

  961.     return ff_vfscanf(&f, fmt, ap);

  962. }

  963. 

  964. int av_sscanf(const char *string, const char *format, ...)

  965. {

  966.     int ret;

  967.     va_list ap;

  968.     va_start(ap, format);

  969.     ret = ff_vsscanf(string, format, ap);

  970.     va_end(ap);

  971.     return ret;

  972. }