Changeset 113163 in spip-zone


Ignore:
Timestamp:
Dec 30, 2018, 6:04:07 PM (4 months ago)
Author:
spip.franck@…
Message:

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

Location:
_core_/branches/spip-3.1/plugins/medias/lib/getid3
Files:
1 added
74 edited

Legend:

Unmodified
Added
Removed
  • _core_/branches/spip-3.1/plugins/medias/lib/getid3/extension.cache.dbm.php

    r96229 r113163  
    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_/branches/spip-3.1/plugins/medias/lib/getid3/extension.cache.mysql.php

    r96229 r113163  
    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
    180216                $SQLquery  = 'CREATE TABLE IF NOT EXISTS `'.mysql_real_escape_string($this->table).'` (';
    181                 $SQLquery .=   '`filename` VARCHAR(500) NOT NULL DEFAULT \'\'';
     217                $SQLquery .=   '`filename` VARCHAR(990) NOT NULL DEFAULT \'\'';
    182218                $SQLquery .= ', `filesize` INT(11) NOT NULL DEFAULT \'0\'';
    183219                $SQLquery .= ', `filetime` INT(11) NOT NULL DEFAULT \'0\'';
    184220                $SQLquery .= ', `analyzetime` INT(11) NOT NULL DEFAULT \'0\'';
    185221                $SQLquery .= ', `value` LONGTEXT NOT NULL';
    186                 $SQLquery .= ', PRIMARY KEY (`filename`, `filesize`, `filetime`)) ENGINE=MyISAM';
     222                $SQLquery .= ', PRIMARY KEY (`filename`, `filesize`, `filetime`))';
    187223                $this->cursor = mysql_query($SQLquery, $this->connection);
    188224                echo mysql_error($this->connection);
  • _core_/branches/spip-3.1/plugins/medias/lib/getid3/extension.cache.sqlite3.php

    r96229 r113163  
    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_/branches/spip-3.1/plugins/medias/lib/getid3/getid3.lib.php

    r96229 r113163  
    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                 // iconv() availble
    964                 if (function_exists('iconv')) {
     1282                // mb_convert_encoding() available
     1283                if (function_exists('mb_convert_encoding')) {
     1284                        if ($converted_string = @mb_convert_encoding($string, $out_charset, $in_charset)) {
     1285                                switch ($out_charset) {
     1286                                        case 'ISO-8859-1':
     1287                                                $converted_string = rtrim($converted_string, "\x00");
     1288                                                break;
     1289                                }
     1290                                return $converted_string;
     1291                        }
     1292                        return $string;
     1293                }
     1294                // iconv() available
     1295                else if (function_exists('iconv')) {
    9651296                        if ($converted_string = @iconv($in_charset, $out_charset.'//TRANSLIT', $string)) {
    9661297                                switch ($out_charset) {
     
    9781309
    9791310
    980                 // iconv() not available
     1311                // neither mb_convert_encoding or iconv() is available
    9811312                static $ConversionFunctionList = array();
    9821313                if (empty($ConversionFunctionList)) {
     
    10001331                        return self::$ConversionFunction($string);
    10011332                }
    1002                 throw new Exception('PHP does not have iconv() support - cannot convert from '.$in_charset.' to '.$out_charset);
    1003         }
    1004 
     1333                throw new Exception('PHP does not has mb_convert_encoding() or iconv() support - cannot convert from '.$in_charset.' to '.$out_charset);
     1334        }
     1335
     1336        /**
     1337         * @param mixed  $data
     1338         * @param string $charset
     1339         *
     1340         * @return mixed
     1341         */
    10051342        public static function recursiveMultiByteCharString2HTML($data, $charset='ISO-8859-1') {
    10061343                if (is_string($data)) {
     
    10171354        }
    10181355
     1356        /**
     1357         * @param string|int|float $string
     1358         * @param string           $charset
     1359         *
     1360         * @return string
     1361         */
    10191362        public static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
    10201363                $string = (string) $string; // in case trying to pass a numeric (float, int) string, would otherwise return an empty string
    10211364                $HTMLstring = '';
    10221365
    1023                 switch ($charset) {
     1366                switch (strtolower($charset)) {
    10241367                        case '1251':
    10251368                        case '1252':
     
    10281371                        case '936':
    10291372                        case '950':
    1030                         case 'BIG5':
    1031                         case 'BIG5-HKSCS':
     1373                        case 'big5':
     1374                        case 'big5-hkscs':
    10321375                        case 'cp1251':
    10331376                        case 'cp1252':
    10341377                        case 'cp866':
    1035                         case 'EUC-JP':
    1036                         case 'EUCJP':
    1037                         case 'GB2312':
     1378                        case 'euc-jp':
     1379                        case 'eucjp':
     1380                        case 'gb2312':
    10381381                        case 'ibm866':
    1039                         case 'ISO-8859-1':
    1040                         case 'ISO-8859-15':
    1041                         case 'ISO8859-1':
    1042                         case 'ISO8859-15':
    1043                         case 'KOI8-R':
     1382                        case 'iso-8859-1':
     1383                        case 'iso-8859-15':
     1384                        case 'iso8859-1':
     1385                        case 'iso8859-15':
     1386                        case 'koi8-r':
    10441387                        case 'koi8-ru':
    10451388                        case 'koi8r':
    1046                         case 'Shift_JIS':
    1047                         case 'SJIS':
     1389                        case 'shift_jis':
     1390                        case 'sjis':
    10481391                        case 'win-1251':
    1049                         case 'Windows-1251':
    1050                         case 'Windows-1252':
     1392                        case 'windows-1251':
     1393                        case 'windows-1252':
    10511394                                $HTMLstring = htmlentities($string, ENT_COMPAT, $charset);
    10521395                                break;
    10531396
    1054                         case 'UTF-8':
     1397                        case 'utf-8':
    10551398                                $strlen = strlen($string);
    10561399                                for ($i = 0; $i < $strlen; $i++) {
     
    10801423                                break;
    10811424
    1082                         case 'UTF-16LE':
     1425                        case 'utf-16le':
    10831426                                for ($i = 0; $i < strlen($string); $i += 2) {
    10841427                                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
     
    10911434                                break;
    10921435
    1093                         case 'UTF-16BE':
     1436                        case 'utf-16be':
    10941437                                for ($i = 0; $i < strlen($string); $i += 2) {
    10951438                                        $charval = self::BigEndian2Int(substr($string, $i, 2));
     
    11091452        }
    11101453
    1111 
    1112 
     1454        /**
     1455         * @param int $namecode
     1456         *
     1457         * @return string
     1458         */
    11131459        public static function RGADnameLookup($namecode) {
    11141460                static $RGADname = array();
     
    11221468        }
    11231469
    1124 
     1470        /**
     1471         * @param int $originatorcode
     1472         *
     1473         * @return string
     1474         */
    11251475        public static function RGADoriginatorLookup($originatorcode) {
    11261476                static $RGADoriginator = array();
     
    11351485        }
    11361486
    1137 
     1487        /**
     1488         * @param int $rawadjustment
     1489         * @param int $signbit
     1490         *
     1491         * @return float
     1492         */
    11381493        public static function RGADadjustmentLookup($rawadjustment, $signbit) {
    1139                 $adjustment = $rawadjustment / 10;
     1494                $adjustment = (float) $rawadjustment / 10;
    11401495                if ($signbit == 1) {
    11411496                        $adjustment *= -1;
    11421497                }
    1143                 return (float) $adjustment;
    1144         }
    1145 
    1146 
     1498                return $adjustment;
     1499        }
     1500
     1501        /**
     1502         * @param int $namecode
     1503         * @param int $originatorcode
     1504         * @param int $replaygain
     1505         *
     1506         * @return string
     1507         */
    11471508        public static function RGADgainString($namecode, $originatorcode, $replaygain) {
    11481509                if ($replaygain < 0) {
     
    11601521        }
    11611522
     1523        /**
     1524         * @param float $amplitude
     1525         *
     1526         * @return float
     1527         */
    11621528        public static function RGADamplitude2dB($amplitude) {
    11631529                return 20 * log10($amplitude);
    11641530        }
    11651531
    1166 
     1532        /**
     1533         * @param string $imgData
     1534         * @param array  $imageinfo
     1535         *
     1536         * @return array|false
     1537         */
    11671538        public static function GetDataImageSize($imgData, &$imageinfo=array()) {
    11681539                static $tempdir = '';
     
    11991570        }
    12001571
     1572        /**
     1573         * @param string $mime_type
     1574         *
     1575         * @return string
     1576         */
    12011577        public static function ImageExtFromMime($mime_type) {
    12021578                // temporary way, works OK for now, but should be reworked in the future
     
    12041580        }
    12051581
    1206         public static function ImageTypesLookup($imagetypeid) {
    1207                 static $ImageTypesLookup = array();
    1208                 if (empty($ImageTypesLookup)) {
    1209                         $ImageTypesLookup[1]  = 'gif';
    1210                         $ImageTypesLookup[2]  = 'jpeg';
    1211                         $ImageTypesLookup[3]  = 'png';
    1212                         $ImageTypesLookup[4]  = 'swf';
    1213                         $ImageTypesLookup[5]  = 'psd';
    1214                         $ImageTypesLookup[6]  = 'bmp';
    1215                         $ImageTypesLookup[7]  = 'tiff (little-endian)';
    1216                         $ImageTypesLookup[8]  = 'tiff (big-endian)';
    1217                         $ImageTypesLookup[9]  = 'jpc';
    1218                         $ImageTypesLookup[10] = 'jp2';
    1219                         $ImageTypesLookup[11] = 'jpx';
    1220                         $ImageTypesLookup[12] = 'jb2';
    1221                         $ImageTypesLookup[13] = 'swc';
    1222                         $ImageTypesLookup[14] = 'iff';
    1223                 }
    1224                 return (isset($ImageTypesLookup[$imagetypeid]) ? $ImageTypesLookup[$imagetypeid] : '');
    1225         }
    1226 
     1582        /**
     1583         * @param array $ThisFileInfo
     1584         *
     1585         * @return bool
     1586         */
    12271587        public static function CopyTagsToComments(&$ThisFileInfo) {
    12281588
     
    12631623                                                        if (is_array($value) || empty($ThisFileInfo['comments'][$tagname]) || !in_array(trim($value), $ThisFileInfo['comments'][$tagname])) {
    12641624                                                                $value = (is_string($value) ? trim($value) : $value);
    1265                                                                 if (!is_numeric($key)) {
     1625                                                                if (!is_int($key) && !ctype_digit($key)) {
    12661626                                                                        $ThisFileInfo['comments'][$tagname][$key] = $value;
    12671627                                                                } else {
    1268                                                                         $ThisFileInfo['comments'][$tagname][]     = $value;
     1628                                                                        if (isset($ThisFileInfo['comments'][$tagname])) {
     1629                                                                                $ThisFileInfo['comments'][$tagname] = array($value);
     1630                                                                        } else {
     1631                                                                                $ThisFileInfo['comments'][$tagname][] = $value;
     1632                                                                        }
    12691633                                                                }
    12701634                                                        }
    12711635                                                }
    12721636                                        }
     1637                                }
     1638                        }
     1639
     1640                        // attempt to standardize spelling of returned keys
     1641                        $StandardizeFieldNames = array(
     1642                                'tracknumber' => 'track_number',
     1643                                'track'       => 'track_number',
     1644                        );
     1645                        foreach ($StandardizeFieldNames as $badkey => $goodkey) {
     1646                                if (array_key_exists($badkey, $ThisFileInfo['comments']) && !array_key_exists($goodkey, $ThisFileInfo['comments'])) {
     1647                                        $ThisFileInfo['comments'][$goodkey] = $ThisFileInfo['comments'][$badkey];
     1648                                        unset($ThisFileInfo['comments'][$badkey]);
    12731649                                }
    12741650                        }
     
    12961672        }
    12971673
    1298 
     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         */
    12991683        public static function EmbeddedLookup($key, $begin, $end, $file, $name) {
    13001684
     
    13431727        }
    13441728
     1729        /**
     1730         * @param string $filename
     1731         * @param string $sourcefile
     1732         * @param bool   $DieOnFailure
     1733         *
     1734         * @return bool
     1735         * @throws Exception
     1736         */
    13451737        public static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
    13461738                global $GETID3_ERRORARRAY;
     
    13631755        }
    13641756
     1757        /**
     1758         * @param string $string
     1759         *
     1760         * @return string
     1761         */
    13651762        public static function trimNullByte($string) {
    13661763                return trim($string, "\x00");
    13671764        }
    13681765
     1766        /**
     1767         * @param string $path
     1768         *
     1769         * @return float|bool
     1770         */
    13691771        public static function getFileSizeSyscall($path) {
    13701772                $filesize = false;
     
    13911793        }
    13921794
    1393 
    1394         /**
    1395         * Workaround for Bug #37268 (https://bugs.php.net/bug.php?id=37268)
    1396         * @param string $path A path.
    1397         * @param string $suffix If the name component ends in suffix this will also be cut off.
    1398         * @return string
    1399         */
     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         */
    14001833        public static function mb_basename($path, $suffix = null) {
    14011834                $splited = preg_split('#/#', rtrim($path, '/ '));
  • _core_/branches/spip-3.1/plugins/medias/lib/getid3/getid3.php

    r96229 r113163  
    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                  //
     
    2323        define('IMG_JPG', IMAGETYPE_JPEG);
    2424}
     25if (!defined('ENT_SUBSTITUTE')) { // PHP5.3 adds ENT_IGNORE, PHP5.4 adds ENT_SUBSTITUTE
     26        define('ENT_SUBSTITUTE', (defined('ENT_IGNORE') ? ENT_IGNORE : 8));
     27}
     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');
    2536
    2637// attempt to define temp dir as something flexible but reliable
     
    7283class getID3
    7384{
    74         // public: Settings
    75         public $encoding        = 'UTF-8';        // CASE SENSITIVE! - i.e. (must be supported by iconv()). Examples:  ISO-8859-1  UTF-8  UTF-16  UTF-16BE
    76         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'
    77 
    78         // public: Optional tag checks - disable for speed.
    79         public $option_tag_id3v1         = true;  // Read and process ID3v1 tags
    80         public $option_tag_id3v2         = true;  // Read and process ID3v2 tags
    81         public $option_tag_lyrics3       = true;  // Read and process Lyrics3 tags
    82         public $option_tag_apetag        = true;  // Read and process APE tags
    83         public $option_tags_process      = true;  // Copy tags to root key 'tags' and encode to $this->encoding
    84         public $option_tags_html         = true;  // Copy tags to root key 'tags_html' properly translated from various encodings to HTML entities
    85 
    86         // public: Optional tag/comment calucations
    87         public $option_extra_info        = true;  // Calculate additional info such as bitrate, channelmode etc
    88 
    89         // public: Optional handling of embedded attachments (e.g. images)
    90         public $option_save_attachments  = true; // defaults to true (ATTACHMENTS_INLINE) for backward compatibility
    91 
    92         // public: Optional calculations
    93         public $option_md5_data          = false; // Get MD5 sum of data part - slow
    94         public $option_md5_data_source   = false; // Use MD5 of source file if availble - only FLAC and OptimFROG
    95         public $option_sha1_data         = false; // Get SHA1 sum of data part - slow
    96         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)
    97 
    98         // 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         */
    99209        public $option_fread_buffer_size = 32768;
    100210
    101211        // Public variables
    102         public $filename;                         // Filename of file being analysed.
    103         public $fp;                               // Filepointer to file being analysed.
    104         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         */
    105237        public $tempdir = GETID3_TEMP_DIR;
     238
     239        /**
     240         * @var int
     241         */
    106242        public $memory_limit = 0;
    107243
    108         // Protected variables
     244        /**
     245         * @var string
     246         */
    109247        protected $startup_error   = '';
     248
     249        /**
     250         * @var string
     251         */
    110252        protected $startup_warning = '';
    111253
    112         const VERSION           = '1.9.12-201602240818';
     254        const VERSION           = '1.9.16-201810171314';
    113255        const FREAD_BUFFER_SIZE = 32768;
    114256
     
    116258        const ATTACHMENTS_INLINE = true;
    117259
    118         // public: constructor
    119260        public function __construct() {
    120261
     
    122263                $required_php_version = '5.3.0';
    123264                if (version_compare(PHP_VERSION, $required_php_version, '<')) {
    124                         $this->startup_error .= 'getID3() requires PHP v'.$required_php_version.' or higher - you are running v'.PHP_VERSION;
    125                         return false;
     265                        $this->startup_error .= 'getID3() requires PHP v'.$required_php_version.' or higher - you are running v'.PHP_VERSION."\n";
     266                        return;
    126267                }
    127268
    128269                // Check memory
    129270                $this->memory_limit = ini_get('memory_limit');
    130                 if (preg_match('#([0-9]+)M#i', $this->memory_limit, $matches)) {
     271                if (preg_match('#([0-9]+) ?M#i', $this->memory_limit, $matches)) {
    131272                        // could be stored as "16M" rather than 16777216 for example
    132273                        $this->memory_limit = $matches[1] * 1048576;
    133                 } 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
    134275                        // could be stored as "2G" rather than 2147483648 for example
    135276                        $this->memory_limit = $matches[1] * 1073741824;
     
    138279                        // memory limits probably disabled
    139280                } elseif ($this->memory_limit <= 4194304) {
    140                         $this->startup_error .= 'PHP has less than 4MB available memory and will very likely run out. Increase memory_limit in php.ini';
     281                        $this->startup_error .= 'PHP has less than 4MB available memory and will very likely run out. Increase memory_limit in php.ini'."\n";
    141282                } elseif ($this->memory_limit <= 12582912) {
    142                         $this->startup_warning .= 'PHP has less than 12MB available memory and might run out if all modules are loaded. Increase memory_limit in php.ini';
     283                        $this->startup_warning .= 'PHP has less than 12MB available memory and might run out if all modules are loaded. Increase memory_limit in php.ini'."\n";
    143284                }
    144285
     
    148289                }
    149290
    150                 if (intval(ini_get('mbstring.func_overload')) > 0) {
    151                         $this->warning('WARNING: php.ini contains "mbstring.func_overload = '.ini_get('mbstring.func_overload').'", this may break things.');
     291                if (($mbstring_func_overload = ini_get('mbstring.func_overload')) && ($mbstring_func_overload & 0x02)) {
     292                        // http://php.net/manual/en/mbstring.overload.php
     293                        // "mbstring.func_overload in php.ini is a positive value that represents a combination of bitmasks specifying the categories of functions to be overloaded. It should be set to 1 to overload the mail() function. 2 for string functions, 4 for regular expression functions"
     294                        // getID3 cannot run when string functions are overloaded. It doesn't matter if mail() or ereg* functions are overloaded since getID3 does not use those.
     295                        $this->startup_error .= 'WARNING: php.ini contains "mbstring.func_overload = '.ini_get('mbstring.func_overload').'", getID3 cannot run with this setting (bitmask 2 (string functions) cannot be set). Recommended to disable entirely.'."\n";
    152296                }
    153297
     
    155299                if (function_exists('get_magic_quotes_runtime')) {
    156300                        if (get_magic_quotes_runtime()) {
    157                                 return $this->startup_error('magic_quotes_runtime must be disabled before running getID3(). Surround getid3 block by set_magic_quotes_runtime(0) and set_magic_quotes_runtime(1).');
     301                                $this->startup_error .= 'magic_quotes_runtime must be disabled before running getID3(). Surround getid3 block by set_magic_quotes_runtime(0) and set_magic_quotes_runtime(1).'."\n";
    158302                        }
    159303                }
     
    162306                if (function_exists('magic_quotes_gpc')) {
    163307                        if (get_magic_quotes_gpc()) {
    164                                 return $this->startup_error('magic_quotes_gpc must be disabled before running getID3(). Surround getid3 block by set_magic_quotes_gpc(0) and set_magic_quotes_gpc(1).');
     308                                $this->startup_error .= 'magic_quotes_gpc must be disabled before running getID3(). Surround getid3 block by set_magic_quotes_gpc(0) and set_magic_quotes_gpc(1).'."\n";
    165309                        }
    166310                }
     
    168312                // Load support library
    169313                if (!include_once(GETID3_INCLUDEPATH.'getid3.lib.php')) {
    170                         $this->startup_error .= 'getid3.lib.php is missing or corrupt';
     314                        $this->startup_error .= 'getid3.lib.php is missing or corrupt'."\n";
    171315                }
    172316
     
    187331
    188332                        if (!is_dir($helperappsdir)) {
    189                                 $this->startup_warning .= '"'.$helperappsdir.'" cannot be defined as GETID3_HELPERAPPSDIR because it does not exist';
     333                                $this->startup_warning .= '"'.$helperappsdir.'" cannot be defined as GETID3_HELPERAPPSDIR because it does not exist'."\n";
    190334                        } elseif (strpos(realpath($helperappsdir), ' ') !== false) {
    191335                                $DirPieces = explode(DIRECTORY_SEPARATOR, realpath($helperappsdir));
     
    207351                                                        }
    208352                                                } else {
    209                                                         $this->startup_warning .= 'GETID3_HELPERAPPSDIR must not have any spaces in it - use 8dot3 naming convention if neccesary. You can run "dir /x" from the commandline to see the correct 8.3-style names.';
     353                                                        $this->startup_warning .= 'GETID3_HELPERAPPSDIR must not have any spaces in it - use 8dot3 naming convention if neccesary. You can run "dir /x" from the commandline to see the correct 8.3-style names.'."\n";
    210354                                                }
    211355                                        }
     
    217361                }
    218362
    219                 return true;
    220         }
    221 
     363                if (!empty($this->startup_error)) {
     364                        echo $this->startup_error;
     365                        throw new getid3_exception($this->startup_error);
     366                }
     367        }
     368
     369        /**
     370         * @return string
     371         */
    222372        public function version() {
    223373                return self::VERSION;
    224374        }
    225375
     376        /**
     377         * @return int
     378         */
    226379        public function fread_buffer_size() {
    227380                return $this->option_fread_buffer_size;
    228381        }
    229382
    230 
    231         // public: setOption
     383        /**
     384         * @param array $optArray
     385         *
     386         * @return bool
     387         */
    232388        public function setOption($optArray) {
    233389                if (!is_array($optArray) || empty($optArray)) {
     
    243399        }
    244400
    245 
     401        /**
     402         * @param string $filename
     403         * @param int    $filesize
     404         *
     405         * @return bool
     406         *
     407         * @throws getid3_exception
     408         */
    246409        public function openfile($filename, $filesize=null) {
    247410                try {
     
    250413                        }
    251414                        if (!empty($this->startup_warning)) {
    252                                 $this->warning($this->startup_warning);
     415                                foreach (explode("\n", $this->startup_warning) as $startup_warning) {
     416                                        $this->warning($startup_warning);
     417                                }
    253418                        }
    254419
     
    260425
    261426                        // remote files not supported
    262                         if (preg_match('/^(ht|f)tp:\/\//', $filename)) {
     427                        if (preg_match('#^(ht|f)tp://#', $filename)) {
    263428                                throw new getid3_exception('Remote files are not supported - please copy the file locally first');
    264429                        }
    265430
    266431                        $filename = str_replace('/', DIRECTORY_SEPARATOR, $filename);
    267                         $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);
    268433
    269434                        // open local file
    270                         //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
    271436                        if ((is_readable($filename) || file_exists($filename)) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) {
    272437                                // great
     
    295460                        $this->info['filename']     = getid3_lib::mb_basename($filename);
    296461                        $this->info['filenamepath'] = $this->info['filepath'].'/'.$this->info['filename'];
    297 
    298 
    299                         // option_max_2gb_check
    300                         if ($this->option_max_2gb_check) {
    301                                 // PHP (32-bit all, and 64-bit Windows) doesn't support integers larger than 2^31 (~2GB)
    302                                 // filesize() simply returns (filesize % (pow(2, 32)), no matter the actual filesize
    303                                 // ftell() returns 0 if seeking to the end is beyond the range of unsigned integer
    304                                 $fseek = fseek($this->fp, 0, SEEK_END);
    305                                 if (($fseek < 0) || (($this->info['filesize'] != 0) && (ftell($this->fp) == 0)) ||
    306                                         ($this->info['filesize'] < 0) ||
    307                                         (ftell($this->fp) < 0)) {
    308                                                 $real_filesize = getid3_lib::getFileSizeSyscall($this->info['filenamepath']);
    309 
    310                                                 if ($real_filesize === false) {
    311                                                         unset($this->info['filesize']);
    312                                                         fclose($this->fp);
    313                                                         throw new getid3_exception('Unable to determine actual filesize. File is most likely larger than '.round(PHP_INT_MAX / 1073741824).'GB and is not supported by PHP.');
    314                                                 } elseif (getid3_lib::intValueSupported($real_filesize)) {
    315                                                         unset($this->info['filesize']);
    316                                                         fclose($this->fp);
    317                                                         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');
    318                                                 }
    319                                                 $this->info['filesize'] = $real_filesize;
    320                                                 $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.');
    321                                 }
    322                         }
    323462
    324463                        // set more parameters
     
    334473                        $this->info['encoding']            = $this->encoding;   // required by id3v2 and iso modules - can be unset at the end if desired
    335474
     475                        // option_max_2gb_check
     476                        if ($this->option_max_2gb_check) {
     477                                // PHP (32-bit all, and 64-bit Windows) doesn't support integers larger than 2^31 (~2GB)
     478                                // filesize() simply returns (filesize % (pow(2, 32)), no matter the actual filesize
     479                                // ftell() returns 0 if seeking to the end is beyond the range of unsigned integer
     480                                $fseek = fseek($this->fp, 0, SEEK_END);
     481                                if (($fseek < 0) || (($this->info['filesize'] != 0) && (ftell($this->fp) == 0)) ||
     482                                        ($this->info['filesize'] < 0) ||
     483                                        (ftell($this->fp) < 0)) {
     484                                                $real_filesize = getid3_lib::getFileSizeSyscall($this->info['filenamepath']);
     485
     486                                                if ($real_filesize === false) {
     487                                                        unset($this->info['filesize']);
     488                                                        fclose($this->fp);
     489                                                        throw new getid3_exception('Unable to determine actual filesize. File is most likely larger than '.round(PHP_INT_MAX / 1073741824).'GB and is not supported by PHP.');
     490                                                } elseif (getid3_lib::intValueSupported($real_filesize)) {
     491                                                        unset($this->info['filesize']);
     492                                                        fclose($this->fp);
     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');
     494                                                }
     495                                                $this->info['filesize'] = $real_filesize;
     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.');
     497                                }
     498                        }
     499
    336500                        return true;
    337501
     
    342506        }
    343507
    344         // 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         */
    345517        public function analyze($filename, $filesize=null, $original_filename='') {
    346518                try {
     
    427599                        }
    428600
    429                         // module requires iconv support
     601                        // module requires mb_convert_encoding/iconv support
    430602                        // Check encoding/iconv support
    431                         if (!empty($determined_format['iconv_req']) && !function_exists('iconv') && !in_array($this->encoding, array('ISO-8859-1', 'UTF-8', 'UTF-16LE', 'UTF-16BE', 'UTF-16'))) {
    432                                 $errormessage = 'iconv() support is required for this module ('.$determined_format['include'].') for encodings other than ISO-8859-1, UTF-8, UTF-16LE, UTF16-BE, UTF-16. ';
     603                        if (!empty($determined_format['iconv_req']) && !function_exists('mb_convert_encoding') && !function_exists('iconv') && !in_array($this->encoding, array('ISO-8859-1', 'UTF-8', 'UTF-16LE', 'UTF-16BE', 'UTF-16'))) {
     604                                $errormessage = 'mb_convert_encoding() or iconv() support is required for this module ('.$determined_format['include'].') for encodings other than ISO-8859-1, UTF-8, UTF-16LE, UTF16-BE, UTF-16. ';
    433605                                if (GETID3_OS_ISWINDOWS) {
    434                                         $errormessage .= 'PHP does not have iconv() support. Please enable php_iconv.dll in php.ini, and copy iconv.dll from c:/php/dlls to c:/windows/system32';
     606                                        $errormessage .= 'PHP does not have mb_convert_encoding() or iconv() support. Please enable php_mbstring.dll / php_iconv.dll in php.ini, and copy php_mbstring.dll / iconv.dll from c:/php/dlls to c:/windows/system32';
    435607                                } else {
    436                                         $errormessage .= 'PHP is not compiled with iconv() support. Please recompile with the --with-iconv switch';
     608                                        $errormessage .= 'PHP is not compiled with mb_convert_encoding() or iconv() support. Please recompile with the --enable-mbstring / --with-iconv switch';
    437609                                }
    438610                                return $this->error($errormessage);
     
    493665
    494666
    495         // private: error handling
     667        /**
     668         * Error handling.
     669         *
     670         * @param string $message
     671         *
     672         * @return array
     673         */
    496674        public function error($message) {
    497675                $this->CleanUp();
     
    504682
    505683
    506         // private: warning handling
     684        /**
     685         * Warning handling.
     686         *
     687         * @param string $message
     688         *
     689         * @return bool
     690         */
    507691        public function warning($message) {
    508692                $this->info['warning'][] = $message;
     
    511695
    512696
    513         // private: CleanUp
     697        /**
     698         * @return bool
     699         */
    514700        private function CleanUp() {
    515701
     
    558744        }
    559745
    560 
    561         // return array containing information about all supported formats
     746        /**
     747         * Return array containing information about all supported formats.
     748         *
     749         * @return array
     750         */
    562751        public function GetFileFormatArray() {
    563752                static $format_info = array();
     
    569758                                // AC-3   - audio      - Dolby AC-3 / Dolby Digital
    570759                                'ac3'  => array(
    571                                                         'pattern'   => '^\x0B\x77',
     760                                                        'pattern'   => '^\\x0B\\x77',
    572761                                                        'group'     => 'audio',
    573762                                                        'module'    => 'ac3',
     
    580769                                                        'group'     => 'audio',
    581770                                                        'module'    => 'aac',
    582                                                         'mime_type' => 'application/octet-stream',
     771                                                        'mime_type' => 'audio/aac',
    583772                                                        'fail_ape'  => 'WARNING',
    584773                                                ),
     
    587776                                // AA   - audio       - Audible Audiobook
    588777                                'aa'   => array(
    589                                                         'pattern'   => '^.{4}\x57\x90\x75\x36',
     778                                                        'pattern'   => '^.{4}\\x57\\x90\\x75\\x36',
    590779                                                        'group'     => 'audio',
    591780                                                        'module'    => 'aa',
     
    595784                                // AAC  - audio       - Advanced Audio Coding (AAC) - ADTS format (very similar to MP3)
    596785                                'adts' => array(
    597                                                         'pattern'   => '^\xFF[\xF0-\xF1\xF8-\xF9]',
     786                                                        'pattern'   => '^\\xFF[\\xF0-\\xF1\\xF8-\\xF9]',
    598787                                                        'group'     => 'audio',
    599788                                                        'module'    => 'aac',
    600                                                         'mime_type' => 'application/octet-stream',
     789                                                        'mime_type' => 'audio/aac',
    601790                                                        'fail_ape'  => 'WARNING',
    602791                                                ),
     
    605794                                // AU   - audio       - NeXT/Sun AUdio (AU)
    606795                                'au'   => array(
    607                                                         'pattern'   => '^\.snd',
     796                                                        'pattern'   => '^\\.snd',
    608797                                                        'group'     => 'audio',
    609798                                                        'module'    => 'au',
     
    613802                                // AMR  - audio       - Adaptive Multi Rate
    614803                                'amr'  => array(
    615                                                         'pattern'   => '^\x23\x21AMR\x0A', // #!AMR[0A]
     804                                                        'pattern'   => '^\\x23\\x21AMR\\x0A', // #!AMR[0A]
    616805                                                        'group'     => 'audio',
    617806                                                        'module'    => 'amr',
     
    629818                                // BONK - audio       - Bonk v0.9+
    630819                                'bonk' => array(
    631                                                         'pattern'   => '^\x00(BONK|INFO|META| ID3)',
     820                                                        'pattern'   => '^\\x00(BONK|INFO|META| ID3)',
    632821                                                        'group'     => 'audio',
    633822                                                        'module'    => 'bonk',
     
    645834                                // DSS  - audio       - Digital Speech Standard
    646835                                'dss'  => array(
    647                                                         'pattern'   => '^[\x02-\x03]ds[s2]',
     836                                                        'pattern'   => '^[\\x02-\\x06]ds[s2]',
    648837                                                        'group'     => 'audio',
    649838                                                        'module'    => 'dss',
     
    653842                                // DTS  - audio       - Dolby Theatre System
    654843                                'dts'  => array(
    655                                                         'pattern'   => '^\x7F\xFE\x80\x01',
     844                                                        'pattern'   => '^\\x7F\\xFE\\x80\\x01',
    656845                                                        'group'     => 'audio',
    657846                                                        'module'    => 'dts',
     
    664853                                                        'group'     => 'audio',
    665854                                                        'module'    => 'flac',
    666                                                         'mime_type' => 'audio/x-flac',
     855                                                        'mime_type' => 'audio/flac',
    667856                                                ),
    668857
     
    696885                                                        'group'     => 'audio',
    697886                                                        'module'    => 'monkey',
    698                                                         'mime_type' => 'application/octet-stream',
     887                                                        'mime_type' => 'audio/x-monkeys-audio',
    699888                                                ),
    700889
     
    738927                                // MPC  - audio       - Musepack / MPEGplus
    739928                                'mpc'  => array(
    740                                                         'pattern'   => '^(MPCK|MP\+|[\x00\x01\x10\x11\x40\x41\x50\x51\x80\x81\x90\x91\xC0\xC1\xD0\xD1][\x20-37][\x00\x20\x40\x60\x80\xA0\xC0\xE0])',
     929                                                        'pattern'   => '^(MPCK|MP\\+|[\\x00\\x01\\x10\\x11\\x40\\x41\\x50\\x51\\x80\\x81\\x90\\x91\\xC0\\xC1\\xD0\\xD1][\\x20-\\x37][\\x00\\x20\\x40\\x60\\x80\\xA0\\xC0\\xE0])',
    741930                                                        'group'     => 'audio',
    742931                                                        'module'    => 'mpc',
     
    746935                                // MP3  - audio       - MPEG-audio Layer 3 (very similar to AAC-ADTS)
    747936                                'mp3'  => array(
    748                                                         'pattern'   => '^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\x0B\x10-\x1B\x20-\x2B\x30-\x3B\x40-\x4B\x50-\x5B\x60-\x6B\x70-\x7B\x80-\x8B\x90-\x9B\xA0-\xAB\xB0-\xBB\xC0-\xCB\xD0-\xDB\xE0-\xEB\xF0-\xFB]',
     937                                                        'pattern'   => '^\\xFF[\\xE2-\\xE7\\xF2-\\xF7\\xFA-\\xFF][\\x00-\\x0B\\x10-\\x1B\\x20-\\x2B\\x30-\\x3B\\x40-\\x4B\\x50-\\x5B\\x60-\\x6B\\x70-\\x7B\\x80-\\x8B\\x90-\\x9B\\xA0-\\xAB\\xB0-\\xBB\\xC0-\\xCB\\xD0-\\xDB\\xE0-\\xEB\\xF0-\\xFB]',
    749938                                                        'group'     => 'audio',
    750939                                                        'module'    => 'mp3',
     
    754943                                // OFR  - audio       - OptimFROG
    755944                                'ofr'  => array(
    756                                                         'pattern'   => '^(\*RIFF|OFR)',
     945                                                        'pattern'   => '^(\\*RIFF|OFR)',
    757946                                                        'group'     => 'audio',
    758947                                                        'module'    => 'optimfrog',
     
    780969                                // TTA  - audio       - TTA Lossless Audio Compressor (http://tta.corecodec.org)
    781970                                'tta'  => array(
    782                                                         'pattern'   => '^TTA',  // could also be '^TTA(\x01|\x02|\x03|2|1)'
     971                                                        'pattern'   => '^TTA',  // could also be '^TTA(\\x01|\\x02|\\x03|2|1)'
    783972                                                        'group'     => 'audio',
    784973                                                        'module'    => 'tta',
     
    8151004                                // ASF  - audio/video - Advanced Streaming Format, Windows Media Video, Windows Media Audio
    8161005                                'asf'  => array(
    817                                                         'pattern'   => '^\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C',
     1006                                                        'pattern'   => '^\\x30\\x26\\xB2\\x75\\x8E\\x66\\xCF\\x11\\xA6\\xD9\\x00\\xAA\\x00\\x62\\xCE\\x6C',
    8181007                                                        'group'     => 'audio-video',
    8191008                                                        'module'    => 'asf',
     
    8321021                                // FLV  - audio/video - FLash Video
    8331022                                'flv' => array(
    834                                                         'pattern'   => '^FLV\x01',
     1023                                                        'pattern'   => '^FLV[\\x01]',
    8351024                                                        'group'     => 'audio-video',
    8361025                                                        'module'    => 'flv',
     
    8401029                                // MKAV - audio/video - Mastroka
    8411030                                'matroska' => array(
    842                                                         'pattern'   => '^\x1A\x45\xDF\xA3',
     1031                                                        'pattern'   => '^\\x1A\\x45\\xDF\\xA3',
    8431032                                                        'group'     => 'audio-video',
    8441033                                                        'module'    => 'matroska',
     
    8481037                                // MPEG - audio/video - MPEG (Moving Pictures Experts Group)
    8491038                                'mpeg' => array(
    850                                                         'pattern'   => '^\x00\x00\x01(\xBA|\xB3)',
     1039                                                        'pattern'   => '^\\x00\\x00\\x01[\\xB3\\xBA]',
    8511040                                                        'group'     => 'audio-video',
    8521041                                                        'module'    => 'mpeg',
     
    8851074                                                        'group'     => 'audio-video',
    8861075                                                        'module'    => 'riff',
    887                                                         'mime_type' => 'audio/x-wav',
     1076                                                        'mime_type' => 'audio/wav',
    8881077                                                        'fail_ape'  => 'WARNING',
    8891078                                                ),
     
    8911080                                // Real - audio/video - RealAudio, RealVideo
    8921081                                'real' => array(
    893                                                         'pattern'   => '^(\\.RMF|\\.ra)',
     1082                                                        'pattern'   => '^\\.(RMF|ra)',
    8941083                                                        'group'     => 'audio-video',
    8951084                                                        'module'    => 'real',
     
    9071096                                // TS - audio/video - MPEG-2 Transport Stream
    9081097                                'ts' => array(
    909                                                         'pattern'   => '^(\x47.{187}){10,}', // packets are 188 bytes long and start with 0x47 "G".  Check for at least 10 packets matching this pattern
     1098                                                        'pattern'   => '^(\\x47.{187}){10,}', // packets are 188 bytes long and start with 0x47 "G".  Check for at least 10 packets matching this pattern
    9101099                                                        'group'     => 'audio-video',
    9111100                                                        'module'    => 'ts',
     
    9381127                                // JPEG - still image - Joint Photographic Experts Group (JPEG)
    9391128                                'jpg'  => array(
    940                                                         'pattern'   => '^\xFF\xD8\xFF',
     1129                                                        'pattern'   => '^\\xFF\\xD8\\xFF',
    9411130                                                        'group'     => 'graphic',
    9421131                                                        'module'    => 'jpg',
     
    9481137                                // PCD  - still image - Kodak Photo CD
    9491138                                'pcd'  => array(
    950                                                         'pattern'   => '^.{2048}PCD_IPI\x00',
     1139                                                        'pattern'   => '^.{2048}PCD_IPI\\x00',
    9511140                                                        'group'     => 'graphic',
    9521141                                                        'module'    => 'pcd',
     
    9591148                                // PNG  - still image - Portable Network Graphics (PNG)
    9601149                                'png'  => array(
    961                                                         'pattern'   => '^\x89\x50\x4E\x47\x0D\x0A\x1A\x0A',
     1150                                                        'pattern'   => '^\\x89\\x50\\x4E\\x47\\x0D\\x0A\\x1A\\x0A',
    9621151                                                        'group'     => 'graphic',
    9631152                                                        'module'    => 'png',
     
    9701159                                // SVG  - still image - Scalable Vector Graphics (SVG)
    9711160                                'svg'  => array(
    972                                                         'pattern'   => '(<!DOCTYPE svg PUBLIC |xmlns="http:\/\/www\.w3\.org\/2000\/svg")',
     1161                                                        'pattern'   => '(<!DOCTYPE svg PUBLIC |xmlns="http://www\\.w3\\.org/2000/svg")',
    9731162                                                        'group'     => 'graphic',
    9741163                                                        'module'    => 'svg',
     
    9811170                                // TIFF - still image - Tagged Information File Format (TIFF)
    9821171                                'tiff' => array(
    983                                                         'pattern'   => '^(II\x2A\x00|MM\x00\x2A)',
     1172                                                        'pattern'   => '^(II\\x2A\\x00|MM\\x00\\x2A)',
    9841173                                                        'group'     => 'graphic',
    9851174                                                        'module'    => 'tiff',
     
    9921181                                // EFAX - still image - eFax (TIFF derivative)
    9931182                                'efax'  => array(
    994                                                         'pattern'   => '^\xDC\xFE',
     1183                                                        'pattern'   => '^\\xDC\\xFE',
    9951184                                                        'group'     => 'graphic',
    9961185                                                        'module'    => 'efax',
     
    10161205                                // RAR  - data        - RAR compressed data
    10171206                                'rar'  => array(
    1018                                                         'pattern'   => '^Rar\!',
     1207                                                        'pattern'   => '^Rar\\!',
    10191208                                                        'group'     => 'archive',
    10201209                                                        'module'    => 'rar',
     
    10261215                                // SZIP - audio/data  - SZIP compressed data
    10271216                                'szip' => array(
    1028                                                         'pattern'   => '^SZ\x0A\x04',
     1217                                                        'pattern'   => '^SZ\\x0A\\x04',
    10291218                                                        'group'     => 'archive',
    10301219                                                        'module'    => 'szip',
     
    10361225                                // TAR  - data        - TAR compressed data
    10371226                                'tar'  => array(
    1038                                                         'pattern'   => '^.{100}[0-9\x20]{7}\x00[0-9\x20]{7}\x00[0-9\x20]{7}\x00[0-9\x20\x00]{12}[0-9\x20\x00]{12}',
     1227                                                        'pattern'   => '^.{100}[0-9\\x20]{7}\\x00[0-9\\x20]{7}\\x00[0-9\\x20]{7}\\x00[0-9\\x20\\x00]{12}[0-9\\x20\\x00]{12}',
    10391228                                                        'group'     => 'archive',
    10401229                                                        'module'    => 'tar',
     
    10461235                                // GZIP  - data        - GZIP compressed data
    10471236                                'gz'  => array(
    1048                                                         'pattern'   => '^\x1F\x8B\x08',
     1237                                                        'pattern'   => '^\\x1F\\x8B\\x08',
    10491238                                                        'group'     => 'archive',
    10501239                                                        'module'    => 'gzip',
    1051                                                         'mime_type' => 'application/x-gzip',
     1240                                                        'mime_type' => 'application/gzip',
    10521241                                                        'fail_id3'  => 'ERROR',
    10531242                                                        'fail_ape'  => 'ERROR',
     
    10561245                                // ZIP  - data         - ZIP compressed data
    10571246                                'zip'  => array(
    1058                                                         'pattern'   => '^PK\x03\x04',
     1247                                                        'pattern'   => '^PK\\x03\\x04',
    10591248                                                        'group'     => 'archive',
    10601249                                                        'module'    => 'zip',
     
    10691258                                // PAR2 - data        - Parity Volume Set Specification 2.0
    10701259                                'par2' => array (
    1071                                                         'pattern'   => '^PAR2\x00PKT',
     1260                                                        'pattern'   => '^PAR2\\x00PKT',
    10721261                                                        'group'     => 'misc',
    10731262                                                        'module'    => 'par2',
     
    10791268                                // PDF  - data        - Portable Document Format
    10801269                                'pdf'  => array(
    1081                                                         'pattern'   => '^\x25PDF',
     1270                                                        'pattern'   => '^\\x25PDF',
    10821271                                                        'group'     => 'misc',
    10831272                                                        'module'    => 'pdf',
     
    10891278                                // MSOFFICE  - data   - ZIP compressed data
    10901279                                'msoffice' => array(
    1091                                                         'pattern'   => '^\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1', // D0CF11E == DOCFILE == Microsoft Office Document
     1280                                                        'pattern'   => '^\\xD0\\xCF\\x11\\xE0\\xA1\\xB1\\x1A\\xE1', // D0CF11E == DOCFILE == Microsoft Office Document
    10921281                                                        'group'     => 'misc',
    10931282                                                        'module'    => 'msoffice',
     
    11111300        }
    11121301
    1113 
    1114 
     1302        /**
     1303         * @param string $filedata
     1304         * @param string $filename
     1305         *
     1306         * @return mixed|false
     1307         */
    11151308        public function GetFileFormat(&$filedata, $filename='') {
    11161309                // this function will determine the format of a file based on usually
     
    11301323
    11311324
    1132                 if (preg_match('#\.mp[123a]$#i', $filename)) {
     1325                if (preg_match('#\\.mp[123a]$#i', $filename)) {
    11331326                        // Too many mp3 encoders on the market put gabage in front of mpeg files
    11341327                        // use assume format on these if format detection failed
     
    11371330                        $info['include'] = 'module.'.$info['group'].'.'.$info['module'].'.php';
    11381331                        return $info;
    1139                 } elseif (preg_match('/\.cue$/i', $filename) && preg_match('#FILE "[^"]+" (BINARY|MOTOROLA|AIFF|WAVE|MP3)#', $filedata)) {
     1332                } elseif (preg_match('#\\.cue$#i', $filename) && preg_match('#FILE "[^"]+" (BINARY|MOTOROLA|AIFF|WAVE|MP3)#', $filedata)) {
    11401333                        // there's not really a useful consistent "magic" at the beginning of .cue files to identify them
    11411334                        // so until I think of something better, just go by filename if all other format checks fail
     
    11501343        }
    11511344
    1152 
    1153         // 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         */
    11541351        public function CharConvert(&$array, $encoding) {
    11551352
     
    11741371        }
    11751372
    1176 
     1373        /**
     1374         * @return bool
     1375         */
    11771376        public function HandleAllTags() {
    11781377
     
    12381437                                }
    12391438
     1439                                $this->CharConvert($this->info['tags'][$tag_name], $this->info[$comment_name]['encoding']);           // only copy gets converted!
     1440
    12401441                                if ($this->option_tags_html) {
    12411442                                        foreach ($this->info['tags'][$tag_name] as $tag_key => $valuearray) {
    1242                                                 $this->info['tags_html'][$tag_name][$tag_key] = getid3_lib::recursiveMultiByteCharString2HTML($valuearray, $encoding);
     1443                                                $this->info['tags_html'][$tag_name][$tag_key] = getid3_lib::recursiveMultiByteCharString2HTML($valuearray, $this->info[$comment_name]['encoding']);
    12431444                                        }
    12441445                                }
    12451446
    1246                                 // ID3v1 encoding detection hack start
    1247                                 // ID3v1 is defined as always using ISO-8859-1 encoding, but it is not uncommon to find files tagged with ID3v1 using Windows-1251 or other character sets
    1248                                 // Since ID3v1 has no concept of character sets there is no certain way to know we have the correct non-ISO-8859-1 character set, but we can guess
    1249                                 if ($comment_name == 'id3v1') {
    1250                                         if ($encoding == 'ISO-8859-1') {
    1251                                                 if (function_exists('iconv')) {
    1252                                                         foreach ($this->info['tags'][$tag_name] as $tag_key => $valuearray) {
    1253                                                                 foreach ($valuearray as $key => $value) {
    1254                                                                         if (preg_match('#^[\\x80-\\xFF]+$#', $value)) {
    1255                                                                                 foreach (array('windows-1251', 'KOI8-R') as $id3v1_bad_encoding) {
    1256                                                                                         if (@iconv($id3v1_bad_encoding, $id3v1_bad_encoding, $value) === $value) {
    1257                                                                                                 $encoding = $id3v1_bad_encoding;
    1258                                                                                                 break 3;
    1259                                                                                         }
    1260                                                                                 }
    1261                                                                         }
    1262                                                                 }
    1263                                                         }
    1264                                                 }
    1265                                         }
    1266                                 }
    1267                                 // ID3v1 encoding detection hack end
    1268 
    1269                                 $this->CharConvert($this->info['tags'][$tag_name], $encoding);           // only copy gets converted!
    12701447                        }
    12711448
     
    13191496        }
    13201497
     1498        /**
     1499         * @param string $algorithm
     1500         *
     1501         * @return array|bool
     1502         */
    13211503        public function getHashdata($algorithm) {
    13221504                switch ($algorithm) {
     
    13831565                                } else {
    13841566
    1385                                         $commandline = 'vorbiscomment -w -c "'.$empty.'" "'.$file.'" "'.$temp.'" 2>&1';
    13861567                                        $commandline = 'vorbiscomment -w -c '.escapeshellarg($empty).' '.escapeshellarg($file).' '.escapeshellarg($temp).' 2>&1';
    13871568                                        $VorbisCommentError = `$commandline`;
     
    13911572                                if (!empty($VorbisCommentError)) {
    13921573
    1393                                         $this->info['warning'][]         = 'Failed making system call to vorbiscomment(.exe) - '.$algorithm.'_data will be incorrect. If vorbiscomment is unavailable, please download from http://www.vorbis.com/download.psp and put in the getID3() directory. Error returned: '.$VorbisCommentError;
    1394                                         $this->info[$algorithm.'_data']  = false;
     1574                                        $this->warning('Failed making system call to vorbiscomment(.exe) - '.$algorithm.'_data will be incorrect. If vorbiscomment is unavailable, please download from http://www.vorbis.com/download.psp and put in the getID3() directory. Error returned: '.$VorbisCommentError);
     1575                                        $this->info[$algorithm.'_data'] = false;
    13951576
    13961577                                } else {
     
    14411622                return true;
    14421623        }
    1443 
    14441624
    14451625        public function ChannelsBitratePlaytimeCalculations() {
     
    15071687        }
    15081688
    1509 
     1689        /**
     1690         * @return bool
     1691         */
    15101692        public function CalculateCompressionRatioVideo() {
    15111693                if (empty($this->info['video'])) {
     
    15551737        }
    15561738
    1557 
     1739        /**
     1740         * @return bool
     1741         */
    15581742        public function CalculateCompressionRatioAudio() {
    15591743                if (empty($this->info['audio']['bitrate']) || empty($this->info['audio']['channels']) || empty($this->info['audio']['sample_rate']) || !is_numeric($this->info['audio']['sample_rate'])) {
     
    15721756        }
    15731757
    1574 
     1758        /**
     1759         * @return bool
     1760         */
    15751761        public function CalculateReplayGain() {
    15761762                if (isset($this->info['replay_gain'])) {
    15771763                        if (!isset($this->info['replay_gain']['reference_volume'])) {
    1578                                 $this->info['replay_gain']['reference_volume'] = (double) 89.0;
     1764                                $this->info['replay_gain']['reference_volume'] = 89.0;
    15791765                        }
    15801766                        if (isset($this->info['replay_gain']['track']['adjustment'])) {
     
    15951781        }
    15961782
     1783        /**
     1784         * @return bool
     1785         */
    15971786        public function ProcessAudioStreams() {
    15981787                if (!empty($this->info['audio']['bitrate']) || !empty($this->info['audio']['channels']) || !empty($this->info['audio']['sample_rate'])) {
     
    16081797        }
    16091798
     1799        /**
     1800         * @return string|bool
     1801         */
    16101802        public function getid3_tempnam() {
    16111803                return tempnam($this->tempdir, 'gI3');
    16121804        }
    16131805
     1806        /**
     1807         * @param string $name
     1808         *
     1809         * @return bool
     1810         *
     1811         * @throws getid3_exception
     1812         */
    16141813        public function include_module($name) {
    16151814                //if (!file_exists($this->include_path.'module.'.$name.'.php')) {
     
    16211820        }
    16221821
     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
    16231838}
    16241839
    16251840
    1626 abstract class getid3_handler {
     1841abstract class getid3_handler
     1842{
    16271843
    16281844        /**
     
    16311847        protected $getid3;                       // pointer
    16321848
    1633         protected $data_string_flag     = false; // analyzing filepointer or string
    1634         protected $data_string          = '';    // string to analyze
    1635         protected $data_string_position = 0;     // seek position in string
    1636         protected $data_string_length   = 0;     // string length
    1637 
    1638         private $dependency_to = null;
    1639 
    1640 
     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         */
    16411888        public function __construct(getID3 $getid3, $call_module=null) {
    16421889                $this->getid3 = $getid3;
     
    16471894        }
    16481895
    1649 
    1650         // Analyze from file pointer
     1896        /**
     1897         * Analyze from file pointer.
     1898         *
     1899         * @return bool
     1900         */
    16511901        abstract public function Analyze();
    16521902
    1653 
    1654         // Analyze from string instead
     1903        /**
     1904         * Analyze from string instead.
     1905         *
     1906         * @param string $string
     1907         */
    16551908        public function AnalyzeString($string) {
    16561909                // Enter string mode
     
    16781931        }
    16791932
     1933        /**
     1934         * @param string $string
     1935         */
    16801936        public function setStringMode($string) {
    16811937                $this->data_string_flag   = true;
     
    16841940        }
    16851941
     1942        /**
     1943         * @return int|bool
     1944         */
    16861945        protected function ftell() {
    16871946                if ($this->data_string_flag) {
     
    16911950        }
    16921951
     1952        /**
     1953         * @param int $bytes
     1954         *
     1955         * @return string|false
     1956         *
     1957         * @throws getid3_exception
     1958         */
    16931959        protected function fread($bytes) {
    16941960                if ($this->data_string_flag) {
     
    17001966                        throw new getid3_exception('cannot fread('.$bytes.' from '.$this->ftell().') because beyond PHP filesystem limit', 10);
    17011967                }
    1702                 return fread($this->getid3->fp, $bytes);
    1703         }
    1704 
     1968
     1969                //return fread($this->getid3->fp, $bytes);
     1970                /*
     1971                * https://www.getid3.org/phpBB3/viewtopic.php?t=1930
     1972                * "I found out that the root cause for the problem was how getID3 uses the PHP system function fread().
     1973                * It seems to assume that fread() would always return as many bytes as were requested.
     1974                * However, according the PHP manual (http://php.net/manual/en/function.fread.php), this is the case only with regular local files, but not e.g. with Linux pipes.
     1975                * The call may return only part of the requested data and a new call is needed to get more."
     1976                */
     1977                $contents = '';
     1978                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                        }
     1982                        $part = fread($this->getid3->fp, $bytes);
     1983                        $partLength  = strlen($part);
     1984                        $bytes      -= $partLength;
     1985                        $contents   .= $part;
     1986                } while (($bytes > 0) && ($partLength > 0));
     1987                return $contents;
     1988        }
     1989
     1990        /**
     1991         * @param int $bytes
     1992         * @param int $whence
     1993         *
     1994         * @return int
     1995         *
     1996         * @throws getid3_exception
     1997         */
    17051998        protected function fseek($bytes, $whence=SEEK_SET) {
    17061999                if ($this->data_string_flag) {
     
    17332026        }
    17342027
     2028        /**
     2029         * @return bool
     2030         */
    17352031        protected function feof() {
    17362032                if ($this->data_string_flag) {
     
    17402036        }
    17412037
     2038        /**
     2039         * @param string $module
     2040         *
     2041         * @return bool
     2042         */
    17422043        final protected function isDependencyFor($module) {
    17432044                return $this->dependency_to == $module;
    17442045        }
    17452046
     2047        /**
     2048         * @param string $text
     2049         *
     2050         * @return bool
     2051         */
    17462052        protected function error($text) {
    17472053                $this->getid3->info['error'][] = $text;
     
    17502056        }
    17512057
     2058        /**
     2059         * @param string $text
     2060         *
     2061         * @return bool
     2062         */
    17522063        protected function warning($text) {
    17532064                return $this->getid3->warning($text);
    17542065        }
    17552066
     2067        /**
     2068         * @param string $text
     2069         */
    17562070        protected function notice($text) {
    17572071                // does nothing for now
    17582072        }
    17592073
     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         */
    17602085        public function saveAttachment($name, $offset, $length, $image_mime=null) {
    17612086                try {
     
    17802105                                // set up destination path
    17812106                                $dir = rtrim(str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $this->getid3->option_save_attachments), DIRECTORY_SEPARATOR);
    1782                                 if (!is_dir($dir) || !is_writable($dir)) { // check supplied directory
     2107                                if (!is_dir($dir) || !getID3::is_writable($dir)) { // check supplied directory
    17832108                                        throw new Exception('supplied path ('.$dir.') does not exist, or is not writable');
    17842109                                }
     
    18112136                        if (isset($fp_dest) && is_resource($fp_dest)) {
    18122137                                fclose($fp_dest);
     2138                        }
     2139
     2140                        if (isset($dest) && file_exists($dest)) {
    18132141                                unlink($dest);
    18142142                        }
  • _core_/branches/spip-3.1/plugins/medias/lib/getid3/module.archive.gzip.php

    r92616 r113163  
    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;
     
    3847
    3948                if ($info['php_memory_limit'] && ($info['filesize'] > $info['php_memory_limit'])) {
    40                         $info['error'][] = 'File is too large ('.number_format($info['filesize']).' bytes) to read into memory (limit: '.number_format($info['php_memory_limit'] / 1048576).'MB)';
     49                        $this->error('File is too large ('.number_format($info['filesize']).' bytes) to read into memory (limit: '.number_format($info['php_memory_limit'] / 1048576).'MB)');
    4150                        return false;
    4251                }
     
    4554
    4655                $arr_members = explode("\x1F\x8B\x08", $buffer);
     56                $num_members = 0;
    4757                while (true) {
    4858                        $is_wrong_members = false;
     
    98108                        $thisInfo['os'] = $this->get_os_type($thisInfo['raw']['os']);
    99109                        if (!$thisInfo['os']) {
    100                                 $info['error'][] = 'Read error on gzip file';
     110                                $this->error('Read error on gzip file');
    101111                                return false;
    102112                        }
     
    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
     
    216226                                                                if (($temp_tar_filename = tempnam(GETID3_TEMP_DIR, 'getID3')) === false) {
    217227                                                                        // can't find anywhere to create a temp file, abort
    218                                                                         $info['error'][] = 'Unable to create temp file to parse TAR inside GZIP file';
     228                                                                        $this->error('Unable to create temp file to parse TAR inside GZIP file');
    219229                                                                        break;
    220230                                                                }
     
    230240                                                                        unlink($temp_tar_filename);
    231241                                                                } else {
    232                                                                         $info['error'][] = 'Unable to fopen() temp file to parse TAR inside GZIP file';
     242                                                                        $this->error('Unable to fopen() temp file to parse TAR inside GZIP file');
    233243                                                                        break;
    234244                                                                }
     
    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_/branches/spip-3.1/plugins/medias/lib/getid3/module.archive.rar.php

    r85814 r113163  
    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;
     
    3742                                        return true;
    3843                                } else {
    39                                         $info['error'][] = 'failed to rar_open('.$info['filename'].')';
     44                                        $this->error('failed to rar_open('.$info['filename'].')');
    4045                                }
    4146                        } else {
    42                                 $info['error'][] = 'RAR support does not appear to be available in this PHP installation';
     47                                $this->error('RAR support does not appear to be available in this PHP installation');
    4348                        }
    4449                } else {
    45                         $info['error'][] = 'PHP-RAR processing has been disabled (set $getid3_rar->option_use_rar_extension=true to enable)';
     50                        $this->error('PHP-RAR processing has been disabled (set $getid3_rar->option_use_rar_extension=true to enable)');
    4651                }
    4752                return false;
  • _core_/branches/spip-3.1/plugins/medias/lib/getid3/module.archive.szip.php

    r85814 r113163  
    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;
     
    2527                $SZIPHeader = $this->fread(6);
    2628                if (substr($SZIPHeader, 0, 4) != "SZ\x0A\x04") {
    27                         $info['error'][] = 'Expecting "53 5A 0A 04" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes(substr($SZIPHeader, 0, 4)).'"';
     29                        $this->error('Expecting "53 5A 0A 04" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes(substr($SZIPHeader, 0, 4)).'"');
    2830                        return false;
    2931                }
     
    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 $info['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_/branches/spip-3.1/plugins/medias/lib/getid3/module.archive.tar.php

    r85814 r113163  
    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_/branches/spip-3.1/plugins/medias/lib/getid3/module.archive.zip.php

    r85814 r113163  
    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;
     
    3133
    3234                if (!getid3_lib::intValueSupported($info['filesize'])) {
    33                         $info['error'][] = 'File is larger than '.round(PHP_INT_MAX / 1073741824).'GB, not supported by PHP';
     35                        $this->error('File is larger than '.round(PHP_INT_MAX / 1073741824).'GB, not supported by PHP');
    3436                        return false;
    3537                } else {
     
    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']++;
     
    6264
    6365                                        if ($info['zip']['entries_count'] == 0) {
    64                                                 $info['error'][] = 'No Central Directory entries found (truncated file?)';
     66                                                $this->error('No Central Directory entries found (truncated file?)');
    6567                                                return false;
    6668                                        }
     
    8789                                                        $info['zip']['entries'][] = $fileentry;
    8890                                                } else {
    89                                                         $info['warning'][] = 'Error parsing Local File Header at offset '.$central_directory_entry['entry_offset'];
     91                                                        $this->warning('Error parsing Local File Header at offset '.$central_directory_entry['entry_offset']);
    9092                                                }
    9193                                        }
     
    114116                        unset($info['zip']);
    115117                        $info['fileformat'] = '';
    116                         $info['error'][] = 'Cannot find End Of Central Directory (truncated file?)';
     118                        $this->error('Cannot find End Of Central Directory (truncated file?)');
    117119                        return false;
    118120                }
     
    121123                // scan through actual file data entries, recover as much as possible from probable trucated file
    122124                if ($info['zip']['compressed_size'] > ($info['filesize'] - 46 - 22)) {
    123                         $info['error'][] = 'Warning: Truncated file! - Total compressed file sizes ('.$info['zip']['compressed_size'].' bytes) is greater than filesize minus Central Directory and End Of Central Directory structures ('.($info['filesize'] - 46 - 22).' bytes)';
    124                 }
    125                 $info['error'][] = 'Cannot find End Of Central Directory - returned list of files in [zip][entries] array may not be complete';
     125                        $this->error('Warning: Truncated file! - Total compressed file sizes ('.$info['zip']['compressed_size'].' bytes) is greater than filesize minus Central Directory and End Of Central Directory structures ('.($info['filesize'] - 46 - 22).' bytes)');
     126                }
     127                $this->error('Cannot find End Of Central Directory - returned list of files in [zip][entries] array may not be complete');
    126128                foreach ($info['zip']['entries'] as $key => $valuearray) {
    127129                        $info['zip']['files'][$valuearray['filename']] = $valuearray['uncompressed_size'];
     
    130132        }
    131133
    132 
     134        /**
     135         * @return bool
     136         */
    133137        public function getZIPHeaderFilepointerTopDown() {
    134138                $info = &$this->getid3->info;
     
    146150                }
    147151                if ($info['zip']['entries_count'] == 0) {
    148                         $info['error'][] = 'No Local File Header entries found';
     152                        $this->error('No Local File Header entries found');
    149153                        return false;
    150154                }
    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']++;
     
    158162                }
    159163                if ($info['zip']['entries_count'] == 0) {
    160                         $info['error'][] = 'No Central Directory entries found (truncated file?)';
     164                        $this->error('No Central Directory entries found (truncated file?)');
    161165                        return false;
    162166                }
     
    165169                        $info['zip']['end_central_directory'] = $EOCD;
    166170                } else {
    167                         $info['error'][] = 'No End Of Central Directory entry found (truncated file?)';
     171                        $this->error('No End Of Central Directory entry found (truncated file?)');
    168172                        return false;
    169173                }
     
    176180        }
    177181
    178 
     182        /**
     183         * @return bool
     184         */
    179185        public function getZIPentriesFilepointer() {
    180186                $info = &$this->getid3->info;
     
    192198                }
    193199                if ($info['zip']['entries_count'] == 0) {
    194                         $info['error'][] = 'No Local File Header entries found';
     200                        $this->error('No Local File Header entries found');
    195201                        return false;
    196202                }
     
    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;
     
    279287                                                        // $LocalFileHeader['compressed_size'] already set from Central Directory
    280288                                                } else {
    281                                                         $this->getid3->info['warning'][] = 'conflicting compressed_size from data_descriptor ('.$LocalFileHeader['data_descriptor']['compressed_size'].') vs Central Directory ('.$central_directory_entry['compressed_size'].') for file at offset '.$LocalFileHeader['offset'];
     289                                                        $this->warning('conflicting compressed_size from data_descriptor ('.$LocalFileHeader['data_descriptor']['compressed_size'].') vs Central Directory ('.$central_directory_entry['compressed_size'].') for file at offset '.$LocalFileHeader['offset']);
    282290                                                }
    283291
     
    285293                                                        $LocalFileHeader['uncompressed_size'] = $LocalFileHeader['data_descriptor']['uncompressed_size'];
    286294                                                } else {
    287                                                         $this->getid3->info['warning'][] = 'conflicting uncompressed_size from data_descriptor ('.$LocalFileHeader['data_descriptor']['uncompressed_size'].') vs Central Directory ('.$central_directory_entry['uncompressed_size'].') for file at offset '.$LocalFileHeader['offset'];
     295                                                        $this->warning('conflicting uncompressed_size from data_descriptor ('.$LocalFileHeader['data_descriptor']['uncompressed_size'].') vs Central Directory ('.$central_directory_entry['uncompressed_size'].') for file at offset '.$LocalFileHeader['offset']);
    288296                                                }
    289297                                                break;
     
    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_/branches/spip-3.1/plugins/medias/lib/getid3/module.audio-video.asf.php

    r96229 r113163  
    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++) {
     
    267274                                        $thisfile_asf_headerextensionobject['reserved_1_guid']     = $this->BytestringToGUID($thisfile_asf_headerextensionobject['reserved_1']);
    268275                                        if ($thisfile_asf_headerextensionobject['reserved_1'] != GETID3_ASF_Reserved_1) {
    269                                                 $info['warning'][] = 'header_extension_object.reserved_1 GUID ('.$this->BytestringToGUID($thisfile_asf_headerextensionobject['reserved_1']).') does not match expected "GETID3_ASF_Reserved_1" GUID ('.$this->BytestringToGUID(GETID3_ASF_Reserved_1).')';
     276                                                $this->warning('header_extension_object.reserved_1 GUID ('.$this->BytestringToGUID($thisfile_asf_headerextensionobject['reserved_1']).') does not match expected "GETID3_ASF_Reserved_1" GUID ('.$this->BytestringToGUID(GETID3_ASF_Reserved_1).')');
    270277                                                //return false;
    271278                                                break;
     
    274281                                        $offset += 2;
    275282                                        if ($thisfile_asf_headerextensionobject['reserved_2'] != 6) {
    276                                                 $info['warning'][] = 'header_extension_object.reserved_2 ('.getid3_lib::PrintHexBytes($thisfile_asf_headerextensionobject['reserved_2']).') does not match expected value of "6"';
     283                                                $this->warning('header_extension_object.reserved_2 ('.getid3_lib::PrintHexBytes($thisfile_asf_headerextensionobject['reserved_2']).') does not match expected value of "6"');
    277284                                                //return false;
    278285                                                break;
     
    317324                                        $thisfile_asf_codeclistobject['reserved_guid']             = $this->BytestringToGUID($thisfile_asf_codeclistobject['reserved']);
    318325                                        if ($thisfile_asf_codeclistobject['reserved'] != $this->GUIDtoBytestring('86D15241-311D-11D0-A3A4-00A0C90348F6')) {
    319                                                 $info['warning'][] = 'codec_list_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_codeclistobject['reserved']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {86D15241-311D-11D0-A3A4-00A0C90348F6}';
     326                                                $this->warning('codec_list_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_codeclistobject['reserved']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {86D15241-311D-11D0-A3A4-00A0C90348F6}');
    320327                                                //return false;
    321328                                                break;
     
    350357
    351358                                                        if (strpos($thisfile_asf_codeclistobject_codecentries_current['description'], ',') === false) {
    352                                                                 $info['warning'][] = '[asf][codec_list_object][codec_entries]['.$CodecEntryCounter.'][description] expected to contain comma-seperated list of parameters: "'.$thisfile_asf_codeclistobject_codecentries_current['description'].'"';
     359                                                                $this->warning('[asf][codec_list_object][codec_entries]['.$CodecEntryCounter.'][description] expected to contain comma-separated list of parameters: "'.$thisfile_asf_codeclistobject_codecentries_current['description'].'"');
    353360                                                        } else {
    354361
     
    413420
    414421                                                                        default:
    415                                                                                 $info['warning'][] = 'unknown frequency: "'.$AudioCodecFrequency.'" ('.$this->TrimConvert($thisfile_asf_codeclistobject_codecentries_current['description']).')';
     422                                                                                $this->warning('unknown frequency: "'.$AudioCodecFrequency.'" ('.$this->TrimConvert($thisfile_asf_codeclistobject_codecentries_current['description']).')');
    416423                                                                                break;
    417424                                                                }
     
    459466                                        $thisfile_asf_scriptcommandobject['reserved_guid']        = $this->BytestringToGUID($thisfile_asf_scriptcommandobject['reserved']);
    460467                                        if ($thisfile_asf_scriptcommandobject['reserved'] != $this->GUIDtoBytestring('4B1ACBE3-100B-11D0-A39B-00A0C90348F6')) {
    461                                                 $info['warning'][] = 'script_command_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_scriptcommandobject['reserved']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {4B1ACBE3-100B-11D0-A39B-00A0C90348F6}';
     468                                                $this->warning('script_command_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_scriptcommandobject['reserved']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {4B1ACBE3-100B-11D0-A39B-00A0C90348F6}');
    462469                                                //return false;
    463470                                                break;
     
    518525                                        $thisfile_asf_markerobject['reserved_guid']        = $this->BytestringToGUID($thisfile_asf_markerobject['reserved']);
    519526                                        if ($thisfile_asf_markerobject['reserved'] != $this->GUIDtoBytestring('4CFEDB20-75F6-11CF-9C0F-00A0C90349CB')) {
    520                                                 $info['warning'][] = 'marker_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_markerobject['reserved_1']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {4CFEDB20-75F6-11CF-9C0F-00A0C90349CB}';
     527                                                $this->warning('marker_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_markerobject['reserved_1']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {4CFEDB20-75F6-11CF-9C0F-00A0C90349CB}');
    521528                                                break;
    522529                                        }
     
    526533                                        $offset += 2;
    527534                                        if ($thisfile_asf_markerobject['reserved_2'] != 0) {
    528                                                 $info['warning'][] = 'marker_object.reserved_2 ('.getid3_lib::PrintHexBytes($thisfile_asf_markerobject['reserved_2']).') does not match expected value of "0"';
     535                                                $this->warning('marker_object.reserved_2 ('.getid3_lib::PrintHexBytes($thisfile_asf_markerobject['reserved_2']).') does not match expected value of "0"');
    529536                                                break;
    530537                                        }
     
    577584                                        $offset += 16;
    578585                                        if (($thisfile_asf_bitratemutualexclusionobject['reserved'] != GETID3_ASF_Mutex_Bitrate) && ($thisfile_asf_bitratemutualexclusionobject['reserved'] != GETID3_ASF_Mutex_Unknown)) {
    579                                                 $info['warning'][] = 'bitrate_mutual_exclusion_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_bitratemutualexclusionobject['reserved']).'} does not match expected "GETID3_ASF_Mutex_Bitrate" GUID {'.$this->BytestringToGUID(GETID3_ASF_Mutex_Bitrate).'} or  "GETID3_ASF_Mutex_Unknown" GUID {'.$this->BytestringToGUID(GETID3_ASF_Mutex_Unknown).'}';
     586                                                $this->warning('bitrate_mutual_exclusion_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_bitratemutualexclusionobject['reserved']).'} does not match expected "GETID3_ASF_Mutex_Bitrate" GUID {'.$this->BytestringToGUID(GETID3_ASF_Mutex_Bitrate).'} or  "GETID3_ASF_Mutex_Unknown" GUID {'.$this->BytestringToGUID(GETID3_ASF_Mutex_Unknown).'}');
    580587                                                //return false;
    581588                                                break;
     
    638645
    639646                                                default:
    640                                                         $info['warning'][] = 'error_correction_object.error_correction_type GUID {'.$this->BytestringToGUID($thisfile_asf_errorcorrectionobject['reserved']).'} does not match expected "GETID3_ASF_No_Error_Correction" GUID {'.$this->BytestringToGUID(GETID3_ASF_No_Error_Correction).'} or  "GETID3_ASF_Audio_Spread" GUID {'.$this->BytestringToGUID(GETID3_ASF_Audio_Spread).'}';
     647                                                        $this->warning('error_correction_object.error_correction_type GUID {'.$this->BytestringToGUID($thisfile_asf_errorcorrectionobject['reserved']).'} does not match expected "GETID3_ASF_No_Error_Correction" GUID {'.$this->BytestringToGUID(GETID3_ASF_No_Error_Correction).'} or  "GETID3_ASF_Audio_Spread" GUID {'.$this->BytestringToGUID(GETID3_ASF_Audio_Spread).'}');
    641648                                                        //return false;
    642649                                                        break;
     
    762769
    763770                                                        default:
    764                                                                 $info['warning'][] = 'extended_content_description.content_descriptors.'.$ExtendedContentDescriptorsCounter.'.value_type is invalid ('.$thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_type'].')';
     771                                                                $this->warning('extended_content_description.content_descriptors.'.$ExtendedContentDescriptorsCounter.'.value_type is invalid ('.$thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_type'].')');
    765772                                                                //return false;
    766773                                                                break;
     
    963970                                        // Implementations shall ignore any standard or non-standard object that they do not know how to handle.
    964971                                        if ($this->GUIDname($NextObjectGUIDtext)) {
    965                                                 $info['warning'][] = 'unhandled GUID "'.$this->GUIDname($NextObjectGUIDtext).'" {'.$NextObjectGUIDtext.'} in ASF header at offset '.($offset - 16 - 8);
     972                                                $this->warning('unhandled GUID "'.$this->GUIDname($NextObjectGUIDtext).'" {'.$NextObjectGUIDtext.'} in ASF header at offset '.($offset - 16 - 8));
    966973                                        } else {
    967                                                 $info['warning'][] = 'unknown GUID {'.$NextObjectGUIDtext.'} in ASF header at offset '.($offset - 16 - 8);
     974                                                $this->warning('unknown GUID {'.$NextObjectGUIDtext.'} in ASF header at offset '.($offset - 16 - 8));
    968975                                        }
    969976                                        $offset += ($NextObjectSize - 16 - 8);
     
    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
     
    11841191                                        $offset += 2;
    11851192                                        if ($thisfile_asf_dataobject['reserved'] != 0x0101) {
    1186                                                 $info['warning'][] = 'data_object.reserved ('.getid3_lib::PrintHexBytes($thisfile_asf_dataobject['reserved']).') does not match expected value of "0x0101"';
     1193                                                $this->warning('data_object.reserved ('.getid3_lib::PrintHexBytes($thisfile_asf_dataobject['reserved']).') does not match expected value of "0x0101"');
    11871194                                                //return false;
    11881195                                                break;
     
    13201327                                        // Implementations shall ignore any standard or non-standard object that they do not know how to handle.
    13211328                                        if ($this->GUIDname($NextObjectGUIDtext)) {
    1322                                                 $info['warning'][] = 'unhandled GUID "'.$this->GUIDname($NextObjectGUIDtext).'" {'.$NextObjectGUIDtext.'} in ASF body at offset '.($offset - 16 - 8);
     1329                                                $this->warning('unhandled GUID "'.$this->GUIDname($NextObjectGUIDtext).'" {'.$NextObjectGUIDtext.'} in ASF body at offset '.($offset - 16 - 8));
    13231330                                        } else {
    1324                                                 $info['warning'][] = 'unknown GUID {'.$NextObjectGUIDtext.'} in ASF body at offset '.($this->ftell() - 16 - 8);
     1331                                                $this->warning('unknown GUID {'.$NextObjectGUIDtext.'} in ASF body at offset '.($this->ftell() - 16 - 8));
    13251332                                        }
    13261333                                        $this->fseek(($NextObjectSize - 16 - 8), SEEK_CUR);
     
    14061413
    14071414                                        default:
    1408                                                 $info['warning'][] = 'Unknown streamtype: [codec_list_object][codec_entries]['.$streamnumber.'][type_raw] == '.$streamdata['type_raw'];
     1415                                                $this->warning('Unknown streamtype: [codec_list_object][codec_entries]['.$streamnumber.'][type_raw] == '.$streamdata['type_raw']);
    14091416                                                break;
    14101417
     
    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
     
    19181970                                        $unhandled_sections++;
    19191971                                        if ($this->GUIDname($thisObject['guid_text'])) {
    1920                                                 $this->getid3->info['warning'][] = 'unhandled Header Extension Object GUID "'.$this->GUIDname($thisObject['guid_text']).'" {'.$thisObject['guid_text'].'} at offset '.($offset - 16 - 8);
     1972                                                $this->warning('unhandled Header Extension Object GUID "'.$this->GUIDname($thisObject['guid_text']).'" {'.$thisObject['guid_text'].'} at offset '.($offset - 16 - 8));
    19211973                                        } else {
    1922                                                 $this->getid3->info['warning'][] = 'unknown Header Extension Object GUID {'.$thisObject['guid_text'].'} in at offset '.($offset - 16 - 8);
     1974                                                $this->warning('unknown Header Extension Object GUID {'.$thisObject['guid_text'].'} in at offset '.($offset - 16 - 8));
    19231975                                        }
    19241976                                        break;
     
    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_/branches/spip-3.1/plugins/medias/lib/getid3/module.audio-video.bink.php

    r85814 r113163  
    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 $info['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']);
     
    3637
    3738                        default:
    38                                 $info['error'][] = 'Expecting "BIK" or "SMK" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes($fileTypeID).'"';
     39                                $this->error('Expecting "BIK" or "SMK" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes($fileTypeID).'"');
    3940                                return false;
    4041                                break;
     
    4546        }
    4647
     48        /**
     49         * @return bool
     50         */
    4751        public function ParseBink() {
    4852                $info = &$this->getid3->info;
     
    5660
    5761                if (($info['avdataend'] - $info['avdataoffset']) != ($info['bink']['data_size'] + 8)) {
    58                         $info['error'][] = 'Probably truncated file: expecting '.$info['bink']['data_size'].' bytes, found '.($info['avdataend'] - $info['avdataoffset']);
     62                        $this->error('Probably truncated file: expecting '.$info['bink']['data_size'].' bytes, found '.($info['avdataend'] - $info['avdataoffset']));
    5963                }
    6064
     
    6266        }
    6367
     68        /**
     69         * @return bool
     70         */
    6471        public function ParseSmacker() {
    6572                $info = &$this->getid3->info;
  • _core_/branches/spip-3.1/plugins/medias/lib/getid3/module.audio-video.flv.php

    r92616 r113163  
    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;
     
    94104
    95105                if ($info['flv']['header']['signature'] != self::magic) {
    96                         $info['error'][] = 'Expecting "'.getid3_lib::PrintHexBytes(self::magic).'" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes($info['flv']['header']['signature']).'"';
     106                        $this->error('Expecting "'.getid3_lib::PrintHexBytes(self::magic).'" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes($info['flv']['header']['signature']).'"');
    97107                        unset($info['flv'], $info['fileformat']);
    98108                        return false;
     
    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_/branches/spip-3.1/plugins/medias/lib/getid3/module.audio-video.matroska.php

    r96229 r113163  
    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        {
     
    235251                        $this->parseEBML($info);
    236252                } catch (Exception $e) {
    237                         $info['error'][] = 'EBML parser: '.$e->getMessage();
     253                        $this->error('EBML parser: '.$e->getMessage());
    238254                }
    239255
     
    331347
    332348                                                        case 'A_AC3':
     349                                                        case 'A_EAC3':
    333350                                                        case 'A_DTS':
    334351                                                        case 'A_MPEG/L3':
    335352                                                        case 'A_MPEG/L2':
    336353                                                        case 'A_FLAC':
    337                                                                 getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.'.($track_info['dataformat'] == 'mp2' ? 'mp3' : $track_info['dataformat']).'.php', __FILE__, true);
     354                                                                $module_dataformat = ($track_info['dataformat'] == 'mp2' ? 'mp3' : ($track_info['dataformat'] == 'eac3' ? 'ac3' : $track_info['dataformat']));
     355                                                                getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.'.$module_dataformat.'.php', __FILE__, true);
    338356
    339357                                                                if (!isset($info['matroska']['track_data_offsets'][$trackarray['TrackNumber']])) {
     
    353371
    354372                                                                // analyze
    355                                                                 $class = 'getid3_'.($track_info['dataformat'] == 'mp2' ? 'mp3' : $track_info['dataformat']);
     373                                                                $class = 'getid3_'.$module_dataformat;
    356374