1:    2:    3:    4:    5:    6:    7:    8:    9:   10:   11:   12:   13:   14:   15:   16:   17:   18:   19:   20:   21:   22:   23:   24:   25:   26:   27:   28:   29:   30:   31:   32:   33:   34:   35:   36:   37:   38:   39:   40:   41:   42:   43:   44:   45:   46:   47:   48:   49:   50:   51:   52:   53:   54:   55:   56:   57:   58:   59:   60:   61:   62:   63:   64:   65:   66:   67:   68:   69:   70:   71:   72:   73:   74:   75:   76:   77:   78:   79:   80:   81:   82:   83:   84:   85:   86:   87:   88:   89:   90:   91:   92:   93:   94:   95:   96:   97:   98:   99:  100:  101:  102:  103:  104:  105:  106:  107:  108:  109:  110:  111:  112:  113:  114:  115:  116:  117:  118:  119:  120:  121:  122:  123:  124:  125:  126:  127:  128:  129:  130:  131:  132:  133:  134:  135:  136:  137:  138:  139:  140:  141:  142:  143:  144:  145:  146:  147:  148:  149:  150:  151:  152:  153:  154:  155:  156:  157:  158:  159:  160:  161:  162:  163:  164:  165:  166:  167:  168:  169:  170:  171:  172:  173:  174:  175:  176:  177:  178:  179:  180:  181:  182:  183:  184:  185:  186:  187:  188:  189:  190:  191:  192:  193:  194:  195:  196:  197:  198:  199:  200:  201:  202:  203:  204:  205:  206:  207:  208:  209:  210:  211:  212:  213:  214:  215:  216:  217:  218:  219:  220:  221:  222:  223:  224:  225:  226:  227:  228:  229:  230:  231:  232:  233:  234:  235:  236:  237:  238:  239:  240:  241:  242:  243:  244:  245:  246:  247:  248:  249:  250:  251:  252:  253:  254:  255:  256:  257:  258:  259:  260:  261:  262:  263:  264:  265:  266:  267:  268:  269:  270:  271:  272:  273:  274:  275:  276:  277:  278:  279:  280:  281:  282:  283:  284:  285:  286:  287:  288:  289:  290:  291:  292:  293:  294:  295:  296:  297:  298:  299:  300:  301:  302:  303:  304:  305:  306:  307:  308:  309:  310:  311:  312:  313:  314:  315:  316:  317:  318:  319:  320:  321:  322:  323:  324:  325:  326:  327:  328:  329:  330:  331:  332:  333:  334:  335:  336:  337:  338:  339:  340:  341:  342:  343:  344:  345:  346:  347:  348:  349:  350:  351:  352:  353:  354:  355:  356:  357:  358:  359:  360:  361:  362:  363:  364:  365:  366:  367:  368:  369:  370:  371:  372:  373:  374:  375:  376:  377:  378:  379:  380:  381:  382:  383:  384:  385:  386:  387:  388:  389:  390:  391:  392:  393:  394:  395:  396:  397:  398:  399:  400:  401:  402:  403:  404:  405:  406:  407:  408:  409:  410:  411:  412:  413:  414:  415:  416:  417:  418:  419:  420:  421:  422:  423:  424:  425:  426:  427:  428:  429:  430:  431:  432:  433:  434:  435:  436:  437:  438:  439:  440:  441:  442:  443:  444:  445:  446:  447:  448:  449:  450:  451:  452:  453:  454:  455:  456:  457:  458:  459:  460:  461:  462:  463:  464:  465:  466:  467:  468:  469:  470:  471:  472:  473:  474:  475:  476:  477:  478:  479:  480:  481:  482:  483:  484:  485:  486:  487:  488:  489:  490:  491:  492:  493:  494:  495:  496:  497:  498:  499:  500:  501:  502:  503:  504:  505:  506:  507:  508:  509:  510:  511:  512:  513:  514:  515:  516:  517:  518:  519:  520:  521:  522:  523:  524:  525:  526:  527:  528:  529:  530:  531:  532:  533:  534:  535:  536:  537:  538:  539:  540:  541:  542:  543:  544:  545:  546:  547:  548:  549:  550:  551:  552:  553:  554:  555:  556:  557:  558:  559:  560:  561:  562:  563:  564:  565:  566:  567:  568:  569:  570:  571:  572:  573:  574:  575:  576:  577:  578:  579:  580:  581:  582:  583:  584:  585:  586:  587:  588:  589:  590:  591:  592:  593:  594:  595:  596:  597:  598:  599:  600:  601:  602:  603:  604:  605:  606:  607:  608:  609:  610:  611:  612:  613:  614:  615:  616:  617:  618:  619:  620:  621:  622:  623:  624:  625:  626:  627:  628:  629:  630:  631:  632:  633:  634:  635:  636:  637:  638:  639:  640:  641:  642:  643:  644:  645:  646:  647:  648:  649:  650:  651:  652:  653:  654:  655:  656:  657:  658:  659:  660:  661:  662:  663:  664:  665:  666:  667:  668:  669:  670:  671:  672:  673:  674:  675:  676:  677:  678:  679:  680:  681:  682:  683:  684:  685:  686:  687:  688:  689:  690:  691:  692:  693:  694:  695:  696:  697:  698:  699:  700:  701:  702:  703:  704:  705:  706:  707:  708:  709:  710:  711:  712:  713:  714:  715:  716:  717:  718:  719:  720:  721:  722:  723:  724:  725:  726:  727:  728:  729:  730:  731:  732:  733:  734:  735:  736:  737:  738:  739:  740:  741:  742:  743:  744:  745:  746:  747:  748:  749:  750:  751:  752:  753:  754:  755:  756:  757:  758:  759:  760:  761:  762:  763:  764:  765:  766:  767:  768:  769:  770:  771:  772:  773:  774:  775:  776:  777:  778:  779:  780:  781:  782:  783:  784:  785:  786:  787:  788:  789:  790:  791:  792:  793:  794:  795:  796:  797:  798:  799:  800:  801:  802:  803:  804:  805:  806:  807:  808:  809:  810:  811:  812:  813:  814:  815:  816:  817:  818:  819:  820:  821:  822:  823:  824:  825:  826:  827:  828:  829:  830:  831:  832:  833:  834:  835:  836:  837:  838:  839:  840:  841:  842:  843:  844:  845:  846:  847:  848:  849:  850:  851:  852:  853:  854:  855:  856:  857:  858:  859:  860:  861:  862:  863:  864:  865:  866:  867:  868:  869:  870:  871:  872:  873:  874:  875:  876:  877:  878:  879:  880:  881:  882:  883:  884:  885:  886:  887:  888:  889:  890:  891:  892:  893:  894:  895:  896:  897:  898:  899:  900:  901:  902:  903:  904:  905:  906:  907:  908:  909:  910:  911:  912:  913:  914:  915:  916:  917:  918:  919:  920:  921:  922:  923:  924:  925:  926:  927:  928:  929:  930:  931:  932:  933:  934:  935:  936:  937:  938:  939:  940:  941:  942:  943:  944:  945:  946:  947:  948:  949:  950:  951:  952:  953:  954:  955:  956:  957:  958:  959:  960:  961:  962:  963:  964:  965:  966:  967:  968:  969:  970:  971:  972:  973:  974:  975:  976:  977:  978:  979:  980:  981:  982:  983:  984:  985:  986:  987:  988:  989:  990:  991:  992:  993:  994:  995:  996:  997:  998:  999: 1000: 1001: 1002: 1003: 1004: 1005: 1006: 1007: 1008: 1009: 1010: 1011: 1012: 1013: 1014: 1015: 1016: 1017: 1018: 1019: 1020: 1021: 1022: 1023: 1024: 1025: 1026: 1027: 1028: 1029: 1030: 1031: 1032: 1033: 1034: 1035: 1036: 1037: 1038: 1039: 1040: 1041: 1042: 1043: 1044: 1045: 1046: 1047: 1048: 1049: 1050: 1051: 1052: 1053: 1054: 1055: 1056: 1057: 1058: 1059: 1060: 1061: 1062: 1063: 1064: 1065: 1066: 1067: 1068: 1069: 1070: 1071: 1072: 1073: 1074: 1075: 1076: 1077: 1078: 1079: 1080: 1081: 1082: 1083: 1084: 1085: 1086: 1087: 1088: 1089: 1090: 1091: 1092: 1093: 1094: 1095: 1096: 1097: 1098: 1099: 1100: 1101: 1102: 1103: 1104: 1105: 1106: 1107: 1108: 1109: 1110: 1111: 1112: 1113: 1114: 1115: 1116: 1117: 1118: 1119: 1120: 1121: 1122: 1123: 1124: 1125: 1126: 1127: 1128: 1129: 1130: 1131: 1132: 1133: 1134: 1135: 1136: 1137: 1138: 1139: 1140: 1141: 1142: 1143: 1144: 1145: 1146: 1147: 1148: 1149: 1150: 1151: 1152: 1153: 1154: 1155: 1156: 1157: 1158: 1159: 1160: 1161: 1162: 1163: 1164: 1165: 1166: 1167: 1168: 1169: 1170: 1171: 1172: 1173: 1174: 1175: 1176: 1177: 1178: 1179: 1180: 1181: 1182: 1183: 1184: 1185: 1186: 1187: 1188: 1189: 1190: 1191: 1192: 1193: 1194: 1195: 1196: 1197: 1198: 1199: 1200: 1201: 1202: 1203: 1204: 1205: 1206: 1207: 1208: 1209: 1210: 1211: 1212: 1213: 1214: 1215: 1216: 1217: 1218: 1219: 1220: 1221: 1222: 1223: 1224: 1225: 1226: 1227: 1228: 1229: 1230: 1231: 1232: 1233: 1234: 1235: 1236: 1237: 1238: 1239: 1240: 1241: 1242: 1243: 1244: 1245: 1246: 1247: 1248: 1249: 1250: 1251: 1252: 1253: 1254: 1255: 1256: 1257: 1258: 1259: 1260: 1261: 1262: 1263: 1264: 1265: 1266: 1267: 1268: 1269: 1270: 1271: 1272: 1273: 1274: 1275: 1276: 1277: 1278: 1279: 1280: 1281: 1282: 1283: 1284: 1285: 1286: 1287: 1288: 1289: 1290: 1291: 1292: 1293: 1294: 1295: 1296: 1297: 1298: 1299: 1300: 1301: 1302: 1303: 1304: 1305: 1306: 1307: 1308: 1309: 1310: 1311: 1312: 1313: 1314: 1315: 1316: 1317: 1318: 1319: 1320: 1321: 1322: 1323: 1324: 1325: 1326: 1327: 1328: 1329: 1330: 1331: 1332: 1333: 1334: 1335: 1336: 1337: 1338: 1339: 1340: 1341: 1342: 1343: 1344: 1345: 1346: 1347: 1348: 1349: 1350: 1351: 1352: 1353: 1354: 1355: 1356: 1357: 1358: 1359: 1360: 1361: 1362: 1363: 1364: 1365: 1366: 1367: 1368: 1369: 1370: 1371: 1372: 1373: 1374: 1375: 1376: 1377: 1378: 1379: 1380: 1381: 1382: 1383: 1384: 1385: 1386: 1387: 1388: 1389: 1390: 1391: 1392: 1393: 1394: 1395: 1396: 1397: 1398: 1399: 1400: 1401: 1402: 1403: 1404: 1405: 1406: 1407: 1408: 1409: 1410: 1411: 1412: 1413: 1414: 1415: 1416: 1417: 1418: 1419: 1420: 1421: 1422: 1423: 1424: 1425: 1426: 1427: 1428: 1429: 1430: 1431: 1432: 1433: 1434: 1435: 1436: 1437: 1438: 1439: 1440: 1441: 1442: 1443: 1444: 1445: 1446: 1447: 1448: 1449: 1450: 1451: 1452: 1453: 1454: 1455: 1456: 1457: 1458: 1459: 1460: 1461: 1462: 1463: 1464: 1465: 1466: 1467: 1468: 1469: 1470: 1471: 1472: 1473: 1474: 1475: 1476: 1477: 1478: 1479: 1480: 1481: 1482: 1483: 1484: 1485: 1486: 1487: 1488: 1489: 1490: 1491: 1492: 1493: 1494: 1495: 1496: 1497: 1498: 1499: 1500: 1501: 1502: 1503: 1504: 1505: 1506: 1507: 1508: 1509: 1510: 1511: 1512: 1513: 1514: 1515: 1516: 1517: 1518: 1519: 1520: 1521: 1522: 1523: 1524: 1525: 1526: 1527: 1528: 1529: 1530: 1531: 1532: 1533: 1534: 1535: 1536: 1537: 1538: 1539: 1540: 1541: 1542: 1543: 1544: 1545: 1546: 1547: 1548: 1549: 1550: 1551: 1552: 1553: 1554: 1555: 1556: 1557: 1558: 1559: 1560: 1561: 1562: 1563: 1564: 1565: 1566: 1567: 1568: 1569: 1570: 1571: 1572: 1573: 1574: 1575: 1576: 1577: 1578: 1579: 1580: 1581: 1582: 1583: 1584: 1585: 1586: 1587: 1588: 1589: 1590: 1591: 1592: 1593: 1594: 1595: 1596: 1597: 1598: 1599: 1600: 1601: 1602: 1603: 1604: 1605: 1606: 1607: 1608: 1609: 1610: 1611: 1612: 1613: 1614: 1615: 1616: 1617: 1618: 1619: 1620: 1621: 1622: 1623: 1624: 1625: 1626: 1627: 1628: 1629: 1630: 1631: 1632: 1633: 1634: 1635: 1636: 1637: 1638: 1639: 1640: 1641: 1642: 1643: 1644: 1645: 1646: 1647: 1648: 1649: 1650: 1651: 1652: 1653: 1654: 1655: 1656: 1657: 1658: 1659: 1660: 1661: 1662: 1663: 1664: 1665: 1666: 1667: 1668: 1669: 1670: 1671: 1672: 1673: 1674: 1675: 1676: 1677: 1678: 1679: 1680: 1681: 1682: 1683: 1684: 1685: 1686: 1687: 1688: 1689: 1690: 1691: 1692: 1693: 1694: 1695: 1696: 1697: 1698: 1699: 1700: 1701: 1702: 1703: 1704: 1705: 1706: 1707: 1708: 1709: 1710: 1711: 1712: 1713: 1714: 1715: 1716: 1717: 1718: 1719: 1720: 1721: 1722: 1723: 1724: 1725: 1726: 1727: 1728: 1729: 1730: 1731: 1732: 1733: 1734: 1735: 1736: 1737: 1738: 1739: 1740: 1741: 1742: 1743: 1744: 1745: 1746: 1747: 1748: 1749: 1750: 1751: 1752: 1753: 1754: 1755: 1756: 1757: 1758: 1759: 1760: 1761: 1762: 1763: 1764: 1765: 1766: 1767: 1768: 1769: 1770: 1771: 1772: 1773: 1774: 1775: 1776: 1777: 1778: 1779: 1780: 1781: 1782: 1783: 1784: 1785: 1786: 1787: 1788: 1789: 1790: 1791: 1792: 1793: 1794: 1795: 1796: 1797: 1798: 1799: 1800: 1801: 1802: 

<?php

/////////////////////////////////////////////////////////////////
/// getID3() by James Heinrich <info@getid3.org>               //
//  available at https://github.com/JamesHeinrich/getID3       //
//            or https://www.getid3.org                        //
//            or http://getid3.sourceforge.net                 //
//                                                             //
// getid3.lib.php - part of getID3()                           //
//  see readme.txt for more details                            //
//                                                            ///
/////////////////////////////////////////////////////////////////


class getid3_lib
{
    /**
     * @param string      $string
     * @param bool        $hex
     * @param bool        $spaces
     * @param string|bool $htmlencoding
     *
     * @return string
     */
    public static function PrintHexBytes($string, $hex=true, $spaces=true, $htmlencoding='UTF-8') {
        $returnstring = '';
        for ($i = 0; $i < strlen($string); $i++) {
            if ($hex) {
                $returnstring .= str_pad(dechex(ord($string[$i])), 2, '0', STR_PAD_LEFT);
            } else {
                $returnstring .= ' '.(preg_match("#[\x20-\x7E]#", $string[$i]) ? $string[$i] : '¤');
            }
            if ($spaces) {
                $returnstring .= ' ';
            }
        }
        if (!empty($htmlencoding)) {
            if ($htmlencoding === true) {
                $htmlencoding = 'UTF-8'; // prior to getID3 v1.9.0 the function's 4th parameter was boolean
            }
            $returnstring = htmlentities($returnstring, ENT_QUOTES, $htmlencoding);
        }
        return $returnstring;
    }

    /**
     * Truncates a floating-point number at the decimal point.
     *
     * @param float $floatnumber
     *
     * @return float|int returns int (if possible, otherwise float)
     */
    public static function trunc($floatnumber) {
        if ($floatnumber >= 1) {
            $truncatednumber = floor($floatnumber);
        } elseif ($floatnumber <= -1) {
            $truncatednumber = ceil($floatnumber);
        } else {
            $truncatednumber = 0;
        }
        if (self::intValueSupported($truncatednumber)) {
            $truncatednumber = (int) $truncatednumber;
        }
        return $truncatednumber;
    }

    /**
     * @param int|null $variable
     * @param int      $increment
     *
     * @return bool
     */
    public static function safe_inc(&$variable, $increment=1) {
        if (isset($variable)) {
            $variable += $increment;
        } else {
            $variable = $increment;
        }
        return true;
    }

    /**
     * @param int|float $floatnum
     *
     * @return int|float
     */
    public static function CastAsInt($floatnum) {
        // convert to float if not already
        $floatnum = (float) $floatnum;

        // convert a float to type int, only if possible
        if (self::trunc($floatnum) == $floatnum) {
            // it's not floating point
            if (self::intValueSupported($floatnum)) {
                // it's within int range
                $floatnum = (int) $floatnum;
            }
        }
        return $floatnum;
    }

    /**
     * @param int $num
     *
     * @return bool
     */
    public static function intValueSupported($num) {
        // check if integers are 64-bit
        static $hasINT64 = null;
        if ($hasINT64 === null) { // 10x faster than is_null()
            $hasINT64 = is_int(pow(2, 31)); // 32-bit int are limited to (2^31)-1
            if (!$hasINT64 && !defined('PHP_INT_MIN')) {
                define('PHP_INT_MIN', ~PHP_INT_MAX);
            }
        }
        // if integers are 64-bit - no other check required
        if ($hasINT64 || (($num <= PHP_INT_MAX) && ($num >= PHP_INT_MIN))) {
            return true;
        }
        return false;
    }

    /**
     * @param string $fraction
     *
     * @return float
     */
    public static function DecimalizeFraction($fraction) {
        list($numerator, $denominator) = explode('/', $fraction);
        return $numerator / ($denominator ? $denominator : 1);
    }

    /**
     * @param string $binarynumerator
     *
     * @return float
     */
    public static function DecimalBinary2Float($binarynumerator) {
        $numerator   = self::Bin2Dec($binarynumerator);
        $denominator = self::Bin2Dec('1'.str_repeat('0', strlen($binarynumerator)));
        return ($numerator / $denominator);
    }

    /**
     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
     *
     * @param string $binarypointnumber
     * @param int    $maxbits
     *
     * @return array
     */
    public static function NormalizeBinaryPoint($binarypointnumber, $maxbits=52) {
        if (strpos($binarypointnumber, '.') === false) {
            $binarypointnumber = '0.'.$binarypointnumber;
        } elseif ($binarypointnumber[0] == '.') {
            $binarypointnumber = '0'.$binarypointnumber;
        }
        $exponent = 0;
        while (($binarypointnumber[0] != '1') || (substr($binarypointnumber, 1, 1) != '.')) {
            if (substr($binarypointnumber, 1, 1) == '.') {
                $exponent--;
                $binarypointnumber = substr($binarypointnumber, 2, 1).'.'.substr($binarypointnumber, 3);
            } else {
                $pointpos = strpos($binarypointnumber, '.');
                $exponent += ($pointpos - 1);
                $binarypointnumber = str_replace('.', '', $binarypointnumber);
                $binarypointnumber = $binarypointnumber[0].'.'.substr($binarypointnumber, 1);
            }
        }
        $binarypointnumber = str_pad(substr($binarypointnumber, 0, $maxbits + 2), $maxbits + 2, '0', STR_PAD_RIGHT);
        return array('normalized'=>$binarypointnumber, 'exponent'=>(int) $exponent);
    }

    /**
     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
     *
     * @param float $floatvalue
     *
     * @return string
     */
    public static function Float2BinaryDecimal($floatvalue) {
        $maxbits = 128; // to how many bits of precision should the calculations be taken?
        $intpart   = self::trunc($floatvalue);
        $floatpart = abs($floatvalue - $intpart);
        $pointbitstring = '';
        while (($floatpart != 0) && (strlen($pointbitstring) < $maxbits)) {
            $floatpart *= 2;
            $pointbitstring .= (string) self::trunc($floatpart);
            $floatpart -= self::trunc($floatpart);
        }
        $binarypointnumber = decbin($intpart).'.'.$pointbitstring;
        return $binarypointnumber;
    }

    /**
     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
     *
     * @param float $floatvalue
     * @param int $bits
     *
     * @return string|false
     */
    public static function Float2String($floatvalue, $bits) {
        $exponentbits = 0;
        $fractionbits = 0;
        switch ($bits) {
            case 32:
                $exponentbits = 8;
                $fractionbits = 23;
                break;

            case 64:
                $exponentbits = 11;
                $fractionbits = 52;
                break;

            default:
                return false;
        }
        if ($floatvalue >= 0) {
            $signbit = '0';
        } else {
            $signbit = '1';
        }
        $normalizedbinary  = self::NormalizeBinaryPoint(self::Float2BinaryDecimal($floatvalue), $fractionbits);
        $biasedexponent    = pow(2, $exponentbits - 1) - 1 + $normalizedbinary['exponent']; // (127 or 1023) +/- exponent
        $exponentbitstring = str_pad(decbin($biasedexponent), $exponentbits, '0', STR_PAD_LEFT);
        $fractionbitstring = str_pad(substr($normalizedbinary['normalized'], 2), $fractionbits, '0', STR_PAD_RIGHT);

        return self::BigEndian2String(self::Bin2Dec($signbit.$exponentbitstring.$fractionbitstring), $bits % 8, false);
    }

    /**
     * @param string $byteword
     *
     * @return float|false
     */
    public static function LittleEndian2Float($byteword) {
        return self::BigEndian2Float(strrev($byteword));
    }

    /**
     * ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
     *
     * @link http://www.psc.edu/general/software/packages/ieee/ieee.html
     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
     *
     * @param string $byteword
     *
     * @return float|false
     */
    public static function BigEndian2Float($byteword) {
        $bitword = self::BigEndian2Bin($byteword);
        if (!$bitword) {
            return 0;
        }
        $signbit = $bitword[0];
        $floatvalue = 0;
        $exponentbits = 0;
        $fractionbits = 0;

        switch (strlen($byteword) * 8) {
            case 32:
                $exponentbits = 8;
                $fractionbits = 23;
                break;

            case 64:
                $exponentbits = 11;
                $fractionbits = 52;
                break;

            case 80:
                // 80-bit Apple SANE format
                // http://www.mactech.com/articles/mactech/Vol.06/06.01/SANENormalized/
                $exponentstring = substr($bitword, 1, 15);
                $isnormalized = intval($bitword[16]);
                $fractionstring = substr($bitword, 17, 63);
                $exponent = pow(2, self::Bin2Dec($exponentstring) - 16383);
                $fraction = $isnormalized + self::DecimalBinary2Float($fractionstring);
                $floatvalue = $exponent * $fraction;
                if ($signbit == '1') {
                    $floatvalue *= -1;
                }
                return $floatvalue;

            default:
                return false;
        }
        $exponentstring = substr($bitword, 1, $exponentbits);
        $fractionstring = substr($bitword, $exponentbits + 1, $fractionbits);
        $exponent = self::Bin2Dec($exponentstring);
        $fraction = self::Bin2Dec($fractionstring);

        if (($exponent == (pow(2, $exponentbits) - 1)) && ($fraction != 0)) {
            // Not a Number
            $floatvalue = false;
        } elseif (($exponent == (pow(2, $exponentbits) - 1)) && ($fraction == 0)) {
            if ($signbit == '1') {
                $floatvalue = '-infinity';
            } else {
                $floatvalue = '+infinity';
            }
        } elseif (($exponent == 0) && ($fraction == 0)) {
            if ($signbit == '1') {
                $floatvalue = -0;
            } else {
                $floatvalue = 0;
            }
            $floatvalue = ($signbit ? 0 : -0);
        } elseif (($exponent == 0) && ($fraction != 0)) {
            // These are 'unnormalized' values
            $floatvalue = pow(2, (-1 * (pow(2, $exponentbits - 1) - 2))) * self::DecimalBinary2Float($fractionstring);
            if ($signbit == '1') {
                $floatvalue *= -1;
            }
        } elseif ($exponent != 0) {
            $floatvalue = pow(2, ($exponent - (pow(2, $exponentbits - 1) - 1))) * (1 + self::DecimalBinary2Float($fractionstring));
            if ($signbit == '1') {
                $floatvalue *= -1;
            }
        }
        return (float) $floatvalue;
    }

    /**
     * @param string $byteword
     * @param bool   $synchsafe
     * @param bool   $signed
     *
     * @return int|float|false
     * @throws Exception
     */
    public static function BigEndian2Int($byteword, $synchsafe=false, $signed=false) {
        $intvalue = 0;
        $bytewordlen = strlen($byteword);
        if ($bytewordlen == 0) {
            return false;
        }
        for ($i = 0; $i < $bytewordlen; $i++) {
            if ($synchsafe) { // disregard MSB, effectively 7-bit bytes
                //$intvalue = $intvalue | (ord($byteword{$i}) & 0x7F) << (($bytewordlen - 1 - $i) * 7); // faster, but runs into problems past 2^31 on 32-bit systems
                $intvalue += (ord($byteword[$i]) & 0x7F) * pow(2, ($bytewordlen - 1 - $i) * 7);
            } else {
                $intvalue += ord($byteword[$i]) * pow(256, ($bytewordlen - 1 - $i));
            }
        }
        if ($signed && !$synchsafe) {
            // synchsafe ints are not allowed to be signed
            if ($bytewordlen <= PHP_INT_SIZE) {
                $signMaskBit = 0x80 << (8 * ($bytewordlen - 1));
                if ($intvalue & $signMaskBit) {
                    $intvalue = 0 - ($intvalue & ($signMaskBit - 1));
                }
            } else {
                throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits ('.strlen($byteword).') in self::BigEndian2Int()');
            }
        }
        return self::CastAsInt($intvalue);
    }

    /**
     * @param string $byteword
     * @param bool   $signed
     *
     * @return int|float|false
     */
    public static function LittleEndian2Int($byteword, $signed=false) {
        return self::BigEndian2Int(strrev($byteword), false, $signed);
    }

    /**
     * @param string $byteword
     *
     * @return string
     */
    public static function LittleEndian2Bin($byteword) {
        return self::BigEndian2Bin(strrev($byteword));
    }

    /**
     * @param string $byteword
     *
     * @return string
     */
    public static function BigEndian2Bin($byteword) {
        $binvalue = '';
        $bytewordlen = strlen($byteword);
        for ($i = 0; $i < $bytewordlen; $i++) {
            $binvalue .= str_pad(decbin(ord($byteword[$i])), 8, '0', STR_PAD_LEFT);
        }
        return $binvalue;
    }

    /**
     * @param int  $number
     * @param int  $minbytes
     * @param bool $synchsafe
     * @param bool $signed
     *
     * @return string
     * @throws Exception
     */
    public static function BigEndian2String($number, $minbytes=1, $synchsafe=false, $signed=false) {
        if ($number < 0) {
            throw new Exception('ERROR: self::BigEndian2String() does not support negative numbers');
        }
        $maskbyte = (($synchsafe || $signed) ? 0x7F : 0xFF);
        $intstring = '';
        if ($signed) {
            if ($minbytes > PHP_INT_SIZE) {
                throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits in self::BigEndian2String()');
            }
            $number = $number & (0x80 << (8 * ($minbytes - 1)));
        }
        while ($number != 0) {
            $quotient = ($number / ($maskbyte + 1));
            $intstring = chr(ceil(($quotient - floor($quotient)) * $maskbyte)).$intstring;
            $number = floor($quotient);
        }
        return str_pad($intstring, $minbytes, "\x00", STR_PAD_LEFT);
    }

    /**
     * @param int $number
     *
     * @return string
     */
    public static function Dec2Bin($number) {
        while ($number >= 256) {
            $bytes[] = (($number / 256) - (floor($number / 256))) * 256;
            $number = floor($number / 256);
        }
        $bytes[] = $number;
        $binstring = '';
        for ($i = 0; $i < count($bytes); $i++) {
            $binstring = (($i == count($bytes) - 1) ? decbin($bytes[$i]) : str_pad(decbin($bytes[$i]), 8, '0', STR_PAD_LEFT)).$binstring;
        }
        return $binstring;
    }

    /**
     * @param string $binstring
     * @param bool   $signed
     *
     * @return int|float
     */
    public static function Bin2Dec($binstring, $signed=false) {
        $signmult = 1;
        if ($signed) {
            if ($binstring[0] == '1') {
                $signmult = -1;
            }
            $binstring = substr($binstring, 1);
        }
        $decvalue = 0;
        for ($i = 0; $i < strlen($binstring); $i++) {
            $decvalue += ((int) substr($binstring, strlen($binstring) - $i - 1, 1)) * pow(2, $i);
        }
        return self::CastAsInt($decvalue * $signmult);
    }

    /**
     * @param string $binstring
     *
     * @return string
     */
    public static function Bin2String($binstring) {
        // return 'hi' for input of '0110100001101001'
        $string = '';
        $binstringreversed = strrev($binstring);
        for ($i = 0; $i < strlen($binstringreversed); $i += 8) {
            $string = chr(self::Bin2Dec(strrev(substr($binstringreversed, $i, 8)))).$string;
        }
        return $string;
    }

    /**
     * @param int  $number
     * @param int  $minbytes
     * @param bool $synchsafe
     *
     * @return string
     */
    public static function LittleEndian2String($number, $minbytes=1, $synchsafe=false) {
        $intstring = '';
        while ($number > 0) {
            if ($synchsafe) {
                $intstring = $intstring.chr($number & 127);
                $number >>= 7;
            } else {
                $intstring = $intstring.chr($number & 255);
                $number >>= 8;
            }
        }
        return str_pad($intstring, $minbytes, "\x00", STR_PAD_RIGHT);
    }

    /**
     * @param mixed $array1
     * @param mixed $array2
     *
     * @return array|false
     */
    public static function array_merge_clobber($array1, $array2) {
        // written by kcØhireability*com
        // taken from http://www.php.net/manual/en/function.array-merge-recursive.php
        if (!is_array($array1) || !is_array($array2)) {
            return false;
        }
        $newarray = $array1;
        foreach ($array2 as $key => $val) {
            if (is_array($val) && isset($newarray[$key]) && is_array($newarray[$key])) {
                $newarray[$key] = self::array_merge_clobber($newarray[$key], $val);
            } else {
                $newarray[$key] = $val;
            }
        }
        return $newarray;
    }

    /**
     * @param mixed $array1
     * @param mixed $array2
     *
     * @return array|false
     */
    public static function array_merge_noclobber($array1, $array2) {
        if (!is_array($array1) || !is_array($array2)) {
            return false;
        }
        $newarray = $array1;
        foreach ($array2 as $key => $val) {
            if (is_array($val) && isset($newarray[$key]) && is_array($newarray[$key])) {
                $newarray[$key] = self::array_merge_noclobber($newarray[$key], $val);
            } elseif (!isset($newarray[$key])) {
                $newarray[$key] = $val;
            }
        }
        return $newarray;
    }

    /**
     * @param mixed $array1
     * @param mixed $array2
     *
     * @return array|false|null
     */
    public static function flipped_array_merge_noclobber($array1, $array2) {
        if (!is_array($array1) || !is_array($array2)) {
            return false;
        }
        # naturally, this only works non-recursively
        $newarray = array_flip($array1);
        foreach (array_flip($array2) as $key => $val) {
            if (!isset($newarray[$key])) {
                $newarray[$key] = count($newarray);
            }
        }
        return array_flip($newarray);
    }

    /**
     * @param array $theArray
     *
     * @return bool
     */
    public static function ksort_recursive(&$theArray) {
        ksort($theArray);
        foreach ($theArray as $key => $value) {
            if (is_array($value)) {
                self::ksort_recursive($theArray[$key]);
            }
        }
        return true;
    }

    /**
     * @param string $filename
     * @param int    $numextensions
     *
     * @return string
     */
    public static function fileextension($filename, $numextensions=1) {
        if (strstr($filename, '.')) {
            $reversedfilename = strrev($filename);
            $offset = 0;
            for ($i = 0; $i < $numextensions; $i++) {
                $offset = strpos($reversedfilename, '.', $offset + 1);
                if ($offset === false) {
                    return '';
                }
            }
            return strrev(substr($reversedfilename, 0, $offset));
        }
        return '';
    }

    /**
     * @param int $seconds
     *
     * @return string
     */
    public static function PlaytimeString($seconds) {
        $sign = (($seconds < 0) ? '-' : '');
        $seconds = round(abs($seconds));
        $H = (int) floor( $seconds                            / 3600);
        $M = (int) floor(($seconds - (3600 * $H)            ) /   60);
        $S = (int) round( $seconds - (3600 * $H) - (60 * $M)        );
        return $sign.($H ? $H.':' : '').($H ? str_pad($M, 2, '0', STR_PAD_LEFT) : intval($M)).':'.str_pad($S, 2, 0, STR_PAD_LEFT);
    }

    /**
     * @param int $macdate
     *
     * @return int|float
     */
    public static function DateMac2Unix($macdate) {
        // Macintosh timestamp: seconds since 00:00h January 1, 1904
        // UNIX timestamp:      seconds since 00:00h January 1, 1970
        return self::CastAsInt($macdate - 2082844800);
    }

    /**
     * @param string $rawdata
     *
     * @return float
     */
    public static function FixedPoint8_8($rawdata) {
        return self::BigEndian2Int(substr($rawdata, 0, 1)) + (float) (self::BigEndian2Int(substr($rawdata, 1, 1)) / pow(2, 8));
    }

    /**
     * @param string $rawdata
     *
     * @return float
     */
    public static function FixedPoint16_16($rawdata) {
        return self::BigEndian2Int(substr($rawdata, 0, 2)) + (float) (self::BigEndian2Int(substr($rawdata, 2, 2)) / pow(2, 16));
    }

    /**
     * @param string $rawdata
     *
     * @return float
     */
    public static function FixedPoint2_30($rawdata) {
        $binarystring = self::BigEndian2Bin($rawdata);
        return self::Bin2Dec(substr($binarystring, 0, 2)) + (float) (self::Bin2Dec(substr($binarystring, 2, 30)) / pow(2, 30));
    }


    /**
     * @param string $ArrayPath
     * @param string $Separator
     * @param mixed $Value
     *
     * @return array
     */
    public static function CreateDeepArray($ArrayPath, $Separator, $Value) {
        // assigns $Value to a nested array path:
        //   $foo = self::CreateDeepArray('/path/to/my', '/', 'file.txt')
        // is the same as:
        //   $foo = array('path'=>array('to'=>'array('my'=>array('file.txt'))));
        // or
        //   $foo['path']['to']['my'] = 'file.txt';
        $ArrayPath = ltrim($ArrayPath, $Separator);
        if (($pos = strpos($ArrayPath, $Separator)) !== false) {
            $ReturnedArray[substr($ArrayPath, 0, $pos)] = self::CreateDeepArray(substr($ArrayPath, $pos + 1), $Separator, $Value);
        } else {
            $ReturnedArray[$ArrayPath] = $Value;
        }
        return $ReturnedArray;
    }

    /**
     * @param array $arraydata
     * @param bool  $returnkey
     *
     * @return int|false
     */
    public static function array_max($arraydata, $returnkey=false) {
        $maxvalue = false;
        $maxkey   = false;
        foreach ($arraydata as $key => $value) {
            if (!is_array($value)) {
                if (($maxvalue === false) || ($value > $maxvalue)) {
                    $maxvalue = $value;
                    $maxkey = $key;
                }
            }
        }
        return ($returnkey ? $maxkey : $maxvalue);
    }

    /**
     * @param array $arraydata
     * @param bool  $returnkey
     *
     * @return int|false
     */
    public static function array_min($arraydata, $returnkey=false) {
        $minvalue = false;
        $minkey   = false;
        foreach ($arraydata as $key => $value) {
            if (!is_array($value)) {
                if (($minvalue === false) || ($value < $minvalue)) {
                    $minvalue = $value;
                    $minkey = $key;
                }
            }
        }
        return ($returnkey ? $minkey : $minvalue);
    }

    /**
     * @param string $XMLstring
     *
     * @return array|false
     */
    public static function XML2array($XMLstring) {
        if (function_exists('simplexml_load_string') && function_exists('libxml_disable_entity_loader')) {
            // http://websec.io/2012/08/27/Preventing-XEE-in-PHP.html
            // https://core.trac.wordpress.org/changeset/29378
            $loader = libxml_disable_entity_loader(true);
            $XMLobject = simplexml_load_string($XMLstring, 'SimpleXMLElement', LIBXML_NOENT);
            $return = self::SimpleXMLelement2array($XMLobject);
            libxml_disable_entity_loader($loader);
            return $return;
        }
        return false;
    }

    /**
    * @param SimpleXMLElement|array|mixed $XMLobject
    *
    * @return mixed
    */
    public static function SimpleXMLelement2array($XMLobject) {
        if (!is_object($XMLobject) && !is_array($XMLobject)) {
            return $XMLobject;
        }
        $XMLarray = $XMLobject instanceof SimpleXMLElement ? get_object_vars($XMLobject) : $XMLobject;
        foreach ($XMLarray as $key => $value) {
            $XMLarray[$key] = self::SimpleXMLelement2array($value);
        }
        return $XMLarray;
    }

    /**
     * Returns checksum for a file from starting position to absolute end position.
     *
     * @param string $file
     * @param int    $offset
     * @param int    $end
     * @param string $algorithm
     *
     * @return string|false
     * @throws getid3_exception
     */
    public static function hash_data($file, $offset, $end, $algorithm) {
        if (!self::intValueSupported($end)) {
            return false;
        }
        if (!in_array($algorithm, array('md5', 'sha1'))) {
            throw new getid3_exception('Invalid algorithm ('.$algorithm.') in self::hash_data()');
        }

        $size = $end - $offset;

        $fp = fopen($file, 'rb');
        fseek($fp, $offset);
        $ctx = hash_init($algorithm);
        while ($size > 0) {
            $buffer = fread($fp, min($size, getID3::FREAD_BUFFER_SIZE));
            hash_update($ctx, $buffer);
            $size -= getID3::FREAD_BUFFER_SIZE;
        }
        $hash = hash_final($ctx);
        fclose($fp);

        return $hash;
    }

    /**
     * @param string $filename_source
     * @param string $filename_dest
     * @param int    $offset
     * @param int    $length
     *
     * @return bool
     * @throws Exception
     *
     * @deprecated Unused, may be removed in future versions of getID3
     */
    public static function CopyFileParts($filename_source, $filename_dest, $offset, $length) {
        if (!self::intValueSupported($offset + $length)) {
            throw new Exception('cannot copy file portion, it extends beyond the '.round(PHP_INT_MAX / 1073741824).'GB limit');
        }
        if (is_readable($filename_source) && is_file($filename_source) && ($fp_src = fopen($filename_source, 'rb'))) {
            if (($fp_dest = fopen($filename_dest, 'wb'))) {
                if (fseek($fp_src, $offset) == 0) {
                    $byteslefttowrite = $length;
                    while (($byteslefttowrite > 0) && ($buffer = fread($fp_src, min($byteslefttowrite, getID3::FREAD_BUFFER_SIZE)))) {
                        $byteswritten = fwrite($fp_dest, $buffer, $byteslefttowrite);
                        $byteslefttowrite -= $byteswritten;
                    }
                    fclose($fp_dest);
                    return true;
                } else {
                    fclose($fp_src);
                    throw new Exception('failed to seek to offset '.$offset.' in '.$filename_source);
                }
            } else {
                throw new Exception('failed to create file for writing '.$filename_dest);
            }
        } else {
            throw new Exception('failed to open file for reading '.$filename_source);
        }
    }

    /**
     * @param int $charval
     *
     * @return string
     */
    public static function iconv_fallback_int_utf8($charval) {
        if ($charval < 128) {
            // 0bbbbbbb
            $newcharstring = chr($charval);
        } elseif ($charval < 2048) {
            // 110bbbbb 10bbbbbb
            $newcharstring  = chr(($charval >>   6) | 0xC0);
            $newcharstring .= chr(($charval & 0x3F) | 0x80);
        } elseif ($charval < 65536) {
            // 1110bbbb 10bbbbbb 10bbbbbb
            $newcharstring  = chr(($charval >>  12) | 0xE0);
            $newcharstring .= chr(($charval >>   6) | 0xC0);
            $newcharstring .= chr(($charval & 0x3F) | 0x80);
        } else {
            // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
            $newcharstring  = chr(($charval >>  18) | 0xF0);
            $newcharstring .= chr(($charval >>  12) | 0xC0);
            $newcharstring .= chr(($charval >>   6) | 0xC0);
            $newcharstring .= chr(($charval & 0x3F) | 0x80);
        }
        return $newcharstring;
    }

    /**
     * ISO-8859-1 => UTF-8
     *
     * @param string $string
     * @param bool   $bom
     *
     * @return string
     */
    public static function iconv_fallback_iso88591_utf8($string, $bom=false) {
        if (function_exists('utf8_encode')) {
            return utf8_encode($string);
        }
        // utf8_encode() unavailable, use getID3()'s iconv_fallback() conversions (possibly PHP is compiled without XML support)
        $newcharstring = '';
        if ($bom) {
            $newcharstring .= "\xEF\xBB\xBF";
        }
        for ($i = 0; $i < strlen($string); $i++) {
            $charval = ord($string[$i]);
            $newcharstring .= self::iconv_fallback_int_utf8($charval);
        }
        return $newcharstring;
    }

    /**
     * ISO-8859-1 => UTF-16BE
     *
     * @param string $string
     * @param bool   $bom
     *
     * @return string
     */
    public static function iconv_fallback_iso88591_utf16be($string, $bom=false) {
        $newcharstring = '';
        if ($bom) {
            $newcharstring .= "\xFE\xFF";
        }
        for ($i = 0; $i < strlen($string); $i++) {
            $newcharstring .= "\x00".$string[$i];
        }
        return $newcharstring;
    }

    /**
     * ISO-8859-1 => UTF-16LE
     *
     * @param string $string
     * @param bool   $bom
     *
     * @return string
     */
    public static function iconv_fallback_iso88591_utf16le($string, $bom=false) {
        $newcharstring = '';
        if ($bom) {
            $newcharstring .= "\xFF\xFE";
        }
        for ($i = 0; $i < strlen($string); $i++) {
            $newcharstring .= $string[$i]."\x00";
        }
        return $newcharstring;
    }

    /**
     * ISO-8859-1 => UTF-16LE (BOM)
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_iso88591_utf16($string) {
        return self::iconv_fallback_iso88591_utf16le($string, true);
    }

    /**
     * UTF-8 => ISO-8859-1
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf8_iso88591($string) {
        if (function_exists('utf8_decode')) {
            return utf8_decode($string);
        }
        // utf8_decode() unavailable, use getID3()'s iconv_fallback() conversions (possibly PHP is compiled without XML support)
        $newcharstring = '';
        $offset = 0;
        $stringlength = strlen($string);
        while ($offset < $stringlength) {
            if ((ord($string[$offset]) | 0x07) == 0xF7) {
                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x07) << 18) &
                           ((ord($string[($offset + 1)]) & 0x3F) << 12) &
                           ((ord($string[($offset + 2)]) & 0x3F) <<  6) &
                            (ord($string[($offset + 3)]) & 0x3F);
                $offset += 4;
            } elseif ((ord($string[$offset]) | 0x0F) == 0xEF) {
                // 1110bbbb 10bbbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x0F) << 12) &
                           ((ord($string[($offset + 1)]) & 0x3F) <<  6) &
                            (ord($string[($offset + 2)]) & 0x3F);
                $offset += 3;
            } elseif ((ord($string[$offset]) | 0x1F) == 0xDF) {
                // 110bbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x1F) <<  6) &
                            (ord($string[($offset + 1)]) & 0x3F);
                $offset += 2;
            } elseif ((ord($string[$offset]) | 0x7F) == 0x7F) {
                // 0bbbbbbb
                $charval = ord($string[$offset]);
                $offset += 1;
            } else {
                // error? throw some kind of warning here?
                $charval = false;
                $offset += 1;
            }
            if ($charval !== false) {
                $newcharstring .= (($charval < 256) ? chr($charval) : '?');
            }
        }
        return $newcharstring;
    }

    /**
     * UTF-8 => UTF-16BE
     *
     * @param string $string
     * @param bool   $bom
     *
     * @return string
     */
    public static function iconv_fallback_utf8_utf16be($string, $bom=false) {
        $newcharstring = '';
        if ($bom) {
            $newcharstring .= "\xFE\xFF";
        }
        $offset = 0;
        $stringlength = strlen($string);
        while ($offset < $stringlength) {
            if ((ord($string[$offset]) | 0x07) == 0xF7) {
                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x07) << 18) &
                           ((ord($string[($offset + 1)]) & 0x3F) << 12) &
                           ((ord($string[($offset + 2)]) & 0x3F) <<  6) &
                            (ord($string[($offset + 3)]) & 0x3F);
                $offset += 4;
            } elseif ((ord($string[$offset]) | 0x0F) == 0xEF) {
                // 1110bbbb 10bbbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x0F) << 12) &
                           ((ord($string[($offset + 1)]) & 0x3F) <<  6) &
                            (ord($string[($offset + 2)]) & 0x3F);
                $offset += 3;
            } elseif ((ord($string[$offset]) | 0x1F) == 0xDF) {
                // 110bbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x1F) <<  6) &
                            (ord($string[($offset + 1)]) & 0x3F);
                $offset += 2;
            } elseif ((ord($string[$offset]) | 0x7F) == 0x7F) {
                // 0bbbbbbb
                $charval = ord($string[$offset]);
                $offset += 1;
            } else {
                // error? throw some kind of warning here?
                $charval = false;
                $offset += 1;
            }
            if ($charval !== false) {
                $newcharstring .= (($charval < 65536) ? self::BigEndian2String($charval, 2) : "\x00".'?');
            }
        }
        return $newcharstring;
    }

    /**
     * UTF-8 => UTF-16LE
     *
     * @param string $string
     * @param bool   $bom
     *
     * @return string
     */
    public static function iconv_fallback_utf8_utf16le($string, $bom=false) {
        $newcharstring = '';
        if ($bom) {
            $newcharstring .= "\xFF\xFE";
        }
        $offset = 0;
        $stringlength = strlen($string);
        while ($offset < $stringlength) {
            if ((ord($string[$offset]) | 0x07) == 0xF7) {
                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x07) << 18) &
                           ((ord($string[($offset + 1)]) & 0x3F) << 12) &
                           ((ord($string[($offset + 2)]) & 0x3F) <<  6) &
                            (ord($string[($offset + 3)]) & 0x3F);
                $offset += 4;
            } elseif ((ord($string[$offset]) | 0x0F) == 0xEF) {
                // 1110bbbb 10bbbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x0F) << 12) &
                           ((ord($string[($offset + 1)]) & 0x3F) <<  6) &
                            (ord($string[($offset + 2)]) & 0x3F);
                $offset += 3;
            } elseif ((ord($string[$offset]) | 0x1F) == 0xDF) {
                // 110bbbbb 10bbbbbb
                $charval = ((ord($string[($offset + 0)]) & 0x1F) <<  6) &
                            (ord($string[($offset + 1)]) & 0x3F);
                $offset += 2;
            } elseif ((ord($string[$offset]) | 0x7F) == 0x7F) {
                // 0bbbbbbb
                $charval = ord($string[$offset]);
                $offset += 1;
            } else {
                // error? maybe throw some warning here?
                $charval = false;
                $offset += 1;
            }
            if ($charval !== false) {
                $newcharstring .= (($charval < 65536) ? self::LittleEndian2String($charval, 2) : '?'."\x00");
            }
        }
        return $newcharstring;
    }

    /**
     * UTF-8 => UTF-16LE (BOM)
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf8_utf16($string) {
        return self::iconv_fallback_utf8_utf16le($string, true);
    }

    /**
     * UTF-16BE => UTF-8
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf16be_utf8($string) {
        if (substr($string, 0, 2) == "\xFE\xFF") {
            // strip BOM
            $string = substr($string, 2);
        }
        $newcharstring = '';
        for ($i = 0; $i < strlen($string); $i += 2) {
            $charval = self::BigEndian2Int(substr($string, $i, 2));
            $newcharstring .= self::iconv_fallback_int_utf8($charval);
        }
        return $newcharstring;
    }

    /**
     * UTF-16LE => UTF-8
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf16le_utf8($string) {
        if (substr($string, 0, 2) == "\xFF\xFE") {
            // strip BOM
            $string = substr($string, 2);
        }
        $newcharstring = '';
        for ($i = 0; $i < strlen($string); $i += 2) {
            $charval = self::LittleEndian2Int(substr($string, $i, 2));
            $newcharstring .= self::iconv_fallback_int_utf8($charval);
        }
        return $newcharstring;
    }

    /**
     * UTF-16BE => ISO-8859-1
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf16be_iso88591($string) {
        if (substr($string, 0, 2) == "\xFE\xFF") {
            // strip BOM
            $string = substr($string, 2);
        }
        $newcharstring = '';
        for ($i = 0; $i < strlen($string); $i += 2) {
            $charval = self::BigEndian2Int(substr($string, $i, 2));
            $newcharstring .= (($charval < 256) ? chr($charval) : '?');
        }
        return $newcharstring;
    }

    /**
     * UTF-16LE => ISO-8859-1
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf16le_iso88591($string) {
        if (substr($string, 0, 2) == "\xFF\xFE") {
            // strip BOM
            $string = substr($string, 2);
        }
        $newcharstring = '';
        for ($i = 0; $i < strlen($string); $i += 2) {
            $charval = self::LittleEndian2Int(substr($string, $i, 2));
            $newcharstring .= (($charval < 256) ? chr($charval) : '?');
        }
        return $newcharstring;
    }

    /**
     * UTF-16 (BOM) => ISO-8859-1
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf16_iso88591($string) {
        $bom = substr($string, 0, 2);
        if ($bom == "\xFE\xFF") {
            return self::iconv_fallback_utf16be_iso88591(substr($string, 2));
        } elseif ($bom == "\xFF\xFE") {
            return self::iconv_fallback_utf16le_iso88591(substr($string, 2));
        }
        return $string;
    }

    /**
     * UTF-16 (BOM) => UTF-8
     *
     * @param string $string
     *
     * @return string
     */
    public static function iconv_fallback_utf16_utf8($string) {
        $bom = substr($string, 0, 2);
        if ($bom == "\xFE\xFF") {
            return self::iconv_fallback_utf16be_utf8(substr($string, 2));
        } elseif ($bom == "\xFF\xFE") {
            return self::iconv_fallback_utf16le_utf8(substr($string, 2));
        }
        return $string;
    }

    /**
     * @param string $in_charset
     * @param string $out_charset
     * @param string $string
     *
     * @return string
     * @throws Exception
     */
    public static function iconv_fallback($in_charset, $out_charset, $string) {

        if ($in_charset == $out_charset) {
            return $string;
        }

        // mb_convert_encoding() available
        if (function_exists('mb_convert_encoding')) {
            if ((strtoupper($in_charset) == 'UTF-16') && (substr($string, 0, 2) != "\xFE\xFF") && (substr($string, 0, 2) != "\xFF\xFE")) {
                // if BOM missing, mb_convert_encoding will mishandle the conversion, assume UTF-16BE and prepend appropriate BOM
                $string = "\xFF\xFE".$string;
            }
            if ((strtoupper($in_charset) == 'UTF-16') && (strtoupper($out_charset) == 'UTF-8')) {
                if (($string == "\xFF\xFE") || ($string == "\xFE\xFF")) {
                    // if string consists of only BOM, mb_convert_encoding will return the BOM unmodified
                    return '';
                }
            }
            if ($converted_string = @mb_convert_encoding($string, $out_charset, $in_charset)) {
                switch ($out_charset) {
                    case 'ISO-8859-1':
                        $converted_string = rtrim($converted_string, "\x00");
                        break;
                }
                return $converted_string;
            }
            return $string;

        // iconv() available
        } elseif (function_exists('iconv')) {
            if ($converted_string = @iconv($in_charset, $out_charset.'//TRANSLIT', $string)) {
                switch ($out_charset) {
                    case 'ISO-8859-1':
                        $converted_string = rtrim($converted_string, "\x00");
                        break;
                }
                return $converted_string;
            }

            // iconv() may sometimes fail with "illegal character in input string" error message
            // and return an empty string, but returning the unconverted string is more useful
            return $string;
        }


        // neither mb_convert_encoding or iconv() is available
        static $ConversionFunctionList = array();
        if (empty($ConversionFunctionList)) {
            $ConversionFunctionList['ISO-8859-1']['UTF-8']    = 'iconv_fallback_iso88591_utf8';
            $ConversionFunctionList['ISO-8859-1']['UTF-16']   = 'iconv_fallback_iso88591_utf16';
            $ConversionFunctionList['ISO-8859-1']['UTF-16BE'] = 'iconv_fallback_iso88591_utf16be';
            $ConversionFunctionList['ISO-8859-1']['UTF-16LE'] = 'iconv_fallback_iso88591_utf16le';
            $ConversionFunctionList['UTF-8']['ISO-8859-1']    = 'iconv_fallback_utf8_iso88591';
            $ConversionFunctionList['UTF-8']['UTF-16']        = 'iconv_fallback_utf8_utf16';
            $ConversionFunctionList['UTF-8']['UTF-16BE']      = 'iconv_fallback_utf8_utf16be';
            $ConversionFunctionList['UTF-8']['UTF-16LE']      = 'iconv_fallback_utf8_utf16le';
            $ConversionFunctionList['UTF-16']['ISO-8859-1']   = 'iconv_fallback_utf16_iso88591';
            $ConversionFunctionList['UTF-16']['UTF-8']        = 'iconv_fallback_utf16_utf8';
            $ConversionFunctionList['UTF-16LE']['ISO-8859-1'] = 'iconv_fallback_utf16le_iso88591';
            $ConversionFunctionList['UTF-16LE']['UTF-8']      = 'iconv_fallback_utf16le_utf8';
            $ConversionFunctionList['UTF-16BE']['ISO-8859-1'] = 'iconv_fallback_utf16be_iso88591';
            $ConversionFunctionList['UTF-16BE']['UTF-8']      = 'iconv_fallback_utf16be_utf8';
        }
        if (isset($ConversionFunctionList[strtoupper($in_charset)][strtoupper($out_charset)])) {
            $ConversionFunction = $ConversionFunctionList[strtoupper($in_charset)][strtoupper($out_charset)];
            return self::$ConversionFunction($string);
        }
        throw new Exception('PHP does not has mb_convert_encoding() or iconv() support - cannot convert from '.$in_charset.' to '.$out_charset);
    }

    /**
     * @param mixed  $data
     * @param string $charset
     *
     * @return mixed
     */
    public static function recursiveMultiByteCharString2HTML($data, $charset='ISO-8859-1') {
        if (is_string($data)) {
            return self::MultiByteCharString2HTML($data, $charset);
        } elseif (is_array($data)) {
            $return_data = array();
            foreach ($data as $key => $value) {
                $return_data[$key] = self::recursiveMultiByteCharString2HTML($value, $charset);
            }
            return $return_data;
        }
        // integer, float, objects, resources, etc
        return $data;
    }

    /**
     * @param string|int|float $string
     * @param string           $charset
     *
     * @return string
     */
    public static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
        $string = (string) $string; // in case trying to pass a numeric (float, int) string, would otherwise return an empty string
        $HTMLstring = '';

        switch (strtolower($charset)) {
            case '1251':
            case '1252':
            case '866':
            case '932':
            case '936':
            case '950':
            case 'big5':
            case 'big5-hkscs':
            case 'cp1251':
            case 'cp1252':
            case 'cp866':
            case 'euc-jp':
            case 'eucjp':
            case 'gb2312':
            case 'ibm866':
            case 'iso-8859-1':
            case 'iso-8859-15':
            case 'iso8859-1':
            case 'iso8859-15':
            case 'koi8-r':
            case 'koi8-ru':
            case 'koi8r':
            case 'shift_jis':
            case 'sjis':
            case 'win-1251':
            case 'windows-1251':
            case 'windows-1252':
                $HTMLstring = htmlentities($string, ENT_COMPAT, $charset);
                break;

            case 'utf-8':
                $strlen = strlen($string);
                for ($i = 0; $i < $strlen; $i++) {
                    $char_ord_val = ord($string[$i]);
                    $charval = 0;
                    if ($char_ord_val < 0x80) {
                        $charval = $char_ord_val;
                    } elseif ((($char_ord_val & 0xF0) >> 4) == 0x0F  &&  $i+3 < $strlen) {
                        $charval  = (($char_ord_val & 0x07) << 18);
                        $charval += ((ord($string[++$i]) & 0x3F) << 12);
                        $charval += ((ord($string[++$i]) & 0x3F) << 6);
                        $charval +=  (ord($string[++$i]) & 0x3F);
                    } elseif ((($char_ord_val & 0xE0) >> 5) == 0x07  &&  $i+2 < $strlen) {
                        $charval  = (($char_ord_val & 0x0F) << 12);
                        $charval += ((ord($string[++$i]) & 0x3F) << 6);
                        $charval +=  (ord($string[++$i]) & 0x3F);
                    } elseif ((($char_ord_val & 0xC0) >> 6) == 0x03  &&  $i+1 < $strlen) {
                        $charval  = (($char_ord_val & 0x1F) << 6);
                        $charval += (ord($string[++$i]) & 0x3F);
                    }
                    if (($charval >= 32) && ($charval <= 127)) {
                        $HTMLstring .= htmlentities(chr($charval));
                    } else {
                        $HTMLstring .= '&#'.$charval.';';
                    }
                }
                break;

            case 'utf-16le':
                for ($i = 0; $i < strlen($string); $i += 2) {
                    $charval = self::LittleEndian2Int(substr($string, $i, 2));
                    if (($charval >= 32) && ($charval <= 127)) {
                        $HTMLstring .= chr($charval);
                    } else {
                        $HTMLstring .= '&#'.$charval.';';
                    }
                }
                break;

            case 'utf-16be':
                for ($i = 0; $i < strlen($string); $i += 2) {
                    $charval = self::BigEndian2Int(substr($string, $i, 2));
                    if (($charval >= 32) && ($charval <= 127)) {
                        $HTMLstring .= chr($charval);
                    } else {
                        $HTMLstring .= '&#'.$charval.';';
                    }
                }
                break;

            default:
                $HTMLstring = 'ERROR: Character set "'.$charset.'" not supported in MultiByteCharString2HTML()';
                break;
        }
        return $HTMLstring;
    }

    /**
     * @param int $namecode
     *
     * @return string
     */
    public static function RGADnameLookup($namecode) {
        static $RGADname = array();
        if (empty($RGADname)) {
            $RGADname[0] = 'not set';
            $RGADname[1] = 'Track Gain Adjustment';
            $RGADname[2] = 'Album Gain Adjustment';
        }

        return (isset($RGADname[$namecode]) ? $RGADname[$namecode] : '');
    }

    /**
     * @param int $originatorcode
     *
     * @return string
     */
    public static function RGADoriginatorLookup($originatorcode) {
        static $RGADoriginator = array();
        if (empty($RGADoriginator)) {
            $RGADoriginator[0] = 'unspecified';
            $RGADoriginator[1] = 'pre-set by artist/producer/mastering engineer';
            $RGADoriginator[2] = 'set by user';
            $RGADoriginator[3] = 'determined automatically';
        }

        return (isset($RGADoriginator[$originatorcode]) ? $RGADoriginator[$originatorcode] : '');
    }

    /**
     * @param int $rawadjustment
     * @param int $signbit
     *
     * @return float
     */
    public static function RGADadjustmentLookup($rawadjustment, $signbit) {
        $adjustment = (float) $rawadjustment / 10;
        if ($signbit == 1) {
            $adjustment *= -1;
        }
        return $adjustment;
    }

    /**
     * @param int $namecode
     * @param int $originatorcode
     * @param int $replaygain
     *
     * @return string
     */
    public static function RGADgainString($namecode, $originatorcode, $replaygain) {
        if ($replaygain < 0) {
            $signbit = '1';
        } else {
            $signbit = '0';
        }
        $storedreplaygain = intval(round($replaygain * 10));
        $gainstring  = str_pad(decbin($namecode), 3, '0', STR_PAD_LEFT);
        $gainstring .= str_pad(decbin($originatorcode), 3, '0', STR_PAD_LEFT);
        $gainstring .= $signbit;
        $gainstring .= str_pad(decbin($storedreplaygain), 9, '0', STR_PAD_LEFT);

        return $gainstring;
    }

    /**
     * @param float $amplitude
     *
     * @return float
     */
    public static function RGADamplitude2dB($amplitude) {
        return 20 * log10($amplitude);
    }

    /**
     * @param string $imgData
     * @param array  $imageinfo
     *
     * @return array|false
     */
    public static function GetDataImageSize($imgData, &$imageinfo=array()) {
        if (PHP_VERSION_ID >= 50400) {
            $GetDataImageSize = @getimagesizefromstring($imgData, $imageinfo);
            if ($GetDataImageSize === false || !isset($GetDataImageSize[0], $GetDataImageSize[1])) {
                return false;
            }
            $GetDataImageSize['height'] = $GetDataImageSize[0];
            $GetDataImageSize['width'] = $GetDataImageSize[1];
            return $GetDataImageSize;
        }
        static $tempdir = '';
        if (empty($tempdir)) {
            if (function_exists('sys_get_temp_dir')) {
                $tempdir = sys_get_temp_dir(); // https://github.com/JamesHeinrich/getID3/issues/52
            }

            // yes this is ugly, feel free to suggest a better way
            if (include_once(dirname(__FILE__).'/getid3.php')) {
                $getid3_temp = new getID3();
                if ($getid3_temp_tempdir = $getid3_temp->tempdir) {
                    $tempdir = $getid3_temp_tempdir;
                }
                unset($getid3_temp, $getid3_temp_tempdir);
            }
        }
        $GetDataImageSize = false;
        if ($tempfilename = tempnam($tempdir, 'gI3')) {
            if (is_writable($tempfilename) && is_file($tempfilename) && ($tmp = fopen($tempfilename, 'wb'))) {
                fwrite($tmp, $imgData);
                fclose($tmp);
                $GetDataImageSize = @getimagesize($tempfilename, $imageinfo);
                if (($GetDataImageSize === false) || !isset($GetDataImageSize[0]) || !isset($GetDataImageSize[1])) {
                    return false;
                }
                $GetDataImageSize['height'] = $GetDataImageSize[0];
                $GetDataImageSize['width']  = $GetDataImageSize[1];
            }
            unlink($tempfilename);
        }
        return $GetDataImageSize;
    }

    /**
     * @param string $mime_type
     *
     * @return string
     */
    public static function ImageExtFromMime($mime_type) {
        // temporary way, works OK for now, but should be reworked in the future
        return str_replace(array('image/', 'x-', 'jpeg'), array('', '', 'jpg'), $mime_type);
    }

    /**
     * @param array $ThisFileInfo
     * @param bool  $option_tags_html default true (just as in the main getID3 class)
     *
     * @return bool
     */
    public static function CopyTagsToComments(&$ThisFileInfo, $option_tags_html=true) {
        // Copy all entries from ['tags'] into common ['comments']
        if (!empty($ThisFileInfo['tags'])) {
            if (isset($ThisFileInfo['tags']['id3v1'])) {
                // bubble ID3v1 to the end, if present to aid in detecting bad ID3v1 encodings
                $ID3v1 = $ThisFileInfo['tags']['id3v1'];
                unset($ThisFileInfo['tags']['id3v1']);
                $ThisFileInfo['tags']['id3v1'] = $ID3v1;
                unset($ID3v1);
            }
            foreach ($ThisFileInfo['tags'] as $tagtype => $tagarray) {
                foreach ($tagarray as $tagname => $tagdata) {
                    foreach ($tagdata as $key => $value) {
                        if (!empty($value)) {
                            if (empty($ThisFileInfo['comments'][$tagname])) {

                                // fall through and append value

                            } elseif ($tagtype == 'id3v1') {

                                $newvaluelength = strlen(trim($value));
                                foreach ($ThisFileInfo['comments'][$tagname] as $existingkey => $existingvalue) {
                                    $oldvaluelength = strlen(trim($existingvalue));
                                    if (($newvaluelength <= $oldvaluelength) && (substr($existingvalue, 0, $newvaluelength) == trim($value))) {
                                        // new value is identical but shorter-than (or equal-length to) one already in comments - skip
                                        break 2;
                                    }
                                }
                                if (function_exists('mb_convert_encoding')) {
                                    if (trim($value) == trim(substr(mb_convert_encoding($existingvalue, $ThisFileInfo['id3v1']['encoding'], $ThisFileInfo['encoding']), 0, 30))) {
                                        // value stored in ID3v1 appears to be probably the multibyte value transliterated (badly) into ISO-8859-1 in ID3v1.
                                        // As an example, Foobar2000 will do this if you tag a file with Chinese or Arabic or Cyrillic or something that doesn't fit into ISO-8859-1 the ID3v1 will consist of mostly "?" characters, one per multibyte unrepresentable character
                                        break 2;
                                    }
                                }

                            } elseif (!is_array($value)) {

                                $newvaluelength = strlen(trim($value));
                                foreach ($ThisFileInfo['comments'][$tagname] as $existingkey => $existingvalue) {
                                    $oldvaluelength = strlen(trim($existingvalue));
                                    if ((strlen($existingvalue) > 10) && ($newvaluelength > $oldvaluelength) && (substr(trim($value), 0, strlen($existingvalue)) == $existingvalue)) {
                                        $ThisFileInfo['comments'][$tagname][$existingkey] = trim($value);
                                        break;
                                    }
                                }

                            }
                            if (is_array($value) || empty($ThisFileInfo['comments'][$tagname]) || !in_array(trim($value), $ThisFileInfo['comments'][$tagname])) {
                                $value = (is_string($value) ? trim($value) : $value);
                                if (!is_int($key) && !ctype_digit($key)) {
                                    $ThisFileInfo['comments'][$tagname][$key] = $value;
                                } else {
                                    if (!isset($ThisFileInfo['comments'][$tagname])) {
                                        $ThisFileInfo['comments'][$tagname] = array($value);
                                    } else {
                                        $ThisFileInfo['comments'][$tagname][] = $value;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // attempt to standardize spelling of returned keys
            $StandardizeFieldNames = array(
                'tracknumber' => 'track_number',
                'track'       => 'track_number',
            );
            foreach ($StandardizeFieldNames as $badkey => $goodkey) {
                if (array_key_exists($badkey, $ThisFileInfo['comments']) && !array_key_exists($goodkey, $ThisFileInfo['comments'])) {
                    $ThisFileInfo['comments'][$goodkey] = $ThisFileInfo['comments'][$badkey];
                    unset($ThisFileInfo['comments'][$badkey]);
                }
            }

            if ($option_tags_html) {
                // Copy ['comments'] to ['comments_html']
                if (!empty($ThisFileInfo['comments'])) {
                    foreach ($ThisFileInfo['comments'] as $field => $values) {
                        if ($field == 'picture') {
                            // pictures can take up a lot of space, and we don't need multiple copies of them
                            // let there be a single copy in [comments][picture], and not elsewhere
                            continue;
                        }
                        foreach ($values as $index => $value) {
                            if (is_array($value)) {
                                $ThisFileInfo['comments_html'][$field][$index] = $value;
                            } else {
                                $ThisFileInfo['comments_html'][$field][$index] = str_replace('&#0;', '', self::MultiByteCharString2HTML($value, $ThisFileInfo['encoding']));
                            }
                        }
                    }
                }
            }

        }
        return true;
    }

    /**
     * @param string $key
     * @param int    $begin
     * @param int    $end
     * @param string $file
     * @param string $name
     *
     * @return string
     */
    public static function EmbeddedLookup($key, $begin, $end, $file, $name) {

        // Cached
        static $cache;
        if (isset($cache[$file][$name])) {
            return (isset($cache[$file][$name][$key]) ? $cache[$file][$name][$key] : '');
        }

        // Init
        $keylength  = strlen($key);
        $line_count = $end - $begin - 7;

        // Open php file
        $fp = fopen($file, 'r');

        // Discard $begin lines
        for ($i = 0; $i < ($begin + 3); $i++) {
            fgets($fp, 1024);
        }

        // Loop thru line
        while (0 < $line_count--) {

            // Read line
            $line = ltrim(fgets($fp, 1024), "\t ");

            // METHOD A: only cache the matching key - less memory but slower on next lookup of not-previously-looked-up key
            //$keycheck = substr($line, 0, $keylength);
            //if ($key == $keycheck)  {
            //  $cache[$file][$name][$keycheck] = substr($line, $keylength + 1);
            //  break;
            //}

            // METHOD B: cache all keys in this lookup - more memory but faster on next lookup of not-previously-looked-up key
            //$cache[$file][$name][substr($line, 0, $keylength)] = trim(substr($line, $keylength + 1));
            $explodedLine = explode("\t", $line, 2);
            $ThisKey   = (isset($explodedLine[0]) ? $explodedLine[0] : '');
            $ThisValue = (isset($explodedLine[1]) ? $explodedLine[1] : '');
            $cache[$file][$name][$ThisKey] = trim($ThisValue);
        }

        // Close and return
        fclose($fp);
        return (isset($cache[$file][$name][$key]) ? $cache[$file][$name][$key] : '');
    }

    /**
     * @param string $filename
     * @param string $sourcefile
     * @param bool   $DieOnFailure
     *
     * @return bool
     * @throws Exception
     */
    public static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
        global $GETID3_ERRORARRAY;

        if (file_exists($filename)) {
            if (include_once($filename)) {
                return true;
            } else {
                $diemessage = basename($sourcefile).' depends on '.$filename.', which has errors';
            }
        } else {
            $diemessage = basename($sourcefile).' depends on '.$filename.', which is missing';
        }
        if ($DieOnFailure) {
            throw new Exception($diemessage);
        } else {
            $GETID3_ERRORARRAY[] = $diemessage;
        }
        return false;
    }

    /**
     * @param string $string
     *
     * @return string
     */
    public static function trimNullByte($string) {
        return trim($string, "\x00");
    }

    /**
     * @param string $path
     *
     * @return float|bool
     */
    public static function getFileSizeSyscall($path) {
        $filesize = false;

        if (GETID3_OS_ISWINDOWS) {
            if (class_exists('COM')) { // From PHP 5.3.15 and 5.4.5, COM and DOTNET is no longer built into the php core.you have to add COM support in php.ini:
                $filesystem = new COM('Scripting.FileSystemObject');
                $file = $filesystem->GetFile($path);
                $filesize = $file->Size();
                unset($filesystem, $file);
            } else {
                $commandline = 'for %I in ('.escapeshellarg($path).') do @echo %~zI';
            }
        } else {
            $commandline = 'ls -l '.escapeshellarg($path).' | awk \'{print $5}\'';
        }
        if (isset($commandline)) {
            $output = trim(`$commandline`);
            if (ctype_digit($output)) {
                $filesize = (float) $output;
            }
        }
        return $filesize;
    }

    /**
     * @param string $filename
     *
     * @return string|false
     */
    public static function truepath($filename) {
        // 2017-11-08: this could use some improvement, patches welcome
        if (preg_match('#^(\\\\\\\\|//)[a-z0-9]#i', $filename, $matches)) {
            // PHP's built-in realpath function does not work on UNC Windows shares
            $goodpath = array();
            foreach (explode('/', str_replace('\\', '/', $filename)) as $part) {
                if ($part == '.') {
                    continue;
                }
                if ($part == '..') {
                    if (count($goodpath)) {
                        array_pop($goodpath);
                    } else {
                        // cannot step above this level, already at top level
                        return false;
                    }
                } else {
                    $goodpath[] = $part;
                }
            }
            return implode(DIRECTORY_SEPARATOR, $goodpath);
        }
        return realpath($filename);
    }

    /**
     * Workaround for Bug #37268 (https://bugs.php.net/bug.php?id=37268)
     *
     * @param string $path A path.
     * @param string $suffix If the name component ends in suffix this will also be cut off.
     *
     * @return string
     */
    public static function mb_basename($path, $suffix = null) {
        $splited = preg_split('#/#', rtrim($path, '/ '));
        return substr(basename('X'.$splited[count($splited) - 1], $suffix), 1);
    }

}