Changeset 1523


Ignore:
Timestamp:
12/28/10 07:54:45 (2 years ago)
Author:
zach
Message:
  • Playlist parsing alpha
Location:
branches/fl5.5a
Files:
13 added
4 edited

Legend:

Unmodified
Added
Removed

  • branches/fl5.5a/build/build.xml

    r1521 r1523  
    242242                        <fileset dir="${basedir}/js/src/utils" includes="jwplayer.utils.animations.js" /> 
    243243                        <fileset dir="${basedir}/js/src/utils" includes="jwplayer.utils.extensionmap.js" /> 
     244                        <fileset dir="${basedir}/js/src/parsers" includes="jwplayer.utils.parsers.js" /> 
     245                        <fileset dir="${basedir}/js/src/parsers" includes="**/*.js" excludes="jwplayer.utils.parsers.js" /> 
    244246                        <fileset dir="${basedir}/js/src/plugins" includes="**/*.js" /> 
    245247                        <fileset dir="${basedir}/js/src/api" includes="**/*.js" /> 

  • branches/fl5.5a/js/bin-debug/jwplayer.js

    r1521 r1523  
    888888        }; 
    889889         
    890 })(jwplayer);/** 
     890        /** 
     891         * Basic serialization: string representations of booleans and numbers are returned typed; 
     892         * strings are returned urldecoded. 
     893         * 
     894         * @param {String} val  String value to serialize. 
     895         * @return {Object}             The original value in the correct primitive type. 
     896         */ 
     897        jwplayer.utils.strings.serialize = function(val) { 
     898                if (val == null) { 
     899                        return null; 
     900                } else if (val == 'true') { 
     901                        return true; 
     902                } else if (val == 'false') { 
     903                        return false; 
     904                } else if (isNaN(Number(val)) || val.length > 5 || val.length == 0) { 
     905                        return val; 
     906                } else { 
     907                        return Number(val); 
     908                } 
     909        } 
     910         
     911         
     912        /** 
     913         * Convert a time-representing string to a number. 
     914         * 
     915         * @param {String}      The input string. Supported are 00:03:00.1 / 03:00.1 / 180.1s / 3.2m / 3.2h 
     916         * @return {Number}     The number of seconds. 
     917         */ 
     918        jwplayer.utils.strings.seconds = function(str) { 
     919                str = str.replace(',', '.'); 
     920                var arr = str.split(':'); 
     921                var sec = 0; 
     922                if (str.substr(-1) == 's') { 
     923                        sec = Number(str.substr(0, str.length - 1)); 
     924                } else if (str.substr(-1) == 'm') { 
     925                        sec = Number(str.substr(0, str.length - 1)) * 60; 
     926                } else if (str.substr(-1) == 'h') { 
     927                        sec = Number(str.substr(0, str.length - 1)) * 3600; 
     928                } else if (arr.length > 1) { 
     929                        sec = Number(arr[arr.length - 1]); 
     930                        sec += Number(arr[arr.length - 2]) * 60; 
     931                        if (arr.length == 3) { 
     932                                sec += Number(arr[arr.length - 3]) * 3600; 
     933                        } 
     934                } else { 
     935                        sec = Number(str); 
     936                } 
     937                return sec; 
     938        } 
     939         
     940         
     941        /** 
     942         * Get the value of a case-insensitive attribute in an XML node 
     943         * @param {XML} xml 
     944         * @param {String} attribute 
     945         * @return {String} Value 
     946         */ 
     947        jwplayer.utils.strings.xmlAttribute = function(xml, attribute) { 
     948                for (var attrib in xml.attributes) { 
     949                        if (xml.attributes[attrib].name && xml.attributes[attrib].name.toLowerCase() == attribute.toLowerCase())  
     950                                return xml.attributes[attrib].value.toString(); 
     951                } 
     952                return ""; 
     953        } 
     954         
     955})(jwplayer); 
     956/** 
    891957 * Utility methods for the JW Player. 
    892958 * 
    … …  
    11671233                } 
    11681234        }; 
     1235})(jwplayer); 
     1236/** 
     1237 * Parser class definition 
     1238 * 
     1239 * @author zach 
     1240 * @version 5.5 
     1241 */ 
     1242(function(jwplayer) { 
     1243 
     1244        jwplayer.utils.parsers = function() { 
     1245        }; 
     1246         
     1247})(jwplayer); 
     1248/** 
     1249 * Parse an ASX feed and translate it to a playlist. 
     1250 * 
     1251 * @author zach 
     1252 * @version 5.5 
     1253 */ 
     1254(function(jwplayer) { 
     1255 
     1256        jwplayer.utils.parsers.asxparser = function() { 
     1257        }; 
     1258         
     1259        /** 
     1260         * Parse an ASX playlist for feed items. 
     1261         * 
     1262         * @param {Object} dat 
     1263         * @return {Array} playlistarray 
     1264         */ 
     1265        jwplayer.utils.parsers.asxparser.parse = function(dat) { 
     1266                var arr = []; 
     1267                for (var i in dat.childNodes) { 
     1268                        if (dat.childNodes[i].localName && dat.childNodes[i].localName.toLowerCase() == 'entry') { 
     1269                                arr.push(_parseItem(dat.childNodes[i])); 
     1270                        } 
     1271                } 
     1272                return arr; 
     1273        } 
     1274         
     1275        /**  
     1276         * Translate ASX item to playlist item. 
     1277         * 
     1278         * @param {XML} obj 
     1279         * @return {PlaylistItem} PlaylistItem 
     1280         */ 
     1281        function _parseItem(obj) { 
     1282                var itm = {}; 
     1283                for (var i in obj.childNodes) { 
     1284                        if (!obj.childNodes[i].localName) { 
     1285                                continue; 
     1286                        } 
     1287                        switch (obj.childNodes[i].localName.toLowerCase()) { 
     1288                                case 'ref': 
     1289                                        itm['file'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'href'); 
     1290                                        break; 
     1291                                case 'title': 
     1292                                        itm['title'] = obj.childNodes[i].textContent; 
     1293                                        break; 
     1294                                case 'moreinfo': 
     1295                                        itm['link'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'href'); 
     1296                                        break; 
     1297                                case 'abstract': 
     1298                                        itm['description'] = obj.childNodes[i].textContent; 
     1299                                        break; 
     1300                                case 'author': 
     1301                                        itm['author'] = obj.childNodes[i].textContent; 
     1302                                        break; 
     1303                                case 'duration': 
     1304                                        itm['duration'] = jwplayer.utils.strings.seconds(jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'value')); 
     1305                                        break; 
     1306                                case 'starttime': 
     1307                                        itm['start'] = jwplayer.utils.strings.seconds(jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'value')); 
     1308                                        break; 
     1309                                case 'param': 
     1310                                        itm[jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'name')] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'value'); 
     1311                                        break; 
     1312                        } 
     1313                } 
     1314                itm = jwplayer.utils.parsers.jwparser.parseEntry(obj, itm); 
     1315                return new jwplayer.html5.playlistitem(itm); 
     1316        } 
     1317         
     1318})(jwplayer); 
     1319/** 
     1320 * Parse an ATOM feed and translate it to a playlist. 
     1321 * 
     1322 * @author zach 
     1323 * @version 5.5 
     1324 */ 
     1325(function(jwplayer) { 
     1326 
     1327        jwplayer.utils.parsers.atomparser = function() { 
     1328        }; 
     1329         
     1330        /** 
     1331         * Parse an RSS playlist for feed items. 
     1332         * 
     1333         * @param {XML} dat 
     1334         * @return {Array} playlistarray 
     1335         */ 
     1336        jwplayer.utils.parsers.atomparser.parse = function(dat) { 
     1337                var arr = []; 
     1338                for (var i in dat.childNodes) { 
     1339                        if (dat.childNodes[i].localName && dat.childNodes[i].localName.toLowerCase() == 'entry') { 
     1340                                arr.push(_parseItem(dat.childNodes[i])); 
     1341                        } 
     1342                } 
     1343                return arr; 
     1344        }; 
     1345         
     1346         
     1347        /** 
     1348         * Translate ATOM item to playlist item. 
     1349         * 
     1350         * @param {XML} obj 
     1351         * @return {PlaylistItem} PlaylistItem 
     1352         */ 
     1353        function _parseItem(obj) { 
     1354                var itm = {}; 
     1355                for (var i in obj.childNodes) { 
     1356                        if (!obj.childNodes[i].localName) { 
     1357                                continue; 
     1358                        } 
     1359                        switch (obj.childNodes[i].localName.toLowerCase()) { 
     1360                                case 'author': 
     1361                                        itm['author'] = obj.childNodes[i].childNodes[0].textContent; 
     1362                                        break; 
     1363                                case 'title': 
     1364                                        itm['title'] = obj.childNodes[i].textContent; 
     1365                                        break; 
     1366                                case 'summary': 
     1367                                        itm['description'] = obj.childNodes[i].textContent; 
     1368                                        break; 
     1369                                case 'link': 
     1370                                        if (jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'rel') == 'alternate') { 
     1371                                                itm['link'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'href'); 
     1372                                        } else if (jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'rel') == 'enclosure') { 
     1373                                                itm['file'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'href'); 
     1374                                        } 
     1375                                        break; 
     1376                                case 'published': 
     1377                                        itm['date'] = obj.childNodes[i].textContent; 
     1378                                        break; 
     1379                        } 
     1380                } 
     1381                itm = jwplayer.utils.parsers.mediaparser.parseGroup(obj, itm); 
     1382                itm = jwplayer.utils.parsers.jwparser.parseEntry(obj, itm); 
     1383                return new jwplayer.html5.playlistitem(itm); 
     1384        } 
     1385         
     1386         
     1387})(jwplayer); 
     1388/** 
     1389 * Parse iTunes specific RSS feed content into playlists. 
     1390 * 
     1391 * @author zach 
     1392 * @version 5.5 
     1393 */ 
     1394(function(jwplayer) { 
     1395        jwplayer.utils.parsers.itunesparser = function() { 
     1396        }; 
     1397         
     1398        /** Prefix for the iTunes namespace. **/ 
     1399        jwplayer.utils.parsers.itunesparser.PREFIX = 'itunes'; 
     1400         
     1401        /** 
     1402         * Parse a feedentry for iTunes content. 
     1403         * 
     1404         * @param       {XML}           obj             The XML object to parse. 
     1405         * @param       {Object}        itm             The playlistentry to amend the object to. 
     1406         * @return      {Object}                        The playlistentry, amended with the iTunes info. 
     1407         * @see RSSParser 
     1408         */ 
     1409        jwplayer.utils.parsers.itunesparser.parseEntry = function(obj, itm) { 
     1410                for (var i in obj.childNodes) { 
     1411                        if (obj.childNodes[i].prefix == jwplayer.utils.parsers.itunesparser.PREFIX) { 
     1412                                if (!obj.childNodes[i].localName) { 
     1413                                        continue; 
     1414                                } 
     1415                                switch (obj.childNodes[i].localName.toLowerCase()) { 
     1416                                        case 'author': 
     1417                                                itm['author'] = obj.childNodes[i].textContent; 
     1418                                                break; 
     1419                                        case 'duration': 
     1420                                                itm['duration'] = jwplayer.utils.strings.seconds(obj.childNodes[i].textContent); 
     1421                                                break; 
     1422                                        case 'summary': 
     1423                                                itm['description'] = obj.childNodes[i].textContent; 
     1424                                                break; 
     1425                                        case 'keywords': 
     1426                                                itm['tags'] = obj.childNodes[i].textContent; 
     1427                                                break; 
     1428                                } 
     1429                        } 
     1430                } 
     1431                return itm; 
     1432        } 
     1433})(jwplayer); 
     1434/** 
     1435 * Parse a feed item for JWPlayer content. 
     1436 * 
     1437 * @author zach 
     1438 * @version 5.5 
     1439 */ 
     1440(function(jwplayer) { 
     1441 
     1442        jwplayer.utils.parsers.jwparser = function() { 
     1443        }; 
     1444         
     1445        jwplayer.utils.parsers.jwparser.PREFIX = 'jwplayer'; 
     1446         
     1447        /** 
     1448         * Parse a feed entry for JWPlayer content. 
     1449         * 
     1450         * @param       {XML}           obj     The XML object to parse. 
     1451         * @param       {Object}        itm     The playlistentry to amend the object to. 
     1452         * @return      {Object}                The playlistentry, amended with the JWPlayer info. 
     1453         * @see                 ASXParser 
     1454         * @see                 ATOMParser 
     1455         * @see                 RSSParser 
     1456         * @see                 SMILParser 
     1457         * @see                 XSPFParser 
     1458         */ 
     1459        jwplayer.utils.parsers.jwparser.parseEntry = function(obj, itm) { 
     1460                for (var i in obj.childNodes) { 
     1461                        if (obj.childNodes[i].prefix == jwplayer.utils.parsers.jwparser.PREFIX) { 
     1462                                itm[obj.childNodes[i].localName] = jwplayer.utils.strings.serialize(obj.childNodes[i].textContent); 
     1463                        } 
     1464                        if (!itm['file'] && String(itm['link']).toLowerCase().indexOf('youtube') > -1) { 
     1465                                itm['file'] = itm['link']; 
     1466                        } 
     1467                } 
     1468                return itm; 
     1469        } 
     1470         
     1471        /** 
     1472         * Determine the provider of an item 
     1473         * @param {Object} item 
     1474         * @return {String} provider 
     1475         */ 
     1476        jwplayer.utils.parsers.jwparser.getProvider = function(item) { 
     1477                if (item['type']) { 
     1478                        return item['type']; 
     1479                } else if (item['file'].indexOf('youtube.com/w') > -1 || item['file'].indexOf('youtube.com/v') > -1) { 
     1480                        return "youtube"; 
     1481                } else if (item['streamer'] && item['streamer'].indexOf('rtmp') == 0) { 
     1482                        return "rtmp"; 
     1483                } else if (item['streamer'] && item['streamer'].indexOf('http') == 0) { 
     1484                        return "http"; 
     1485                } else { 
     1486                        var ext = jwplayer.utils.strings.extension(item['file']); 
     1487                        if (extensions.hasOwnProperty(ext)) { 
     1488                                return extensions[ext]; 
     1489                        } 
     1490                } 
     1491                return ""; 
     1492        } 
     1493         
     1494})(jwplayer); 
     1495/** 
     1496 * Parse an RTMP Loadbalancing SMIL feed and translate it to a list of levels. 
     1497 * 
     1498 * @author zach 
     1499 * @version 5.5 
     1500 */ 
     1501(function(jwplayer) { 
     1502 
     1503        jwplayer.utils.parsers.loadbalanceparser = function() { 
     1504        } 
     1505         
     1506        /** 
     1507         * Parse an SMIL playlist for feed items. 
     1508         * 
     1509         * @param {Object} dat 
     1510         * @return {Array} playlist 
     1511         */ 
     1512        jwplayer.utils.parsers.loadbalanceparser.parse = function(dat) { 
     1513                var array = []; 
     1514                var meta = dat.childNodes[0].childNodes[0]; 
     1515                var streamer = jwplayer.utils.strings.xmlAttribute(meta, 'base'); 
     1516                var switchOrVideo = dat.childNodes[1].childNodes[0]; 
     1517                if (switchOrVideo.localName.toLowerCase() == 'switch') { 
     1518                        for (var i in switchOrVideo.childNodes) { 
     1519                                var level = new jwplayer.html5.playlistitemLevel(jwplayer.utils.strings.xmlAttribute(i, 'src'), Number(jwplayer.utils.strings.xmlAttribute(i, 'system-bitrate')) / 1000, Number(jwplayer.utils.strings.xmlAttribute(i, 'width')), streamer); 
     1520                                array.push(level); 
     1521                        } 
     1522                } else { 
     1523                        array.push({ 
     1524                                file: jwplayer.utils.strings.xmlAttribute(switchOrVideo, 'src'), 
     1525                                streamer: streamer 
     1526                        }); 
     1527                } 
     1528                return array; 
     1529        } 
     1530})(jwplayer); 
     1531/** 
     1532 * Parse a MRSS group into a playlistitem (used in RSS and ATOM). 
     1533 * 
     1534 * author zach 
     1535 * version 5.5 
     1536 */ 
     1537(function(jwplayer) { 
     1538 
     1539        jwplayer.utils.parsers.mediaparser = function() { 
     1540        }; 
     1541         
     1542        /** Prefix for the JW Player namespace. **/ 
     1543        jwplayer.utils.parsers.mediaparser.PREFIX = 'media'; 
     1544         
     1545        /** 
     1546         * Parse a feeditem for Yahoo MediaRSS extensions. 
     1547         * The 'content' and 'group' elements can nest other MediaRSS elements. 
     1548         * @param       {XML}           obj             The entire MRSS XML object. 
     1549         * @param       {Object}        itm             The playlistentry to amend the object to. 
     1550         * @return      {Object}                        The playlistentry, amended with the MRSS info. 
     1551         * @see ATOMParser 
     1552         * @see RSSParser 
     1553         **/ 
     1554        jwplayer.utils.parsers.mediaparser.parseGroup = function(obj, itm) { 
     1555                var ytp = false; 
     1556                 
     1557                for (var i in obj.childNodes) { 
     1558                        if (obj.childNodes[i].prefix == jwplayer.utils.parsers.mediaparser.PREFIX) { 
     1559                                if (!obj.childNodes[i].localName){ 
     1560                                        continue; 
     1561                                } 
     1562                                switch (obj.childNodes[i].localName.toLowerCase()) { 
     1563                                        case 'content': 
     1564                                                if (!ytp) { 
     1565                                                        itm['file'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'url'); 
     1566                                                } 
     1567                                                if (obj.childNodes[i].attributes.duration) { 
     1568                                                        itm['duration'] = jwplayer.utils.strings.seconds(jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'duration')); 
     1569                                                } 
     1570                                                if (obj.childNodes[i].attributes.start) { 
     1571                                                        itm['start'] = jwplayer.utils.strings.seconds(jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'start')); 
     1572                                                } 
     1573                                                if (obj.childNodes[i].childNodes && obj.childNodes[i].childNodes.length > 0) { 
     1574                                                        itm = jwplayer.utils.parsers.mediaparser.parseGroup(obj.childNodes[i], itm); 
     1575                                                } 
     1576                                                if (obj.childNodes[i].attributes.width || obj.childNodes[i].attributes.bitrate) { 
     1577                                                        if (!itm.levels) { 
     1578                                                                itm.levels = []; 
     1579                                                        } 
     1580                                                        itm.levels.push({ 
     1581                                                                width: jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'width'), 
     1582                                                                bitrate: jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'bitrate'), 
     1583                                                                file: jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'url') 
     1584                                                        }); 
     1585                                                } 
     1586                                                break; 
     1587                                        case 'title': 
     1588                                                itm['title'] = obj.childNodes[i].textContent; 
     1589                                                break; 
     1590                                        case 'description': 
     1591                                                itm['description'] = obj.childNodes[i].textContent; 
     1592                                                break; 
     1593                                        case 'keywords': 
     1594                                                itm['tags'] = obj.childNodes[i].textContent; 
     1595                                                break; 
     1596                                        case 'thumbnail': 
     1597                                                itm['image'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'url'); 
     1598                                                break; 
     1599                                        case 'credit': 
     1600                                                itm['author'] = obj.childNodes[i].textContent; 
     1601                                                break; 
     1602                                        case 'player': 
     1603                                                if (obj.childNodes[i].url.indexOf('youtube.com') > 0) { 
     1604                                                        ytp = true; 
     1605                                                        itm['file'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'url'); 
     1606                                                } 
     1607                                                break; 
     1608                                        case 'group': 
     1609                                                itm = jwplayer.utils.parsers.mediaparser.parseGroup(obj.childNodes[i], itm); 
     1610                                                break; 
     1611                                } 
     1612                        } 
     1613                } 
     1614                return itm; 
     1615        } 
     1616         
     1617})(jwplayer); 
     1618/** 
     1619 * Parser factory for the JW Player. 
     1620 * 
     1621 * @author zach 
     1622 * @version 5.5 
     1623 */ 
     1624(function(jwplayer) { 
     1625 
     1626        jwplayer.utils.parsers.parserfactory = function() { 
     1627        }; 
     1628         
     1629        /** 
     1630         * Determines the parser for a feed 
     1631         * @param {XML} list 
     1632         * @return {IPlaylistParser} parser 
     1633         */ 
     1634        jwplayer.utils.parsers.parserfactory.getParser = function(list) { 
     1635         
     1636                switch (list.localName.toString().toLowerCase()) { 
     1637                        case 'asx': 
     1638                                return jwplayer.utils.parsers.asxparser; 
     1639                                break; 
     1640                        case 'feed': 
     1641                                return jwplayer.utils.parsers.atomparser; 
     1642                                break; 
     1643                        case 'playlist': 
     1644                                return jwplayer.utils.parsers.xspfparser; 
     1645                                break; 
     1646                        case 'rss': 
     1647                                return jwplayer.utils.parsers.rssparser; 
     1648                                break; 
     1649                        case 'smil': 
     1650                                return jwplayer.utils.parsers.smilparser; 
     1651                                break; 
     1652                } 
     1653                 
     1654                return null; 
     1655        }; 
     1656})(jwplayer); 
     1657/** 
     1658 * Parse an RSS feed and translate it to a playlist. 
     1659 * 
     1660 * @author zach 
     1661 * @version 5.5 
     1662 */ 
     1663(function(jwplayer) { 
     1664 
     1665        jwplayer.utils.parsers.rssparser = function() { 
     1666        }; 
     1667         
     1668        /** 
     1669         * Parse an RSS playlist for feed items. 
     1670         * 
     1671         * @param {XML} dat 
     1672         * @reuturn {Array} playlistarray 
     1673         */ 
     1674        jwplayer.utils.parsers.rssparser.parse = function(dat) { 
     1675                var arr = []; 
     1676                for (var i in dat.childNodes) { 
     1677                        if (dat.childNodes[i].localName && dat.childNodes[i].localName.toLowerCase() == 'channel') { 
     1678                                for (var j in dat.childNodes[i].childNodes) { 
     1679                                        if (dat.childNodes[i].childNodes[j].localName && dat.childNodes[i].childNodes[j].localName.toLowerCase() == 'item') { 
     1680                                                arr.push(_parseItem(dat.childNodes[i].childNodes[j])); 
     1681                                        } 
     1682                                } 
     1683                        } 
     1684                } 
     1685                return arr; 
     1686        }; 
     1687         
     1688         
     1689        /**  
     1690         * Translate RSS item to playlist item. 
     1691         * 
     1692         * @param {XML} obj 
     1693         * @return {PlaylistItem} PlaylistItem 
     1694         */ 
     1695        function _parseItem(obj) { 
     1696                var itm = {}; 
     1697                for (var i in obj.childNodes) { 
     1698                        if (!obj.childNodes[i].localName){ 
     1699                                continue; 
     1700                        } 
     1701                        switch (obj.childNodes[i].localName.toLowerCase()) { 
     1702                                case 'enclosure': 
     1703                                        itm['file'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'url'); 
     1704                                        break; 
     1705                                case 'title': 
     1706                                        itm['title'] = obj.childNodes[i].textContent; 
     1707                                        break; 
     1708                                case 'pubdate': 
     1709                                        itm['date'] = obj.childNodes[i].textContent; 
     1710                                        break; 
     1711                                case 'description': 
     1712                                        itm['description'] = obj.childNodes[i].textContent; 
     1713                                        break; 
     1714                                case 'link': 
     1715                                        itm['link'] = obj.childNodes[i].textContent; 
     1716                                        break; 
     1717                                case 'category': 
     1718                                        if (itm['tags']) { 
     1719                                                itm['tags'] += obj.childNodes[i].textContent; 
     1720                                        } else { 
     1721                                                itm['tags'] = obj.childNodes[i].textContent; 
     1722                                        } 
     1723                                        break; 
     1724                        } 
     1725                } 
     1726                itm = jwplayer.utils.parsers.itunesparser.parseEntry(obj, itm); 
     1727                itm = jwplayer.utils.parsers.mediaparser.parseGroup(obj, itm); 
     1728                itm = jwplayer.utils.parsers.jwparser.parseEntry(obj, itm); 
     1729                console.log(itm); 
     1730                return new jwplayer.html5.playlistitem(itm); 
     1731        } 
     1732         
     1733         
     1734})(jwplayer); 
     1735/** 
     1736 * Parse an SMIL feed and translate it to a playlist. 
     1737 * 
     1738 * @author zach 
     1739 * @version 5.5 
     1740 */ 
     1741(function(jwplayer) { 
     1742 
     1743        jwplayer.utils.parsers.smilparser = function() { 
     1744        }; 
     1745         
     1746        /** 
     1747         * Parse an SMIL playlist for feeditems. 
     1748         * 
     1749         * @param {Object} dat 
     1750         * @return {Array} playlistarray 
     1751         */ 
     1752        jwplayer.utils.parsers.smilparser.parse = function(dat) { 
     1753                var arr = []; 
     1754                for (var i in dat.childNodes) { 
     1755                        if (dat.childNodes[i].localName && dat.childNodes[i].localName.toLowerCase() == 'body') { 
     1756                                for (var j in dat.childNodes[i].childNodes) { 
     1757                                        var elm = dat.childNodes[i].childNodes[j]; 
     1758                                        if (elm.localName && elm.localName.toLowerCase() == 'seq') { 
     1759                                                for (var k in elm.childNodes) { 
     1760                                                        if (elm.childNodes[k].localName) { 
     1761                                                                arr.push(new jwplayer.html5.playlistitem(_parseSeq(elm.childNodes[k]))); 
     1762                                                        } 
     1763                                                } 
     1764                                        } else { 
     1765                                                //arr.push(_parseItem(elm)); 
     1766                                        } 
     1767                                         
     1768                                } 
     1769                        } 
     1770                } 
     1771                return arr; 
     1772        }; 
     1773         
     1774        /** 
     1775         * 
     1776         * @param {XML} obj 
     1777         * @return {PlaylistItem} 
     1778         */ 
     1779        function _parseItem(obj) { 
     1780                return new jwplayer.html5.playlistitem(_parsePar(obj)); 
     1781        }; 
     1782         
     1783         
     1784        /** 
     1785         * Translate SMIL sequence item to playlistitem. 
     1786         * @param {XML} obj 
     1787         * @return {Object} obj 
     1788         */ 
     1789        function _parseSeq(obj) { 
     1790                var itm = {}; 
     1791                switch (obj.localName.toLowerCase()) { 
     1792                        case 'par': 
     1793                                itm = _parsePar(obj); 
     1794                                break; 
     1795                        case 'img': 
     1796                        case 'video': 
     1797                        case 'audio': 
     1798                                itm = _parseAttributes(obj, itm); 
     1799                                break; 
     1800                        default: 
     1801                                break; 
     1802                } 
     1803                return itm; 
     1804        } 
     1805         
     1806        /**  
     1807         * Translate a SMIL par group to playlistitem 
     1808         * 
     1809         * @param {XML} obj 
     1810         * @return {Object} obj 
     1811         */ 
     1812        function _parsePar(obj) { 
     1813                var itm = {}; 
     1814                for (var i in obj.childNodes) { 
     1815                        if (!obj.childNodes[i].localName) { 
     1816                                continue; 
     1817                        } 
     1818                        switch (obj.childNodes[i].localName.toLowerCase()) { 
     1819                                case 'anchor': 
     1820                                        itm['link'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'href'); 
     1821                                        break; 
     1822                                case 'img': 
     1823                                        if (itm['file']) { 
     1824                                                itm['image'] = jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'src'); 
     1825                                                break; 
     1826                                        } else { 
     1827                                                itm = _parseAttributes(obj.childNodes[i], itm); 
     1828                                        } 
     1829                                        break; 
     1830                                case 'video': 
     1831                                case 'audio': 
     1832                                        itm = _parseAttributes(obj.childNodes[i], itm); 
     1833                                        break; 
     1834                                default: 
     1835                                        break; 
     1836                        } 
     1837                } 
     1838                itm = jwplayer.utils.parsers.jwparser.parseEntry(obj, itm); 
     1839                return itm; 
     1840        } 
     1841         
     1842        /**  
     1843         * Get attributes from a SMIL element. 
     1844         * 
     1845         * @param {XML} obj 
     1846         * @param {Object} itm 
     1847         * @return {Object} obj 
     1848         */ 
     1849        function _parseAttributes(obj, itm) { 
     1850                for (var i = 0; i < obj.attributes.length; i++) { 
     1851                        var att = obj.attributes[i].name.toString(); 
     1852                        switch (att) { 
     1853                                case 'begin': 
     1854                                        itm['start'] = jwplayer.utils.strings.seconds(jwplayer.utils.strings.xmlAttribute(obj, 'begin')); 
     1855                                        break; 
     1856                                case 'src': 
     1857                                        itm['file'] = jwplayer.utils.strings.xmlAttribute(obj, 'src'); 
     1858                                        break; 
     1859                                case 'dur': 
     1860                                        itm['duration'] = jwplayer.utils.strings.seconds(jwplayer.utils.strings.xmlAttribute(obj, 'dur')); 
     1861                                        break; 
     1862                                case 'alt': 
     1863                                        itm['description'] = jwplayer.utils.strings.xmlAttribute(obj, 'alt'); 
     1864                                        break; 
     1865                                default: 
     1866                                        itm[att] = obj.attributes[i].toString(); 
     1867                                        break; 
     1868                        } 
     1869                } 
     1870                return itm; 
     1871        } 
     1872})(jwplayer); 
     1873/** 
     1874 * Parse an XSPF feed and translate it to a playlist. 
     1875 * 
     1876 * @author zach 
     1877 * @version 5.5 
     1878 */ 
     1879(function(jwplayer) { 
     1880 
     1881        jwplayer.utils.parsers.xspfparser = function() { 
     1882        }; 
     1883         
     1884        /** 
     1885         * Parse an XSPF playlist for feed items. 
     1886         * @param {Object} dat 
     1887         * @return {Array} arr 
     1888         */ 
     1889        jwplayer.utils.parsers.xspfparser.parse = function(dat) { 
     1890                var arr = []; 
     1891                for (var i in dat.childNodes) { 
     1892                        if (dat.childNodes[i].localName && dat.childNodes[i].localName.toLowerCase() == 'tracklist') { 
     1893                                for (var j in dat.childNodes[i].childNodes) { 
     1894                                        if (dat.childNodes[i].childNodes[j].localName && dat.childNodes[i].childNodes[j].localName.toLowerCase() == 'track') { 
     1895                                                arr.push(_parseItem(dat.childNodes[i].childNodes[j])); 
     1896                                        } 
     1897                                } 
     1898                        } 
     1899                } 
     1900                return arr; 
     1901                 
     1902        } 
     1903         
     1904        /** 
     1905         * Translate XSPF item to playlist item. 
     1906         * @param {XML} obj 
     1907         * @return {PlaylistItem} 
     1908         */ 
     1909        function _parseItem(obj) { 
     1910                var itm = {}; 
     1911                for (var i in obj.childNodes) { 
     1912                        if (!obj.childNodes[i].localName) { 
     1913                                continue; 
     1914                        } 
     1915                        switch (obj.childNodes[i].localName.toLowerCase()) { 
     1916                                case 'location': 
     1917                                        itm['file'] = obj.childNodes[i].textContent; 
     1918                                        break; 
     1919                                case 'title': 
     1920                                        itm['title'] = obj.childNodes[i].textContent; 
     1921                                        break; 
     1922                                case 'annotation': 
     1923                                        itm['description'] = obj.childNodes[i].textContent; 
     1924                                        break; 
     1925                                case 'info': 
     1926                                        itm['link'] = obj.childNodes[i].textContent; 
     1927                                        break; 
     1928                                case 'image': 
     1929                                        itm['image'] = obj.childNodes[i].textContent; 
     1930                                        break; 
     1931                                case 'creator': 
     1932                                        itm['author'] = obj.childNodes[i].textContent; 
     1933                                        break; 
     1934                                case 'duration': 
     1935                                        itm['duration'] = jwplayer.utils.strings.seconds(obj.childNodes[i].textContent); 
     1936                                        break; 
     1937                                case 'meta': 
     1938                                        itm[jwplayer.utils.strings.xmlAttribute(obj.childNodes[i], 'rel')] = obj.childNodes[i].textContent; 
     1939                                        break; 
     1940                                case 'extension': 
     1941                                        for (var ext in obj.childNodes[i].childNodes) { 
     1942                                                if (obj.childNodes[i].childNodes.ext.localName){ 
     1943                                                        itm[obj.childNodes[i].childNodes.ext.localName.toLowerCase()] = obj.childNodes[i].childNodes.ext.textContent;            
     1944                                                } 
     1945                                        } 
     1946                                        break; 
     1947                        } 
     1948                } 
     1949                itm = jwplayer.utils.parsers.jwparser.parseEntry(obj, itm); 
     1950                return new jwplayer.html5.playlistitem(itm); 
     1951        } 
     1952         
    11691953})(jwplayer); 
    11701954/** 

  • branches/fl5.5a/js/src/utils/jwplayer.utils.strings.js

    r1435 r1523  
    1515        }; 
    1616         
     17        /** 
     18         * Basic serialization: string representations of booleans and numbers are returned typed; 
     19         * strings are returned urldecoded. 
     20         * 
     21         * @param {String} val  String value to serialize. 
     22         * @return {Object}             The original value in the correct primitive type. 
     23         */ 
     24        jwplayer.utils.strings.serialize = function(val) { 
     25                if (val == null) { 
     26                        return null; 
     27                } else if (val == 'true') { 
     28                        return true; 
     29                } else if (val == 'false') { 
     30                        return false; 
     31                } else if (isNaN(Number(val)) || val.length > 5 || val.length == 0) { 
     32                        return val; 
     33                } else { 
     34                        return Number(val); 
     35                } 
     36        } 
     37         
     38         
     39        /** 
     40         * Convert a time-representing string to a number. 
     41         * 
     42         * @param {String}      The input string. Supported are 00:03:00.1 / 03:00.1 / 180.1s / 3.2m / 3.2h 
     43         * @return {Number}     The number of seconds. 
     44         */ 
     45        jwplayer.utils.strings.seconds = function(str) { 
     46                str = str.replace(',', '.'); 
     47                var arr = str.split(':'); 
     48                var sec = 0; 
     49                if (str.substr(-1) == 's') { 
     50                        sec = Number(str.substr(0, str.length - 1)); 
     51                } else if (str.substr(-1) == 'm') { 
     52                        sec = Number(str.substr(0, str.length - 1)) * 60; 
     53                } else if (str.substr(-1) == 'h') { 
     54                        sec = Number(str.substr(0, str.length - 1)) * 3600; 
     55                } else if (arr.length > 1) { 
     56                        sec = Number(arr[arr.length - 1]); 
     57                        sec += Number(arr[arr.length - 2]) * 60; 
     58                        if (arr.length == 3) { 
     59                                sec += Number(arr[arr.length - 3]) * 3600; 
     60                        } 
     61                } else { 
     62                        sec = Number(str); 
     63                } 
     64                return sec; 
     65        } 
     66         
     67         
     68        /** 
     69         * Get the value of a case-insensitive attribute in an XML node 
     70         * @param {XML} xml 
     71         * @param {String} attribute 
     72         * @return {String} Value 
     73         */ 
     74        jwplayer.utils.strings.xmlAttribute = function(xml, attribute) { 
     75                for (var attrib in xml.attributes) { 
     76                        if (xml.attributes[attrib].name && xml.attributes[attrib].name.toLowerCase() == attribute.toLowerCase())  
     77                                return xml.attributes[attrib].value.toString(); 
     78                } 
     79                return ""; 
     80        } 
     81         
    1782})(jwplayer); 

  • branches/fl5.5a/js/test/examples/index.html

    r1521 r1523  
    6060                                "RTMP": "playlist.html?type=rtmp", 
    6161                                "Mixed": "playlist.html?type=mixed", 
    62                                 "XML Playlits": "xmlplaylists.html" 
     62                                "XML Playlits": "xmlplaylists.html", 
     63                                                "Playlist formats": { 
     64                                                        "ASX" : "playlistparsing.html?"+escape('var config = {title:"ASX Playlists", "playlist":"../files/asx.xml"}'), 
     65                                                        "Atom" : "playlistparsing.html?"+escape('var config = {title:"Atom Playlists", "playlist":"../files/atom.xml"}'), 
     66                                                        "iTunes" : "playlistparsing.html?"+escape('var config = {title:"iTunes Playlists", "playlist":"../files/irss.xml"}'), 
     67                                                        "mRSS" : "playlistparsing.html?"+escape('var config = {title:"mRSS Playlists", "playlist":"../files/mrss.xml"}'), 
     68                                                        "XSPF" : "playlistparsing.html?"+escape('var config = {title:"XSPF Playlists", "playlist":"../files/xspf.xml"}')                                                         
     69                                                }, 
     70                                                "Bitrate Switching" : "playlistparsing.html?"+escape('var config = {title:"Bitrate Switching", "playlist":"../files/bitrates.xml"}'), 
     71                                                "Dynamic Streaming" : "playlistparsing.html?"+escape('var config = {title:"Dynamic Streaming", "playlist":"../files/dynamic.xml"}'), 
     72                                                "Highwinds" : "playlistparsing.html?"+escape('var config = {title:"Highwinds", "playlist":"../files/highwinds.xml"}'), 
     73                                                "SMIL Loadbalancing" : "playlistparsing.html?"+escape('var config = {title:"SMIL Loadbalancing", "playlist":"../files/smil.xml"}') 
    6374                        }, 
    6475                        "Components": { 
Note: See TracChangeset for help on using the changeset viewer.