Changeset 113161 in spip-zone


Ignore:
Timestamp:
Dec 30, 2018, 5:57:42 PM (4 months ago)
Author:
spip.franck@…
Message:

Mise à jour de la lib getid en 1.9.16, nous étions en 1.9.14
https://github.com/JamesHeinrich/getID3/blob/master/changelog.txt

Location:
_core_/plugins/medias/lib/getid3
Files:
75 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/medias/lib/getid3/extension.cache.dbm.php

    r96228 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
    88//                                                             //
    99// extension.cache.dbm.php - part of getID3()                  //
     
    7373class getID3_cached_dbm extends getID3
    7474{
    75 
    76         // public: constructor - see top of this file for cache type and cache_options
     75        /**
     76         * @var resource
     77         */
     78        private $dba;
     79
     80        /**
     81         * @var resource|bool
     82         */
     83        private $lock;
     84
     85        /**
     86         * @var string
     87         */
     88        private $cache_type;
     89
     90        /**
     91         * @var string
     92         */
     93        private $dbm_filename;
     94
     95        /**
     96         * constructor - see top of this file for cache type and cache_options
     97         *
     98         * @param string $cache_type
     99         * @param string $dbm_filename
     100         * @param string $lock_filename
     101         *
     102         * @throws Exception
     103         * @throws getid3_exception
     104         */
    77105        public function __construct($cache_type, $dbm_filename, $lock_filename) {
    78106
     
    142170
    143171
    144         // public: destructor
     172        /**
     173         * destructor
     174         */
    145175        public function __destruct() {
    146176
     
    157187
    158188
    159         // public: clear cache
     189        /**
     190         * clear cache
     191         *
     192         * @throws Exception
     193         */
    160194        public function clear_cache() {
    161195
     
    179213
    180214
    181         // public: analyze file
    182         public function analyze($filename) {
     215        /**
     216         * clear cache
     217         *
     218         * @param string $filename
     219         * @param int    $filesize
     220         * @param string $original_filename
     221         *
     222         * @return mixed
     223         */
     224        public function analyze($filename, $filesize=null, $original_filename='') {
    183225
    184226                if (file_exists($filename)) {
     
    200242
    201243                // Save result
    202                 if (file_exists($filename)) {
     244                if (isset($key) && file_exists($filename)) {
    203245                        dba_insert($key, serialize($result), $this->dba);
    204246                }
  • _core_/plugins/medias/lib/getid3/extension.cache.mysql.php

    r101151 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
    88//                                                             //
    99// extension.cache.mysql.php - part of getID3()                //
     
    7474class getID3_cached_mysql extends getID3
    7575{
    76 
    77         // private vars
     76        /**
     77         * @var resource
     78         */
    7879        private $cursor;
     80
     81        /**
     82         * @var resource
     83         */
    7984        private $connection;
    8085
    81 
    82         // public: constructor - see top of this file for cache type and cache_options
     86        /**
     87         * @var string
     88         */
     89        private $table;
     90
     91
     92        /**
     93         * constructor - see top of this file for cache type and cache_options
     94         *
     95         * @param string $host
     96         * @param string $database
     97         * @param string $username
     98         * @param string $password
     99         * @param string $table
     100         *
     101         * @throws Exception
     102         * @throws getid3_exception
     103         */
    83104        public function __construct($host, $database, $username, $password, $table='getid3_cache') {
    84105
     
    125146
    126147
    127         // public: clear cache
     148        /**
     149         * clear cache
     150         */
    128151        public function clear_cache() {
    129152
     
    134157
    135158
    136         // public: analyze file
     159        /**
     160         * analyze file
     161         *
     162         * @param string $filename
     163         * @param int    $filesize
     164         * @param string $original_filename
     165         *
     166         * @return mixed
     167         */
    137168        public function analyze($filename, $filesize=null, $original_filename='') {
    138169
     170        $filetime = 0;
    139171                if (file_exists($filename)) {
    140172
     
    175207
    176208
    177         // private: (re)create sql table
     209        /**
     210         * (re)create sql table
     211         *
     212         * @param bool $drop
     213         */
    178214        private function create_table($drop=false) {
    179215
     
    184220                $SQLquery .= ', `analyzetime` INT(11) NOT NULL DEFAULT \'0\'';
    185221                $SQLquery .= ', `value` LONGTEXT NOT NULL';
    186                 $SQLquery .= ', PRIMARY KEY (`filename`, `filesize`, `filetime`)) ENGINE=MyISAM CHARACTER SET=latin1 COLLATE=latin1_general_ci';
     222                $SQLquery .= ', PRIMARY KEY (`filename`, `filesize`, `filetime`))';
    187223                $this->cursor = mysql_query($SQLquery, $this->connection);
    188224                echo mysql_error($this->connection);
  • _core_/plugins/medias/lib/getid3/extension.cache.mysqli.php

    r101151 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
    88//                                                             //
    9 // extension.cache.mysqli.php - part of getID3()                //
     9// extension.cache.mysqli.php - part of getID3()               //
    1010// Please see readme.txt for more information                  //
    11 //                                                            ///
     11//                                                             //
    1212/////////////////////////////////////////////////////////////////
    1313//                                                             //
     
    7373class getID3_cached_mysqli extends getID3
    7474{
    75         // private vars
     75        /**
     76         * @var mysqli
     77         */
    7678        private $mysqli;
     79
     80        /**
     81         * @var mysqli_result
     82         */
    7783        private $cursor;
    7884
    79 
    80         // public: constructor - see top of this file for cache type and cache_options
     85        /**
     86         * @var string
     87         */
     88        private $table;
     89
     90
     91        /**
     92         * constructor - see top of this file for cache type and cache_options
     93         *
     94         * @param string $host
     95         * @param string $database
     96         * @param string $username
     97         * @param string $password
     98         * @param string $table
     99         *
     100         * @throws Exception
     101         * @throws getid3_exception
     102         */
    81103        public function __construct($host, $database, $username, $password, $table='getid3_cache') {
    82104
     
    122144
    123145
    124         // public: clear cache
     146        /**
     147         * clear cache
     148         */
    125149        public function clear_cache() {
    126150                $this->mysqli->query('DELETE FROM `'.$this->mysqli->real_escape_string($this->table).'`');
     
    129153
    130154
    131         // public: analyze file
     155        /**
     156         * analyze file
     157         *
     158         * @param string $filename
     159         * @param int    $filesize
     160         * @param string $original_filename
     161         *
     162         * @return mixed
     163         */
    132164        public function analyze($filename, $filesize=null, $original_filename='') {
    133165
     166        $filetime = 0;
    134167                if (file_exists($filename)) {
    135168
     
    169202
    170203
    171         // private: (re)create mysqli table
     204        /**
     205         * (re)create mysqli table
     206         *
     207         * @param bool $drop
     208         */
    172209        private function create_table($drop=false) {
    173210                $SQLquery  = 'CREATE TABLE IF NOT EXISTS `'.$this->mysqli->real_escape_string($this->table).'` (';
     
    177214                $SQLquery .= ', `analyzetime` INT(11) NOT NULL DEFAULT \'0\'';
    178215                $SQLquery .= ', `value` LONGTEXT NOT NULL';
    179                 $SQLquery .= ', PRIMARY KEY (`filename`, `filesize`, `filetime`)) ENGINE=MyISAM CHARACTER SET=latin1 COLLATE=latin1_general_ci';
     216                $SQLquery .= ', PRIMARY KEY (`filename`, `filesize`, `filetime`))';
    180217                $this->cursor = $this->mysqli->query($SQLquery);
    181218                echo $this->mysqli->error;
  • _core_/plugins/medias/lib/getid3/extension.cache.sqlite3.php

    r96228 r113161  
    11<?php
    2 /////////////////////////////////////////////////////////////////////////////////
    3 /// getID3() by James Heinrich <info@getid3.org>                               //
    4 //  available at http://getid3.sourceforge.net                                 //
    5 //            or http://www.getid3.org                                         //
    6 //          also https://github.com/JamesHeinrich/getID3                       //
    7 /////////////////////////////////////////////////////////////////////////////////
    8 ///                                                                            //
    9 // extension.cache.sqlite3.php - part of getID3()                              //
    10 // Please see readme.txt for more information                                  //
    11 //                                                                            ///
    12 /////////////////////////////////////////////////////////////////////////////////
    13 ///                                                                            //
    14 // MySQL extension written by Allan Hansen <ahØartemis*dk>                     //
    15 // Table name mod by Carlo Capocasa <calroØcarlocapocasa*com>                  //
    16 // MySQL extension was reworked for SQLite3 by Karl G. Holz <newaeonØmac*com>  //
    17 //                                                                            ///
    18 /////////////////////////////////////////////////////////////////////////////////
     2/////////////////////////////////////////////////////////////////
     3/// getID3() by James Heinrich <info@getid3.org>               //
     4//  available at https://github.com/JamesHeinrich/getID3       //
     5//            or https://www.getid3.org                        //
     6//            or http://getid3.sourceforge.net                 //
     7//                                                             //
     8// extension.cache.mysqli.php - part of getID3()               //
     9// Please see readme.txt for more information                  //
     10//                                                             //
     11/////////////////////////////////////////////////////////////////
     12//                                                             //
     13// extension.cache.sqlite3.php - part of getID3()              //
     14// Please see readme.txt for more information                  //
     15//                                                             //
     16/////////////////////////////////////////////////////////////////
     17///                                                            //
     18// MySQL extension written by Allan Hansen <ahØartemis*dk>     //
     19// Table name mod by Carlo Capocasa <calroØcarlocapocasa*com>  //
     20// MySQL extension was reworked for SQLite3 by                 //
     21//   Karl G. Holz <newaeonØmac*com>                            //
     22//                                                            ///
     23/////////////////////////////////////////////////////////////////
     24
    1925/**
    2026* This is a caching extension for getID3(). It works the exact same
     
    9096*
    9197*/
    92 class getID3_cached_sqlite3 extends getID3 {
    93 
    94         /**
    95         * __construct()
    96         * @param string $table holds name of sqlite table
    97         * @return type
    98         */
     98class getID3_cached_sqlite3 extends getID3
     99{
     100        /**
     101         * hold the sqlite db
     102         *
     103         * @var SQLite3 Resource
     104         */
     105        private $db;
     106
     107        /**
     108         * table to use for caching
     109         *
     110         * @var string $table
     111         */
     112        private $table;
     113
     114        /**
     115         * @param string  $table holds name of sqlite table
     116         * @param boolean $hide
     117         *
     118         * @throws getid3_exception
     119         * @throws Exception
     120         */
    99121        public function __construct($table='getid3_cache', $hide=false) {
     122                // Check for SQLite3 support
     123                if (!function_exists('sqlite_open')) {
     124                        throw new Exception('PHP not compiled with SQLite3 support.');
     125                }
     126
    100127                $this->table = $table; // Set table
    101128                $file = dirname(__FILE__).'/'.basename(__FILE__, 'php').'sqlite';
     
    107134                $this->create_table();   // Create cache table if not exists
    108135                $version = '';
    109                 $sql = $this->version_check;
     136                $sql = $this->getQuery('version_check');
    110137                $stmt = $db->prepare($sql);
    111138                $stmt->bindValue(':filename', getID3::VERSION, SQLITE3_TEXT);
     
    115142                        $this->clear_cache();
    116143                }
    117                 return parent::__construct();
    118         }
    119 
    120         /**
    121         * close the database connection
    122         */
     144                parent::__construct();
     145        }
     146
     147        /**
     148         * close the database connection
     149         */
    123150        public function __destruct() {
    124151                $db=$this->db;
     
    127154
    128155        /**
    129         * hold the sqlite db
    130         * @var SQLite Resource
    131         */
    132         private $db;
    133 
    134         /**
    135         * table to use for caching
    136         * @var string $table
    137         */
    138         private $table;
    139 
    140         /**
    141         * clear the cache
    142         * @access private
    143         * @return type
    144         */
     156         * clear the cache
     157         *
     158         * @return SQLite3Result
     159         */
    145160        private function clear_cache() {
    146161                $db = $this->db;
    147                 $sql = $this->delete_cache;
     162                $sql = $this->getQuery('delete_cache');
    148163                $db->exec($sql);
    149                 $sql = $this->set_version;
     164                $sql = $this->getQuery('set_version');
    150165                $stmt = $db->prepare($sql);
    151166                $stmt->bindValue(':filename', getID3::VERSION, SQLITE3_TEXT);
     
    156171
    157172        /**
    158         * analyze file and cache them, if cached pull from the db
    159         * @param type $filename
    160         * @return boolean
    161         */
     173         * analyze file and cache them, if cached pull from the db
     174         *
     175         * @param string  $filename
     176         * @param integer $filesize
     177         * @param string  $original_filename
     178         *
     179         * @return mixed|false
     180         */
    162181        public function analyze($filename, $filesize=null, $original_filename='') {
    163182                if (!file_exists($filename)) {
     
    172191                // Lookup file
    173192                $db = $this->db;
    174                 $sql = $this->get_id3_data;
     193                $sql = $this->getQuery('get_id3_data');
    175194                $stmt = $db->prepare($sql);
    176195                $stmt->bindValue(':filename', $filename,      SQLITE3_TEXT);
     
    185204                $analysis = parent::analyze($filename, $filesize, $original_filename);
    186205                // Save result
    187                 $sql = $this->cache_file;
     206                $sql = $this->getQuery('cache_file');
    188207                $stmt = $db->prepare($sql);
    189208                $stmt->bindValue(':filename', $filename,                           SQLITE3_TEXT);
     
    198217
    199218        /**
    200         * create data base table
    201         * this is almost the same as MySQL, with the exception of the dirname being added
    202         * @return type
    203         */
     219         * create data base table
     220         * this is almost the same as MySQL, with the exception of the dirname being added
     221         *
     222         * @return bool
     223         */
    204224        private function create_table() {
    205225                $db = $this->db;
    206                 $sql = $this->make_table;
     226                $sql = $this->getQuery('make_table');
    207227                return $db->exec($sql);
    208228        }
    209229
    210230        /**
    211         * get cached directory
    212         *
    213         * This function is not in the MySQL extention, it's ment to speed up requesting multiple files
    214         * which is ideal for podcasting, playlists, etc.
    215         *
    216         * @access public
    217         * @param string $dir directory to search the cache database for
    218         * @return array return an array of matching id3 data
    219         */
     231         * get cached directory
     232         *
     233         * This function is not in the MySQL extention, it's ment to speed up requesting multiple files
     234         * which is ideal for podcasting, playlists, etc.
     235         *
     236         * @param string $dir directory to search the cache database for
     237         *
     238         * @return array return an array of matching id3 data
     239         */
    220240        public function get_cached_dir($dir) {
    221241                $db = $this->db;
    222242                $rows = array();
    223                 $sql = $this->get_cached_dir;
     243                $sql = $this->getQuery('get_cached_dir');
    224244                $stmt = $db->prepare($sql);
    225245                $stmt->bindValue(':dirname', $dir, SQLITE3_TEXT);
     
    232252
    233253        /**
     254         * returns NULL if query is not found
     255         *
     256         * @param string $name
     257         *
     258         * @return null|string
     259         */
     260        public function getQuery($name)
     261        {
     262                switch ($name) {
     263                        case 'version_check':
     264                                return "SELECT val FROM $this->table WHERE filename = :filename AND filesize = '-1' AND filetime = '-1' AND analyzetime = '-1'";
     265                                break;
     266                        case 'delete_cache':
     267                                return "DELETE FROM $this->table";
     268                                break;
     269                        case 'set_version':
     270                                return "INSERT INTO $this->table (filename, dirname, filesize, filetime, analyzetime, val) VALUES (:filename, :dirname, -1, -1, -1, :val)";
     271                                break;
     272                        case 'get_id3_data':
     273                                return "SELECT val FROM $this->table WHERE filename = :filename AND filesize = :filesize AND filetime = :filetime";
     274                                break;
     275                        case 'cache_file':
     276                                return "INSERT INTO $this->table (filename, dirname, filesize, filetime, analyzetime, val) VALUES (:filename, :dirname, :filesize, :filetime, :atime, :val)";
     277                                break;
     278                        case 'make_table':
     279                                return "CREATE TABLE IF NOT EXISTS $this->table (filename VARCHAR(255) DEFAULT '', dirname VARCHAR(255) DEFAULT '', filesize INT(11) DEFAULT '0', filetime INT(11) DEFAULT '0', analyzetime INT(11) DEFAULT '0', val text, PRIMARY KEY (filename, filesize, filetime))";
     280                                break;
     281                        case 'get_cached_dir':
     282                                return "SELECT val FROM $this->table WHERE dirname = :dirname";
     283                                break;
     284                        default:
     285                                return null;
     286                }
     287        }
     288
     289        /**
    234290        * use the magical __get() for sql queries
    235291        *
    236292        * access as easy as $this->{case name}, returns NULL if query is not found
     293        *
     294        * @param string $name
     295        *
     296        * @return string
     297        * @deprecated use getQuery() instead
    237298        */
    238299        public function __get($name) {
    239                 switch($name) {
    240                         case 'version_check':
    241                                 return "SELECT val FROM $this->table WHERE filename = :filename AND filesize = '-1' AND filetime = '-1' AND analyzetime = '-1'";
    242                                 break;
    243                         case 'delete_cache':
    244                                 return "DELETE FROM $this->table";
    245                                 break;
    246                         case 'set_version':
    247                                 return "INSERT INTO $this->table (filename, dirname, filesize, filetime, analyzetime, val) VALUES (:filename, :dirname, -1, -1, -1, :val)";
    248                                 break;
    249                         case 'get_id3_data':
    250                                 return "SELECT val FROM $this->table WHERE filename = :filename AND filesize = :filesize AND filetime = :filetime";
    251                                 break;
    252                         case 'cache_file':
    253                                 return "INSERT INTO $this->table (filename, dirname, filesize, filetime, analyzetime, val) VALUES (:filename, :dirname, :filesize, :filetime, :atime, :val)";
    254                                 break;
    255                         case 'make_table':
    256                                 //return "CREATE TABLE IF NOT EXISTS $this->table (filename VARCHAR(255) NOT NULL DEFAULT '', dirname VARCHAR(255) NOT NULL DEFAULT '', filesize INT(11) NOT NULL DEFAULT '0', filetime INT(11) NOT NULL DEFAULT '0', analyzetime INT(11) NOT NULL DEFAULT '0', val text not null, PRIMARY KEY (filename, filesize, filetime))";
    257                                 return "CREATE TABLE IF NOT EXISTS $this->table (filename VARCHAR(255) DEFAULT '', dirname VARCHAR(255) DEFAULT '', filesize INT(11) DEFAULT '0', filetime INT(11) DEFAULT '0', analyzetime INT(11) DEFAULT '0', val text, PRIMARY KEY (filename, filesize, filetime))";
    258                                 break;
    259                         case 'get_cached_dir':
    260                                 return "SELECT val FROM $this->table WHERE dirname = :dirname";
    261                                 break;
    262                 }
    263                 return null;
     300                return $this->getQuery($name);
    264301        }
    265302
  • _core_/plugins/medias/lib/getid3/getid3.lib.php

    r101151 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
    88//                                                             //
    99// getid3.lib.php - part of getID3()                           //
    10 // See readme.txt for more details                             //
     10//  see readme.txt for more details                            //
    1111//                                                            ///
    1212/////////////////////////////////////////////////////////////////
     
    1515class getid3_lib
    1616{
    17 
     17        /**
     18         * @param string $string
     19         * @param bool   $hex
     20         * @param bool   $spaces
     21         * @param string $htmlencoding
     22         *
     23         * @return string
     24         */
    1825        public static function PrintHexBytes($string, $hex=true, $spaces=true, $htmlencoding='UTF-8') {
    1926                $returnstring = '';
     
    3744        }
    3845
     46        /**
     47         * Truncates a floating-point number at the decimal point.
     48         *
     49         * @param float $floatnumber
     50         *
     51         * @return float|int returns int (if possible, otherwise float)
     52         */
    3953        public static function trunc($floatnumber) {
    40                 // truncates a floating-point number at the decimal point
    41                 // returns int (if possible, otherwise float)
    4254                if ($floatnumber >= 1) {
    4355                        $truncatednumber = floor($floatnumber);
     
    5365        }
    5466
    55 
     67        /**
     68         * @param int|null $variable
     69         * @param int      $increment
     70         *
     71         * @return bool
     72         */
    5673        public static function safe_inc(&$variable, $increment=1) {
    5774                if (isset($variable)) {
     
    6380        }
    6481
     82        /**
     83         * @param int|float $floatnum
     84         *
     85         * @return int|float
     86         */
    6587        public static function CastAsInt($floatnum) {
    6688                // convert to float if not already
     
    78100        }
    79101
     102        /**
     103         * @param int $num
     104         *
     105         * @return bool
     106         */
    80107        public static function intValueSupported($num) {
    81108                // check if integers are 64-bit
     
    94121        }
    95122
     123        /**
     124         * @param string $fraction
     125         *
     126         * @return float
     127         */
    96128        public static function DecimalizeFraction($fraction) {
    97129                list($numerator, $denominator) = explode('/', $fraction);
     
    99131        }
    100132
    101 
     133        /**
     134         * @param string $binarynumerator
     135         *
     136         * @return float
     137         */
    102138        public static function DecimalBinary2Float($binarynumerator) {
    103139                $numerator   = self::Bin2Dec($binarynumerator);
     
    106142        }
    107143
    108 
     144        /**
     145         * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
     146         *
     147         * @param string $binarypointnumber
     148         * @param int    $maxbits
     149         *
     150         * @return array
     151         */
    109152        public static function NormalizeBinaryPoint($binarypointnumber, $maxbits=52) {
    110                 // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
    111153                if (strpos($binarypointnumber, '.') === false) {
    112154                        $binarypointnumber = '0.'.$binarypointnumber;
     
    130172        }
    131173
    132 
     174        /**
     175         * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
     176         *
     177         * @param float $floatvalue
     178         *
     179         * @return string
     180         */
    133181        public static function Float2BinaryDecimal($floatvalue) {
    134                 // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
    135182                $maxbits = 128; // to how many bits of precision should the calculations be taken?
    136183                $intpart   = self::trunc($floatvalue);
     
    146193        }
    147194
    148 
     195        /**
     196         * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
     197         *
     198         * @param float $floatvalue
     199         * @param int $bits
     200         *
     201         * @return string|false
     202         */
    149203        public static function Float2String($floatvalue, $bits) {
    150                 // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
     204                $exponentbits = 0;
     205                $fractionbits = 0;
    151206                switch ($bits) {
    152207                        case 32:
     
    177232        }
    178233
    179 
     234        /**
     235         * @param string $byteword
     236         *
     237         * @return float|false
     238         */
    180239        public static function LittleEndian2Float($byteword) {
    181240                return self::BigEndian2Float(strrev($byteword));
    182241        }
    183242
    184 
     243        /**
     244         * ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
     245         *
     246         * @link http://www.psc.edu/general/software/packages/ieee/ieee.html
     247         * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
     248         *
     249         * @param string $byteword
     250         *
     251         * @return float|false
     252         */
    185253        public static function BigEndian2Float($byteword) {
    186                 // ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
    187                 // http://www.psc.edu/general/software/packages/ieee/ieee.html
    188                 // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
    189 
    190254                $bitword = self::BigEndian2Bin($byteword);
    191255                if (!$bitword) {
     
    193257                }
    194258                $signbit = $bitword{0};
     259                $floatvalue = 0;
     260                $exponentbits = 0;
     261                $fractionbits = 0;
    195262
    196263                switch (strlen($byteword) * 8) {
     
    260327        }
    261328
    262 
     329        /**
     330         * @param string $byteword
     331         * @param bool   $synchsafe
     332         * @param bool   $signed
     333         *
     334         * @return int|float|false
     335         * @throws Exception
     336         */
    263337        public static function BigEndian2Int($byteword, $synchsafe=false, $signed=false) {
    264338                $intvalue = 0;
     
    289363        }
    290364
    291 
     365        /**
     366         * @param string $byteword
     367         * @param bool   $signed
     368         *
     369         * @return int|float|false
     370         */
    292371        public static function LittleEndian2Int($byteword, $signed=false) {
    293372                return self::BigEndian2Int(strrev($byteword), false, $signed);
    294373        }
    295374
    296 
     375        /**
     376         * @param string $byteword
     377         *
     378         * @return string
     379         */
     380        public static function LittleEndian2Bin($byteword) {
     381                return self::BigEndian2Bin(strrev($byteword));
     382        }
     383
     384        /**
     385         * @param string $byteword
     386         *
     387         * @return string
     388         */
    297389        public static function BigEndian2Bin($byteword) {
    298390                $binvalue = '';
     
    304396        }
    305397
    306 
     398        /**
     399         * @param int  $number
     400         * @param int  $minbytes
     401         * @param bool $synchsafe
     402         * @param bool $signed
     403         *
     404         * @return string
     405         * @throws Exception
     406         */
    307407        public static function BigEndian2String($number, $minbytes=1, $synchsafe=false, $signed=false) {
    308408                if ($number < 0) {
     
    325425        }
    326426
    327 
     427        /**
     428         * @param int $number
     429         *
     430         * @return string
     431         */
    328432        public static function Dec2Bin($number) {
    329433                while ($number >= 256) {
     
    339443        }
    340444
    341 
     445        /**
     446         * @param string $binstring
     447         * @param bool   $signed
     448         *
     449         * @return int|float
     450         */
    342451        public static function Bin2Dec($binstring, $signed=false) {
    343452                $signmult = 1;
     
    355464        }
    356465
    357 
     466        /**
     467         * @param string $binstring
     468         *
     469         * @return string
     470         */
    358471        public static function Bin2String($binstring) {
    359472                // return 'hi' for input of '0110100001101001'
     
    366479        }
    367480
    368 
     481        /**
     482         * @param int  $number
     483         * @param int  $minbytes
     484         * @param bool $synchsafe
     485         *
     486         * @return string
     487         */
    369488        public static function LittleEndian2String($number, $minbytes=1, $synchsafe=false) {
    370489                $intstring = '';
     
    381500        }
    382501
    383 
     502        /**
     503         * @param array $array1
     504         * @param array $array2
     505         *
     506         * @return array|false
     507         */
    384508        public static function array_merge_clobber($array1, $array2) {
    385509                // written by kcØhireability*com
     
    399523        }
    400524
    401 
     525        /**
     526         * @param array $array1
     527         * @param array $array2
     528         *
     529         * @return array|false
     530         */
    402531        public static function array_merge_noclobber($array1, $array2) {
    403532                if (!is_array($array1) || !is_array($array2)) {
     
    415544        }
    416545
     546        /**
     547         * @param array $array1
     548         * @param array $array2
     549         *
     550         * @return array|false|null
     551         */
    417552        public static function flipped_array_merge_noclobber($array1, $array2) {
    418553                if (!is_array($array1) || !is_array($array2)) {
     
    429564        }
    430565
    431 
     566        /**
     567         * @param array $theArray
     568         *
     569         * @return bool
     570         */
    432571        public static function ksort_recursive(&$theArray) {
    433572                ksort($theArray);
     
    440579        }
    441580
     581        /**
     582         * @param string $filename
     583         * @param int    $numextensions
     584         *
     585         * @return string
     586         */
    442587        public static function fileextension($filename, $numextensions=1) {
    443588                if (strstr($filename, '.')) {
     
    455600        }
    456601
    457 
     602        /**
     603         * @param int $seconds
     604         *
     605         * @return string
     606         */
    458607        public static function PlaytimeString($seconds) {
    459608                $sign = (($seconds < 0) ? '-' : '');
     
    465614        }
    466615
    467 
     616        /**
     617         * @param int $macdate
     618         *
     619         * @return int|float
     620         */
    468621        public static function DateMac2Unix($macdate) {
    469622                // Macintosh timestamp: seconds since 00:00h January 1, 1904
     
    472625        }
    473626
    474 
     627        /**
     628         * @param string $rawdata
     629         *
     630         * @return float
     631         */
    475632        public static function FixedPoint8_8($rawdata) {
    476633                return self::BigEndian2Int(substr($rawdata, 0, 1)) + (float) (self::BigEndian2Int(substr($rawdata, 1, 1)) / pow(2, 8));
    477634        }
    478635
    479 
     636        /**
     637         * @param string $rawdata
     638         *
     639         * @return float
     640         */
    480641        public static function FixedPoint16_16($rawdata) {
    481642                return self::BigEndian2Int(substr($rawdata, 0, 2)) + (float) (self::BigEndian2Int(substr($rawdata, 2, 2)) / pow(2, 16));
    482643        }
    483644
    484 
     645        /**
     646         * @param string $rawdata
     647         *
     648         * @return float
     649         */
    485650        public static function FixedPoint2_30($rawdata) {
    486651                $binarystring = self::BigEndian2Bin($rawdata);
     
    489654
    490655
     656        /**
     657         * @param string $ArrayPath
     658         * @param string $Separator
     659         * @param mixed $Value
     660         *
     661         * @return array
     662         */
    491663        public static function CreateDeepArray($ArrayPath, $Separator, $Value) {
    492664                // assigns $Value to a nested array path:
     
    505677        }
    506678
     679        /**
     680         * @param array $arraydata
     681         * @param bool  $returnkey
     682         *
     683         * @return int|false
     684         */
    507685        public static function array_max($arraydata, $returnkey=false) {
    508686                $maxvalue = false;
     
    519697        }
    520698
     699        /**
     700         * @param array $arraydata
     701         * @param bool  $returnkey
     702         *
     703         * @return int|false
     704         */
    521705        public static function array_min($arraydata, $returnkey=false) {
    522706                $minvalue = false;
     
    533717        }
    534718
     719        /**
     720         * @param string $XMLstring
     721         *
     722         * @return array|false
     723         */
    535724        public static function XML2array($XMLstring) {
    536725                if (function_exists('simplexml_load_string') && function_exists('libxml_disable_entity_loader')) {
     
    546735        }
    547736
     737        /**
     738        * @param SimpleXMLElement|array $XMLobject
     739        *
     740        * @return array
     741        */
    548742        public static function SimpleXMLelement2array($XMLobject) {
    549743                if (!is_object($XMLobject) && !is_array($XMLobject)) {
    550744                        return $XMLobject;
    551745                }
    552                 $XMLarray = (is_object($XMLobject) ? get_object_vars($XMLobject) : $XMLobject);
     746                $XMLarray = $XMLobject instanceof SimpleXMLElement ? get_object_vars($XMLobject) : $XMLobject;
    553747                foreach ($XMLarray as $key => $value) {
    554748                        $XMLarray[$key] = self::SimpleXMLelement2array($value);
     
    557751        }
    558752
    559 
    560         // Allan Hansen <ahØartemis*dk>
    561         // self::md5_data() - returns md5sum for a file from startuing position to absolute end position
     753        /**
     754         * self::md5_data() - returns md5sum for a file from startuing position to absolute end position
     755         *
     756         * @author Allan Hansen <ahØartemis*dk>
     757         *
     758         * @param string $file
     759         * @param int    $offset
     760         * @param int    $end
     761         * @param string $algorithm
     762         *
     763         * @return string|false
     764         * @throws Exception
     765         * @throws getid3_exception
     766         */
    562767        public static function hash_data($file, $offset, $end, $algorithm) {
    563768                static $tempdir = '';
     769                $windows_call = null;
     770                $unix_call = null;
     771                $hash_length = null;
     772                $hash_function = null;
    564773                if (!self::intValueSupported($end)) {
    565774                        return false;
     
    646855        }
    647856
     857        /**
     858         * @param string $filename_source
     859         * @param string $filename_dest
     860         * @param int    $offset
     861         * @param int    $length
     862         *
     863         * @return bool
     864         * @throws Exception
     865         */
    648866        public static function CopyFileParts($filename_source, $filename_dest, $offset, $length) {
    649867                if (!self::intValueSupported($offset + $length)) {
     
    658876                                                $byteslefttowrite -= $byteswritten;
    659877                                        }
     878                                        fclose($fp_dest);
    660879                                        return true;
    661880                                } else {
     881                                        fclose($fp_src);
    662882                                        throw new Exception('failed to seek to offset '.$offset.' in '.$filename_source);
    663883                                }
    664                                 fclose($fp_dest);
    665884                        } else {
    666885                                throw new Exception('failed to create file for writing '.$filename_dest);
    667886                        }
    668                         fclose($fp_src);
    669887                } else {
    670888                        throw new Exception('failed to open file for reading '.$filename_source);
    671889                }
    672                 return false;
    673         }
    674 
     890        }
     891
     892        /**
     893         * @param int $charval
     894         *
     895         * @return string
     896         */
    675897        public static function iconv_fallback_int_utf8($charval) {
    676898                if ($charval < 128) {
     
    696918        }
    697919
    698         // ISO-8859-1 => UTF-8
     920        /**
     921         * ISO-8859-1 => UTF-8
     922         *
     923         * @param string $string
     924         * @param bool   $bom
     925         *
     926         * @return string
     927         */
    699928        public static function iconv_fallback_iso88591_utf8($string, $bom=false) {
    700929                if (function_exists('utf8_encode')) {
     
    713942        }
    714943
    715         // ISO-8859-1 => UTF-16BE
     944        /**
     945         * ISO-8859-1 => UTF-16BE
     946         *
     947         * @param string $string
     948         * @param bool   $bom
     949         *
     950         * @return string
     951         */
    716952        public static function iconv_fallback_iso88591_utf16be($string, $bom=false) {
    717953                $newcharstring = '';
     
    725961        }
    726962
    727         // ISO-8859-1 => UTF-16LE
     963        /**
     964         * ISO-8859-1 => UTF-16LE
     965         *
     966         * @param string $string
     967         * @param bool   $bom
     968         *
     969         * @return string
     970         */
    728971        public static function iconv_fallback_iso88591_utf16le($string, $bom=false) {
    729972                $newcharstring = '';
     
    737980        }
    738981
    739         // ISO-8859-1 => UTF-16LE (BOM)
     982        /**
     983         * ISO-8859-1 => UTF-16LE (BOM)
     984         *
     985         * @param string $string
     986         *
     987         * @return string
     988         */
    740989        public static function iconv_fallback_iso88591_utf16($string) {
    741990                return self::iconv_fallback_iso88591_utf16le($string, true);
    742991        }
    743992
    744         // UTF-8 => ISO-8859-1
     993        /**
     994         * UTF-8 => ISO-8859-1
     995         *
     996         * @param string $string
     997         *
     998         * @return string
     999         */
    7451000        public static function iconv_fallback_utf8_iso88591($string) {
    7461001                if (function_exists('utf8_decode')) {
     
    7861041        }
    7871042
    788         // UTF-8 => UTF-16BE
     1043        /**
     1044         * UTF-8 => UTF-16BE
     1045         *
     1046         * @param string $string
     1047         * @param bool   $bom
     1048         *
     1049         * @return string
     1050         */
    7891051        public static function iconv_fallback_utf8_utf16be($string, $bom=false) {
    7901052                $newcharstring = '';
     
    8291091        }
    8301092
    831         // UTF-8 => UTF-16LE
     1093        /**
     1094         * UTF-8 => UTF-16LE
     1095         *
     1096         * @param string $string
     1097         * @param bool   $bom
     1098         *
     1099         * @return string
     1100         */
    8321101        public static function iconv_fallback_utf8_utf16le($string, $bom=false) {
    8331102                $newcharstring = '';
     
    8721141        }
    8731142
    874         // UTF-8 => UTF-16LE (BOM)
     1143        /**
     1144         * UTF-8 => UTF-16LE (BOM)
     1145         *
     1146         * @param string $string
     1147         *
     1148         * @return string
     1149         */
    8751150        public static function iconv_fallback_utf8_utf16($string) {
    8761151                return self::iconv_fallback_utf8_utf16le($string, true);
    8771152        }
    8781153
    879         // UTF-16BE => UTF-8
     1154        /**
     1155         * UTF-16BE => UTF-8
     1156         *
     1157         * @param string $string
     1158         *
     1159         * @return string
     1160         */
    8801161        public static function iconv_fallback_utf16be_utf8($string) {
    8811162                if (substr($string, 0, 2) == "\xFE\xFF") {
     
    8911172        }
    8921173
    893         // UTF-16LE => UTF-8
     1174        /**
     1175         * UTF-16LE => UTF-8
     1176         *
     1177         * @param string $string
     1178         *
     1179         * @return string
     1180         */
    8941181        public static function iconv_fallback_utf16le_utf8($string) {
    8951182                if (substr($string, 0, 2) == "\xFF\xFE") {
     
    9051192        }
    9061193
    907         // UTF-16BE => ISO-8859-1
     1194        /**
     1195         * UTF-16BE => ISO-8859-1
     1196         *
     1197         * @param string $string
     1198         *
     1199         * @return string
     1200         */
    9081201        public static function iconv_fallback_utf16be_iso88591($string) {
    9091202                if (substr($string, 0, 2) == "\xFE\xFF") {
     
    9191212        }
    9201213
    921         // UTF-16LE => ISO-8859-1
     1214        /**
     1215         * UTF-16LE => ISO-8859-1
     1216         *
     1217         * @param string $string
     1218         *
     1219         * @return string
     1220         */
    9221221        public static function iconv_fallback_utf16le_iso88591($string) {
    9231222                if (substr($string, 0, 2) == "\xFF\xFE") {
     
    9331232        }
    9341233
    935         // UTF-16 (BOM) => ISO-8859-1
     1234        /**
     1235         * UTF-16 (BOM) => ISO-8859-1
     1236         *
     1237         * @param string $string
     1238         *
     1239         * @return string
     1240         */
    9361241        public static function iconv_fallback_utf16_iso88591($string) {
    9371242                $bom = substr($string, 0, 2);
     
    9441249        }
    9451250
    946         // UTF-16 (BOM) => UTF-8
     1251        /**
     1252         * UTF-16 (BOM) => UTF-8
     1253         *
     1254         * @param string $string
     1255         *
     1256         * @return string
     1257         */
    9471258        public static function iconv_fallback_utf16_utf8($string) {
    9481259                $bom = substr($string, 0, 2);
     
    9551266        }
    9561267
     1268        /**
     1269         * @param string $in_charset
     1270         * @param string $out_charset
     1271         * @param string $string
     1272         *
     1273         * @return string
     1274         * @throws Exception
     1275         */
    9571276        public static function iconv_fallback($in_charset, $out_charset, $string) {
    9581277
     
    9611280                }
    9621281
    963                 // mb_convert_encoding() availble
     1282                // mb_convert_encoding() available
    9641283                if (function_exists('mb_convert_encoding')) {
    9651284                        if ($converted_string = @mb_convert_encoding($string, $out_charset, $in_charset)) {
     
    9731292                        return $string;
    9741293                }
    975                 // iconv() availble
     1294                // iconv() available
    9761295                else if (function_exists('iconv')) {
    9771296                        if ($converted_string = @iconv($in_charset, $out_charset.'//TRANSLIT', $string)) {
     
    10151334        }
    10161335
     1336        /**
     1337         * @param mixed  $data
     1338         * @param string $charset
     1339         *
     1340         * @return mixed
     1341         */
    10171342        public static function recursiveMultiByteCharString2HTML($data, $charset='ISO-8859-1') {
    10181343                if (is_string($data)) {
     
    10291354        }
    10301355
     1356        /**
     1357         * @param string|int|float $string
     1358         * @param string           $charset
     1359         *
     1360         * @return string
     1361         */
    10311362        public static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
    10321363                $string = (string) $string; // in case trying to pass a numeric (float, int) string, would otherwise return an empty string
     
    11211452        }
    11221453
    1123 
    1124 
     1454        /**
     1455         * @param int $namecode
     1456         *
     1457         * @return string
     1458         */
    11251459        public static function RGADnameLookup($namecode) {
    11261460                static $RGADname = array();
     
    11341468        }
    11351469
    1136 
     1470        /**
     1471         * @param int $originatorcode
     1472         *
     1473         * @return string
     1474         */
    11371475        public static function RGADoriginatorLookup($originatorcode) {
    11381476                static $RGADoriginator = array();
     
    11471485        }
    11481486
    1149 
     1487        /**
     1488         * @param int $rawadjustment
     1489         * @param int $signbit
     1490         *
     1491         * @return float
     1492         */
    11501493        public static function RGADadjustmentLookup($rawadjustment, $signbit) {
    1151                 $adjustment = $rawadjustment / 10;
     1494                $adjustment = (float) $rawadjustment / 10;
    11521495                if ($signbit == 1) {
    11531496                        $adjustment *= -1;
    11541497                }
    1155                 return (float) $adjustment;
    1156         }
    1157 
    1158 
     1498                return $adjustment;
     1499        }
     1500
     1501        /**
     1502         * @param int $namecode
     1503         * @param int $originatorcode
     1504         * @param int $replaygain
     1505         *
     1506         * @return string
     1507         */
    11591508        public static function RGADgainString($namecode, $originatorcode, $replaygain) {
    11601509                if ($replaygain < 0) {
     
    11721521        }
    11731522
     1523        /**
     1524         * @param float $amplitude
     1525         *
     1526         * @return float
     1527         */
    11741528        public static function RGADamplitude2dB($amplitude) {
    11751529                return 20 * log10($amplitude);
    11761530        }
    11771531
    1178 
     1532        /**
     1533         * @param string $imgData
     1534         * @param array  $imageinfo
     1535         *
     1536         * @return array|false
     1537         */
    11791538        public static function GetDataImageSize($imgData, &$imageinfo=array()) {
    11801539                static $tempdir = '';
     
    12111570        }
    12121571
     1572        /**
     1573         * @param string $mime_type
     1574         *
     1575         * @return string
     1576         */
    12131577        public static function ImageExtFromMime($mime_type) {
    12141578                // temporary way, works OK for now, but should be reworked in the future
     
    12161580        }
    12171581
    1218         public static function ImageTypesLookup($imagetypeid) {
    1219                 static $ImageTypesLookup = array();
    1220                 if (empty($ImageTypesLookup)) {
    1221                         $ImageTypesLookup[1]  = 'gif';
    1222                         $ImageTypesLookup[2]  = 'jpeg';
    1223                         $ImageTypesLookup[3]  = 'png';
    1224                         $ImageTypesLookup[4]  = 'swf';
    1225                         $ImageTypesLookup[5]  = 'psd';
    1226                         $ImageTypesLookup[6]  = 'bmp';
    1227                         $ImageTypesLookup[7]  = 'tiff (little-endian)';
    1228                         $ImageTypesLookup[8]  = 'tiff (big-endian)';
    1229                         $ImageTypesLookup[9]  = 'jpc';
    1230                         $ImageTypesLookup[10] = 'jp2';
    1231                         $ImageTypesLookup[11] = 'jpx';
    1232                         $ImageTypesLookup[12] = 'jb2';
    1233                         $ImageTypesLookup[13] = 'swc';
    1234                         $ImageTypesLookup[14] = 'iff';
    1235                 }
    1236                 return (isset($ImageTypesLookup[$imagetypeid]) ? $ImageTypesLookup[$imagetypeid] : '');
    1237         }
    1238 
     1582        /**
     1583         * @param array $ThisFileInfo
     1584         *
     1585         * @return bool
     1586         */
    12391587        public static function CopyTagsToComments(&$ThisFileInfo) {
    12401588
     
    13241672        }
    13251673
    1326 
     1674        /**
     1675         * @param string $key
     1676         * @param int    $begin
     1677         * @param int    $end
     1678         * @param string $file
     1679         * @param string $name
     1680         *
     1681         * @return string
     1682         */
    13271683        public static function EmbeddedLookup($key, $begin, $end, $file, $name) {
    13281684
     
    13711727        }
    13721728
     1729        /**
     1730         * @param string $filename
     1731         * @param string $sourcefile
     1732         * @param bool   $DieOnFailure
     1733         *
     1734         * @return bool
     1735         * @throws Exception
     1736         */
    13731737        public static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
    13741738                global $GETID3_ERRORARRAY;
     
    13911755        }
    13921756
     1757        /**
     1758         * @param string $string
     1759         *
     1760         * @return string
     1761         */
    13931762        public static function trimNullByte($string) {
    13941763                return trim($string, "\x00");
    13951764        }
    13961765
     1766        /**
     1767         * @param string $path
     1768         *
     1769         * @return float|bool
     1770         */
    13971771        public static function getFileSizeSyscall($path) {
    13981772                $filesize = false;
     
    14191793        }
    14201794
    1421 
    1422         /**
    1423         * Workaround for Bug #37268 (https://bugs.php.net/bug.php?id=37268)
    1424         * @param string $path A path.
    1425         * @param string $suffix If the name component ends in suffix this will also be cut off.
    1426         * @return string
    1427         */
     1795        /**
     1796         * @param string $filename
     1797         *
     1798         * @return string|false
     1799         */
     1800        public static function truepath($filename) {
     1801                // 2017-11-08: this could use some improvement, patches welcome
     1802                if (preg_match('#^(\\\\\\\\|//)[a-z0-9]#i', $filename, $matches)) {
     1803                        // PHP's built-in realpath function does not work on UNC Windows shares
     1804                        $goodpath = array();
     1805                        foreach (explode('/', str_replace('\\', '/', $filename)) as $part) {
     1806                                if ($part == '.') {
     1807                                        continue;
     1808                                }
     1809                                if ($part == '..') {
     1810                                        if (count($goodpath)) {
     1811                                                array_pop($goodpath);
     1812                                        } else {
     1813                                                // cannot step above this level, already at top level
     1814                                                return false;
     1815                                        }
     1816                                } else {
     1817                                        $goodpath[] = $part;
     1818                                }
     1819                        }
     1820                        return implode(DIRECTORY_SEPARATOR, $goodpath);
     1821                }
     1822                return realpath($filename);
     1823        }
     1824
     1825        /**
     1826         * Workaround for Bug #37268 (https://bugs.php.net/bug.php?id=37268)
     1827         *
     1828         * @param string $path A path.
     1829         * @param string $suffix If the name component ends in suffix this will also be cut off.
     1830         *
     1831         * @return string
     1832         */
    14281833        public static function mb_basename($path, $suffix = null) {
    14291834                $splited = preg_split('#/#', rtrim($path, '/ '));
  • _core_/plugins/medias/lib/getid3/getid3.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
    88//                                                             //
    99// Please see readme.txt for more information                  //
     
    2626        define('ENT_SUBSTITUTE', (defined('ENT_IGNORE') ? ENT_IGNORE : 8));
    2727}
     28
     29/*
     30https://www.getid3.org/phpBB3/viewtopic.php?t=2114
     31If you are running into a the problem where filenames with special characters are being handled
     32incorrectly by external helper programs (e.g. metaflac), notably with the special characters removed,
     33and you are passing in the filename in UTF8 (typically via a HTML form), try uncommenting this line:
     34*/
     35//setlocale(LC_CTYPE, 'en_US.UTF-8');
    2836
    2937// attempt to define temp dir as something flexible but reliable
     
    7583class getID3
    7684{
    77         // public: Settings
    78         public $encoding        = 'UTF-8';        // CASE SENSITIVE! - i.e. (must be supported by iconv()). Examples:  ISO-8859-1  UTF-8  UTF-16  UTF-16BE
    79         public $encoding_id3v1  = 'ISO-8859-1';   // Should always be 'ISO-8859-1', but some tags may be written in other encodings such as 'EUC-CN' or 'CP1252'
    80 
    81         // public: Optional tag checks - disable for speed.
    82         public $option_tag_id3v1         = true;  // Read and process ID3v1 tags
    83         public $option_tag_id3v2         = true;  // Read and process ID3v2 tags
    84         public $option_tag_lyrics3       = true;  // Read and process Lyrics3 tags
    85         public $option_tag_apetag        = true;  // Read and process APE tags
    86         public $option_tags_process      = true;  // Copy tags to root key 'tags' and encode to $this->encoding
    87         public $option_tags_html         = true;  // Copy tags to root key 'tags_html' properly translated from various encodings to HTML entities
    88 
    89         // public: Optional tag/comment calucations
    90         public $option_extra_info        = true;  // Calculate additional info such as bitrate, channelmode etc
    91 
    92         // public: Optional handling of embedded attachments (e.g. images)
    93         public $option_save_attachments  = true; // defaults to true (ATTACHMENTS_INLINE) for backward compatibility
    94 
    95         // public: Optional calculations
    96         public $option_md5_data          = false; // Get MD5 sum of data part - slow
    97         public $option_md5_data_source   = false; // Use MD5 of source file if availble - only FLAC and OptimFROG
    98         public $option_sha1_data         = false; // Get SHA1 sum of data part - slow
    99         public $option_max_2gb_check     = null;  // Check whether file is larger than 2GB and thus not supported by 32-bit PHP (null: auto-detect based on PHP_INT_MAX)
    100 
    101         // public: Read buffer size in bytes
     85        /*
     86         * Settings
     87         */
     88
     89        /**
     90         * CASE SENSITIVE! - i.e. (must be supported by iconv()). Examples:  ISO-8859-1  UTF-8  UTF-16  UTF-16BE
     91         *
     92         * @var string
     93         */
     94        public $encoding        = 'UTF-8';
     95
     96        /**
     97         * Should always be 'ISO-8859-1', but some tags may be written in other encodings such as 'EUC-CN' or 'CP1252'
     98         *
     99         * @var string
     100         */
     101        public $encoding_id3v1  = 'ISO-8859-1';
     102
     103        /*
     104         * Optional tag checks - disable for speed.
     105         */
     106
     107        /**
     108         * Read and process ID3v1 tags
     109         *
     110         * @var bool
     111         */
     112        public $option_tag_id3v1         = true;
     113
     114        /**
     115         * Read and process ID3v2 tags
     116         *
     117         * @var bool
     118         */
     119        public $option_tag_id3v2         = true;
     120
     121        /**
     122         * Read and process Lyrics3 tags
     123         *
     124         * @var bool
     125         */
     126        public $option_tag_lyrics3       = true;
     127
     128        /**
     129         * Read and process APE tags
     130         *
     131         * @var bool
     132         */
     133        public $option_tag_apetag        = true;
     134
     135        /**
     136         * Copy tags to root key 'tags' and encode to $this->encoding
     137         *
     138         * @var bool
     139         */
     140        public $option_tags_process      = true;
     141
     142        /**
     143         * Copy tags to root key 'tags_html' properly translated from various encodings to HTML entities
     144         *
     145         * @var bool
     146         */
     147        public $option_tags_html         = true;
     148
     149        /*
     150         * Optional tag/comment calculations
     151         */
     152
     153        /**
     154         * Calculate additional info such as bitrate, channelmode etc
     155         *
     156         * @var bool
     157         */
     158        public $option_extra_info        = true;
     159
     160        /*
     161         * Optional handling of embedded attachments (e.g. images)
     162         */
     163
     164        /**
     165         * Defaults to true (ATTACHMENTS_INLINE) for backward compatibility
     166         *
     167         * @var bool|string
     168         */
     169        public $option_save_attachments  = true;
     170
     171        /*
     172         * Optional calculations
     173         */
     174
     175        /**
     176         * Get MD5 sum of data part - slow
     177         *
     178         * @var bool
     179         */
     180        public $option_md5_data          = false;
     181
     182        /**
     183         * Use MD5 of source file if availble - only FLAC and OptimFROG
     184         *
     185         * @var bool
     186         */
     187        public $option_md5_data_source   = false;
     188
     189        /**
     190         * Get SHA1 sum of data part - slow
     191         *
     192         * @var bool
     193         */
     194        public $option_sha1_data         = false;
     195
     196        /**
     197         * Check whether file is larger than 2GB and thus not supported by 32-bit PHP (null: auto-detect based on
     198         * PHP_INT_MAX)
     199         *
     200         * @var bool|null
     201         */
     202        public $option_max_2gb_check;
     203
     204        /**
     205         * Read buffer size in bytes
     206         *
     207         * @var int
     208         */
    102209        public $option_fread_buffer_size = 32768;
    103210
    104211        // Public variables
    105         public $filename;                         // Filename of file being analysed.
    106         public $fp;                               // Filepointer to file being analysed.
    107         public $info;                             // Result array.
     212
     213        /**
     214         * Filename of file being analysed.
     215         *
     216         * @var string
     217         */
     218        public $filename;
     219
     220        /**
     221         * Filepointer to file being analysed.
     222         *
     223         * @var resource
     224         */
     225        public $fp;
     226
     227        /**
     228         * Result array.
     229         *
     230         * @var array
     231         */
     232        public $info;
     233
     234        /**
     235         * @var string
     236         */
    108237        public $tempdir = GETID3_TEMP_DIR;
     238
     239        /**
     240         * @var int
     241         */
    109242        public $memory_limit = 0;
    110243
    111         // Protected variables
     244        /**
     245         * @var string
     246         */
    112247        protected $startup_error   = '';
     248
     249        /**
     250         * @var string
     251         */
    113252        protected $startup_warning = '';
    114253
    115         const VERSION           = '1.9.14-201703261440';
     254        const VERSION           = '1.9.16-201810171314';
    116255        const FREAD_BUFFER_SIZE = 32768;
    117256
     
    119258        const ATTACHMENTS_INLINE = true;
    120259
    121         // public: constructor
    122260        public function __construct() {
    123261
     
    126264                if (version_compare(PHP_VERSION, $required_php_version, '<')) {
    127265                        $this->startup_error .= 'getID3() requires PHP v'.$required_php_version.' or higher - you are running v'.PHP_VERSION."\n";
    128                         return false;
     266                        return;
    129267                }
    130268
    131269                // Check memory
    132270                $this->memory_limit = ini_get('memory_limit');
    133                 if (preg_match('#([0-9]+)M#i', $this->memory_limit, $matches)) {
     271                if (preg_match('#([0-9]+) ?M#i', $this->memory_limit, $matches)) {
    134272                        // could be stored as "16M" rather than 16777216 for example
    135273                        $this->memory_limit = $matches[1] * 1048576;
    136                 } elseif (preg_match('#([0-9]+)G#i', $this->memory_limit, $matches)) { // The 'G' modifier is available since PHP 5.1.0
     274                } elseif (preg_match('#([0-9]+) ?G#i', $this->memory_limit, $matches)) { // The 'G' modifier is available since PHP 5.1.0
    137275                        // could be stored as "2G" rather than 2147483648 for example
    138276                        $this->memory_limit = $matches[1] * 1073741824;
     
    227365                        throw new getid3_exception($this->startup_error);
    228366                }
    229 
    230                 return true;
    231         }
    232 
     367        }
     368
     369        /**
     370         * @return string
     371         */
    233372        public function version() {
    234373                return self::VERSION;
    235374        }
    236375
     376        /**
     377         * @return int
     378         */
    237379        public function fread_buffer_size() {
    238380                return $this->option_fread_buffer_size;
    239381        }
    240382
    241 
    242         // public: setOption
     383        /**
     384         * @param array $optArray
     385         *
     386         * @return bool
     387         */
    243388        public function setOption($optArray) {
    244389                if (!is_array($optArray) || empty($optArray)) {
     
    254399        }
    255400
    256 
     401        /**
     402         * @param string $filename
     403         * @param int    $filesize
     404         *
     405         * @return bool
     406         *
     407         * @throws getid3_exception
     408         */
    257409        public function openfile($filename, $filesize=null) {
    258410                try {
     
    278430
    279431                        $filename = str_replace('/', DIRECTORY_SEPARATOR, $filename);
    280                         $filename = preg_replace('#(.+)'.preg_quote(DIRECTORY_SEPARATOR).'{2,}#U', '\1'.DIRECTORY_SEPARATOR, $filename);
     432                        //$filename = preg_replace('#(?<!gs:)('.preg_quote(DIRECTORY_SEPARATOR).'{2,})#', DIRECTORY_SEPARATOR, $filename);
    281433
    282434                        // open local file
    283                         //if (is_readable($filename) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) { // see http://www.getid3.org/phpBB3/viewtopic.php?t=1720
     435                        //if (is_readable($filename) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) { // see https://www.getid3.org/phpBB3/viewtopic.php?t=1720
    284436                        if ((is_readable($filename) || file_exists($filename)) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) {
    285437                                // great
     
    339491                                                        unset($this->info['filesize']);
    340492                                                        fclose($this->fp);
    341                                                         throw new getid3_exception('PHP seems to think the file is larger than '.round(PHP_INT_MAX / 1073741824).'GB, but filesystem reports it as '.number_format($real_filesize, 3).'GB, please report to info@getid3.org');
     493                                                        throw new getid3_exception('PHP seems to think the file is larger than '.round(PHP_INT_MAX / 1073741824).'GB, but filesystem reports it as '.number_format($real_filesize / 1073741824, 3).'GB, please report to info@getid3.org');
    342494                                                }
    343495                                                $this->info['filesize'] = $real_filesize;
    344                                                 $this->warning('File is larger than '.round(PHP_INT_MAX / 1073741824).'GB (filesystem reports it as '.number_format($real_filesize, 3).'GB) and is not properly supported by PHP.');
     496                                                $this->warning('File is larger than '.round(PHP_INT_MAX / 1073741824).'GB (filesystem reports it as '.number_format($real_filesize / 1073741824, 3).'GB) and is not properly supported by PHP.');
    345497                                }
    346498                        }
     
    354506        }
    355507
    356         // public: analyze file
     508        /**
     509         * analyze file
     510         *
     511         * @param string $filename
     512         * @param int    $filesize
     513         * @param string $original_filename
     514         *
     515         * @return array
     516         */
    357517        public function analyze($filename, $filesize=null, $original_filename='') {
    358518                try {
     
    505665
    506666
    507         // private: error handling
     667        /**
     668         * Error handling.
     669         *
     670         * @param string $message
     671         *
     672         * @return array
     673         */
    508674        public function error($message) {
    509675                $this->CleanUp();
     
    516682
    517683
    518         // private: warning handling
     684        /**
     685         * Warning handling.
     686         *
     687         * @param string $message
     688         *
     689         * @return bool
     690         */
    519691        public function warning($message) {
    520692                $this->info['warning'][] = $message;
     
    523695
    524696
    525         // private: CleanUp
     697        /**
     698         * @return bool
     699         */
    526700        private function CleanUp() {
    527701
     
    570744        }
    571745
    572 
    573         // return array containing information about all supported formats
     746        /**
     747         * Return array containing information about all supported formats.
     748         *
     749         * @return array
     750         */
    574751        public function GetFileFormatArray() {
    575752                static $format_info = array();
     
    592769                                                        'group'     => 'audio',
    593770                                                        'module'    => 'aac',
    594                                                         'mime_type' => 'application/octet-stream',
     771                                                        'mime_type' => 'audio/aac',
    595772                                                        'fail_ape'  => 'WARNING',
    596773                                                ),
     
    610787                                                        'group'     => 'audio',
    611788                                                        'module'    => 'aac',
    612                                                         'mime_type' => 'application/octet-stream',
     789                                                        'mime_type' => 'audio/aac',
    613790                                                        'fail_ape'  => 'WARNING',
    614791                                                ),
     
    676853                                                        'group'     => 'audio',
    677854                                                        'module'    => 'flac',
    678                                                         'mime_type' => 'audio/x-flac',
     855                                                        'mime_type' => 'audio/flac',
    679856                                                ),
    680857
     
    708885                                                        'group'     => 'audio',
    709886                                                        'module'    => 'monkey',
    710                                                         'mime_type' => 'application/octet-stream',
     887                                                        'mime_type' => 'audio/x-monkeys-audio',
    711888                                                ),
    712889
     
    8971074                                                        'group'     => 'audio-video',
    8981075                                                        'module'    => 'riff',
    899                                                         'mime_type' => 'audio/x-wav',
     1076                                                        'mime_type' => 'audio/wav',
    9001077                                                        'fail_ape'  => 'WARNING',
    9011078                                                ),
     
    10611238                                                        'group'     => 'archive',
    10621239                                                        'module'    => 'gzip',
    1063                                                         'mime_type' => 'application/x-gzip',
     1240                                                        'mime_type' => 'application/gzip',
    10641241                                                        'fail_id3'  => 'ERROR',
    10651242                                                        'fail_ape'  => 'ERROR',
     
    11231300        }
    11241301
    1125 
    1126 
     1302        /**
     1303         * @param string $filedata
     1304         * @param string $filename
     1305         *
     1306         * @return mixed|false
     1307         */
    11271308        public function GetFileFormat(&$filedata, $filename='') {
    11281309                // this function will determine the format of a file based on usually
     
    11621343        }
    11631344
    1164 
    1165         // converts array to $encoding charset from $this->encoding
     1345        /**
     1346         * Converts array to $encoding charset from $this->encoding.
     1347         *
     1348         * @param array  $array
     1349         * @param string $encoding
     1350         */
    11661351        public function CharConvert(&$array, $encoding) {
    11671352
     
    11861371        }
    11871372
    1188 
     1373        /**
     1374         * @return bool
     1375         */
    11891376        public function HandleAllTags() {
    11901377
     
    13091496        }
    13101497
     1498        /**
     1499         * @param string $algorithm
     1500         *
     1501         * @return array|bool
     1502         */
    13111503        public function getHashdata($algorithm) {
    13121504                switch ($algorithm) {
     
    13731565                                } else {
    13741566
    1375                                         $commandline = 'vorbiscomment -w -c "'.$empty.'" "'.$file.'" "'.$temp.'" 2>&1';
    13761567                                        $commandline = 'vorbiscomment -w -c '.escapeshellarg($empty).' '.escapeshellarg($file).' '.escapeshellarg($temp).' 2>&1';
    13771568                                        $VorbisCommentError = `$commandline`;
     
    14311622                return true;
    14321623        }
    1433 
    14341624
    14351625        public function ChannelsBitratePlaytimeCalculations() {
     
    14971687        }
    14981688
    1499 
     1689        /**
     1690         * @return bool
     1691         */
    15001692        public function CalculateCompressionRatioVideo() {
    15011693                if (empty($this->info['video'])) {
     
    15451737        }
    15461738
    1547 
     1739        /**
     1740         * @return bool
     1741         */
    15481742        public function CalculateCompressionRatioAudio() {
    15491743                if (empty($this->info['audio']['bitrate']) || empty($this->info['audio']['channels']) || empty($this->info['audio']['sample_rate']) || !is_numeric($this->info['audio']['sample_rate'])) {
     
    15621756        }
    15631757
    1564 
     1758        /**
     1759         * @return bool
     1760         */
    15651761        public function CalculateReplayGain() {
    15661762                if (isset($this->info['replay_gain'])) {
    15671763                        if (!isset($this->info['replay_gain']['reference_volume'])) {
    1568                                 $this->info['replay_gain']['reference_volume'] = (double) 89.0;
     1764                                $this->info['replay_gain']['reference_volume'] = 89.0;
    15691765                        }
    15701766                        if (isset($this->info['replay_gain']['track']['adjustment'])) {
     
    15851781        }
    15861782
     1783        /**
     1784         * @return bool
     1785         */
    15871786        public function ProcessAudioStreams() {
    15881787                if (!empty($this->info['audio']['bitrate']) || !empty($this->info['audio']['channels']) || !empty($this->info['audio']['sample_rate'])) {
     
    15981797        }
    15991798
     1799        /**
     1800         * @return string|bool
     1801         */
    16001802        public function getid3_tempnam() {
    16011803                return tempnam($this->tempdir, 'gI3');
    16021804        }
    16031805
     1806        /**
     1807         * @param string $name
     1808         *
     1809         * @return bool
     1810         *
     1811         * @throws getid3_exception
     1812         */
    16041813        public function include_module($name) {
    16051814                //if (!file_exists($this->include_path.'module.'.$name.'.php')) {
     
    16111820        }
    16121821
     1822        /**
     1823         * @param string $filename
     1824         *
     1825         * @return bool
     1826         */
     1827    public static function is_writable ($filename) {
     1828        $ret = is_writable($filename);
     1829
     1830        if (!$ret) {
     1831            $perms = fileperms($filename);
     1832            $ret = ($perms & 0x0080) || ($perms & 0x0010) || ($perms & 0x0002);
     1833        }
     1834
     1835        return $ret;
     1836    }
     1837
    16131838}
    16141839
    16151840
    1616 abstract class getid3_handler {
     1841abstract class getid3_handler
     1842{
    16171843
    16181844        /**
     
    16211847        protected $getid3;                       // pointer
    16221848
    1623         protected $data_string_flag     = false; // analyzing filepointer or string
    1624         protected $data_string          = '';    // string to analyze
    1625         protected $data_string_position = 0;     // seek position in string
    1626         protected $data_string_length   = 0;     // string length
    1627 
    1628         private $dependency_to = null;
    1629 
    1630 
     1849        /**
     1850         * Analyzing filepointer or string.
     1851         *
     1852         * @var bool
     1853         */
     1854        protected $data_string_flag     = false;
     1855
     1856        /**
     1857         * String to analyze.
     1858         *
     1859         * @var string
     1860         */
     1861        protected $data_string          = '';
     1862
     1863        /**
     1864         * Seek position in string.
     1865         *
     1866         * @var int
     1867         */
     1868        protected $data_string_position = 0;
     1869
     1870        /**
     1871         * String length.
     1872         *
     1873         * @var int
     1874         */
     1875        protected $data_string_length   = 0;
     1876
     1877        /**
     1878         * @var string
     1879         */
     1880        private $dependency_to;
     1881
     1882        /**
     1883         * getid3_handler constructor.
     1884         *
     1885         * @param getID3 $getid3
     1886         * @param string $call_module
     1887         */
    16311888        public function __construct(getID3 $getid3, $call_module=null) {
    16321889                $this->getid3 = $getid3;
     
    16371894        }
    16381895
    1639 
    1640         // Analyze from file pointer
     1896        /**
     1897         * Analyze from file pointer.
     1898         *
     1899         * @return bool
     1900         */
    16411901        abstract public function Analyze();
    16421902
    1643 
    1644         // Analyze from string instead
     1903        /**
     1904         * Analyze from string instead.
     1905         *
     1906         * @param string $string
     1907         */
    16451908        public function AnalyzeString($string) {
    16461909                // Enter string mode
     
    16681931        }
    16691932
     1933        /**
     1934         * @param string $string
     1935         */
    16701936        public function setStringMode($string) {
    16711937                $this->data_string_flag   = true;
     
    16741940        }
    16751941
     1942        /**
     1943         * @return int|bool
     1944         */
    16761945        protected function ftell() {
    16771946                if ($this->data_string_flag) {
     
    16811950        }
    16821951
     1952        /**
     1953         * @param int $bytes
     1954         *
     1955         * @return string|false
     1956         *
     1957         * @throws getid3_exception
     1958         */
    16831959        protected function fread($bytes) {
    16841960                if ($this->data_string_flag) {
     
    16931969                //return fread($this->getid3->fp, $bytes);
    16941970                /*
    1695                 * http://www.getid3.org/phpBB3/viewtopic.php?t=1930
     1971                * https://www.getid3.org/phpBB3/viewtopic.php?t=1930
    16961972                * "I found out that the root cause for the problem was how getID3 uses the PHP system function fread().
    16971973                * It seems to assume that fread() would always return as many bytes as were requested.
     
    17011977                $contents = '';
    17021978                do {
     1979                        if (($this->getid3->memory_limit > 0) && ($bytes > $this->getid3->memory_limit)) {
     1980                                throw new getid3_exception('cannot fread('.$bytes.' from '.$this->ftell().') that is more than available PHP memory ('.$this->getid3->memory_limit.')', 10);
     1981                        }
    17031982                        $part = fread($this->getid3->fp, $bytes);
    17041983                        $partLength  = strlen($part);
     
    17091988        }
    17101989
     1990        /**
     1991         * @param int $bytes
     1992         * @param int $whence
     1993         *
     1994         * @return int
     1995         *
     1996         * @throws getid3_exception
     1997         */
    17111998        protected function fseek($bytes, $whence=SEEK_SET) {
    17121999                if ($this->data_string_flag) {
     
    17392026        }
    17402027
     2028        /**
     2029         * @return bool
     2030         */
    17412031        protected function feof() {
    17422032                if ($this->data_string_flag) {
     
    17462036        }
    17472037
     2038        /**
     2039         * @param string $module
     2040         *
     2041         * @return bool
     2042         */
    17482043        final protected function isDependencyFor($module) {
    17492044                return $this->dependency_to == $module;
    17502045        }
    17512046
     2047        /**
     2048         * @param string $text
     2049         *
     2050         * @return bool
     2051         */
    17522052        protected function error($text) {
    17532053                $this->getid3->info['error'][] = $text;
     
    17562056        }
    17572057
     2058        /**
     2059         * @param string $text
     2060         *
     2061         * @return bool
     2062         */
    17582063        protected function warning($text) {
    17592064                return $this->getid3->warning($text);
    17602065        }
    17612066
     2067        /**
     2068         * @param string $text
     2069         */
    17622070        protected function notice($text) {
    17632071                // does nothing for now
    17642072        }
    17652073
     2074        /**
     2075         * @param string $name
     2076         * @param int    $offset
     2077         * @param int    $length
     2078         * @param string $image_mime
     2079         *
     2080         * @return string|null
     2081         *
     2082         * @throws Exception
     2083         * @throws getid3_exception
     2084         */
    17662085        public function saveAttachment($name, $offset, $length, $image_mime=null) {
    17672086                try {
     
    17862105                                // set up destination path
    17872106                                $dir = rtrim(str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $this->getid3->option_save_attachments), DIRECTORY_SEPARATOR);
    1788                                 if (!is_dir($dir) || !is_writable($dir)) { // check supplied directory
     2107                                if (!is_dir($dir) || !getID3::is_writable($dir)) { // check supplied directory
    17892108                                        throw new Exception('supplied path ('.$dir.') does not exist, or is not writable');
    17902109                                }
     
    18172136                        if (isset($fp_dest) && is_resource($fp_dest)) {
    18182137                                fclose($fp_dest);
     2138                        }
     2139
     2140                        if (isset($dest) && file_exists($dest)) {
    18192141                                unlink($dest);
    18202142                        }
  • _core_/plugins/medias/lib/getid3/module.archive.gzip.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    2121
    2222
    23 class getid3_gzip extends getid3_handler {
    24 
    25         // public: Optional file list - disable for speed.
    26         public $option_gzip_parse_contents = false; // decode gzipped files, if possible, and parse recursively (.tar.gz for example)
    27 
     23class getid3_gzip extends getid3_handler
     24{
     25        /**
     26         * Optional file list - disable for speed.
     27         *
     28         * Decode gzipped files, if possible, and parse recursively (.tar.gz for example).
     29         *
     30         * @var bool
     31         */
     32        public $option_gzip_parse_contents = false;
     33
     34        /**
     35         * @return bool
     36         */
    2837        public function Analyze() {
    2938                $info = &$this->getid3->info;
     
    4554
    4655                $arr_members = explode("\x1F\x8B\x08", $buffer);
     56                $num_members = 0;
    4757                while (true) {
    4858                        $is_wrong_members = false;
     
    200210
    201211                                        // Calculate CRC32 for inflated content
    202                                         $thisInfo['crc32_valid'] = (bool) (sprintf('%u', crc32($inflated)) == $thisInfo['crc32']);
     212                                        $thisInfo['crc32_valid'] = sprintf('%u', crc32($inflated)) == $thisInfo['crc32'];
    203213
    204214                                        // determine format
     
    241251                                                        break;
    242252                                        }
     253                                } else {
     254                                        $this->warning('PHP is not compiled with gzinflate() support. Please enable PHP Zlib extension or recompile with the --with-zlib switch');
    243255                                }
    244256                        }
     
    247259        }
    248260
    249         // Converts the OS type
     261        /**
     262         * Converts the OS type.
     263         *
     264         * @param string $key
     265         *
     266         * @return string
     267         */
    250268        public function get_os_type($key) {
    251269                static $os_type = array(
     
    269287        }
    270288
    271         // Converts the eXtra FLags
     289        /**
     290         * Converts the eXtra FLags.
     291         *
     292         * @param string $key
     293         *
     294         * @return string
     295         */
    272296        public function get_xflag_type($key) {
    273297                static $xflag_type = array(
  • _core_/plugins/medias/lib/getid3/module.archive.rar.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    1818class getid3_rar extends getid3_handler
    1919{
    20 
     20        /**
     21         * @var bool
     22         */
    2123        public $option_use_rar_extension = false;
    2224
     25        /**
     26         * @return bool
     27         */
    2328        public function Analyze() {
    2429                $info = &$this->getid3->info;
  • _core_/plugins/medias/lib/getid3/module.archive.szip.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    1818class getid3_szip extends getid3_handler
    1919{
    20 
     20        /**
     21         * @return bool
     22         */
    2123        public function Analyze() {
    2224                $info = &$this->getid3->info;
     
    3133                $info['szip']['major_version'] = getid3_lib::BigEndian2Int(substr($SZIPHeader, 4, 1));
    3234                $info['szip']['minor_version'] = getid3_lib::BigEndian2Int(substr($SZIPHeader, 5, 1));
    33 $this->error('SZIP parsing not enabled in this version of getID3() ['.$this->getid3->version().']');
    34 return false;
     35                $this->error('SZIP parsing not enabled in this version of getID3() ['.$this->getid3->version().']');
     36                return false;
    3537
    3638                while (!$this->feof()) {
  • _core_/plugins/medias/lib/getid3/module.archive.tar.php

    r85814 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    2323class getid3_tar extends getid3_handler
    2424{
    25 
     25        /**
     26         * @return bool
     27         */
    2628        public function Analyze() {
    2729                $info = &$this->getid3->info;
     
    118120        }
    119121
    120         // Parses the file mode to file permissions
     122        /**
     123         * Parses the file mode to file permissions.
     124         *
     125         * @param int $mode
     126         *
     127         * @return string
     128         */
    121129        public function display_perms($mode) {
    122130                // Determine Type
     
    153161        }
    154162
    155         // Converts the file type
     163        /**
     164         * Converts the file type.
     165         *
     166         * @param string $typflag
     167         *
     168         * @return mixed|string
     169         */
    156170        public function get_flag_type($typflag) {
    157171                static $flag_types = array(
  • _core_/plugins/medias/lib/getid3/module.archive.zip.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    1818class getid3_zip extends getid3_handler
    1919{
    20 
     20        /**
     21         * @return bool
     22         */
    2123        public function Analyze() {
    2224                $info = &$this->getid3->info;
     
    4951                                        $this->fseek($info['zip']['end_central_directory']['directory_offset']);
    5052                                        $info['zip']['entries_count'] = 0;
    51                                         while ($centraldirectoryentry = $this->ZIPparseCentralDirectory($this->getid3->fp)) {
     53                                        while ($centraldirectoryentry = $this->ZIPparseCentralDirectory()) {
    5254                                                $info['zip']['central_directory'][] = $centraldirectoryentry;
    5355                                                $info['zip']['entries_count']++;
     
    130132        }
    131133
    132 
     134        /**
     135         * @return bool
     136         */
    133137        public function getZIPHeaderFilepointerTopDown() {
    134138                $info = &$this->getid3->info;
     
    151155
    152156                $info['zip']['entries_count']     = 0;
    153                 while ($centraldirectoryentry = $this->ZIPparseCentralDirectory($this->getid3->fp)) {
     157                while ($centraldirectoryentry = $this->ZIPparseCentralDirectory()) {
    154158                        $info['zip']['central_directory'][] = $centraldirectoryentry;
    155159                        $info['zip']['entries_count']++;
     
    176180        }
    177181
    178 
     182        /**
     183         * @return bool
     184         */
    179185        public function getZIPentriesFilepointer() {
    180186                $info = &$this->getid3->info;
     
    199205        }
    200206
    201 
     207        /**
     208         * @return array|false
     209         */
    202210        public function ZIPparseLocalFileHeader() {
    203211                $LocalFileHeader['offset'] = $this->ftell();
     
    266274                        $LocalFileHeader['data_descriptor']['signature']         = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  0, 4));
    267275                        if ($LocalFileHeader['data_descriptor']['signature'] != 0x08074B50) { // "PK\x07\x08"
    268                                 $this->getid3->warning[] = 'invalid Local File Header Data Descriptor Signature at offset '.($this->ftell() - 16).' - expecting 08 07 4B 50, found '.getid3_lib::PrintHexBytes($LocalFileHeader['data_descriptor']['signature']);
     276                                $this->getid3->warning('invalid Local File Header Data Descriptor Signature at offset '.($this->ftell() - 16).' - expecting 08 07 4B 50, found '.getid3_lib::PrintHexBytes($LocalFileHeader['data_descriptor']['signature']));
    269277                                $this->fseek($LocalFileHeader['offset']); // seek back to where filepointer originally was so it can be handled properly
    270278                                return false;
     
    295303        }
    296304
    297 
     305        /**
     306         * @return array|false
     307         */
    298308        public function ZIPparseCentralDirectory() {
    299309                $CentralDirectory['offset'] = $this->ftell();
     
    352362        }
    353363
     364        /**
     365         * @return array|false
     366         */
    354367        public function ZIPparseEndOfCentralDirectory() {
    355368                $EndOfCentralDirectory['offset'] = $this->ftell();
     
    378391        }
    379392
    380 
     393        /**
     394         * @param int $flagbytes
     395         * @param int $compressionmethod
     396         *
     397         * @return array
     398         */
    381399        public static function ZIPparseGeneralPurposeFlags($flagbytes, $compressionmethod) {
    382400                // https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip-printable.html
     401                $ParsedFlags = array();
    383402                $ParsedFlags['encrypted']               = (bool) ($flagbytes & 0x0001);
    384403                //                                                             0x0002 -- see below
     
    426445        }
    427446
    428 
     447        /**
     448         * @param int $index
     449         *
     450         * @return string
     451         */
    429452        public static function ZIPversionOSLookup($index) {
    430453                static $ZIPversionOSLookup = array(
     
    454477        }
    455478
     479        /**
     480         * @param int $index
     481         *
     482         * @return string
     483         */
    456484        public static function ZIPcompressionMethodLookup($index) {
    457485                // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/ZIP.html
     
    485513        }
    486514
     515        /**
     516         * @param int $DOSdate
     517         * @param int $DOStime
     518         *
     519         * @return int
     520         */
    487521        public static function DOStime2UNIXtime($DOSdate, $DOStime) {
    488522                // wFatDate
  • _core_/plugins/medias/lib/getid3/module.audio-video.asf.php

    r106591 r113161  
    22/////////////////////////////////////////////////////////////////
    33/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     4//  available at https://github.com/JamesHeinrich/getID3       //
     5//            or https://www.getid3.org                        //
     6//            or http://getid3.sourceforge.net                 //
     7//  see readme.txt for more details                            //
    98/////////////////////////////////////////////////////////////////
    109//                                                             //
     
    1716getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.riff.php', __FILE__, true);
    1817
    19 class getid3_asf extends getid3_handler {
    20 
     18class getid3_asf extends getid3_handler
     19{
     20        /**
     21         * @param getID3 $getid3
     22         */
    2123        public function __construct(getID3 $getid3) {
    2224                parent::__construct($getid3);  // extends getid3_handler::__construct()
     
    3133        }
    3234
     35        /**
     36         * @return bool
     37         */
    3338        public function Analyze() {
    3439                $info = &$this->getid3->info;
     
    8489                $ASFHeaderData = $this->fread($thisfile_asf_headerobject['objectsize'] - 30);
    8590                $offset = 0;
     91                $thisfile_asf_streambitratepropertiesobject = array();
     92                $thisfile_asf_codeclistobject = array();
    8693
    8794                for ($HeaderObjectsCounter = 0; $HeaderObjectsCounter < $thisfile_asf_headerobject['headerobjects']; $HeaderObjectsCounter++) {
     
    971978                        }
    972979                }
    973                 if (isset($thisfile_asf_streambitrateproperties['bitrate_records_count'])) {
     980                if (isset($thisfile_asf_streambitratepropertiesobject['bitrate_records_count'])) {
    974981                        $ASFbitrateAudio = 0;
    975982                        $ASFbitrateVideo = 0;
    976                         for ($BitrateRecordsCounter = 0; $BitrateRecordsCounter < $thisfile_asf_streambitrateproperties['bitrate_records_count']; $BitrateRecordsCounter++) {
     983                        for ($BitrateRecordsCounter = 0; $BitrateRecordsCounter < $thisfile_asf_streambitratepropertiesobject['bitrate_records_count']; $BitrateRecordsCounter++) {
    977984                                if (isset($thisfile_asf_codeclistobject['codec_entries'][$BitrateRecordsCounter])) {
    978985                                        switch ($thisfile_asf_codeclistobject['codec_entries'][$BitrateRecordsCounter]['type_raw']) {
    979986                                                case 1:
    980                                                         $ASFbitrateVideo += $thisfile_asf_streambitrateproperties['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
     987                                                        $ASFbitrateVideo += $thisfile_asf_streambitratepropertiesobject['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
    981988                                                        break;
    982989
    983990                                                case 2:
    984                                                         $ASFbitrateAudio += $thisfile_asf_streambitrateproperties['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
     991                                                        $ASFbitrateAudio += $thisfile_asf_streambitratepropertiesobject['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
    985992                                                        break;
    986993
     
    14411448        }
    14421449
     1450        /**
     1451         * @param int $CodecListType
     1452         *
     1453         * @return string
     1454         */
    14431455        public static function codecListObjectTypeLookup($CodecListType) {
    14441456                static $lookup = array(
     
    14511463        }
    14521464
     1465        /**
     1466         * @return array
     1467         */
    14531468        public static function KnownGUIDs() {
    14541469                static $GUIDarray = array(
     
    15651580        }
    15661581
     1582        /**
     1583         * @param string $GUIDstring
     1584         *
     1585         * @return string|false
     1586         */
    15671587        public static function GUIDname($GUIDstring) {
    15681588                static $GUIDarray = array();
     
    15731593        }
    15741594
     1595        /**
     1596         * @param int $id
     1597         *
     1598         * @return string
     1599         */
    15751600        public static function ASFIndexObjectIndexTypeLookup($id) {
    15761601                static $ASFIndexObjectIndexTypeLookup = array();
     
    15831608        }
    15841609
     1610        /**
     1611         * @param string $GUIDstring
     1612         *
     1613         * @return string
     1614         */
    15851615        public static function GUIDtoBytestring($GUIDstring) {
    15861616                // Microsoft defines these 16-byte (128-bit) GUIDs in the strangest way:
     
    16181648        }
    16191649
     1650        /**
     1651         * @param string $Bytestring
     1652         *
     1653         * @return string
     1654         */
    16201655        public static function BytestringToGUID($Bytestring) {
    16211656                $GUIDstring  = str_pad(dechex(ord($Bytestring{3})),  2, '0', STR_PAD_LEFT);
     
    16431678        }
    16441679
     1680        /**
     1681         * @param int  $FILETIME
     1682         * @param bool $round
     1683         *
     1684         * @return float|int
     1685         */
    16451686        public static function FILETIMEtoUNIXtime($FILETIME, $round=true) {
    16461687                // FILETIME is a 64-bit unsigned integer representing
     
    16541695        }
    16551696
     1697        /**
     1698         * @param int $WMpictureType
     1699         *
     1700         * @return string
     1701         */
    16561702        public static function WMpictureTypeLookup($WMpictureType) {
    16571703                static $lookup = null;
     
    16851731        }
    16861732
     1733        /**
     1734         * @param string $asf_header_extension_object_data
     1735         * @param int    $unhandled_sections
     1736         *
     1737         * @return array
     1738         */
    16871739        public function HeaderExtensionObjectDataParse(&$asf_header_extension_object_data, &$unhandled_sections) {
    16881740                // http://msdn.microsoft.com/en-us/library/bb643323.aspx
     
    19311983        }
    19321984
    1933 
     1985        /**
     1986         * @param int $id
     1987         *
     1988         * @return string
     1989         */
    19341990        public static function metadataLibraryObjectDataTypeLookup($id) {
    19351991                static $lookup = array(
     
    19452001        }
    19462002
     2003        /**
     2004         * @param string $data
     2005         *
     2006         * @return array
     2007         */
    19472008        public function ASF_WMpicture(&$data) {
    19482009                //typedef struct _WMPicture{
     
    19952056        }
    19962057
    1997 
    1998         // Remove terminator 00 00 and convert UTF-16LE to Latin-1
     2058        /**
     2059         * Remove terminator 00 00 and convert UTF-16LE to Latin-1.
     2060         *
     2061         * @param string $string
     2062         *
     2063         * @return string
     2064         */
    19992065        public static function TrimConvert($string) {
    20002066                return trim(getid3_lib::iconv_fallback('UTF-16LE', 'ISO-8859-1', self::TrimTerm($string)), ' ');
    20012067        }
    20022068
    2003 
    2004         // Remove terminator 00 00
     2069        /**
     2070         * Remove terminator 00 00.
     2071         *
     2072         * @param string $string
     2073         *
     2074         * @return string
     2075         */
    20052076        public static function TrimTerm($string) {
    20062077                // remove terminator, only if present (it should be, but...)
  • _core_/plugins/medias/lib/getid3/module.audio-video.bink.php

    r106591 r113161  
    22/////////////////////////////////////////////////////////////////
    33/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     4//  available at https://github.com/JamesHeinrich/getID3       //
     5//            or https://www.getid3.org                        //
     6//            or http://getid3.sourceforge.net                 //
     7//  see readme.txt for more details                            //
    98/////////////////////////////////////////////////////////////////
    109//                                                             //
     
    1817class getid3_bink extends getid3_handler
    1918{
    20 
     19        /**
     20         * @return bool
     21         */
    2122        public function Analyze() {
    2223                $info = &$this->getid3->info;
    2324
    24 $this->error('Bink / Smacker files not properly processed by this version of getID3() ['.$this->getid3->version().']');
     25                $this->error('Bink / Smacker files not properly processed by this version of getID3() ['.$this->getid3->version().']');
    2526
    2627                $this->fseek($info['avdataoffset']);
     
    4546        }
    4647
     48        /**
     49         * @return bool
     50         */
    4751        public function ParseBink() {
    4852                $info = &$this->getid3->info;
     
    6266        }
    6367
     68        /**
     69         * @return bool
     70         */
    6471        public function ParseSmacker() {
    6572                $info = &$this->getid3->info;
  • _core_/plugins/medias/lib/getid3/module.audio-video.flv.php

    r106591 r113161  
    22/////////////////////////////////////////////////////////////////
    33/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
     4//  available at https://github.com/JamesHeinrich/getID3       //
     5//            or https://www.getid3.org                        //
     6//            or http://getid3.sourceforge.net                 //
     7//  see readme.txt for more details                            //
     8/////////////////////////////////////////////////////////////////
     9//                                                             //
     10// module.audio-video.flv.php                                  //
     11// module for analyzing Shockwave Flash Video files            //
     12// dependencies: NONE                                          //
     13//                                                             //
     14/////////////////////////////////////////////////////////////////
    715//                                                             //
    816//  FLV module by Seth Kaufman <sethØwhirl-i-gig*com>          //
    917//                                                             //
    1018//  * version 0.1 (26 June 2005)                               //
    11 //                                                             //
    1219//                                                             //
    1320//  * version 0.1.1 (15 July 2005)                             //
     
    4451//  improved AVCSequenceParameterSetReader::readData()         //
    4552//    by Xander Schouwerwou <schouwerwouØgmail*com>            //
    46 //                                                             //
    47 /////////////////////////////////////////////////////////////////
    48 //                                                             //
    49 // module.audio-video.flv.php                                  //
    50 // module for analyzing Shockwave Flash Video files            //
    51 // dependencies: NONE                                          //
    5253//                                                            ///
    5354/////////////////////////////////////////////////////////////////
     
    7475define('H264_PROFILE_HIGH444_PREDICTIVE', 244);
    7576
    76 class getid3_flv extends getid3_handler {
    77 
     77class getid3_flv extends getid3_handler
     78{
    7879        const magic = 'FLV';
    7980
    80         public $max_frames = 100000; // break out of the loop if too many frames have been scanned; only scan this many if meta frame does not contain useful duration
    81 
     81        /**
     82         * Break out of the loop if too many frames have been scanned; only scan this
     83         * many if meta frame does not contain useful duration.
     84         *
     85         * @var int
     86         */
     87        public $max_frames = 100000;
     88
     89        /**
     90         * @return bool
     91         */
    8292        public function Analyze() {
    8393                $info = &$this->getid3->info;
     
    333343        }
    334344
    335 
     345        /**
     346         * @param int $id
     347         *
     348         * @return string|false
     349         */
    336350        public static function audioFormatLookup($id) {
    337351                static $lookup = array(
     
    356370        }
    357371
     372        /**
     373         * @param int $id
     374         *
     375         * @return int|false
     376         */
    358377        public static function audioRateLookup($id) {
    359378                static $lookup = array(
     
    366385        }
    367386
     387        /**
     388         * @param int $id
     389         *
     390         * @return int|false
     391         */
    368392        public static function audioBitDepthLookup($id) {
    369393                static $lookup = array(
     
    374398        }
    375399
     400        /**
     401         * @param int $id
     402         *
     403         * @return string|false
     404         */
    376405        public static function videoCodecLookup($id) {
    377406                static $lookup = array(
     
    387416}
    388417
    389 class AMFStream {
     418class AMFStream
     419{
     420        /**
     421         * @var string
     422         */
    390423        public $bytes;
     424
     425        /**
     426         * @var int
     427         */
    391428        public $pos;
    392429
     430        /**
     431         * @param string $bytes
     432         */
    393433        public function __construct(&$bytes) {
    394434                $this->bytes =& $bytes;
     
    396436        }
    397437
    398         public function readByte() {
    399                 return getid3_lib::BigEndian2Int(substr($this->bytes, $this->pos++, 1));
    400         }
    401 
    402         public function readInt() {
     438        /**
     439         * @return int
     440         */
     441        public function readByte() { //  8-bit
     442                return ord(substr($this->bytes, $this->pos++, 1));
     443        }
     444
     445        /**
     446         * @return int
     447         */
     448        public function readInt() { // 16-bit
    403449                return ($this->readByte() << 8) + $this->readByte();
    404450        }
    405451
    406         public function readLong() {
     452        /**
     453         * @return int
     454         */
     455        public function readLong() { // 32-bit
    407456                return ($this->readByte() << 24) + ($this->readByte() << 16) + ($this->readByte() << 8) + $this->readByte();
    408457        }
    409458
     459        /**
     460         * @return float|false
     461         */
    410462        public function readDouble() {
    411463                return getid3_lib::BigEndian2Float($this->read(8));
    412464        }
    413465
     466        /**
     467         * @return string
     468         */
    414469        public function readUTF() {
    415470                $length = $this->readInt();
     
    417472        }
    418473
     474        /**
     475         * @return string
     476         */
    419477        public function readLongUTF() {
    420478                $length = $this->readLong();
     
    422480        }
    423481
     482        /**
     483         * @param int $length
     484         *
     485         * @return string
     486         */
    424487        public function read($length) {
    425488                $val = substr($this->bytes, $this->pos, $length);
     
    428491        }
    429492
     493        /**
     494         * @return int
     495         */
    430496        public function peekByte() {
    431497                $pos = $this->pos;
     
    435501        }
    436502
     503        /**
     504         * @return int
     505         */
    437506        public function peekInt() {
    438507                $pos = $this->pos;
     
    442511        }
    443512
     513        /**
     514         * @return int
     515         */
    444516        public function peekLong() {
    445517                $pos = $this->pos;
     
    449521        }
    450522
     523        /**
     524         * @return float|false
     525         */
    451526        public function peekDouble() {
    452527                $pos = $this->pos;
     
    456531        }
    457532
     533        /**
     534         * @return string
     535         */
    458536        public function peekUTF() {
    459537                $pos = $this->pos;
     
    463541        }
    464542
     543        /**
     544         * @return string
     545         */
    465546        public function peekLongUTF() {
    466547                $pos = $this->pos;
     
    471552}
    472553
    473 class AMFReader {
     554class AMFReader
     555{
     556        /**
     557        * @var AMFStream
     558        */
    474559        public $stream;
    475560
    476         public function __construct(&$stream) {
    477                 $this->stream =& $stream;
    478         }
    479 
     561        /**
     562         * @param AMFStream $stream
     563         */
     564        public function __construct(AMFStream $stream) {
     565                $this->stream = $stream;
     566        }
     567
     568        /**
     569         * @return mixed
     570         */
    480571        public function readData() {
    481572                $value = null;
     
    548639        }
    549640
     641        /**
     642         * @return float|false
     643         */
    550644        public function readDouble() {
    551645                return $this->stream->readDouble();
    552646        }
    553647
     648        /**
     649         * @return bool
     650         */
    554651        public function readBoolean() {
    555652                return $this->stream->readByte() == 1;
    556653        }
    557654
     655        /**
     656         * @return string
     657         */
    558658        public function readString() {
    559659                return $this->stream->readUTF();
    560660        }
    561661
     662        /**
     663         * @return array
     664         */
    562665        public function readObject() {
    563666                // Get highest numerical index - ignored
     
    565668
    566669                $data = array();
     670                $key = null;
    567671
    568672                while ($key = $this->stream->readUTF()) {
     
    577681        }
    578682
     683        /**
     684         * @return array
     685         */
    579686        public function readMixedArray() {
    580687                // Get highest numerical index - ignored
     
    582689
    583690                $data = array();
     691                $key = null;
    584692
    585693                while ($key = $this->stream->readUTF()) {
    586694                        if (is_numeric($key)) {
    587                                 $key = (float) $key;
     695                                $key = (int) $key;
    588696                        }
    589697                        $data[$key] = $this->readData();
     
    598706        }
    599707
     708        /**
     709         * @return array
     710         */
    600711        public function readArray() {
    601712                $length = $this->stream->readLong();
     
    608719        }
    609720
     721        /**
     722         * @return float|false
     723         */
    610724        public function readDate() {
    611725                $timestamp = $this->stream->readDouble();
     
    614728        }
    615729
     730        /**
     731         * @return string
     732         */
    616733        public function readLongString() {
    617734                return $this->stream->readLongUTF();
    618735        }
    619736
     737        /**
     738         * @return string
     739         */
    620740        public function readXML() {
    621741                return $this->stream->readLongUTF();
    622742        }
    623743
     744        /**
     745         * @return array
     746         */
    624747        public function readTypedObject() {
    625748                $className = $this->stream->readUTF();
     
    628751}
    629752
    630 class AVCSequenceParameterSetReader {
     753class AVCSequenceParameterSetReader
     754{
     755        /**
     756         * @var string
     757         */
    631758        public $sps;
    632759        public $start = 0;
    633760        public $currentBytes = 0;
    634761        public $currentBits = 0;
     762
     763        /**
     764         * @var int
     765         */
    635766        public $width;
     767
     768        /**
     769         * @var int
     770         */
    636771        public $height;
    637772
     773        /**
     774         * @param string $sps
     775         */
    638776        public function __construct($sps) {
    639777                $this->sps = $sps;
     
    692830        }
    693831
     832        /**
     833         * @param int $bits
     834         */
    694835        public function skipBits($bits) {
    695836                $newBits = $this->currentBits + $bits;
     
    698839        }
    699840
     841        /**
     842         * @return int
     843         */
    700844        public function getBit() {
    701845                $result = (getid3_lib::BigEndian2Int(substr($this->sps, $this->currentBytes, 1)) >> (7 - $this->currentBits)) & 0x01;
     
    704848        }
    705849
     850        /**
     851         * @param int $bits
     852         *
     853         * @return int
     854         */
    706855        public function getBits($bits) {
    707856                $result = 0;
     
    712861        }
    713862
     863        /**
     864         * @return int
     865         */
    714866        public function expGolombUe() {
    715867                $significantBits = 0;
     
    727879        }
    728880
     881        /**
     882         * @return int
     883         */
    729884        public function expGolombSe() {
    730885                $result = $this->expGolombUe();
     
    736891        }
    737892
     893        /**
     894         * @return int
     895         */
    738896        public function getWidth() {
    739897                return $this->width;
    740898        }
    741899
     900        /**
     901         * @return int
     902         */
    742903        public function getHeight() {
    743904                return $this->height;
  • _core_/plugins/medias/lib/getid3/module.audio-video.matroska.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    7373define('EBML_ID_FILEUID',                       0x06AE); //         [46][AE] -- Unique ID representing the file, as random as possible.
    7474define('EBML_ID_CONTENTENCALGO',                0x07E1); //         [47][E1] -- The encryption algorithm used. The value '0' means that the contents have not been encrypted but only signed. Predefined values:
    75 define('EBML_ID_CONTENTENCKEYID',               0x07E2); //         [47][E2] -- For public key algorithms this is the ID of the public key the the data was encrypted with.
     75define('EBML_ID_CONTENTENCKEYID',               0x07E2); //         [47][E2] -- For public key algorithms this is the ID of the public key the data was encrypted with.
    7676define('EBML_ID_CONTENTSIGNATURE',              0x07E3); //         [47][E3] -- A cryptographic signature of the contents.
    7777define('EBML_ID_CONTENTSIGKEYID',               0x07E4); //         [47][E4] -- This is the ID of the private key the data was signed with.
     
    216216class getid3_matroska extends getid3_handler
    217217{
    218         // public options
    219         public static $hide_clusters    = true;  // if true, do not return information about CLUSTER chunks, since there's a lot of them and they're not usually useful [default: TRUE]
    220         public static $parse_whole_file = false; // true to parse the whole file, not only header [default: FALSE]
    221 
    222         // private parser settings/placeholders
     218        /**
     219         * If true, do not return information about CLUSTER chunks, since there's a lot of them
     220         * and they're not usually useful [default: TRUE].
     221         *
     222         * @var bool
     223         */
     224        public static $hide_clusters    = true;
     225
     226        /**
     227         * True to parse the whole file, not only header [default: FALSE].
     228         *
     229         * @var bool
     230         */
     231        public static $parse_whole_file = false;
     232
     233        /*
     234         * Private parser settings/placeholders.
     235         */
    223236        private $EBMLbuffer        = '';
    224237        private $EBMLbuffer_offset = 0;
     
    227240        private $unuseful_elements = array(EBML_ID_CRC32, EBML_ID_VOID);
    228241
     242        /**
     243         * @return bool
     244         */
    229245        public function Analyze()
    230246        {
     
    367383                                                                        $info['matroska']['track_codec_parsed'][$trackarray['TrackNumber']] = $getid3_temp->info[$header_data_key];
    368384                                                                        if (isset($getid3_temp->info['audio']) && is_array($getid3_temp->info['audio'])) {
    369                                                                                 foreach ($getid3_temp->info['audio'] as $key => $value) {
    370                                                                                         $track_info[$key] = $value;
     385                                                                                foreach ($getid3_temp->info['audio'] as $sub_key => $value) {
     386                                                                                        $track_info[$sub_key] = $value;
    371387                                                                                }
    372388                                                                        }
     
    422438                                                                        $info['matroska']['track_codec_parsed'][$trackarray['TrackNumber']] = $getid3_temp->info['ogg'];
    423439                                                                        if (isset($getid3_temp->info['audio']) && is_array($getid3_temp->info['audio'])) {
    424                                                                                 foreach ($getid3_temp->info['audio'] as $key => $value) {
    425                                                                                         $track_info[$key] = $value;
     440                                                                                foreach ($getid3_temp->info['audio'] as $sub_key => $value) {
     441                                                                                        $track_info[$sub_key] = $value;
    426442                                                                                }
    427443                                                                        }
     
    450466
    451467                                                                $parsed = getid3_riff::parseWAVEFORMATex($trackarray['CodecPrivate']);
    452                                                                 foreach ($parsed as $key => $value) {
    453                                                                         if ($key != 'raw') {
    454                                                                                 $track_info[$key] = $value;
     468                                                                foreach ($parsed as $sub_key => $value) {
     469                                                                        if ($sub_key != 'raw') {
     470                                                                                $track_info[$sub_key] = $value;
    455471                                                                        }
    456472                                                                }
     
    497513        }
    498514
     515        /**
     516         * @param array $info
     517         */
    499518        private function parseEBML(&$info) {
    500519                // http://www.matroska.org/technical/specs/index.html#EBMLBasics
     
    12291248        }
    12301249
     1250        /**
     1251         * @param int $min_data
     1252         *
     1253         * @return bool
     1254         */
    12311255        private function EnsureBufferHasEnoughData($min_data=1024) {
    12321256                if (($this->current_offset - $this->EBMLbuffer_offset) >= ($this->EBMLbuffer_length - $min_data)) {
     
    12501274        }
    12511275
     1276        /**
     1277         * @return int|float|false
     1278         */
    12521279        private function readEBMLint() {
    12531280                $actual_offset = $this->current_offset - $this->EBMLbuffer_offset;
     
    12821309        }
    12831310
     1311        /**
     1312         * @param int  $length
     1313         * @param bool $check_buffer
     1314         *
     1315         * @return string|false
     1316         */
    12841317        private function readEBMLelementData($length, $check_buffer=false) {
    12851318                if ($check_buffer && !$this->EnsureBufferHasEnoughData($length)) {
     
    12911324        }
    12921325
     1326        /**
     1327         * @param array      $element
     1328         * @param int        $parent_end
     1329         * @param array|bool $get_data
     1330         *
     1331         * @return bool
     1332         */
    12931333        private function getEBMLelement(&$element, $parent_end, $get_data=false) {
    12941334                if ($this->current_offset >= $parent_end) {
     
    13271367        }
    13281368
     1369        /**
     1370         * @param string $type
     1371         * @param int    $line
     1372         * @param array  $element
     1373         */
    13291374        private function unhandledElement($type, $line, $element) {
    13301375                // warn only about unknown and missed elements, not about unuseful
     
    13391384        }
    13401385
     1386        /**
     1387         * @param array $SimpleTagArray
     1388         *
     1389         * @return bool
     1390         */
    13411391        private function ExtractCommentsSimpleTag($SimpleTagArray) {
    13421392                if (!empty($SimpleTagArray['SimpleTag'])) {
     
    13541404        }
    13551405
     1406        /**
     1407         * @param int $parent_end
     1408         *
     1409         * @return array
     1410         */
    13561411        private function HandleEMBLSimpleTag($parent_end) {
    13571412                $simpletag_entry = array();
     
    13841439        }
    13851440
     1441        /**
     1442         * @param array $element
     1443         * @param int   $block_type
     1444         * @param array $info
     1445         *
     1446         * @return array
     1447         */
    13861448        private function HandleEMBLClusterBlock($element, $block_type, &$info) {
    13871449                // http://www.matroska.org/technical/specs/index.html#block_structure
     
    14471509        }
    14481510
     1511        /**
     1512         * @param string $EBMLstring
     1513         *
     1514         * @return int|float|false
     1515         */
    14491516        private static function EBML2Int($EBMLstring) {
    14501517                // http://matroska.org/specs/
     
    14891556        }
    14901557
     1558        /**
     1559         * @param int $EBMLdatestamp
     1560         *
     1561         * @return float
     1562         */
    14911563        private static function EBMLdate2unix($EBMLdatestamp) {
    14921564                // Date - signed 8 octets integer in nanoseconds with 0 indicating the precise beginning of the millennium (at 2001-01-01T00:00:00,000000000 UTC)
     
    14951567        }
    14961568
     1569        /**
     1570         * @param int $target_type
     1571         *
     1572         * @return string|int
     1573         */
    14971574        public static function TargetTypeValue($target_type) {
    14981575                // http://www.matroska.org/technical/specs/tagging/index.html
     
    15101587        }
    15111588
     1589        /**
     1590         * @param int $lacingtype
     1591         *
     1592         * @return string|int
     1593         */
    15121594        public static function BlockLacingType($lacingtype) {
    15131595                // http://matroska.org/technical/specs/index.html#block_structure
     
    15221604        }
    15231605
     1606        /**
     1607         * @param string $codecid
     1608         *
     1609         * @return string
     1610         */
    15241611        public static function CodecIDtoCommonName($codecid) {
    15251612                // http://www.matroska.org/technical/specs/codecid/index.html
     
    15581645        }
    15591646
     1647        /**
     1648         * @param int $value
     1649         *
     1650         * @return string
     1651         */
    15601652        private static function EBMLidName($value) {
    15611653                static $EBMLidList = array();
     
    17561848        }
    17571849
     1850        /**
     1851         * @param int $value
     1852         *
     1853         * @return string
     1854         */
    17581855        public static function displayUnit($value) {
    17591856                // http://www.matroska.org/technical/specs/index.html#DisplayUnit
     
    17671864        }
    17681865
     1866        /**
     1867         * @param array $streams
     1868         *
     1869         * @return array
     1870         */
    17691871        private static function getDefaultStreamInfo($streams)
    17701872        {
     1873                $stream = array();
    17711874                foreach (array_reverse($streams) as $stream) {
    17721875                        if ($stream['default']) {
  • _core_/plugins/medias/lib/getid3/module.audio-video.mpeg.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    1717getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.mp3.php', __FILE__, true);
    1818
    19 class getid3_mpeg extends getid3_handler {
     19class getid3_mpeg extends getid3_handler
     20{
    2021
    2122        const START_CODE_BASE       = "\x00\x00\x01";
     
    2930        const AUDIO_START           = "\x00\x00\x01\xC0";
    3031
    31 
     32        /**
     33         * @return bool
     34         */
    3235        public function Analyze() {
    3336                $info = &$this->getid3->info;
     
    123126                                        }
    124127
    125                                         $info['mpeg']['video']['pixel_aspect_ratio']      =     self::videoAspectRatioLookup($info['mpeg']['video']['raw']['aspect_ratio_information']);
    126                                         $info['mpeg']['video']['pixel_aspect_ratio_text'] = self::videoAspectRatioTextLookup($info['mpeg']['video']['raw']['aspect_ratio_information']);
     128                                        $info['mpeg']['video']['pixel_aspect_ratio']      =     self::videoAspectRatioLookup($info['mpeg']['video']['raw']['aspect_ratio_information']); // may be overridden later if file turns out to be MPEG-2
     129                                        $info['mpeg']['video']['pixel_aspect_ratio_text'] = self::videoAspectRatioTextLookup($info['mpeg']['video']['raw']['aspect_ratio_information']); // may be overridden later if file turns out to be MPEG-2
    127130                                        $info['mpeg']['video']['frame_rate']              =       self::videoFramerateLookup($info['mpeg']['video']['raw']['frame_rate_code']);
    128131                                        if ($info['mpeg']['video']['raw']['bitrate'] == 0x3FFFF) { // 18 set bits = VBR
     
    170173                                                        $info['mpeg']['video']['interlaced']    = !$info['mpeg']['video']['raw']['progressive_sequence'];
    171174                                                        $info['mpeg']['video']['chroma_format'] = self::chromaFormatTextLookup($info['mpeg']['video']['raw']['chroma_format']);
     175
     176                                                        if (isset($info['mpeg']['video']['raw']['aspect_ratio_information'])) {
     177                                                                // MPEG-2 defines the aspect ratio flag differently from MPEG-1, but the MPEG-2 extension start code may occur after we've already looked up the aspect ratio assuming it was MPEG-1, so re-lookup assuming MPEG-2
     178                                                                // This must be done after the extended size is known, so the display aspect ratios can be converted to pixel aspect ratios.
     179                                                                $info['mpeg']['video']['pixel_aspect_ratio']      =     self::videoAspectRatioLookup($info['mpeg']['video']['raw']['aspect_ratio_information'], 2, $info['video']['resolution_x'], $info['video']['resolution_y']);
     180                                                                $info['mpeg']['video']['pixel_aspect_ratio_text'] = self::videoAspectRatioTextLookup($info['mpeg']['video']['raw']['aspect_ratio_information'], 2);
     181                                                                $info['video']['pixel_aspect_ratio'] = $info['mpeg']['video']['pixel_aspect_ratio'];
     182                                                                $info['video']['pixel_aspect_ratio_text'] = $info['mpeg']['video']['pixel_aspect_ratio_text'];
     183                                                        }
     184
    172185                                                        break;
    173186
     
    259272                                case 0xB8: // group_of_pictures_header
    260273                                        $GOPcounter++;
    261                                         if ($info['mpeg']['video']['bitrate_mode'] == 'vbr') {
     274                                        if (!empty($info['mpeg']['video']['bitrate_mode']) && ($info['mpeg']['video']['bitrate_mode'] == 'vbr')) {
    262275                                                $bitstream = getid3_lib::BigEndian2Bin(substr($MPEGstreamData, $StartCodeOffset + 4, 4)); // 27 bits needed for group_of_pictures_header
    263276                                                $bitstreamoffset = 0;
     
    275288                                                $GOPheader['broken_link']        = self::readBitsFromStream($bitstream, $bitstreamoffset,  1); //  1 bit flag: broken_link
    276289
    277                                                 $time_code_separator = ($GOPheader['drop_frame_flag'] ? ';' : ':'); // While non-drop time code is displayed with colons separating the digit pairs—"HH:MM:SS:FF"—drop frame is usually represented with a semi-colon (;) or period (.) as the divider between all the digit pairs—"HH;MM;SS;FF", "HH.MM.SS.FF"
     290                                                $time_code_separator = ($GOPheader['drop_frame_flag'] ? ';' : ':'); // While non-drop time code is displayed with colons separating the digit pairs "HH:MM:SS:FF" drop frame is usually represented with a semi-colon (;) or period (.) as the divider between all the digit pairs "HH;MM;SS;FF", "HH.MM.SS.FF"
    278291                                                $GOPheader['time_code'] = sprintf('%02d'.$time_code_separator.'%02d'.$time_code_separator.'%02d'.$time_code_separator.'%02d', $GOPheader['time_code_hours'], $GOPheader['time_code_minutes'], $GOPheader['time_code_seconds'], $GOPheader['time_code_pictures']);
    279292
     
    503516        }
    504517
     518        /**
     519         * @param string $bitstream
     520         * @param int    $bitstreamoffset
     521         * @param int    $bits_to_read
     522         * @param bool $return_singlebit_as_boolean
     523         *
     524         * @return bool|float|int
     525         */
    505526        private function readBitsFromStream(&$bitstream, &$bitstreamoffset, $bits_to_read, $return_singlebit_as_boolean=true) {
    506527                $return = bindec(substr($bitstream, $bitstreamoffset, $bits_to_read));
     
    512533        }
    513534
    514 
     535        /**
     536         * @param int $VideoBitrate
     537         * @param int $AudioBitrate
     538         *
     539         * @return float|int
     540         */
    515541        public static function systemNonOverheadPercentage($VideoBitrate, $AudioBitrate) {
    516542                $OverheadPercentage = 0;
     
    564590        }
    565591
    566 
     592        /**
     593         * @param int $rawframerate
     594         *
     595         * @return float
     596         */
    567597        public static function videoFramerateLookup($rawframerate) {
    568598                $lookup = array(0, 23.976, 24, 25, 29.97, 30, 50, 59.94, 60);
    569                 return (isset($lookup[$rawframerate]) ? (float) $lookup[$rawframerate] : (float) 0);
    570         }
    571 
    572         public static function videoAspectRatioLookup($rawaspectratio) {
    573                 $lookup = array(0, 1, 0.6735, 0.7031, 0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815, 1.0255, 1.0695, 1.0950, 1.1575, 1.2015, 0);
    574                 return (isset($lookup[$rawaspectratio]) ? (float) $lookup[$rawaspectratio] : (float) 0);
    575         }
    576 
    577         public static function videoAspectRatioTextLookup($rawaspectratio) {
    578                 $lookup = array('forbidden', 'square pixels', '0.6735', '16:9, 625 line, PAL', '0.7615', '0.8055', '16:9, 525 line, NTSC', '0.8935', '4:3, 625 line, PAL, CCIR601', '0.9815', '1.0255', '1.0695', '4:3, 525 line, NTSC, CCIR601', '1.1575', '1.2015', 'reserved');
    579                 return (isset($lookup[$rawaspectratio]) ? $lookup[$rawaspectratio] : '');
    580         }
    581 
     599                return (float) (isset($lookup[$rawframerate]) ? $lookup[$rawframerate] : 0);
     600        }
     601
     602        /**
     603         * @param int $rawaspectratio
     604         * @param int $mpeg_version
     605         * @param int $width
     606         * @param int $height
     607         *
     608         * @return float
     609         */
     610        public static function videoAspectRatioLookup($rawaspectratio, $mpeg_version=1, $width=0, $height=0) {
     611                $lookup = array(
     612                        1 => array(0, 1, 0.6735, 0.7031, 0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815, 1.0255, 1.0695, 1.0950, 1.1575, 1.2015, 0),
     613                        2 => array(0, 1, 1.3333, 1.7778, 2.2100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
     614                );
     615                $ratio = (float) (isset($lookup[$mpeg_version][$rawaspectratio]) ? $lookup[$mpeg_version][$rawaspectratio] : 0);
     616                if ($mpeg_version == 2 && $ratio != 1) {
     617                        // Calculate pixel aspect ratio from MPEG-2 display aspect ratio
     618                        $ratio = $ratio * $height / $width;
     619                }
     620                return $ratio;
     621        }
     622
     623        /**
     624         * @param int $rawaspectratio
     625     * @param int $mpeg_version
     626         *
     627         * @return string
     628         */
     629        public static function videoAspectRatioTextLookup($rawaspectratio, $mpeg_version=1) {
     630                $lookup = array(
     631                        1 => array('forbidden', 'square pixels', '0.6735', '16:9, 625 line, PAL', '0.7615', '0.8055', '16:9, 525 line, NTSC', '0.8935', '4:3, 625 line, PAL, CCIR601', '0.9815', '1.0255', '1.0695', '4:3, 525 line, NTSC, CCIR601', '1.1575', '1.2015', 'reserved'),
     632                        2 => array('forbidden', 'square pixels', '4:3', '16:9', '2.21:1', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved', 'reserved'), // http://dvd.sourceforge.net/dvdinfo/mpeghdrs.html
     633                );
     634                return (isset($lookup[$mpeg_version][$rawaspectratio]) ? $lookup[$mpeg_version][$rawaspectratio] : '');
     635        }
     636
     637        /**
     638         * @param int $video_format
     639         *
     640         * @return string
     641         */
    582642        public static function videoFormatTextLookup($video_format) {
    583643                // ISO/IEC 13818-2, section 6.3.6, Table 6-6. Meaning of video_format
     
    586646        }
    587647
     648        /**
     649         * @param int $scalable_mode
     650         *
     651         * @return string
     652         */
    588653        public static function scalableModeTextLookup($scalable_mode) {
    589654                // ISO/IEC 13818-2, section 6.3.8, Table 6-10. Definition of scalable_mode
     
    592657        }
    593658
     659        /**
     660         * @param int $picture_structure
     661         *
     662         * @return string
     663         */
    594664        public static function pictureStructureTextLookup($picture_structure) {
    595665                // ISO/IEC 13818-2, section 6.3.11, Table 6-14 Meaning of picture_structure
     
    598668        }
    599669
     670        /**
     671         * @param int $chroma_format
     672         *
     673         * @return string
     674         */
    600675        public static function chromaFormatTextLookup($chroma_format) {
    601676                // ISO/IEC 13818-2, section 6.3.11, Table 6-14 Meaning of picture_structure
  • _core_/plugins/medias/lib/getid3/module.audio-video.nsv.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    1818class getid3_nsv extends getid3_handler
    1919{
    20 
     20        /**
     21         * @return bool
     22         */
    2123        public function Analyze() {
    2224                $info = &$this->getid3->info;
     
    6062        }
    6163
     64        /**
     65         * @param int $fileoffset
     66         *
     67         * @return bool
     68         */
    6269        public function getNSVsHeaderFilepointer($fileoffset) {
    6370                $info = &$this->getid3->info;
     
    133140        }
    134141
     142        /**
     143         * @param int  $fileoffset
     144         * @param bool $getTOCoffsets
     145         *
     146         * @return bool
     147         */
    135148        public function getNSVfHeaderFilepointer($fileoffset, $getTOCoffsets=false) {
    136149                $info = &$this->getid3->info;
     
    206219        }
    207220
    208 
     221        /**
     222         * @param int $framerateindex
     223         *
     224         * @return float|false
     225         */
    209226        public static function NSVframerateLookup($framerateindex) {
    210227                if ($framerateindex <= 127) {
     
    213230                static $NSVframerateLookup = array();
    214231                if (empty($NSVframerateLookup)) {
    215                         $NSVframerateLookup[129] = (float) 29.970;
    216                         $NSVframerateLookup[131] = (float) 23.976;
    217                         $NSVframerateLookup[133] = (float) 14.985;
    218                         $NSVframerateLookup[197] = (float) 59.940;
    219                         $NSVframerateLookup[199] = (float) 47.952;
     232                        $NSVframerateLookup[129] = 29.970;
     233                        $NSVframerateLookup[131] = 23.976;
     234                        $NSVframerateLookup[133] = 14.985;
     235                        $NSVframerateLookup[197] = 59.940;
     236                        $NSVframerateLookup[199] = 47.952;
    220237                }
    221238                return (isset($NSVframerateLookup[$framerateindex]) ? $NSVframerateLookup[$framerateindex] : false);
  • _core_/plugins/medias/lib/getid3/module.audio-video.quicktime.php

    r106591 r113161  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
     
    2525        public $ParseAllPossibleAtoms = false;
    2626
     27        /**
     28         * @return bool
     29         */
    2730        public function Analyze() {
    2831                $info = &$this->getid3->info;
     
    163166                        $info['audio']['bitrate'] = $info['bitrate'];
    164167                }
     168                if (!empty($info['bitrate']) && !empty($info['audio']['bitrate']) && empty($info['video']['bitrate']) && !empty($info['video']['frame_rate']) && !empty($info['video']['resolution_x']) && ($info['bitrate'] > $info['audio']['bitrate'])) {
     169                        $info['video']['bitrate'] = $info['bitrate'] - $info['audio']['bitrate'];
     170                }
    165171                if (!empty($info['playtime_seconds']) && !isset($info['video']['frame_rate']) && !empty($info['quicktime']['stts_framecount'])) {
    166172                        foreach ($info['quicktime']['stts_framecount'] as $key => $samples_count) {
     
    194200                        $info['video']['dataformat'] = 'quicktime';
    195201                }
     202                if (isset($info['video']) && ($info['mime_type'] == 'audio/mp4') && empty($info['video']['resolution_x']) && empty($info['video']['resolution_y']))  {
     203                        unset($info['video']);
     204                }
    196205
    197206                return true;
    198207        }
    199208
     209        /**
     210         * @param string $atomname
     211         * @param int    $atomsize
     212         * @param string $atom_data
     213         * @param int    $baseoffset
     214         * @param array  $atomHierarchy
     215         * @param bool   $ParseAllPossibleAtoms
     216         *
     217         * @return array|false
     218         */
    200219        public function QuicktimeParseAtom($atomname, $atomsize, $atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
    201220                // http://developer.apple.com/techpubs/quicktime/qtdevdocs/APIREF/INDEX/atomalphaindex.htm
     
    204223                $info = &$this->getid3->info;
    205224
    206                 $atom_parent = end($atomHierarchy); // not array_pop($atomHierarchy); see http://www.getid3.org/phpBB3/viewtopic.php?t=1717
     225                $atom_parent = end($atomHierarchy); // not array_pop($atomHierarchy); see https://www.getid3.org/phpBB3/viewtopic.php?t=1717
    207226                array_push($atomHierarchy, $atomname);
    208227                $atom_structure['hierarchy'] = implode(' ', $atomHierarchy);
     
    210229                $atom_structure['size']      = $atomsize;
    211230                $atom_structure['offset']    = $baseoffset;
    212                 switch ($atomname) {
    213                         case 'moov': // MOVie container atom
    214                         case 'trak': // TRAcK container atom
    215                         case 'clip': // CLIPping container atom
    216                         case 'matt': // track MATTe container atom
    217                         case 'edts': // EDiTS container atom
    218                         case 'tref': // Track REFerence container atom
    219                         case 'mdia': // MeDIA container atom
    220                         case 'minf': // Media INFormation container atom
    221                         case 'dinf': // Data INFormation container atom
    222                         case 'udta': // User DaTA container atom
    223                         case 'cmov': // Compressed MOVie container atom
    224                         case 'rmra': // Reference Movie Record Atom
    225                         case 'rmda': // Reference Movie Descriptor Atom
    226                         case 'gmhd': // Generic Media info HeaDer atom (seen on QTVR)
    227                                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    228                                 break;
    229 
    230                         case 'ilst': // Item LiST container atom
    231                                 if ($atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms)) {
    232                                         // some "ilst" atoms contain data atoms that have a numeric name, and the data is far more accessible if the returned array is compacted
    233                                         $allnumericnames = true;
    234                                         foreach ($atom_structure['subatoms'] as $subatomarray) {
    235                                                 if (!is_integer($subatomarray['name']) || (count($subatomarray['subatoms']) != 1)) {
    236                                                         $allnumericnames = false;
    237                                                         break;
    238                                                 }
    239                                         }
    240                                         if ($allnumericnames) {
    241                                                 $newData = array();
     231                if (substr($atomname, 0, 3) == "\x00\x00\x00") {
     232                        // https://github.com/JamesHeinrich/getID3/issues/139
     233                        $atomname = getid3_lib::BigEndian2Int($atomname);
     234                        $atom_structure['name'] = $atomname;
     235                        $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     236                } else {
     237                        switch ($atomname) {
     238                                case 'moov': // MOVie container atom
     239                                case 'trak': // TRAcK container atom
     240                                case 'clip': // CLIPping container atom
     241                                case 'matt': // track MATTe container atom
     242                                case 'edts': // EDiTS container atom
     243                                case 'tref': // Track REFerence container atom
     244                                case 'mdia': // MeDIA container atom
     245                                case 'minf': // Media INFormation container atom
     246                                case 'dinf': // Data INFormation container atom
     247                                case 'udta': // User DaTA container atom
     248                                case 'cmov': // Compressed MOVie container atom
     249                                case 'rmra': // Reference Movie Record Atom
     250                                case 'rmda': // Reference Movie Descriptor Atom
     251                                case 'gmhd': // Generic Media info HeaDer atom (seen on QTVR)
     252                                        $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     253                                        break;
     254
     255                                case 'ilst': // Item LiST container atom
     256                                        if ($atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms)) {
     257                                                // some "ilst" atoms contain data atoms that have a numeric name, and the data is far more accessible if the returned array is compacted
     258                                                $allnumericnames = true;
    242259                                                foreach ($atom_structure['subatoms'] as $subatomarray) {
    243                                                         foreach ($subatomarray['subatoms'] as $newData_subatomarray) {
    244                                                                 unset($newData_subatomarray['hierarchy'], $newData_subatomarray['name']);
    245                                                                 $newData[$subatomarray['name']] = $newData_subatomarray;
     260                                                        if (!is_integer($subatomarray['name']) || (count($subatomarray['subatoms']) != 1)) {
     261                                                                $allnumericnames = false;
    246262                                                                break;
    247263                                                        }
    248264                                                }
    249                                                 $atom_structure['data'] = $newData;
    250                                                 unset($atom_structure['subatoms']);
    251                                         }
    252                                 }
    253                                 break;
    254 
    255                         case "\x00\x00\x00\x01":
    256                         case "\x00\x00\x00\x02":
    257                         case "\x00\x00\x00\x03":
    258                         case "\x00\x00\x00\x04":
    259                         case "\x00\x00\x00\x05":
    260                                 $atomname = getid3_lib::BigEndian2Int($atomname);
    261                                 $atom_structure['name'] = $atomname;
    262                                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    263                                 break;
    264 
    265                         case 'stbl': // Sample TaBLe container atom
    266                                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    267                                 $isVideo = false;
    268                                 $framerate  = 0;
    269                                 $framecount = 0;
    270                                 foreach ($atom_structure['subatoms'] as $key => $value_array) {
    271                                         if (isset($value_array['sample_description_table'])) {
    272                                                 foreach ($value_array['sample_description_table'] as $key2 => $value_array2) {
    273                                                         if (isset($value_array2['data_format'])) {
    274                                                                 switch ($value_array2['data_format']) {
    275                                                                         case 'avc1':
    276                                                                         case 'mp4v':
    277                                                                                 // video data
    278                                                                                 $isVideo = true;
    279                                                                                 break;
    280                                                                         case 'mp4a':
    281                                                                                 // audio data
    282                                                                                 break;
     265                                                if ($allnumericnames) {
     266                                                        $newData = array();
     267                                                        foreach ($atom_structure['subatoms'] as $subatomarray) {
     268                                                                foreach ($subatomarray['subatoms'] as $newData_subatomarray) {
     269                                                                        unset($newData_subatomarray['hierarchy'], $newData_subatomarray['name']);
     270                                                                        $newData[$subatomarray['name']] = $newData_subatomarray;
     271                                                                        break;
     272                                                                }
     273                                                        }
     274                                                        $atom_structure['data'] = $newData;
     275                                                        unset($atom_structure['subatoms']);
     276                                                }
     277                                        }
     278                                        break;
     279
     280                                case 'stbl': // Sample TaBLe container atom
     281                                        $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     282                                        $isVideo = false;
     283                                        $framerate  = 0;
     284                                        $framecount = 0;
     285                                        foreach ($atom_structure['subatoms'] as $key => $value_array) {
     286                                                if (isset($value_array['sample_description_table'])) {
     287                                                        foreach ($value_array['sample_description_table'] as $key2 => $value_array2) {
     288                                                                if (isset($value_array2['data_format'])) {
     289                                                                        switch ($value_array2['data_format']) {
     290                                                                                case 'avc1':
     291                                                                                case 'mp4v':
     292                                                                                        // video data
     293                                                                                        $isVideo = true;
     294                                                                                        break;
     295                                                                                case 'mp4a':
     296                                                                                        // audio data
     297                                                                                        break;
     298                                                                        }
     299                                                                }
     300                                                        }
     301                                                } elseif (isset($value_array['time_to_sample_table'])) {
     302                                                        foreach ($value_array['time_to_sample_table'] as $key2 => $value_array2) {
     303                                                                if (isset($value_array2['sample_count']) && isset($value_array2['sample_duration']) && ($value_array2['sample_duration'] > 0)) {
     304                                                                        $framerate  = round($info['quicktime']['time_scale'] / $value_array2['sample_duration'], 3);
     305                                                                        $framecount = $value_array2['sample_count'];
    283306                                                                }
    284307                                                        }
    285308                                                }
    286                                         } elseif (isset($value_array['time_to_sample_table'])) {
    287                                                 foreach ($value_array['time_to_sample_table'] as $key2 => $value_array2) {
    288                                                         if (isset($value_array2['sample_count']) && isset($value_array2['sample_duration']) && ($value_array2['sample_duration'] > 0)) {
    289                                                                 $framerate  = round($info['quicktime']['time_scale'] / $value_array2['sample_duration'], 3);
    290                                                                 $framecount = $value_array2['sample_count'];
    291                                                         }
    292                                                 }
    293                                         }
    294                                 }
    295                                 if ($isVideo && $framerate) {
    296                                         $info['quicktime']['video']['frame_rate'] = $framerate;
    297                                         $info['video']['frame_rate'] = $info['quicktime']['video']['frame_rate'];
    298                                 }
    299                                 if ($isVideo && $framecount) {
    300                                         $info['quicktime']['video']['frame_count'] = $framecount;
    301                                 }
    302                                 break;
    303 
    304 
    305                         case "\xA9".'alb': // ALBum
    306                         case "\xA9".'ART': //
    307                         case "\xA9".'art': // ARTist
    308                         case "\xA9".'aut': //
    309                         case "\xA9".'cmt': // CoMmenT
    310                         case "\xA9".'com': // COMposer
    311                         case "\xA9".'cpy': //
    312                         case "\xA9".'day': // content created year
    313                         case "\xA9".'dir': //
    314                         case "\xA9".'ed1': //
    315                         case "\xA9".'ed2': //
    316                         case "\xA9".'ed3': //
    317                         case "\xA9".'ed4': //
    318                         case "\xA9".'ed5': //
    319                         case "\xA9".'ed6': //
    320                         case "\xA9".'ed7': //
    321                         case "\xA9".'ed8': //
    322                         case "\xA9".'ed9': //
    323                         case "\xA9".'enc': //
    324                         case "\xA9".'fmt': //
    325                         case "\xA9".'gen': // GENre
    326                         case "\xA9".'grp': // GRouPing
    327                         case "\xA9".'hst': //
    328                         case "\xA9".'inf': //
    329                         case "\xA9".'lyr': // LYRics
    330                         case "\xA9".'mak': //
    331                         case "\xA9".'mod': //
    332                         case "\xA9".'nam': // full NAMe
    333                         case "\xA9".'ope': //
    334                         case "\xA9".'PRD': //
    335                         case "\xA9".'prf': //
    336                         case "\xA9".'req': //
    337                         case "\xA9".'src': //
    338                         case "\xA9".'swr': //
    339                         case "\xA9".'too': // encoder
    340                         case "\xA9".'trk': // TRacK
    341                         case "\xA9".'url': //
    342                         case "\xA9".'wrn': //
    343                         case "\xA9".'wrt': // WRiTer
    344                         case '----': // itunes specific
    345                         case 'aART': // Album ARTist
    346                         case 'akID': // iTunes store account type
    347                         case 'apID': // Purchase Account
    348                         case 'atID': //
    349                         case 'catg': // CaTeGory
    350                         case 'cmID': //
    351                         case 'cnID': //
    352                         case 'covr': // COVeR artwork
    353                         case 'cpil': // ComPILation
    354                         case 'cprt': // CoPyRighT
    355                         case 'desc': // DESCription
    356                         case 'disk': // DISK number
    357                         case 'egid': // Episode Global ID
    358                         case 'geID': //
    359                         case 'gnre': // GeNRE
    360                         case 'hdvd': // HD ViDeo
    361                         case 'keyw': // KEYWord
    362                         case 'ldes': // Long DEScription
    363                         case 'pcst': // PodCaST
    364                         case 'pgap': // GAPless Playback
    365                         case 'plID': //
    366                         case 'purd': // PURchase Date
    367                         case 'purl': // Podcast URL
    368                         case 'rati': //
    369                         case 'rndu': //
    370                         case 'rpdu': //
    371                         case 'rtng': // RaTiNG
    372                         case 'sfID': // iTunes store country
    373                         case 'soaa': // SOrt Album Artist
    374                         case 'soal': // SOrt ALbum
    375                         case 'soar': // SOrt ARtist
    376                         case 'soco': // SOrt COmposer
    377                         case 'sonm': // SOrt NaMe
    378                         case 'sosn': // SOrt Show Name
    379                         case 'stik': //
    380                         case 'tmpo': // TeMPO (BPM)
    381                         case 'trkn': // TRacK Number
    382                         case 'tven': // tvEpisodeID
    383                         case 'tves': // TV EpiSode
    384                         case 'tvnn': // TV Network Name
    385                         case 'tvsh': // TV SHow Name
    386                         case 'tvsn': // TV SeasoN
    387                                 if ($atom_parent == 'udta') {
    388                                         // User data atom handler
    389                                         $atom_structure['data_length'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
    390                                         $atom_structure['language_id'] = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2));
    391                                         $atom_structure['data']        =                           substr($atom_data, 4);
    392 
    393                                         $atom_structure['language']    = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
    394                                         if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
    395                                                 $info['comments']['language'][] = $atom_structure['language'];
    396                                         }
    397                                 } else {
    398                                         // Apple item list box atom handler
    399                                         $atomoffset = 0;
    400                                         if (substr($atom_data, 2, 2) == "\x10\xB5") {
    401                                                 // not sure what it means, but observed on iPhone4 data.
    402                                                 // Each $atom_data has 2 bytes of datasize, plus 0x10B5, then data
    403                                                 while ($atomoffset < strlen($atom_data)) {
    404                                                         $boxsmallsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset,     2));
    405                                                         $boxsmalltype =                           substr($atom_data, $atomoffset + 2, 2);
    406                                                         $boxsmalldata =                           substr($atom_data, $atomoffset + 4, $boxsmallsize);
    407                                                         if ($boxsmallsize <= 1) {
    408                                                                 $this->warning('Invalid QuickTime atom smallbox size "'.$boxsmallsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
    409                                                                 $atom_structure['data'] = null;
    410                                                                 $atomoffset = strlen($atom_data);
    411                                                                 break;
    412                                                         }
    413                                                         switch ($boxsmalltype) {
    414                                                                 case "\x10\xB5":
    415                                                                         $atom_structure['data'] = $boxsmalldata;
    416                                                                         break;
    417                                                                 default:
    418                                                                         $this->warning('Unknown QuickTime smallbox type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $boxsmalltype).'" ('.trim(getid3_lib::PrintHexBytes($boxsmalltype)).') at offset '.$baseoffset);
    419                                                                         $atom_structure['data'] = $atom_data;
    420                                                                         break;
    421                                                         }
    422                                                         $atomoffset += (4 + $boxsmallsize);
     309                                        }
     310                                        if ($isVideo && $framerate) {
     311                                                $info['quicktime']['video']['frame_rate'] = $framerate;
     312                                                $info['video']['frame_rate'] = $info['quicktime']['video']['frame_rate'];
     313                                        }
     314                                        if ($isVideo && $framecount) {
     315                                                $info['quicktime']['video']['frame_count'] = $framecount;
     316                                        }
     317                                        break;
     318
     319
     320                                case "\xA9".'alb': // ALBum
     321                                case "\xA9".'ART': //
     322                                case "\xA9".'art': // ARTist
     323                                case "\xA9".'aut': //
     324                                case "\xA9".'cmt': // CoMmenT
     325                                case "\xA9".'com': // COMposer
     326                                case "\xA9".'cpy': //
     327                                case "\xA9".'day': // content created year
     328                                case "\xA9".'dir': //
     329                                case "\xA9".'ed1': //
     330                                case "\xA9".'ed2': //
     331                                case "\xA9".'ed3': //
     332                                case "\xA9".'ed4': //
     333                                case "\xA9".'ed5': //
     334                                case "\xA9".'ed6': //
     335                                case "\xA9".'ed7': //
     336                                case "\xA9".'ed8': //
     337                                case "\xA9".'ed9': //
     338                                case "\xA9".'enc': //
     339                                case "\xA9".'fmt': //
     340                                case "\xA9".'gen': // GENre
     341                                case "\xA9".'grp': // GRouPing
     342                                case "\xA9".'hst': //
     343                                case "\xA9".'inf': //
     344                                case "\xA9".'lyr': // LYRics
     345                                case "\xA9".'mak': //
     346                                case "\xA9".'mod': //
     347                                case "\xA9".'nam': // full NAMe
     348                                case "\xA9".'ope': //
     349                                case "\xA9".'PRD': //
     350                                case "\xA9".'prf': //
     351                                case "\xA9".'req': //
     352                                case "\xA9".'src': //
     353                                case "\xA9".'swr': //
     354                                case "\xA9".'too': // encoder
     355                                case "\xA9".'trk': // TRacK
     356                                case "\xA9".'url': //
     357                                case "\xA9".'wrn': //
     358                                case "\xA9".'wrt': // WRiTer
     359                                case '----': // itunes specific
     360                                case 'aART': // Album ARTist
     361                                case 'akID': // iTunes store account type
     362                                case 'apID': // Purchase Account
     363                                case 'atID': //
     364                                case 'catg': // CaTeGory
     365                                case 'cmID': //
     366                                case 'cnID': //
     367                                case 'covr': // COVeR artwork
     368                                case 'cpil': // ComPILation
     369                                case 'cprt': // CoPyRighT
     370                                case 'desc': // DESCription
     371                                case 'disk': // DISK number
     372                                case 'egid': // Episode Global ID
     373                                case 'geID': //
     374                                case 'gnre': // GeNRE
     375                                case 'hdvd': // HD ViDeo
     376                                case 'keyw': // KEYWord
     377                                case 'ldes': // Long DEScription
     378                                case 'pcst': // PodCaST
     379                                case 'pgap': // GAPless Playback
     380                                case 'plID': //
     381                                case 'purd': // PURchase Date
     382                                case 'purl': // Podcast URL
     383                                case 'rati': //
     384                                case 'rndu': //
     385                                case 'rpdu': //
     386                                case 'rtng': // RaTiNG
     387                                case 'sfID': // iTunes store country
     388                                case 'soaa': // SOrt Album Artist
     389                                case 'soal': // SOrt ALbum
     390                                case 'soar': // SOrt ARtist
     391                                case 'soco': // SOrt COmposer
     392                                case 'sonm': // SOrt NaMe
     393                                case 'sosn': // SOrt Show Name
     394                                case 'stik': //
     395                                case 'tmpo': // TeMPO (BPM)
     396                                case 'trkn': // TRacK Number
     397                                case 'tven': // tvEpisodeID
     398                                case 'tves': // TV EpiSode
     399                                case 'tvnn': // TV Network Name
     400                                case 'tvsh': // TV SHow Name
     401                                case 'tvsn': // TV SeasoN
     402                                        if ($atom_parent == 'udta') {
     403                                                // User data atom handler
     404                                                $atom_structure['data_length'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
     405                                                $atom_structure['language_id'] = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2));
     406                                                $atom_structure['data']        =                           substr($atom_data, 4);
     407
     408                                                $atom_structure['language']    = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
     409                                                if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
     410                                                        $info['comments']['language'][] = $atom_structure['language'];
    423411                                                }
    424412                                        } else {
    425                                                 while ($atomoffset < strlen($atom_data)) {
    426                                                         $boxsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset, 4));
    427                                                         $boxtype =                           substr($atom_data, $atomoffset + 4, 4);
    428                                                         $boxdata =                           substr($atom_data, $atomoffset + 8, $boxsize - 8);
    429                                                         if ($boxsize <= 1) {
    430                                                                 $this->warning('Invalid QuickTime atom box size "'.$boxsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
    431                                                                 $atom_structure['data'] = null;
    432                                                                 $atomoffset = strlen($atom_data);
    433                                                                 break;
     413                                                // Apple item list box atom handler
     414                                                $atomoffset = 0;
     415                                                if (substr($atom_data, 2, 2) == "\x10\xB5") {
     416                                                        // not sure what it means, but observed on iPhone4 data.
     417                                                        // Each $atom_data has 2 bytes of datasize, plus 0x10B5, then data
     418                                                        while ($atomoffset < strlen($atom_data)) {
     419                                                                $boxsmallsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset,     2));
     420                                                                $boxsmalltype =                           substr($atom_data, $atomoffset + 2, 2);
     421                                                                $boxsmalldata =                           substr($atom_data, $atomoffset + 4, $boxsmallsize);
     422                                                                if ($boxsmallsize <= 1) {
     423                                                                        $this->warning('Invalid QuickTime atom smallbox size "'.$boxsmallsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
     424                                                                        $atom_structure['data'] = null;
     425                                                                        $atomoffset = strlen($atom_data);
     426                                                                        break;
     427                                                                }
     428                                                                switch ($boxsmalltype) {
     429                                                                        case "\x10\xB5":
     430                                                                                $atom_structure['data'] = $boxsmalldata;
     431                                                                                break;
     432                                                                        default:
     433                                                                                $this->warning('Unknown QuickTime smallbox type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $boxsmalltype).'" ('.trim(getid3_lib::PrintHexBytes($boxsmalltype)).') at offset '.$baseoffset);
     434                                                                                $atom_structure['data'] = $atom_data;
     435                                                                                break;
     436                                                                }
     437                                                                $atomoffset += (4 + $boxsmallsize);
    434438                                                        }
    435                                                         $atomoffset += $boxsize;
    436 
    437                                                         switch ($boxtype) {
    438                                                                 case 'mean':
    439                                                                 case 'name':
    440                                                                         $atom_structure[$boxtype] = substr($boxdata, 4);
     439                                                } else {
     440                                                        while ($atomoffset < strlen($atom_data)) {
     441                                                                $boxsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset, 4));
     442                                                                $boxtype =                           substr($atom_data, $atomoffset + 4, 4);
     443                                                                $boxdata =                           substr($atom_data, $atomoffset + 8, $boxsize - 8);
     444                                                                if ($boxsize <= 1) {
     445                                                                        $this->warning('Invalid QuickTime atom box size "'.$boxsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
     446                                                                        $atom_structure['data'] = null;
     447                                                                        $atomoffset = strlen($atom_data);
    441448                                                                        break;
    442 
    443                                                                 case 'data':
    444                                                                         $atom_structure['version']   = getid3_lib::BigEndian2Int(substr($boxdata,  0, 1));
    445                                                                         $atom_structure['flags_raw'] = getid3_lib::BigEndian2Int(substr($boxdata,  1, 3));
    446                                                                         switch ($atom_structure['flags_raw']) {
    447                                                                                 case  0: // data flag
    448                                                                                 case 21: // tmpo/cpil flag
    449                                                                                         switch ($atomname) {
    450                                                                                                 case 'cpil':
    451                                                                                                 case 'hdvd':
    452                                                                                                 case 'pcst':
    453                                                                                                 case 'pgap':
    454                                                                                                         // 8-bit integer (boolean)
    455                                                                                                         $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
    456                                                                                                         break;
    457 
    458                                                                                                 case 'tmpo':
    459                                                                                                         // 16-bit integer
    460                                                                                                         $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 2));
    461                                                                                                         break;
    462 
    463                                                                                                 case 'disk':
    464                                                                                                 case 'trkn':
    465                                                                                                         // binary
    466                                                                                                         $num       = getid3_lib::BigEndian2Int(substr($boxdata, 10, 2));
    467                                                                                                         $num_total = getid3_lib::BigEndian2Int(substr($boxdata, 12, 2));
    468                                                                                                         $atom_structure['data']  = empty($num) ? '' : $num;
    469                                                                                                         $atom_structure['data'] .= empty($num_total) ? '' : '/'.$num_total;
    470                                                                                                         break;
    471 
    472                                                                                                 case 'gnre':
    473                                                                                                         // enum
    474                                                                                                         $GenreID = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
    475                                                                                                         $atom_structure['data']    = getid3_id3v1::LookupGenreName($GenreID - 1);
    476                                                                                                         break;
    477 
    478                                                                                                 case 'rtng':
    479                                                                                                         // 8-bit integer
    480                                                                                                         $atom_structure[$atomname] = getid3_lib::BigEndian2Int