Changeset 71835 in spip-zone for _plugins_/getID3


Ignore:
Timestamp:
Apr 9, 2013, 2:06:07 PM (6 years ago)
Author:
kent1@…
Message:

Upgrade de la lib en 1.9.5

Voir le changelog : http://www.getid3.org/source/changelog.txt

Location:
_plugins_/getID3/trunk/getid3
Files:
2 added
70 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/getID3/trunk/getid3/extension.cache.dbm.php

    r62460 r71835  
    7474
    7575        // public: constructor - see top of this file for cache type and cache_options
    76         function getID3_cached_dbm($cache_type, $dbm_filename, $lock_filename) {
     76        public function getID3_cached_dbm($cache_type, $dbm_filename, $lock_filename) {
    7777
    7878                // Check for dba extension
     
    141141
    142142
    143         // public: destuctor
    144         function __destruct() {
     143        // public: destructor
     144        public function __destruct() {
    145145
    146146                // Close dbm file
     
    157157
    158158        // public: clear cache
    159         function clear_cache() {
     159        public function clear_cache() {
    160160
    161161                // Close dbm file
     
    179179
    180180        // public: analyze file
    181         function analyze($filename) {
     181        public function analyze($filename) {
    182182
    183183                if (file_exists($filename)) {
     
    207207
    208208}
    209 
    210 
    211 ?>
  • _plugins_/getID3/trunk/getid3/extension.cache.mysql.php

    r62460 r71835  
    7575
    7676        // private vars
    77         var $cursor;
    78         var $connection;
     77        private $cursor;
     78        private $connection;
    7979
    8080
    8181        // public: constructor - see top of this file for cache type and cache_options
    82         function getID3_cached_mysql($host, $database, $username, $password, $table='getid3_cache') {
     82        public function getID3_cached_mysql($host, $database, $username, $password, $table='getid3_cache') {
    8383
    8484                // Check for mysql support
     
    119119
    120120        // public: clear cache
    121         function clear_cache() {
     121        public function clear_cache() {
    122122
    123123                $this->cursor = mysql_query("DELETE FROM `".mysql_real_escape_string($this->table)."`", $this->connection);
     
    128128
    129129        // public: analyze file
    130         function analyze($filename) {
     130        public function analyze($filename) {
    131131
    132132                if (file_exists($filename)) {
     
    158158
    159159        // private: (re)create sql table
    160         function create_table($drop=false) {
     160        private function create_table($drop=false) {
    161161
    162162                $this->cursor = mysql_query("CREATE TABLE IF NOT EXISTS `".mysql_real_escape_string($this->table)."` (
     
    166166                        `analyzetime` INT(11) NOT NULL DEFAULT '0',
    167167                        `value` TEXT NOT NULL,
    168                         PRIMARY KEY (`filename`,`filesize`,`filetime`)) TYPE=MyISAM", $this->connection);
     168                        PRIMARY KEY (`filename`,`filesize`,`filetime`)) ENGINE=MyISAM", $this->connection);
    169169                echo mysql_error($this->connection);
    170170        }
    171171}
    172 
    173 ?>
  • _plugins_/getID3/trunk/getid3/getid3.lib.php

    r62460 r71835  
    1515{
    1616
    17         static function PrintHexBytes($string, $hex=true, $spaces=true, $htmlencoding='UTF-8') {
     17        public static function PrintHexBytes($string, $hex=true, $spaces=true, $htmlencoding='UTF-8') {
    1818                $returnstring = '';
    1919                for ($i = 0; $i < strlen($string); $i++) {
     
    3636        }
    3737
    38         static function trunc($floatnumber) {
     38        public static function trunc($floatnumber) {
    3939                // truncates a floating-point number at the decimal point
    4040                // returns int (if possible, otherwise float)
     
    4646                        $truncatednumber = 0;
    4747                }
    48                 if (getid3_lib::intValueSupported($truncatednumber)) {
     48                if (self::intValueSupported($truncatednumber)) {
    4949                        $truncatednumber = (int) $truncatednumber;
    5050                }
     
    5353
    5454
    55         static function safe_inc(&$variable, $increment=1) {
     55        public static function safe_inc(&$variable, $increment=1) {
    5656                if (isset($variable)) {
    5757                        $variable += $increment;
     
    6262        }
    6363
    64         static function CastAsInt($floatnum) {
     64        public static function CastAsInt($floatnum) {
    6565                // convert to float if not already
    6666                $floatnum = (float) $floatnum;
    6767
    6868                // convert a float to type int, only if possible
    69                 if (getid3_lib::trunc($floatnum) == $floatnum) {
     69                if (self::trunc($floatnum) == $floatnum) {
    7070                        // it's not floating point
    71                         if (getid3_lib::intValueSupported($floatnum)) {
     71                        if (self::intValueSupported($floatnum)) {
    7272                                // it's within int range
    7373                                $floatnum = (int) $floatnum;
     
    9393        }
    9494
    95         static function DecimalizeFraction($fraction) {
     95        public static function DecimalizeFraction($fraction) {
    9696                list($numerator, $denominator) = explode('/', $fraction);
    9797                return $numerator / ($denominator ? $denominator : 1);
     
    9999
    100100
    101         static function DecimalBinary2Float($binarynumerator) {
    102                 $numerator   = getid3_lib::Bin2Dec($binarynumerator);
    103                 $denominator = getid3_lib::Bin2Dec('1'.str_repeat('0', strlen($binarynumerator)));
     101        public static function DecimalBinary2Float($binarynumerator) {
     102                $numerator   = self::Bin2Dec($binarynumerator);
     103                $denominator = self::Bin2Dec('1'.str_repeat('0', strlen($binarynumerator)));
    104104                return ($numerator / $denominator);
    105105        }
    106106
    107107
    108         static function NormalizeBinaryPoint($binarypointnumber, $maxbits=52) {
     108        public static function NormalizeBinaryPoint($binarypointnumber, $maxbits=52) {
    109109                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
    110110                if (strpos($binarypointnumber, '.') === false) {
     
    130130
    131131
    132         static function Float2BinaryDecimal($floatvalue) {
     132        public static function Float2BinaryDecimal($floatvalue) {
    133133                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
    134134                $maxbits = 128; // to how many bits of precision should the calculations be taken?
    135                 $intpart   = getid3_lib::trunc($floatvalue);
     135                $intpart   = self::trunc($floatvalue);
    136136                $floatpart = abs($floatvalue - $intpart);
    137137                $pointbitstring = '';
    138138                while (($floatpart != 0) && (strlen($pointbitstring) < $maxbits)) {
    139139                        $floatpart *= 2;
    140                         $pointbitstring .= (string) getid3_lib::trunc($floatpart);
    141                         $floatpart -= getid3_lib::trunc($floatpart);
     140                        $pointbitstring .= (string) self::trunc($floatpart);
     141                        $floatpart -= self::trunc($floatpart);
    142142                }
    143143                $binarypointnumber = decbin($intpart).'.'.$pointbitstring;
     
    146146
    147147
    148         static function Float2String($floatvalue, $bits) {
     148        public static function Float2String($floatvalue, $bits) {
    149149                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
    150150                switch ($bits) {
     
    168168                        $signbit = '1';
    169169                }
    170                 $normalizedbinary  = getid3_lib::NormalizeBinaryPoint(getid3_lib::Float2BinaryDecimal($floatvalue), $fractionbits);
     170                $normalizedbinary  = self::NormalizeBinaryPoint(self::Float2BinaryDecimal($floatvalue), $fractionbits);
    171171                $biasedexponent    = pow(2, $exponentbits - 1) - 1 + $normalizedbinary['exponent']; // (127 or 1023) +/- exponent
    172172                $exponentbitstring = str_pad(decbin($biasedexponent), $exponentbits, '0', STR_PAD_LEFT);
    173173                $fractionbitstring = str_pad(substr($normalizedbinary['normalized'], 2), $fractionbits, '0', STR_PAD_RIGHT);
    174174
    175                 return getid3_lib::BigEndian2String(getid3_lib::Bin2Dec($signbit.$exponentbitstring.$fractionbitstring), $bits % 8, false);
    176         }
    177 
    178 
    179         static function LittleEndian2Float($byteword) {
    180                 return getid3_lib::BigEndian2Float(strrev($byteword));
    181         }
    182 
    183 
    184         static function BigEndian2Float($byteword) {
     175                return self::BigEndian2String(self::Bin2Dec($signbit.$exponentbitstring.$fractionbitstring), $bits % 8, false);
     176        }
     177
     178
     179        public static function LittleEndian2Float($byteword) {
     180                return self::BigEndian2Float(strrev($byteword));
     181        }
     182
     183
     184        public static function BigEndian2Float($byteword) {
    185185                // ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
    186186                // http://www.psc.edu/general/software/packages/ieee/ieee.html
    187187                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
    188188
    189                 $bitword = getid3_lib::BigEndian2Bin($byteword);
     189                $bitword = self::BigEndian2Bin($byteword);
    190190                if (!$bitword) {
    191191                        return 0;
     
    210210                                $isnormalized = intval($bitword{16});
    211211                                $fractionstring = substr($bitword, 17, 63);
    212                                 $exponent = pow(2, getid3_lib::Bin2Dec($exponentstring) - 16383);
    213                                 $fraction = $isnormalized + getid3_lib::DecimalBinary2Float($fractionstring);
     212                                $exponent = pow(2, self::Bin2Dec($exponentstring) - 16383);
     213                                $fraction = $isnormalized + self::DecimalBinary2Float($fractionstring);
    214214                                $floatvalue = $exponent * $fraction;
    215215                                if ($signbit == '1') {
     
    225225                $exponentstring = substr($bitword, 1, $exponentbits);
    226226                $fractionstring = substr($bitword, $exponentbits + 1, $fractionbits);
    227                 $exponent = getid3_lib::Bin2Dec($exponentstring);
    228                 $fraction = getid3_lib::Bin2Dec($fractionstring);
     227                $exponent = self::Bin2Dec($exponentstring);
     228                $fraction = self::Bin2Dec($fractionstring);
    229229
    230230                if (($exponent == (pow(2, $exponentbits) - 1)) && ($fraction != 0)) {
     
    246246                } elseif (($exponent == 0) && ($fraction != 0)) {
    247247                        // These are 'unnormalized' values
    248                         $floatvalue = pow(2, (-1 * (pow(2, $exponentbits - 1) - 2))) * getid3_lib::DecimalBinary2Float($fractionstring);
     248                        $floatvalue = pow(2, (-1 * (pow(2, $exponentbits - 1) - 2))) * self::DecimalBinary2Float($fractionstring);
    249249                        if ($signbit == '1') {
    250250                                $floatvalue *= -1;
    251251                        }
    252252                } elseif ($exponent != 0) {
    253                         $floatvalue = pow(2, ($exponent - (pow(2, $exponentbits - 1) - 1))) * (1 + getid3_lib::DecimalBinary2Float($fractionstring));
     253                        $floatvalue = pow(2, ($exponent - (pow(2, $exponentbits - 1) - 1))) * (1 + self::DecimalBinary2Float($fractionstring));
    254254                        if ($signbit == '1') {
    255255                                $floatvalue *= -1;
     
    260260
    261261
    262         static function BigEndian2Int($byteword, $synchsafe=false, $signed=false) {
     262        public static function BigEndian2Int($byteword, $synchsafe=false, $signed=false) {
    263263                $intvalue = 0;
    264264                $bytewordlen = strlen($byteword);
     
    282282                                }
    283283                        } else {
    284                                 throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits ('.strlen($byteword).') in getid3_lib::BigEndian2Int()');
    285                                 break;
    286                         }
    287                 }
    288                 return getid3_lib::CastAsInt($intvalue);
    289         }
    290 
    291 
    292         static function LittleEndian2Int($byteword, $signed=false) {
    293                 return getid3_lib::BigEndian2Int(strrev($byteword), false, $signed);
    294         }
    295 
    296 
    297         static function BigEndian2Bin($byteword) {
     284                                throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits ('.strlen($byteword).') in self::BigEndian2Int()');
     285                                break;
     286                        }
     287                }
     288                return self::CastAsInt($intvalue);
     289        }
     290
     291
     292        public static function LittleEndian2Int($byteword, $signed=false) {
     293                return self::BigEndian2Int(strrev($byteword), false, $signed);
     294        }
     295
     296
     297        public static function BigEndian2Bin($byteword) {
    298298                $binvalue = '';
    299299                $bytewordlen = strlen($byteword);
     
    305305
    306306
    307         static function BigEndian2String($number, $minbytes=1, $synchsafe=false, $signed=false) {
     307        public static function BigEndian2String($number, $minbytes=1, $synchsafe=false, $signed=false) {
    308308                if ($number < 0) {
    309                         throw new Exception('ERROR: getid3_lib::BigEndian2String() does not support negative numbers');
     309                        throw new Exception('ERROR: self::BigEndian2String() does not support negative numbers');
    310310                }
    311311                $maskbyte = (($synchsafe || $signed) ? 0x7F : 0xFF);
     
    313313                if ($signed) {
    314314                        if ($minbytes > PHP_INT_SIZE) {
    315                                 throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits in getid3_lib::BigEndian2String()');
     315                                throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits in self::BigEndian2String()');
    316316                        }
    317317                        $number = $number & (0x80 << (8 * ($minbytes - 1)));
     
    326326
    327327
    328         static function Dec2Bin($number) {
     328        public static function Dec2Bin($number) {
    329329                while ($number >= 256) {
    330330                        $bytes[] = (($number / 256) - (floor($number / 256))) * 256;
     
    340340
    341341
    342         static function Bin2Dec($binstring, $signed=false) {
     342        public static function Bin2Dec($binstring, $signed=false) {
    343343                $signmult = 1;
    344344                if ($signed) {
     
    352352                        $decvalue += ((int) substr($binstring, strlen($binstring) - $i - 1, 1)) * pow(2, $i);
    353353                }
    354                 return getid3_lib::CastAsInt($decvalue * $signmult);
    355         }
    356 
    357 
    358         static function Bin2String($binstring) {
     354                return self::CastAsInt($decvalue * $signmult);
     355        }
     356
     357
     358        public static function Bin2String($binstring) {
    359359                // return 'hi' for input of '0110100001101001'
    360360                $string = '';
    361361                $binstringreversed = strrev($binstring);
    362362                for ($i = 0; $i < strlen($binstringreversed); $i += 8) {
    363                         $string = chr(getid3_lib::Bin2Dec(strrev(substr($binstringreversed, $i, 8)))).$string;
     363                        $string = chr(self::Bin2Dec(strrev(substr($binstringreversed, $i, 8)))).$string;
    364364                }
    365365                return $string;
     
    367367
    368368
    369         static function LittleEndian2String($number, $minbytes=1, $synchsafe=false) {
     369        public static function LittleEndian2String($number, $minbytes=1, $synchsafe=false) {
    370370                $intstring = '';
    371371                while ($number > 0) {
     
    382382
    383383
    384         static function array_merge_clobber($array1, $array2) {
     384        public static function array_merge_clobber($array1, $array2) {
    385385                // written by kcØhireability*com
    386386                // taken from http://www.php.net/manual/en/function.array-merge-recursive.php
     
    391391                foreach ($array2 as $key => $val) {
    392392                        if (is_array($val) && isset($newarray[$key]) && is_array($newarray[$key])) {
    393                                 $newarray[$key] = getid3_lib::array_merge_clobber($newarray[$key], $val);
     393                                $newarray[$key] = self::array_merge_clobber($newarray[$key], $val);
    394394                        } else {
    395395                                $newarray[$key] = $val;
     
    400400
    401401
    402         static function array_merge_noclobber($array1, $array2) {
     402        public static function array_merge_noclobber($array1, $array2) {
    403403                if (!is_array($array1) || !is_array($array2)) {
    404404                        return false;
     
    407407                foreach ($array2 as $key => $val) {
    408408                        if (is_array($val) && isset($newarray[$key]) && is_array($newarray[$key])) {
    409                                 $newarray[$key] = getid3_lib::array_merge_noclobber($newarray[$key], $val);
     409                                $newarray[$key] = self::array_merge_noclobber($newarray[$key], $val);
    410410                        } elseif (!isset($newarray[$key])) {
    411411                                $newarray[$key] = $val;
     
    416416
    417417
    418         static function ksort_recursive(&$theArray) {
     418        public static function ksort_recursive(&$theArray) {
    419419                ksort($theArray);
    420420                foreach ($theArray as $key => $value) {
     
    426426        }
    427427
    428         static function fileextension($filename, $numextensions=1) {
     428        public static function fileextension($filename, $numextensions=1) {
    429429                if (strstr($filename, '.')) {
    430430                        $reversedfilename = strrev($filename);
     
    442442
    443443
    444         static function PlaytimeString($seconds) {
     444        public static function PlaytimeString($seconds) {
    445445                $sign = (($seconds < 0) ? '-' : '');
    446                 $seconds = abs($seconds);
    447                 $H = floor( $seconds                            / 3600);
    448                 $M = floor(($seconds - (3600 * $H)            ) /   60);
    449                 $S = round( $seconds - (3600 * $H) - (60 * $M)        );
     446                $seconds = round(abs($seconds));
     447                $H = (int) floor( $seconds                            / 3600);
     448                $M = (int) floor(($seconds - (3600 * $H)            ) /   60);
     449                $S = (int) round( $seconds - (3600 * $H) - (60 * $M)        );
    450450                return $sign.($H ? $H.':' : '').($H ? str_pad($M, 2, '0', STR_PAD_LEFT) : intval($M)).':'.str_pad($S, 2, 0, STR_PAD_LEFT);
    451451        }
    452452
    453453
    454         static function DateMac2Unix($macdate) {
     454        public static function DateMac2Unix($macdate) {
    455455                // Macintosh timestamp: seconds since 00:00h January 1, 1904
    456456                // UNIX timestamp:      seconds since 00:00h January 1, 1970
    457                 return getid3_lib::CastAsInt($macdate - 2082844800);
    458         }
    459 
    460 
    461         static function FixedPoint8_8($rawdata) {
    462                 return getid3_lib::BigEndian2Int(substr($rawdata, 0, 1)) + (float) (getid3_lib::BigEndian2Int(substr($rawdata, 1, 1)) / pow(2, 8));
    463         }
    464 
    465 
    466         static function FixedPoint16_16($rawdata) {
    467                 return getid3_lib::BigEndian2Int(substr($rawdata, 0, 2)) + (float) (getid3_lib::BigEndian2Int(substr($rawdata, 2, 2)) / pow(2, 16));
    468         }
    469 
    470 
    471         static function FixedPoint2_30($rawdata) {
    472                 $binarystring = getid3_lib::BigEndian2Bin($rawdata);
    473                 return getid3_lib::Bin2Dec(substr($binarystring, 0, 2)) + (float) (getid3_lib::Bin2Dec(substr($binarystring, 2, 30)) / pow(2, 30));
    474         }
    475 
    476 
    477         static function CreateDeepArray($ArrayPath, $Separator, $Value) {
     457                return self::CastAsInt($macdate - 2082844800);
     458        }
     459
     460
     461        public static function FixedPoint8_8($rawdata) {
     462                return self::BigEndian2Int(substr($rawdata, 0, 1)) + (float) (self::BigEndian2Int(substr($rawdata, 1, 1)) / pow(2, 8));
     463        }
     464
     465
     466        public static function FixedPoint16_16($rawdata) {
     467                return self::BigEndian2Int(substr($rawdata, 0, 2)) + (float) (self::BigEndian2Int(substr($rawdata, 2, 2)) / pow(2, 16));
     468        }
     469
     470
     471        public static function FixedPoint2_30($rawdata) {
     472                $binarystring = self::BigEndian2Bin($rawdata);
     473                return self::Bin2Dec(substr($binarystring, 0, 2)) + (float) (self::Bin2Dec(substr($binarystring, 2, 30)) / pow(2, 30));
     474        }
     475
     476
     477        public static function CreateDeepArray($ArrayPath, $Separator, $Value) {
    478478                // assigns $Value to a nested array path:
    479                 //   $foo = getid3_lib::CreateDeepArray('/path/to/my', '/', 'file.txt')
     479                //   $foo = self::CreateDeepArray('/path/to/my', '/', 'file.txt')
    480480                // is the same as:
    481481                //   $foo = array('path'=>array('to'=>'array('my'=>array('file.txt'))));
    482482                // or
    483483                //   $foo['path']['to']['my'] = 'file.txt';
    484                 while ($ArrayPath && ($ArrayPath{0} == $Separator)) {
    485                         $ArrayPath = substr($ArrayPath, 1);
    486                 }
     484                $ArrayPath = ltrim($ArrayPath, $Separator);
    487485                if (($pos = strpos($ArrayPath, $Separator)) !== false) {
    488                         $ReturnedArray[substr($ArrayPath, 0, $pos)] = getid3_lib::CreateDeepArray(substr($ArrayPath, $pos + 1), $Separator, $Value);
     486                        $ReturnedArray[substr($ArrayPath, 0, $pos)] = self::CreateDeepArray(substr($ArrayPath, $pos + 1), $Separator, $Value);
    489487                } else {
    490488                        $ReturnedArray[$ArrayPath] = $Value;
     
    493491        }
    494492
    495         static function array_max($arraydata, $returnkey=false) {
     493        public static function array_max($arraydata, $returnkey=false) {
    496494                $maxvalue = false;
    497495                $maxkey = false;
     
    507505        }
    508506
    509         static function array_min($arraydata, $returnkey=false) {
     507        public static function array_min($arraydata, $returnkey=false) {
    510508                $minvalue = false;
    511509                $minkey = false;
     
    521519        }
    522520
    523         static function XML2array($XMLstring) {
     521        public static function XML2array($XMLstring) {
    524522                if (function_exists('simplexml_load_string')) {
    525523                        if (function_exists('get_object_vars')) {
     
    531529        }
    532530
    533         static function SimpleXMLelement2array($XMLobject) {
     531        public static function SimpleXMLelement2array($XMLobject) {
    534532                if (!is_object($XMLobject) && !is_array($XMLobject)) {
    535533                        return $XMLobject;
     
    544542
    545543        // Allan Hansen <ahØartemis*dk>
    546         // getid3_lib::md5_data() - returns md5sum for a file from startuing position to absolute end position
    547         static function hash_data($file, $offset, $end, $algorithm) {
     544        // self::md5_data() - returns md5sum for a file from startuing position to absolute end position
     545        public static function hash_data($file, $offset, $end, $algorithm) {
    548546                static $tempdir = '';
    549                 if (!getid3_lib::intValueSupported($end)) {
     547                if (!self::intValueSupported($end)) {
    550548                        return false;
    551549                }
     
    566564
    567565                        default:
    568                                 throw new Exception('Invalid algorithm ('.$algorithm.') in getid3_lib::hash_data()');
     566                                throw new Exception('Invalid algorithm ('.$algorithm.') in self::hash_data()');
    569567                                break;
    570568                }
     
    583581                                        if (!is_readable(GETID3_HELPERAPPSDIR.$required_file)) {
    584582                                                // helper apps not available - fall back to old method
    585                                                 break;
     583                                                break 2;
    586584                                        }
    587585                                }
    588                                 $commandline  = GETID3_HELPERAPPSDIR.'head.exe -c '.$end.' "'.escapeshellarg(str_replace('/', DIRECTORY_SEPARATOR, $file)).'" | ';
     586                                $commandline  = GETID3_HELPERAPPSDIR.'head.exe -c '.$end.' '.escapeshellarg(str_replace('/', DIRECTORY_SEPARATOR, $file)).' | ';
    589587                                $commandline .= GETID3_HELPERAPPSDIR.'tail.exe -c '.$size.' | ';
    590588                                $commandline .= GETID3_HELPERAPPSDIR.$windows_call;
     
    622620                // copy parts of file
    623621                try {
    624                         getid3_lib::CopyFileParts($file, $data_filename, $offset, $end - $offset);
     622                        self::CopyFileParts($file, $data_filename, $offset, $end - $offset);
    625623                        $result = $hash_function($data_filename);
    626624                } catch (Exception $e) {
    627                         throw new Exception('getid3_lib::CopyFileParts() failed in getid_lib::hash_data(): '.$e->getMessage());
     625                        throw new Exception('self::CopyFileParts() failed in getid_lib::hash_data(): '.$e->getMessage());
    628626                }
    629627                unlink($data_filename);
     
    631629        }
    632630
    633         static function CopyFileParts($filename_source, $filename_dest, $offset, $length) {
    634                 if (!getid3_lib::intValueSupported($offset + $length)) {
     631        public static function CopyFileParts($filename_source, $filename_dest, $offset, $length) {
     632                if (!self::intValueSupported($offset + $length)) {
    635633                        throw new Exception('cannot copy file portion, it extends beyond the '.round(PHP_INT_MAX / 1073741824).'GB limit');
    636634                }
     
    658656        }
    659657
    660         static function iconv_fallback_int_utf8($charval) {
     658        public static function iconv_fallback_int_utf8($charval) {
    661659                if ($charval < 128) {
    662660                        // 0bbbbbbb
     
    682680
    683681        // ISO-8859-1 => UTF-8
    684         static function iconv_fallback_iso88591_utf8($string, $bom=false) {
     682        public static function iconv_fallback_iso88591_utf8($string, $bom=false) {
    685683                if (function_exists('utf8_encode')) {
    686684                        return utf8_encode($string);
     
    693691                for ($i = 0; $i < strlen($string); $i++) {
    694692                        $charval = ord($string{$i});
    695                         $newcharstring .= getid3_lib::iconv_fallback_int_utf8($charval);
     693                        $newcharstring .= self::iconv_fallback_int_utf8($charval);
    696694                }
    697695                return $newcharstring;
     
    699697
    700698        // ISO-8859-1 => UTF-16BE
    701         static function iconv_fallback_iso88591_utf16be($string, $bom=false) {
     699        public static function iconv_fallback_iso88591_utf16be($string, $bom=false) {
    702700                $newcharstring = '';
    703701                if ($bom) {
     
    711709
    712710        // ISO-8859-1 => UTF-16LE
    713         static function iconv_fallback_iso88591_utf16le($string, $bom=false) {
     711        public static function iconv_fallback_iso88591_utf16le($string, $bom=false) {
    714712                $newcharstring = '';
    715713                if ($bom) {
     
    723721
    724722        // ISO-8859-1 => UTF-16LE (BOM)
    725         static function iconv_fallback_iso88591_utf16($string) {
    726                 return getid3_lib::iconv_fallback_iso88591_utf16le($string, true);
     723        public static function iconv_fallback_iso88591_utf16($string) {
     724                return self::iconv_fallback_iso88591_utf16le($string, true);
    727725        }
    728726
    729727        // UTF-8 => ISO-8859-1
    730         static function iconv_fallback_utf8_iso88591($string) {
     728        public static function iconv_fallback_utf8_iso88591($string) {
    731729                if (function_exists('utf8_decode')) {
    732730                        return utf8_decode($string);
     
    772770
    773771        // UTF-8 => UTF-16BE
    774         static function iconv_fallback_utf8_utf16be($string, $bom=false) {
     772        public static function iconv_fallback_utf8_utf16be($string, $bom=false) {
    775773                $newcharstring = '';
    776774                if ($bom) {
     
    808806                        }
    809807                        if ($charval !== false) {
    810                                 $newcharstring .= (($charval < 65536) ? getid3_lib::BigEndian2String($charval, 2) : "\x00".'?');
     808                                $newcharstring .= (($charval < 65536) ? self::BigEndian2String($charval, 2) : "\x00".'?');
    811809                        }
    812810                }
     
    815813
    816814        // UTF-8 => UTF-16LE
    817         static function iconv_fallback_utf8_utf16le($string, $bom=false) {
     815        public static function iconv_fallback_utf8_utf16le($string, $bom=false) {
    818816                $newcharstring = '';
    819817                if ($bom) {
     
    851849                        }
    852850                        if ($charval !== false) {
    853                                 $newcharstring .= (($charval < 65536) ? getid3_lib::LittleEndian2String($charval, 2) : '?'."\x00");
     851                                $newcharstring .= (($charval < 65536) ? self::LittleEndian2String($charval, 2) : '?'."\x00");
    854852                        }
    855853                }
     
    858856
    859857        // UTF-8 => UTF-16LE (BOM)
    860         static function iconv_fallback_utf8_utf16($string) {
    861                 return getid3_lib::iconv_fallback_utf8_utf16le($string, true);
     858        public static function iconv_fallback_utf8_utf16($string) {
     859                return self::iconv_fallback_utf8_utf16le($string, true);
    862860        }
    863861
    864862        // UTF-16BE => UTF-8
    865         static function iconv_fallback_utf16be_utf8($string) {
     863        public static function iconv_fallback_utf16be_utf8($string) {
    866864                if (substr($string, 0, 2) == "\xFE\xFF") {
    867865                        // strip BOM
     
    870868                $newcharstring = '';
    871869                for ($i = 0; $i < strlen($string); $i += 2) {
    872                         $charval = getid3_lib::BigEndian2Int(substr($string, $i, 2));
    873                         $newcharstring .= getid3_lib::iconv_fallback_int_utf8($charval);
     870                        $charval = self::BigEndian2Int(substr($string, $i, 2));
     871                        $newcharstring .= self::iconv_fallback_int_utf8($charval);
    874872                }
    875873                return $newcharstring;
     
    877875
    878876        // UTF-16LE => UTF-8
    879         static function iconv_fallback_utf16le_utf8($string) {
     877        public static function iconv_fallback_utf16le_utf8($string) {
    880878                if (substr($string, 0, 2) == "\xFF\xFE") {
    881879                        // strip BOM
     
    884882                $newcharstring = '';
    885883                for ($i = 0; $i < strlen($string); $i += 2) {
    886                         $charval = getid3_lib::LittleEndian2Int(substr($string, $i, 2));
    887                         $newcharstring .= getid3_lib::iconv_fallback_int_utf8($charval);
     884                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
     885                        $newcharstring .= self::iconv_fallback_int_utf8($charval);
    888886                }
    889887                return $newcharstring;
     
    891889
    892890        // UTF-16BE => ISO-8859-1
    893         static function iconv_fallback_utf16be_iso88591($string) {
     891        public static function iconv_fallback_utf16be_iso88591($string) {
    894892                if (substr($string, 0, 2) == "\xFE\xFF") {
    895893                        // strip BOM
     
    898896                $newcharstring = '';
    899897                for ($i = 0; $i < strlen($string); $i += 2) {
    900                         $charval = getid3_lib::BigEndian2Int(substr($string, $i, 2));
     898                        $charval = self::BigEndian2Int(substr($string, $i, 2));
    901899                        $newcharstring .= (($charval < 256) ? chr($charval) : '?');
    902900                }
     
    905903
    906904        // UTF-16LE => ISO-8859-1
    907         static function iconv_fallback_utf16le_iso88591($string) {
     905        public static function iconv_fallback_utf16le_iso88591($string) {
    908906                if (substr($string, 0, 2) == "\xFF\xFE") {
    909907                        // strip BOM
     
    912910                $newcharstring = '';
    913911                for ($i = 0; $i < strlen($string); $i += 2) {
    914                         $charval = getid3_lib::LittleEndian2Int(substr($string, $i, 2));
     912                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
    915913                        $newcharstring .= (($charval < 256) ? chr($charval) : '?');
    916914                }
     
    919917
    920918        // UTF-16 (BOM) => ISO-8859-1
    921         static function iconv_fallback_utf16_iso88591($string) {
     919        public static function iconv_fallback_utf16_iso88591($string) {
    922920                $bom = substr($string, 0, 2);
    923921                if ($bom == "\xFE\xFF") {
    924                         return getid3_lib::iconv_fallback_utf16be_iso88591(substr($string, 2));
     922                        return self::iconv_fallback_utf16be_iso88591(substr($string, 2));
    925923                } elseif ($bom == "\xFF\xFE") {
    926                         return getid3_lib::iconv_fallback_utf16le_iso88591(substr($string, 2));
     924                        return self::iconv_fallback_utf16le_iso88591(substr($string, 2));
    927925                }
    928926                return $string;
     
    930928
    931929        // UTF-16 (BOM) => UTF-8
    932         static function iconv_fallback_utf16_utf8($string) {
     930        public static function iconv_fallback_utf16_utf8($string) {
    933931                $bom = substr($string, 0, 2);
    934932                if ($bom == "\xFE\xFF") {
    935                         return getid3_lib::iconv_fallback_utf16be_utf8(substr($string, 2));
     933                        return self::iconv_fallback_utf16be_utf8(substr($string, 2));
    936934                } elseif ($bom == "\xFF\xFE") {
    937                         return getid3_lib::iconv_fallback_utf16le_utf8(substr($string, 2));
     935                        return self::iconv_fallback_utf16le_utf8(substr($string, 2));
    938936                }
    939937                return $string;
    940938        }
    941939
    942         static function iconv_fallback($in_charset, $out_charset, $string) {
     940        public static function iconv_fallback($in_charset, $out_charset, $string) {
    943941
    944942                if ($in_charset == $out_charset) {
     
    983981                if (isset($ConversionFunctionList[strtoupper($in_charset)][strtoupper($out_charset)])) {
    984982                        $ConversionFunction = $ConversionFunctionList[strtoupper($in_charset)][strtoupper($out_charset)];
    985                         return getid3_lib::$ConversionFunction($string);
     983                        return self::$ConversionFunction($string);
    986984                }
    987985                throw new Exception('PHP does not have iconv() support - cannot convert from '.$in_charset.' to '.$out_charset);
     
    989987
    990988
    991         static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
     989        public static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
    992990                $string = (string) $string; // in case trying to pass a numeric (float, int) string, would otherwise return an empty string
    993991                $HTMLstring = '';
     
    10541052                        case 'UTF-16LE':
    10551053                                for ($i = 0; $i < strlen($string); $i += 2) {
    1056                                         $charval = getid3_lib::LittleEndian2Int(substr($string, $i, 2));
     1054                                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
    10571055                                        if (($charval >= 32) && ($charval <= 127)) {
    10581056                                                $HTMLstring .= chr($charval);
     
    10651063                        case 'UTF-16BE':
    10661064                                for ($i = 0; $i < strlen($string); $i += 2) {
    1067                                         $charval = getid3_lib::BigEndian2Int(substr($string, $i, 2));
     1065                                        $charval = self::BigEndian2Int(substr($string, $i, 2));
    10681066                                        if (($charval >= 32) && ($charval <= 127)) {
    10691067                                                $HTMLstring .= chr($charval);
     
    10831081
    10841082
    1085         static function RGADnameLookup($namecode) {
     1083        public static function RGADnameLookup($namecode) {
    10861084                static $RGADname = array();
    10871085                if (empty($RGADname)) {
     
    10951093
    10961094
    1097         static function RGADoriginatorLookup($originatorcode) {
     1095        public static function RGADoriginatorLookup($originatorcode) {
    10981096                static $RGADoriginator = array();
    10991097                if (empty($RGADoriginator)) {
     
    11081106
    11091107
    1110         static function RGADadjustmentLookup($rawadjustment, $signbit) {
     1108        public static function RGADadjustmentLookup($rawadjustment, $signbit) {
    11111109                $adjustment = $rawadjustment / 10;
    11121110                if ($signbit == 1) {
     
    11171115
    11181116
    1119         static function RGADgainString($namecode, $originatorcode, $replaygain) {
     1117        public static function RGADgainString($namecode, $originatorcode, $replaygain) {
    11201118                if ($replaygain < 0) {
    11211119                        $signbit = '1';
     
    11321130        }
    11331131
    1134         static function RGADamplitude2dB($amplitude) {
     1132        public static function RGADamplitude2dB($amplitude) {
    11351133                return 20 * log10($amplitude);
    11361134        }
    11371135
    11381136
    1139         static function GetDataImageSize($imgData, &$imageinfo) {
     1137        public static function GetDataImageSize($imgData, &$imageinfo=array()) {
    11401138                static $tempdir = '';
    11411139                if (empty($tempdir)) {
     
    11511149                                fwrite($tmp, $imgData);
    11521150                                fclose($tmp);
    1153                                 $GetDataImageSize = @GetImageSize($tempfilename, $imageinfo);
     1151                                $GetDataImageSize = @getimagesize($tempfilename, $imageinfo);
    11541152                        }
    11551153                        unlink($tempfilename);
     
    11581156        }
    11591157
    1160         static function ImageTypesLookup($imagetypeid) {
     1158        public static function ImageExtFromMime($mime_type) {
     1159                // temporary way, works OK for now, but should be reworked in the future
     1160                return str_replace(array('image/', 'x-', 'jpeg'), array('', '', 'jpg'), $mime_type);
     1161        }
     1162
     1163        public static function ImageTypesLookup($imagetypeid) {
    11611164                static $ImageTypesLookup = array();
    11621165                if (empty($ImageTypesLookup)) {
     
    11791182        }
    11801183
    1181         static function CopyTagsToComments(&$ThisFileInfo) {
     1184        public static function CopyTagsToComments(&$ThisFileInfo) {
    11821185
    11831186                // Copy all entries from ['tags'] into common ['comments']
     
    12341237                                                $ThisFileInfo['comments_html'][$field][$index] = $value;
    12351238                                        } else {
    1236                                                 $ThisFileInfo['comments_html'][$field][$index] = str_replace('&#0;', '', getid3_lib::MultiByteCharString2HTML($value, $ThisFileInfo['encoding']));
     1239                                                $ThisFileInfo['comments_html'][$field][$index] = str_replace('&#0;', '', self::MultiByteCharString2HTML($value, $ThisFileInfo['encoding']));
    12371240                                        }
    12381241                                }
     
    12431246
    12441247
    1245         static function EmbeddedLookup($key, $begin, $end, $file, $name) {
     1248        public static function EmbeddedLookup($key, $begin, $end, $file, $name) {
    12461249
    12471250                // Cached
     
    12891292        }
    12901293
    1291         static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
     1294        public static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
    12921295                global $GETID3_ERRORARRAY;
    12931296
     
    13131316        }
    13141317
     1318        public static function getFileSizeSyscall($path) {
     1319                $filesize = false;
     1320
     1321                if (GETID3_OS_ISWINDOWS) {
     1322                        if (class_exists('COM')) { // From PHP 5.3.15 and 5.4.5, COM and DOTNET is no longer built into the php core.you have to add COM support in php.ini:
     1323                                $filesystem = new COM('Scripting.FileSystemObject');
     1324                                $file = $filesystem->GetFile($path);
     1325                                $filesize = $file->Size();
     1326                                unset($filesystem, $file);
     1327                        } else {
     1328                                $commandline = 'for %I in ('.escapeshellarg($path).') do @echo %~zI';
     1329                        }
     1330                } else {
     1331                        $commandline = 'ls -l '.escapeshellarg($path).' | awk \'{print $5}\'';
     1332                }
     1333                if (isset($commandline)) {
     1334                        $output = trim(`$commandline`);
     1335                        if (ctype_digit($output)) {
     1336                                $filesize = (float) $output;
     1337                        }
     1338                }
     1339                return $filesize;
     1340        }
     1341
    13151342}
    1316 
    1317 ?>
  • _plugins_/getID3/trunk/getid3/getid3.php

    r62460 r71835  
    99//                                                            ///
    1010/////////////////////////////////////////////////////////////////
     11
     12// define a constant rather than looking up every time it is needed
     13if (!defined('GETID3_OS_ISWINDOWS')) {
     14        define('GETID3_OS_ISWINDOWS', (stripos(PHP_OS, 'WIN') === 0));
     15}
     16// Get base path of getID3() - ONCE
     17if (!defined('GETID3_INCLUDEPATH')) {
     18        define('GETID3_INCLUDEPATH', dirname(__FILE__).DIRECTORY_SEPARATOR);
     19}
    1120
    1221// attempt to define temp dir as something flexible but reliable
     
    3039        }
    3140        $found_valid_tempdir = false;
    32         $open_basedirs = explode(':', $open_basedir);
     41        $open_basedirs = explode(PATH_SEPARATOR, $open_basedir);
    3342        foreach ($open_basedirs as $basedir) {
    3443                if (substr($basedir, -1, 1) != DIRECTORY_SEPARATOR) {
     
    5261unset($open_basedir, $temp_dir);
    5362
    54 
    55 // define a constant rather than looking up every time it is needed
    56 if (!defined('GETID3_OS_ISWINDOWS')) {
    57         if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN') {
    58                 define('GETID3_OS_ISWINDOWS', true);
    59         } else {
    60                 define('GETID3_OS_ISWINDOWS', false);
    61         }
    62 }
    63 
    64 // Get base path of getID3() - ONCE
    65 if (!defined('GETID3_INCLUDEPATH')) {
    66         foreach (get_included_files() as $key => $val) {
    67                 if (basename($val) == 'getid3.php') {
    68                         define('GETID3_INCLUDEPATH', dirname($val).DIRECTORY_SEPARATOR);
    69                         break;
    70                 }
    71         }
    72 }
    73 
    7463// End: Defines
    7564
     
    10897        public $fp;                               // Filepointer to file being analysed.
    10998        public $info;                             // Result array.
     99        public $tempdir = GETID3_TEMP_DIR;
    110100
    111101        // Protected variables
     
    114104        protected $memory_limit    = 0;
    115105
    116         const VERSION           = '1.9.3-20111213';
     106        const VERSION           = '1.9.5-20130220';
    117107        const FREAD_BUFFER_SIZE = 32768;
    118         var $tempdir            = GETID3_TEMP_DIR;
    119108
    120109        const ATTACHMENTS_NONE   = false;
     
    235224
    236225        // public: setOption
    237         function setOption($optArray) {
     226        public function setOption($optArray) {
    238227                if (!is_array($optArray) || empty($optArray)) {
    239228                        return false;
     
    295284                                        ($this->info['filesize'] < 0) ||
    296285                                        (ftell($this->fp) < 0)) {
    297                                                 $real_filesize = false;
    298                                                 if (GETID3_OS_ISWINDOWS) {
    299                                                         $commandline = 'dir /-C "'.str_replace('/', DIRECTORY_SEPARATOR, $filename).'"';
    300                                                         $dir_output = `$commandline`;
    301                                                         if (preg_match('#1 File\(s\)[ ]+([0-9]+) bytes#i', $dir_output, $matches)) {
    302                                                                 $real_filesize = (float) $matches[1];
    303                                                         }
    304                                                 } else {
    305                                                         $commandline = 'ls -o -g -G --time-style=long-iso '.escapeshellarg($filename);
    306                                                         $dir_output = `$commandline`;
    307                                                         if (preg_match('#([0-9]+) ([0-9]{4}-[0-9]{2}\-[0-9]{2} [0-9]{2}:[0-9]{2}) '.str_replace('#', '\\#', preg_quote($filename)).'$#', $dir_output, $matches)) {
    308                                                                 $real_filesize = (float) $matches[1];
    309                                                         }
    310                                                 }
     286                                                $real_filesize = getid3_lib::getFileSizeSyscall($this->info['filenamepath']);
     287
    311288                                                if ($real_filesize === false) {
    312289                                                        unset($this->info['filesize']);
     
    344321
    345322        // public: analyze file
    346         function analyze($filename) {
     323        public function analyze($filename) {
    347324                try {
    348325                        if (!$this->openfile($filename)) {
     
    448425                                return $this->error('Format not supported, module "'.$determined_format['include'].'" is corrupt.');
    449426                        }
    450                         //if (isset($determined_format['option'])) {
    451                         //      //$class = new $class_name($this->fp, $this->info, $determined_format['option']);
    452                         //} else {
    453                                 //$class = new $class_name($this->fp, $this->info);
    454                                 $class = new $class_name($this);
    455                         //}
    456 
    457                         if (!empty($determined_format['set_inline_attachments'])) {
    458                                 $class->inline_attachments = $this->option_save_attachments;
    459                         }
     427                        $class = new $class_name($this);
    460428                        $class->Analyze();
    461 
    462429                        unset($class);
    463430
     
    481448                        // get the MD5 sum of the audio/video portion of the file - without ID3/APE/Lyrics3/etc header/footer tags
    482449                        if ($this->option_md5_data) {
    483                                 // do not cald md5_data if md5_data_source is present - set by flac only - future MPC/SV8 too
     450                                // do not calc md5_data if md5_data_source is present - set by flac only - future MPC/SV8 too
    484451                                if (!$this->option_md5_data_source || empty($this->info['md5_data_source'])) {
    485452                                        $this->getHashdata('md5');
     
    505472
    506473        // private: error handling
    507         function error($message) {
     474        public function error($message) {
    508475                $this->CleanUp();
    509476                if (!isset($this->info['error'])) {
     
    516483
    517484        // private: warning handling
    518         function warning($message) {
     485        public function warning($message) {
    519486                $this->info['warning'][] = $message;
    520487                return true;
     
    523490
    524491        // private: CleanUp
    525         function CleanUp() {
     492        private function CleanUp() {
    526493
    527494                // remove possible empty keys
     
    571538
    572539        // return array containing information about all supported formats
    573         function GetFileFormatArray() {
     540        public function GetFileFormatArray() {
    574541                static $format_info = array();
    575542                if (empty($format_info)) {
     
    595562                                                ),
    596563
    597 
     564/*
    598565                                // AA   - audio       - Audible Audiobook
    599                                 'adts' => array(
     566                                'aa'  => array(
    600567                                                        'pattern'   => '^.{4}\x57\x90\x75\x36',
    601568                                                        'group'     => 'audio',
    602569                                                        'module'    => 'aa',
    603                                                         'mime_type' => 'audio/audible ',
    604                                                 ),
    605 
     570                                                        'mime_type' => 'audio/audible',
     571                                                ),
     572*/
    606573                                // AAC  - audio       - Advanced Audio Coding (AAC) - ADTS format (very similar to MP3)
    607574                                'adts' => array(
     
    640607                                // DSS  - audio       - Digital Speech Standard
    641608                                'dss'  => array(
    642                                                         'pattern'   => '^[\x02-\x03]dss',
     609                                                        'pattern'   => '^[\x02-\x03]ds[s2]',
    643610                                                        'group'     => 'audio',
    644611                                                        'module'    => 'dss',
     
    660627                                                        'module'    => 'flac',
    661628                                                        'mime_type' => 'audio/x-flac',
    662                                                         'set_inline_attachments' => true,
    663629                                                ),
    664630
     
    840806                                                        'module'    => 'matroska',
    841807                                                        'mime_type' => 'video/x-matroska', // may also be audio/x-matroska
    842                                                         'set_inline_attachments' => true,
    843808                                                ),
    844809
     
    867832                                                        'fail_id3'  => 'WARNING',
    868833                                                        'fail_ape'  => 'WARNING',
    869                                                         'set_inline_attachments' => true,
    870834                                                ),
    871835
     
    901865                                                        'module'    => 'swf',
    902866                                                        'mime_type' => 'application/x-shockwave-flash',
     867                                                ),
     868
     869                                // TS - audio/video - MPEG-2 Transport Stream
     870                                'ts' => array(
     871                                                        'pattern'   => '^(\x47.{187}){10,}', // packets are 188 bytes long and start with 0x47 "G".  Check for at least 10 packets matching this pattern
     872                                                        'group'     => 'audio-video',
     873                                                        'module'    => 'ts',
     874                                                        'mime_type' => 'video/MP2T',
    903875                                                ),
    904876
     
    981953
    982954                                // EFAX - still image - eFax (TIFF derivative)
    983                                 'bmp'  => array(
     955                                'efax'  => array(
    984956                                                        'pattern'   => '^\xDC\xFE',
    985957                                                        'group'     => 'graphic',
     
    11031075
    11041076
    1105         function GetFileFormat(&$filedata, $filename='') {
     1077        public function GetFileFormat(&$filedata, $filename='') {
    11061078                // this function will determine the format of a file based on usually
    11071079                // the first 2-4 bytes of the file (8 bytes for PNG, 16 bytes for JPG,
     
    11421114
    11431115        // converts array to $encoding charset from $this->encoding
    1144         function CharConvert(&$array, $encoding) {
     1116        public function CharConvert(&$array, $encoding) {
    11451117
    11461118                // identical encoding - end here
     
    11651137
    11661138
    1167         function HandleAllTags() {
     1139        public function HandleAllTags() {
    11681140
    11691141                // key name => array (tag name, character encoding)
     
    11881160                                'cue'       => array('cue'           , 'ISO-8859-1'),
    11891161                                'matroska'  => array('matroska'      , 'UTF-8'),
     1162                                'flac'      => array('vorbiscomment' , 'UTF-8'),
     1163                                'divxtag'   => array('divx'          , 'ISO-8859-1'),
    11901164                        );
    11911165                }
     
    12021176                        // copy comments if key name set
    12031177                        if (!empty($this->info[$comment_name]['comments'])) {
    1204 
    12051178                                foreach ($this->info[$comment_name]['comments'] as $tag_key => $valuearray) {
    12061179                                        foreach ($valuearray as $key => $value) {
     
    12111184                                                        $this->info['tags'][trim($tag_name)][trim($tag_key)][] = $value;
    12121185                                                }
     1186                                        }
     1187                                        if ($tag_key == 'picture') {
     1188                                                unset($this->info[$comment_name]['comments'][$tag_key]);
    12131189                                        }
    12141190                                }
     
    12851261
    12861262
    1287         function getHashdata($algorithm) {
     1263        public function getHashdata($algorithm) {
    12881264                switch ($algorithm) {
    12891265                        case 'md5':
     
    14091385
    14101386
    1411         function ChannelsBitratePlaytimeCalculations() {
     1387        public function ChannelsBitratePlaytimeCalculations() {
    14121388
    14131389                // set channelmode on audio
     
    14741450
    14751451
    1476         function CalculateCompressionRatioVideo() {
     1452        public function CalculateCompressionRatioVideo() {
    14771453                if (empty($this->info['video'])) {
    14781454                        return false;
     
    15221498
    15231499
    1524         function CalculateCompressionRatioAudio() {
    1525                 if (empty($this->info['audio']['bitrate']) || empty($this->info['audio']['channels']) || empty($this->info['audio']['sample_rate'])) {
     1500        public function CalculateCompressionRatioAudio() {
     1501                if (empty($this->info['audio']['bitrate']) || empty($this->info['audio']['channels']) || empty($this->info['audio']['sample_rate']) || !is_numeric($this->info['audio']['sample_rate'])) {
    15261502                        return false;
    15271503                }
     
    15391515
    15401516
    1541         function CalculateReplayGain() {
     1517        public function CalculateReplayGain() {
    15421518                if (isset($this->info['replay_gain'])) {
    15431519                        if (!isset($this->info['replay_gain']['reference_volume'])) {
     
    15611537        }
    15621538
    1563         function ProcessAudioStreams() {
     1539        public function ProcessAudioStreams() {
    15641540                if (!empty($this->info['audio']['bitrate']) || !empty($this->info['audio']['channels']) || !empty($this->info['audio']['sample_rate'])) {
    15651541                        if (!isset($this->info['audio']['streams'])) {
     
    15741550        }
    15751551
    1576         function getid3_tempnam() {
     1552        public function getid3_tempnam() {
    15771553                return tempnam($this->tempdir, 'gI3');
    15781554        }
    1579 
    1580 
    1581         public function saveAttachment(&$ThisFileInfoIndex, $filename, $offset, $length) {
    1582                 try {
    1583                         if (!getid3_lib::intValueSupported($offset + $length)) {
    1584                                 throw new Exception('cannot extract attachment, it extends beyond the '.round(PHP_INT_MAX / 1073741824).'GB limit');
    1585                         }
    1586 
    1587                         // do not extract at all
    1588                         if ($this->option_save_attachments === getID3::ATTACHMENTS_NONE) {
    1589 
    1590                                 unset($ThisFileInfoIndex); // do not set any
    1591 
    1592                         // extract to return array
    1593                         } elseif ($this->option_save_attachments === getID3::ATTACHMENTS_INLINE) {
    1594 
    1595                                 // get whole data in one pass, till it is anyway stored in memory
    1596                                 $ThisFileInfoIndex = file_get_contents($this->info['filenamepath'], false, null, $offset, $length);
    1597                                 if (($ThisFileInfoIndex === false) || (strlen($ThisFileInfoIndex) != $length)) { // verify
    1598                                         throw new Exception('failed to read attachment data');
    1599                                 }
    1600 
    1601                         // assume directory path is given
    1602                         } else {
    1603 
    1604                                 $dir = rtrim(str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $this->option_save_attachments), DIRECTORY_SEPARATOR);
    1605                                 // check supplied directory
    1606                                 if (!is_dir($dir) || !is_writable($dir)) {
    1607                                         throw new Exception('getID3::saveAttachment() -- supplied path ('.$dir.') does not exist, or is not writable');
    1608                                 }
    1609 
    1610                                 // set up destination path
    1611                                 $dest = $dir.DIRECTORY_SEPARATOR.$filename;
    1612 
    1613                                 // optimize speed if read buffer size is configured to be large enough
    1614                                 // here stream_copy_to_stream() may also be used. need to do speed-compare tests
    1615                                 if ($length <= $this->fread_buffer_size()) {
    1616                                         $data = file_get_contents($this->info['filenamepath'], false, null, $offset, $length);
    1617                                         if (($data === false) || (strlen($data) != $length)) { // verify
    1618                                                 throw new Exception('failed to read attachment data');
    1619                                         }
    1620                                         if (!file_put_contents($dest, $data)) {
    1621                                                 throw new Exception('failed to create file '.$dest);
    1622                                         }
    1623                                 } else {
    1624                                         // optimization not available - copy data in loop
    1625                                         // here stream_copy_to_stream() shouldn't be used because it's internal read buffer may be larger than ours!
    1626                                         getid3_lib::CopyFileParts($this->info['filenamepath'], $dest, $offset, $length);
    1627                                 }
    1628                                 $ThisFileInfoIndex = $dest;
    1629                         }
    1630 
    1631                 } catch (Exception $e) {
    1632 
    1633                         unset($ThisFileInfoIndex); // do not set any is case of error
    1634                         $this->warning('Failed to extract attachment '.$filename.': '.$e->getMessage());
    1635                         return false;
    1636 
    1637                 }
    1638                 return true;
    1639         }
    1640 
    16411555
    16421556        public function include_module($name) {
     
    16541568abstract class getid3_handler
    16551569{
    1656     protected $getid3;                          // pointer
    1657 
    1658     protected $data_string_flag = false;        // analyzing filepointer or string
    1659     protected $data_string;                     // string to analyze
    1660     protected $data_string_position = 0;        // seek position in string
    1661 
    1662 
    1663     public function __construct(getID3 $getid3) {
    1664         $this->getid3 = $getid3;
    1665     }
    1666 
    1667 
    1668     // Analyze from file pointer
    1669     abstract public function Analyze();
    1670 
    1671 
    1672     // Analyze from string instead
    1673     public function AnalyzeString(&$string) {
    1674         // Enter string mode
    1675         $this->data_string_flag = true;
    1676         $this->data_string      = $string;
    1677 
    1678         // Save info
    1679         $saved_avdataoffset = $this->getid3->info['avdataoffset'];
    1680         $saved_avdataend    = $this->getid3->info['avdataend'];
    1681         $saved_filesize     = $this->getid3->info['filesize'];
    1682 
    1683         // Reset some info
    1684         $this->getid3->info['avdataoffset'] = 0;
    1685         $this->getid3->info['avdataend']    = $this->getid3->info['filesize'] = strlen($string);
    1686 
    1687         // Analyze
    1688         $this->Analyze();
    1689 
    1690         // Restore some info
    1691         $this->getid3->info['avdataoffset'] = $saved_avdataoffset;
    1692         $this->getid3->info['avdataend']    = $saved_avdataend;
    1693         $this->getid3->info['filesize']     = $saved_filesize;
    1694 
    1695         // Exit string mode
    1696         $this->data_string_flag = false;
    1697     }
    1698 
    1699 
    1700     protected function ftell() {
    1701         if ($this->data_string_flag) {
    1702             return $this->data_string_position;
    1703         }
    1704         return ftell($this->getid3->fp);
    1705     }
    1706 
    1707 
    1708     protected function fread($bytes) {
    1709         if ($this->data_string_flag) {
    1710             $this->data_string_position += $bytes;
    1711             return substr($this->data_string, $this->data_string_position - $bytes, $bytes);
    1712         }
    1713         return fread($this->getid3->fp, $bytes);
    1714     }
    1715 
    1716 
    1717     protected function fseek($bytes, $whence = SEEK_SET) {
    1718         if ($this->data_string_flag) {
    1719             switch ($whence) {
    1720                 case SEEK_SET:
    1721                     $this->data_string_position = $bytes;
    1722                     return;
    1723 
    1724                 case SEEK_CUR:
    1725                     $this->data_string_position += $bytes;
    1726                     return;
    1727 
    1728                 case SEEK_END:
    1729                     $this->data_string_position = strlen($this->data_string) + $bytes;
    1730                     return;
    1731             }
    1732         }
    1733         return fseek($this->getid3->fp, $bytes, $whence);
    1734     }
     1570        protected $getid3;                       // pointer
     1571
     1572        protected $data_string_flag     = false; // analyzing filepointer or string
     1573        protected $data_string          = '';    // string to analyze
     1574        protected $data_string_position = 0;     // seek position in string
     1575        protected $data_string_length   = 0;     // string length
     1576
     1577        private $dependency_to = null;
     1578
     1579
     1580        public function __construct(getID3 $getid3, $call_module=null) {
     1581                $this->getid3 = $getid3;
     1582
     1583                if ($call_module) {
     1584                        $this->dependency_to = str_replace('getid3_', '', $call_module);
     1585                }
     1586        }
     1587
     1588
     1589        // Analyze from file pointer
     1590        abstract public function Analyze();
     1591
     1592
     1593        // Analyze from string instead
     1594        public function AnalyzeString($string) {
     1595                // Enter string mode
     1596            $this->setStringMode($string);
     1597
     1598                // Save info
     1599                $saved_avdataoffset = $this->getid3->info['avdataoffset'];
     1600                $saved_avdataend    = $this->getid3->info['avdataend'];
     1601                $saved_filesize     = (isset($this->getid3->info['filesize']) ? $this->getid3->info['filesize'] : null); // may be not set if called as dependency without openfile() call
     1602
     1603                // Reset some info
     1604                $this->getid3->info['avdataoffset'] = 0;
     1605                $this->getid3->info['avdataend']    = $this->getid3->info['filesize'] = $this->data_string_length;
     1606
     1607                // Analyze
     1608                $this->Analyze();
     1609
     1610                // Restore some info
     1611                $this->getid3->info['avdataoffset'] = $saved_avdataoffset;
     1612                $this->getid3->info['avdataend']    = $saved_avdataend;
     1613                $this->getid3->info['filesize']     = $saved_filesize;
     1614
     1615                // Exit string mode
     1616                $this->data_string_flag = false;
     1617        }
     1618
     1619        public function setStringMode($string) {
     1620                $this->data_string_flag   = true;
     1621                $this->data_string        = $string;
     1622                $this->data_string_length = strlen($string);
     1623        }
     1624
     1625        protected function ftell() {
     1626                if ($this->data_string_flag) {
     1627                        return $this->data_string_position;
     1628                }
     1629                return ftell($this->getid3->fp);
     1630        }
     1631
     1632        protected function fread($bytes) {
     1633                if ($this->data_string_flag) {
     1634                        $this->data_string_position += $bytes;
     1635                        return substr($this->data_string, $this->data_string_position - $bytes, $bytes);
     1636                }
     1637            $pos = $this->ftell() + $bytes;
     1638            if (!getid3_lib::intValueSupported($pos)) {
     1639                        throw new getid3_exception('cannot fread('.$bytes.' from '.$this->ftell().') because beyond PHP filesystem limit', 10);
     1640            }
     1641                return fread($this->getid3->fp, $bytes);
     1642        }
     1643
     1644        protected function fseek($bytes, $whence=SEEK_SET) {
     1645                if ($this->data_string_flag) {
     1646                        switch ($whence) {
     1647                                case SEEK_SET:
     1648                                        $this->data_string_position = $bytes;
     1649                                        break;
     1650
     1651                                case SEEK_CUR:
     1652                                        $this->data_string_position += $bytes;
     1653                                        break;
     1654
     1655                                case SEEK_END:
     1656                                        $this->data_string_position = $this->data_string_length + $bytes;
     1657                                        break;
     1658                        }
     1659                        return 0;
     1660            } else {
     1661                $pos = $bytes;
     1662                if ($whence == SEEK_CUR) {
     1663                                $pos = $this->ftell() + $bytes;
     1664                } elseif ($whence == SEEK_END) {
     1665                                $pos = $this->info['filesize'] + $bytes;
     1666                }
     1667                if (!getid3_lib::intValueSupported($pos)) {
     1668                                throw new getid3_exception('cannot fseek('.$pos.') because beyond PHP filesystem limit', 10);
     1669                        }
     1670                }
     1671                return fseek($this->getid3->fp, $bytes, $whence);
     1672        }
     1673
     1674        protected function feof() {
     1675                if ($this->data_string_flag) {
     1676                        return $this->data_string_position >= $this->data_string_length;
     1677                }
     1678                return feof($this->getid3->fp);
     1679        }
     1680
     1681        final protected function isDependencyFor($module) {
     1682                return $this->dependency_to == $module;
     1683        }
     1684
     1685        protected function error($text)
     1686        {
     1687                $this->getid3->info['error'][] = $text;
     1688
     1689                return false;
     1690        }
     1691
     1692        protected function warning($text)
     1693        {
     1694                return $this->getid3->warning($text);
     1695        }
     1696
     1697        protected function notice($text)
     1698        {
     1699                // does nothing for now
     1700        }
     1701
     1702        public function saveAttachment($name, $offset, $length, $image_mime=null) {
     1703                try {
     1704
     1705                        // do not extract at all
     1706                        if ($this->getid3->option_save_attachments === getID3::ATTACHMENTS_NONE) {
     1707
     1708                                $attachment = null; // do not set any
     1709
     1710                        // extract to return array
     1711                        } elseif ($this->getid3->option_save_attachments === getID3::ATTACHMENTS_INLINE) {
     1712
     1713                                $this->fseek($offset);
     1714                                $attachment = $this->fread($length); // get whole data in one pass, till it is anyway stored in memory
     1715                                if ($attachment === false || strlen($attachment) != $length) {
     1716                                        throw new Exception('failed to read attachment data');
     1717                                }
     1718
     1719                        // assume directory path is given
     1720                        } else {
     1721
     1722                                // set up destination path
     1723                                $dir = rtrim(str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $this->getid3->option_save_attachments), DIRECTORY_SEPARATOR);
     1724                                if (!is_dir($dir) || !is_writable($dir)) { // check supplied directory
     1725                                        throw new Exception('supplied path ('.$dir.') does not exist, or is not writable');
     1726                                }
     1727                                $dest = $dir.DIRECTORY_SEPARATOR.$name.($image_mime ? '.'.getid3_lib::ImageExtFromMime($image_mime) : '');
     1728
     1729                                // create dest file
     1730                                if (($fp_dest = fopen($dest, 'wb')) == false) {
     1731                                        throw new Exception('failed to create file '.$dest);
     1732                                }
     1733
     1734                                // copy data
     1735                                $this->fseek($offset);
     1736                                $buffersize = ($this->data_string_flag ? $length : $this->getid3->fread_buffer_size());
     1737                                $bytesleft = $length;
     1738                                while ($bytesleft > 0) {
     1739                                        if (($buffer = $this->fread(min($buffersize, $bytesleft))) === false || ($byteswritten = fwrite($fp_dest, $buffer)) === false || ($byteswritten === 0)) {
     1740                                                throw new Exception($buffer === false ? 'not enough data to read' : 'failed to write to destination file, may be not enough disk space');
     1741                                        }
     1742                                        $bytesleft -= $byteswritten;
     1743                                }
     1744
     1745                                fclose($fp_dest);
     1746                                $attachment = $dest;
     1747
     1748                        }
     1749
     1750                } catch (Exception $e) {
     1751
     1752                        // close and remove dest file if created
     1753                        if (isset($fp_dest) && is_resource($fp_dest)) {
     1754                                fclose($fp_dest);
     1755                                unlink($dest);
     1756                        }
     1757
     1758                        // do not set any is case of error
     1759                        $attachment = null;
     1760                        $this->warning('Failed to extract attachment '.$name.': '.$e->getMessage());
     1761
     1762                }
     1763
     1764                // seek to the end of attachment
     1765                $this->fseek($offset + $length);
     1766
     1767                return $attachment;
     1768        }
    17351769
    17361770}
     
    17391773class getid3_exception extends Exception
    17401774{
    1741     public $message;
     1775        public $message;
    17421776}
    1743 
    1744 ?>
  • _plugins_/getID3/trunk/getid3/module.archive.gzip.php

    r51852 r71835  
    2323
    2424        // public: Optional file list - disable for speed.
    25         var $option_gzip_parse_contents = false; // decode gzipped files, if possible, and parse recursively (.tar.gz for example)
    26 
    27         function Analyze() {
     25        public $option_gzip_parse_contents = false; // decode gzipped files, if possible, and parse recursively (.tar.gz for example)
     26
     27        public function Analyze() {
    2828                $info = &$this->getid3->info;
    2929
     
    141141                        //+=========================================+
    142142                        // GZIP files may have only one file, with no filename, so assume original filename is current filename without .gz
    143                         $thisInfo['filename'] = preg_replace('#\.gz$#i', '', $info['filename']);
     143                        $thisInfo['filename'] = preg_replace('#\\.gz$#i', '', $info['filename']);
    144144                        if ($thisInfo['flags']['filename']) {
     145                                $thisInfo['filename'] = '';
    145146                                while (true) {
    146147                                        if (ord($buff[$fpointer]) == 0) {
     
    246247
    247248        // Converts the OS type
    248         function get_os_type($key) {
     249        public function get_os_type($key) {
    249250                static $os_type = array(
    250251                        '0'   => 'FAT filesystem (MS-DOS, OS/2, NT/Win32)',
     
    268269
    269270        // Converts the eXtra FLags
    270         function get_xflag_type($key) {
     271        public function get_xflag_type($key) {
    271272                static $xflag_type = array(
    272273                        '0' => 'unknown',
     
    278279}
    279280
    280 ?>
  • _plugins_/getID3/trunk/getid3/module.archive.rar.php

    r51852 r71835  
    1818{
    1919
    20         var $option_use_rar_extension = false;
     20        public $option_use_rar_extension = false;
    2121
    22         function Analyze() {
     22        public function Analyze() {
    2323                $info = &$this->getid3->info;
    2424
     
    4949
    5050}
    51 
    52 
    53 ?>
  • _plugins_/getID3/trunk/getid3/module.archive.szip.php

    r51852 r71835  
    1818{
    1919
    20         function Analyze() {
     20        public function Analyze() {
    2121                $info = &$this->getid3->info;
    2222
    23                 fseek($this->getid3->fp, $info['avdataoffset'], SEEK_SET);
    24                 $SZIPHeader = fread($this->getid3->fp, 6);
     23                $this->fseek($info['avdataoffset']);
     24                $SZIPHeader = $this->fread(6);
    2525                if (substr($SZIPHeader, 0, 4) != "SZ\x0A\x04") {
    2626                        $info['error'][] = 'Expecting "53 5A 0A 04" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes(substr($SZIPHeader, 0, 4)).'"';
     
    3030                $info['szip']['major_version'] = getid3_lib::BigEndian2Int(substr($SZIPHeader, 4, 1));
    3131                $info['szip']['minor_version'] = getid3_lib::BigEndian2Int(substr($SZIPHeader, 5, 1));
     32$info['error'][] = 'SZIP parsing not enabled in this version of getID3() ['.$this->getid3->version().']';
     33return false;
    3234
    33                 while (!feof($this->getid3->fp)) {
    34                         $NextBlockID = fread($this->getid3->fp, 2);
     35                while (!$this->feof()) {
     36                        $NextBlockID = $this->fread(2);
    3537                        switch ($NextBlockID) {
    3638                                case 'SZ':
     
    3840                                        // concatenating the files. this also means that global header blocks
    3941                                        // might be present between directory/data blocks.
    40                                         fseek($this->getid3->fp, 4, SEEK_CUR);
     42                                        $this->fseek(4, SEEK_CUR);
    4143                                        break;
    4244
    4345                                case 'BH':
    44                                         $BHheaderbytes  = getid3_lib::BigEndian2Int(fread($this->getid3->fp, 3));
    45                                         $BHheaderdata   = fread($this->getid3->fp, $BHheaderbytes);
     46                                        $BHheaderbytes  = getid3_lib::BigEndian2Int($this->fread(3));
     47                                        $BHheaderdata   = $this->fread($BHheaderbytes);
    4648                                        $BHheaderoffset = 0;
    4749                                        while (strpos($BHheaderdata, "\x00", $BHheaderoffset) > 0) {
     
    9395
    9496}
    95 
    96 ?>
  • _plugins_/getID3/trunk/getid3/module.archive.tar.php

    r51852 r71835  
    2323{
    2424
    25         function Analyze() {
     25        public function Analyze() {
    2626                $info = &$this->getid3->info;
    2727
     
    9797                                'name'     => $name,
    9898                                'mode_raw' => $mode,
    99                                 'mode'     => getid3_tar::display_perms($mode),
     99                                'mode'     => self::display_perms($mode),
    100100                                'uid'      => $uid,
    101101                                'gid'      => $gid,
     
    103103                                'mtime'    => $mtime,
    104104                                'chksum'   => $chksum,
    105                                 'typeflag' => getid3_tar::get_flag_type($typflag),
     105                                'typeflag' => self::get_flag_type($typflag),
    106106                                'linkname' => $lnkname,
    107107                                'magic'    => $magic,
     
    118118
    119119        // Parses the file mode to file permissions
    120         function display_perms($mode) {
     120        public function display_perms($mode) {
    121121                // Determine Type
    122122                if     ($mode & 0x1000) $type='p'; // FIFO pipe
     
    153153
    154154        // Converts the file type
    155         function get_flag_type($typflag) {
     155        public function get_flag_type($typflag) {
    156156                static $flag_types = array(
    157157                        '0' => 'LF_NORMAL',
     
    175175
    176176}
    177 
    178 ?>
  • _plugins_/getID3/trunk/getid3/module.archive.zip.php

    r51852 r71835  
    1818{
    1919
    20         function Analyze() {
     20        public function Analyze() {
    2121                $info = &$this->getid3->info;
    2222
     
    5454                                                $info['zip']['uncompressed_size'] += $centraldirectoryentry['uncompressed_size'];
    5555
    56                                                 if ($centraldirectoryentry['uncompressed_size'] > 0) {
     56                                                //if ($centraldirectoryentry['uncompressed_size'] > 0) { zero-byte files are valid
     57                                                if (!empty($centraldirectoryentry['filename'])) {
    5758                                                        $info['zip']['files'] = getid3_lib::array_merge_clobber($info['zip']['files'], getid3_lib::CreateDeepArray($centraldirectoryentry['filename'], '/', $centraldirectoryentry['uncompressed_size']));
    5859                                                }
     
    7879                                        }
    7980
     81                                        // secondary check - we (should) already have all the info we NEED from the Central Directory above, but scanning each
     82                                        // Local File Header entry will
     83                                        foreach ($info['zip']['central_directory'] as $central_directory_entry) {
     84                                                fseek($this->getid3->fp, $central_directory_entry['entry_offset'], SEEK_SET);
     85                                                if ($fileentry = $this->ZIPparseLocalFileHeader()) {
     86                                                        $info['zip']['entries'][] = $fileentry;
     87                                                } else {
     88                                                        $info['warning'][] = 'Error parsing Local File Header at offset '.$central_directory_entry['entry_offset'];
     89                                                }
     90                                        }
     91
     92                                        if (!empty($info['zip']['files']['[Content_Types].xml']) &&
     93                                            !empty($info['zip']['files']['_rels']['.rels'])      &&
     94                                            !empty($info['zip']['files']['docProps']['app.xml']) &&
     95                                            !empty($info['zip']['files']['docProps']['core.xml'])) {
     96                                                   // http://technet.microsoft.com/en-us/library/cc179224.aspx
     97                                                   $info['fileformat'] = 'zip.msoffice';
     98                                                   if (!empty($ThisFileInfo['zip']['files']['ppt'])) {
     99                                                      $info['mime_type'] = 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
     100                                                   } elseif (!empty($ThisFileInfo['zip']['files']['xl'])) {
     101                                                      $info['mime_type'] = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
     102                                                   } elseif (!empty($ThisFileInfo['zip']['files']['word'])) {
     103                                                      $info['mime_type'] = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
     104                                                   }
     105                                        }
     106
    80107                                        return true;
    81 
    82108                                }
    83109                        }
    84110                }
    85111
    86                 if ($this->getZIPentriesFilepointer()) {
    87 
    88                         // central directory couldn't be found and/or parsed
    89                         // scan through actual file data entries, recover as much as possible from probable trucated file
    90                         if ($info['zip']['compressed_size'] > ($info['filesize'] - 46 - 22)) {
    91                                 $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)';
    92                         }
    93                         $info['error'][] = 'Cannot find End Of Central Directory - returned list of files in [zip][entries] array may not be complete';
    94                         foreach ($info['zip']['entries'] as $key => $valuearray) {
    95                                 $info['zip']['files'][$valuearray['filename']] = $valuearray['uncompressed_size'];
    96                         }
    97                         return true;
    98 
    99                 } else {
    100 
     112                if (!$this->getZIPentriesFilepointer()) {
    101113                        unset($info['zip']);
    102114                        $info['fileformat'] = '';
    103115                        $info['error'][] = 'Cannot find End Of Central Directory (truncated file?)';
    104116                        return false;
    105 
    106                 }
    107         }
    108 
    109 
    110         function getZIPHeaderFilepointerTopDown() {
     117                }
     118
     119                // central directory couldn't be found and/or parsed
     120                // scan through actual file data entries, recover as much as possible from probable trucated file
     121                if ($info['zip']['compressed_size'] > ($info['filesize'] - 46 - 22)) {
     122                        $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)';
     123                }
     124                $info['error'][] = 'Cannot find End Of Central Directory - returned list of files in [zip][entries] array may not be complete';
     125                foreach ($info['zip']['entries'] as $key => $valuearray) {
     126                        $info['zip']['files'][$valuearray['filename']] = $valuearray['uncompressed_size'];
     127                }
     128                return true;
     129        }
     130
     131
     132        public function getZIPHeaderFilepointerTopDown() {
    111133                $info = &$this->getid3->info;
    112134
     
    154176
    155177
    156         function getZIPentriesFilepointer() {
     178        public function getZIPentriesFilepointer() {
    157179                $info = &$this->getid3->info;
    158180
     
    177199
    178200
    179         function ZIPparseLocalFileHeader() {
     201        public function ZIPparseLocalFileHeader() {
    180202                $LocalFileHeader['offset'] = ftell($this->getid3->fp);
    181203
     
    183205
    184206                $LocalFileHeader['raw']['signature']          = getid3_lib::LittleEndian2Int(substr($ZIPlocalFileHeader,  0, 4));
    185                 if ($LocalFileHeader['raw']['signature'] != 0x04034B50) {
     207                if ($LocalFileHeader['raw']['signature'] != 0x04034B50) { // "PK\x03\x04"
    186208                        // invalid Local File Header Signature
    187209                        fseek($this->getid3->fp, $LocalFileHeader['offset'], SEEK_SET); // seek back to where filepointer originally was so it can be handled properly
     
    219241                }
    220242
     243                if ($LocalFileHeader['compressed_size'] == 0) {
     244                        // *Could* be a zero-byte file
     245                        // But could also be a file written on the fly that didn't know compressed filesize beforehand.
     246                        // Correct compressed filesize should be in the data_descriptor located after this file data, and also in Central Directory (at end of zip file)
     247                        if (!empty($this->getid3->info['zip']['central_directory'])) {
     248                                foreach ($this->getid3->info['zip']['central_directory'] as $central_directory_entry) {
     249                                        if ($central_directory_entry['entry_offset'] == $LocalFileHeader['offset']) {
     250                                                if ($central_directory_entry['compressed_size'] > 0) {
     251                                                        // overwrite local zero value (but not ['raw']'compressed_size']) so that seeking for data_descriptor (and next file entry) works correctly
     252                                                        $LocalFileHeader['compressed_size'] = $central_directory_entry['compressed_size'];
     253                                                }
     254                                                break;
     255                                        }
     256                                }
     257                        }
     258
     259                }
    221260                $LocalFileHeader['data_offset'] = ftell($this->getid3->fp);
    222                 //$LocalFileHeader['compressed_data'] = fread($this->getid3->fp, $LocalFileHeader['raw']['compressed_size']);
    223                 fseek($this->getid3->fp, $LocalFileHeader['raw']['compressed_size'], SEEK_CUR);
     261                fseek($this->getid3->fp, $LocalFileHeader['compressed_size'], SEEK_CUR); // this should (but may not) match value in $LocalFileHeader['raw']['compressed_size'] -- $LocalFileHeader['compressed_size'] could have been overwritten above with value from Central Directory
    224262
    225263                if ($LocalFileHeader['flags']['data_descriptor_used']) {
    226                         $DataDescriptor = fread($this->getid3->fp, 12);
    227                         $LocalFileHeader['data_descriptor']['crc_32']            = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  0, 4));
    228                         $LocalFileHeader['data_descriptor']['compressed_size']   = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  4, 4));
    229                         $LocalFileHeader['data_descriptor']['uncompressed_size'] = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  8, 4));
    230                 }
    231 
     264                        $DataDescriptor = fread($this->getid3->fp, 16);
     265                        $LocalFileHeader['data_descriptor']['signature']         = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  0, 4));
     266                        if ($LocalFileHeader['data_descriptor']['signature'] != 0x08074B50) { // "PK\x07\x08"
     267                                $this->getid3->warning[] = 'invalid Local File Header Data Descriptor Signature at offset '.(ftell($this->getid3->fp) - 16).' - expecting 08 07 4B 50, found '.getid3_lib::PrintHexBytes($LocalFileHeader['data_descriptor']['signature']);
     268                                fseek($this->getid3->fp, $LocalFileHeader['offset'], SEEK_SET); // seek back to where filepointer originally was so it can be handled properly
     269                                return false;
     270                        }
     271                        $LocalFileHeader['data_descriptor']['crc_32']            = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  4, 4));
     272                        $LocalFileHeader['data_descriptor']['compressed_size']   = getid3_lib::LittleEndian2Int(substr($DataDescriptor,  8, 4));
     273                        $LocalFileHeader['data_descriptor']['uncompressed_size'] = getid3_lib::LittleEndian2Int(substr($DataDescriptor, 12, 4));
     274                        if (!$LocalFileHeader['raw']['compressed_size'] && $LocalFileHeader['data_descriptor']['compressed_size']) {
     275                                foreach ($this->getid3->info['zip']['central_directory'] as $central_directory_entry) {
     276                                        if ($central_directory_entry['entry_offset'] == $LocalFileHeader['offset']) {
     277                                                if ($LocalFileHeader['data_descriptor']['compressed_size'] == $central_directory_entry['compressed_size']) {
     278                                                        // $LocalFileHeader['compressed_size'] already set from Central Directory
     279                                                } else {
     280                                                        $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'];
     281                                                }
     282
     283                                                if ($LocalFileHeader['data_descriptor']['uncompressed_size'] == $central_directory_entry['uncompressed_size']) {
     284                                                        $LocalFileHeader['uncompressed_size'] = $LocalFileHeader['data_descriptor']['uncompressed_size'];
     285                                                } else {
     286                                                        $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'];
     287                                                }
     288                                                break;
     289                                        }
     290                                }
     291                        }
     292                }
    232293                return $LocalFileHeader;
    233294        }
    234295
    235296
    236         function ZIPparseCentralDirectory() {
     297        public function ZIPparseCentralDirectory() {
    237298                $CentralDirectory['offset'] = ftell($this->getid3->fp);
    238299
     
    290351        }
    291352
    292         function ZIPparseEndOfCentralDirectory() {
     353        public function ZIPparseEndOfCentralDirectory() {
    293354                $EndOfCentralDirectory['offset'] = ftell($this->getid3->fp);
    294355
     
    317378
    318379
    319         static function ZIPparseGeneralPurposeFlags($flagbytes, $compressionmethod) {
    320                 $ParsedFlags['encrypted'] = (bool) ($flagbytes & 0x0001);
     380        public static function ZIPparseGeneralPurposeFlags($flagbytes, $compressionmethod) {
     381                // https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip-printable.html
     382                $ParsedFlags['encrypted']               = (bool) ($flagbytes & 0x0001);
     383                //                                                             0x0002 -- see below
     384                //                                                             0x0004 -- see below
     385                $ParsedFlags['data_descriptor_used']    = (bool) ($flagbytes & 0x0008);
     386                $ParsedFlags['enhanced_deflation']      = (bool) ($flagbytes & 0x0010);
     387                $ParsedFlags['compressed_patched_data'] = (bool) ($flagbytes & 0x0020);
     388                $ParsedFlags['strong_encryption']       = (bool) ($flagbytes & 0x0040);
     389                //                                                             0x0080 - unused
     390                //                                                             0x0100 - unused
     391                //                                                             0x0200 - unused
     392                //                                                             0x0400 - unused
     393                $ParsedFlags['language_encoding']       = (bool) ($flagbytes & 0x0800);
     394                //                                                             0x1000 - reserved
     395                $ParsedFlags['mask_header_values']      = (bool) ($flagbytes & 0x2000);
     396                //                                                             0x4000 - reserved
     397                //                                                             0x8000 - reserved
    321398
    322399                switch ($compressionmethod) {
     
    344421                                break;
    345422                }
    346                 $ParsedFlags['data_descriptor_used']       = (bool) ($flagbytes & 0x0008);
    347423
    348424                return $ParsedFlags;
     
    350426
    351427
    352         static function ZIPversionOSLookup($index) {
     428        public static function ZIPversionOSLookup($index) {
    353429                static $ZIPversionOSLookup = array(
    354430                        0  => 'MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems)',
     
    369445                        15 => 'Alternate MVS',
    370446                        16 => 'BeOS',
    371                         17 => 'Tandem'
     447                        17 => 'Tandem',
     448                        18 => 'OS/400',
     449                        19 => 'OS/X (Darwin)',
    372450                );
    373451
     
    375453        }
    376454
    377         static function ZIPcompressionMethodLookup($index) {
     455        public static function ZIPcompressionMethodLookup($index) {
     456                // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/ZIP.html
    378457                static $ZIPcompressionMethodLookup = array(
    379458                        0  => 'store',
     
    387466                        8  => 'deflate',
    388467                        9  => 'deflate64',
    389                         10 => 'PKWARE Date Compression Library Imploding'
     468                        10 => 'Imploded (old IBM TERSE)',
     469                        11 => 'RESERVED[11]',
     470                        12 => 'BZIP2',
     471                        13 => 'RESERVED[13]',
     472                        14 => 'LZMA (EFS)',
     473                        15 => 'RESERVED[15]',
     474                        16 => 'RESERVED[16]',
     475                        17 => 'RESERVED[17]',
     476                        18 => 'IBM TERSE (new)',
     477                        19 => 'IBM LZ77 z Architecture (PFS)',
     478                        96 => 'JPEG recompressed',
     479                        97 => 'WavPack compressed',
     480                        98 => 'PPMd version I, Rev 1',
    390481                );
    391482
     
    393484        }
    394485
    395         static function DOStime2UNIXtime($DOSdate, $DOStime) {
     486        public static function DOStime2UNIXtime($DOSdate, $DOStime) {
    396487                // wFatDate
    397488                // Specifies the MS-DOS date. The date is a packed 16-bit value with the following format:
     
    420511
    421512}
    422 
    423 
    424 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.asf.php

    r62460 r71835  
    1919{
    2020
    21         function __construct(getID3 $getid3) {
     21        public function __construct(getID3 $getid3) {
    2222                parent::__construct($getid3);  // extends getid3_handler::__construct()
    2323
     
    3131        }
    3232
    33         function Analyze() {
     33        public function Analyze() {
    3434                $info = &$this->getid3->info;
    3535
     
    227227                                                        $thisfile_audio['bitrate_mode'] = (!empty($thisfile_audio['bitrate_mode']) ? $thisfile_audio['bitrate_mode'] : 'cbr');
    228228
    229                                                         $audiodata = getid3_riff::RIFFparseWAVEFORMATex(substr($StreamPropertiesObjectData['type_specific_data'], 0, 16));
     229                                                        $audiodata = getid3_riff::parseWAVEFORMATex(substr($StreamPropertiesObjectData['type_specific_data'], 0, 16));
    230230                                                        unset($audiodata['raw']);
    231231                                                        $thisfile_audio = getid3_lib::array_merge_noclobber($audiodata, $thisfile_audio);
     
    10341034                                                $audiomediaoffset = 0;
    10351035
    1036                                                 $thisfile_asf_audiomedia_currentstream = getid3_riff::RIFFparseWAVEFORMATex(substr($streamdata['type_specific_data'], $audiomediaoffset, 16));
     1036                                                $thisfile_asf_audiomedia_currentstream = getid3_riff::parseWAVEFORMATex(substr($streamdata['type_specific_data'], $audiomediaoffset, 16));
    10371037                                                $audiomediaoffset += 16;
    10381038
     
    11421142                                                }
    11431143
    1144                                                 $thisfile_asf_videomedia_currentstream['format_data']['codec'] = getid3_riff::RIFFfourccLookup($thisfile_asf_videomedia_currentstream['format_data']['codec_fourcc']);
     1144                                                $thisfile_asf_videomedia_currentstream['format_data']['codec'] = getid3_riff::fourccLookup($thisfile_asf_videomedia_currentstream['format_data']['codec_fourcc']);
    11451145
    11461146                                                $thisfile_video['streams'][$streamnumber]['fourcc']          = $thisfile_asf_videomedia_currentstream['format_data']['codec_fourcc'];
     
    14521452        }
    14531453
    1454         static function ASFCodecListObjectTypeLookup($CodecListType) {
     1454        public static function ASFCodecListObjectTypeLookup($CodecListType) {
    14551455                static $ASFCodecListObjectTypeLookup = array();
    14561456                if (empty($ASFCodecListObjectTypeLookup)) {
     
    14631463        }
    14641464
    1465         static function KnownGUIDs() {
     1465        public static function KnownGUIDs() {
    14661466                static $GUIDarray = array(
    14671467                        'GETID3_ASF_Extended_Stream_Properties_Object'   => '14E6A5CB-C672-4332-8399-A96952065B5A',
     
    15771577        }
    15781578
    1579         static function GUIDname($GUIDstring) {
     1579        public static function GUIDname($GUIDstring) {
    15801580                static $GUIDarray = array();
    15811581                if (empty($GUIDarray)) {
    1582                         $GUIDarray = getid3_asf::KnownGUIDs();
     1582                        $GUIDarray = self::KnownGUIDs();
    15831583                }
    15841584                return array_search($GUIDstring, $GUIDarray);
    15851585        }
    15861586
    1587         static function ASFIndexObjectIndexTypeLookup($id) {
     1587        public static function ASFIndexObjectIndexTypeLookup($id) {
    15881588                static $ASFIndexObjectIndexTypeLookup = array();
    15891589                if (empty($ASFIndexObjectIndexTypeLookup)) {
     
    15951595        }
    15961596
    1597         static function GUIDtoBytestring($GUIDstring) {
     1597        public static function GUIDtoBytestring($GUIDstring) {
    15981598                // Microsoft defines these 16-byte (128-bit) GUIDs in the strangest way:
    15991599                // first 4 bytes are in little-endian order
     
    16301630        }
    16311631
    1632         static function BytestringToGUID($Bytestring) {
     1632        public static function BytestringToGUID($Bytestring) {
    16331633                $GUIDstring  = str_pad(dechex(ord($Bytestring{3})),  2, '0', STR_PAD_LEFT);
    16341634                $GUIDstring .= str_pad(dechex(ord($Bytestring{2})),  2, '0', STR_PAD_LEFT);
     
    16551655        }
    16561656
    1657         static function FILETIMEtoUNIXtime($FILETIME, $round=true) {
     1657        public static function FILETIMEtoUNIXtime($FILETIME, $round=true) {
    16581658                // FILETIME is a 64-bit unsigned integer representing
    16591659                // the number of 100-nanosecond intervals since January 1, 1601
     
    16661666        }
    16671667
    1668         static function WMpictureTypeLookup($WMpictureType) {
     1668        public static function WMpictureTypeLookup($WMpictureType) {
    16691669                static $WMpictureTypeLookup = array();
    16701670                if (empty($WMpictureTypeLookup)) {
     
    16911691        }
    16921692
    1693         function ASF_HeaderExtensionObjectDataParse(&$asf_header_extension_object_data, &$unhandled_sections) {
     1693        public function ASF_HeaderExtensionObjectDataParse(&$asf_header_extension_object_data, &$unhandled_sections) {
    16941694                // http://msdn.microsoft.com/en-us/library/bb643323.aspx
    16951695
     
    19381938
    19391939
    1940         static function ASFmetadataLibraryObjectDataTypeLookup($id) {
     1940        public static function ASFmetadataLibraryObjectDataTypeLookup($id) {
    19411941                static $ASFmetadataLibraryObjectDataTypeLookup = array(
    19421942                        0x0000 => 'Unicode string', // The data consists of a sequence of Unicode characters
     
    19511951        }
    19521952
    1953         function ASF_WMpicture(&$data) {
     1953        public function ASF_WMpicture(&$data) {
    19541954                //typedef struct _WMPicture{
    19551955                //  LPWSTR  pwszMIMEType;
     
    20032003
    20042004        // Remove terminator 00 00 and convert UTF-16LE to Latin-1
    2005         static function TrimConvert($string) {
    2006                 return trim(getid3_lib::iconv_fallback('UTF-16LE', 'ISO-8859-1', getid3_asf::TrimTerm($string)), ' ');
     2005        public static function TrimConvert($string) {
     2006                return trim(getid3_lib::iconv_fallback('UTF-16LE', 'ISO-8859-1', self::TrimTerm($string)), ' ');
    20072007        }
    20082008
    20092009
    20102010        // Remove terminator 00 00
    2011         static function TrimTerm($string) {
     2011        public static function TrimTerm($string) {
    20122012                // remove terminator, only if present (it should be, but...)
    20132013                if (substr($string, -2) === "\x00\x00") {
     
    20182018
    20192019}
    2020 
    2021 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.bink.php

    r51852 r71835  
    1818{
    1919
    20         function Analyze() {
     20        public function Analyze() {
    2121                $info = &$this->getid3->info;
    2222
     
    4444        }
    4545
    46         function ParseBink() {
     46        public function ParseBink() {
    4747                $info = &$this->getid3->info;
    4848                $info['fileformat']          = 'bink';
     
    6161        }
    6262
    63         function ParseSmacker() {
     63        public function ParseSmacker() {
    6464                $info = &$this->getid3->info;
    6565                $info['fileformat']          = 'smacker';
     
    7070
    7171}
    72 
    73 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.flv.php

    r62460 r71835  
    55//            or http://www.getid3.org                         //
    66//                                                             //
    7 //  FLV module by Seth Kaufman <seth@whirl-i-gig.com>          //
     7//  FLV module by Seth Kaufman <sethØwhirl-i-gig*com>          //
    88//                                                             //
    99//  * version 0.1 (26 June 2005)                               //
     
    1515//  * version 0.2 (22 February 2006)                           //
    1616//  Support for On2 VP6 codec and meta information             //
    17 //    by Steve Webster <steve.webster@featurecreep.com>        //
     17//    by Steve Webster <steve.websterØfeaturecreep*com>        //
    1818//                                                             //
    1919//  * version 0.3 (15 June 2006)                               //
     
    2424//  Bugfixes for incorrectly parsed FLV dimensions             //
    2525//    and incorrect parsing of onMetaTag                       //
    26 //    by Evgeny Moysevich <moysevich@gmail.com>                //
     26//    by Evgeny Moysevich <moysevichØgmail*com>                //
    2727//                                                             //
    2828//  * version 0.5 (21 May 2009)                                //
     
    3030//    details. The duration is now read from onMetaTag (if     //
    3131//    exists), rather than parsing whole file                  //
    32 //    by Nigel Barnes <ngbarnes@hotmail.com>                   //
     32//    by Nigel Barnes <ngbarnesØhotmail*com>                   //
    3333//                                                             //
    3434//  * version 0.6 (24 May 2009)                                //
     
    7070class getid3_flv extends getid3_handler
    7171{
    72         var $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
    73 
    74         function Analyze() {
     72        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
     73
     74        public function Analyze() {
    7575                $info = &$this->getid3->info;
    7676
     
    318318
    319319
    320         function FLVaudioFormat($id) {
     320        public function FLVaudioFormat($id) {
    321321                $FLVaudioFormat = array(
    322322                        0  => 'Linear PCM, platform endian',
     
    340340        }
    341341
    342         function FLVaudioRate($id) {
     342        public function FLVaudioRate($id) {
    343343                $FLVaudioRate = array(
    344344                        0 =>  5500,
     
    350350        }
    351351
    352         function FLVaudioBitDepth($id) {
     352        public function FLVaudioBitDepth($id) {
    353353                $FLVaudioBitDepth = array(
    354354                        0 =>  8,
     
    358358        }
    359359
    360         function FLVvideoCodec($id) {
     360        public function FLVvideoCodec($id) {
    361361                $FLVvideoCodec = array(
    362362                        GETID3_FLV_VIDEO_H263         => 'Sorenson H.263',
     
    372372
    373373class AMFStream {
    374         var $bytes;
    375         var $pos;
    376 
    377         function AMFStream(&$bytes) {
     374        public $bytes;
     375        public $pos;
     376
     377        public function AMFStream(&$bytes) {
    378378                $this->bytes =& $bytes;
    379379                $this->pos = 0;
    380380        }
    381381
    382         function readByte() {
     382        public function readByte() {
    383383                return getid3_lib::BigEndian2Int(substr($this->bytes, $this->pos++, 1));
    384384        }
    385385
    386         function readInt() {
     386        public function readInt() {
    387387                return ($this->readByte() << 8) + $this->readByte();
    388388        }
    389389
    390         function readLong() {
     390        public function readLong() {
    391391                return ($this->readByte() << 24) + ($this->readByte() << 16) + ($this->readByte() << 8) + $this->readByte();
    392392        }
    393393
    394         function readDouble() {
     394        public function readDouble() {
    395395                return getid3_lib::BigEndian2Float($this->read(8));
    396396        }
    397397
    398         function readUTF() {
     398        public function readUTF() {
    399399                $length = $this->readInt();
    400400                return $this->read($length);
    401401        }
    402402
    403         function readLongUTF() {
     403        public function readLongUTF() {
    404404                $length = $this->readLong();
    405405                return $this->read($length);
    406406        }
    407407
    408         function read($length) {
     408        public function read($length) {
    409409                $val = substr($this->bytes, $this->pos, $length);
    410410                $this->pos += $length;
     
    412412        }
    413413
    414         function peekByte() {
     414        public function peekByte() {
    415415                $pos = $this->pos;
    416416                $val = $this->readByte();
     
    419419        }
    420420
    421         function peekInt() {
     421        public function peekInt() {
    422422                $pos = $this->pos;
    423423                $val = $this->readInt();
     
    426426        }
    427427
    428         function peekLong() {
     428        public function peekLong() {
    429429                $pos = $this->pos;
    430430                $val = $this->readLong();
     
    433433        }
    434434
    435         function peekDouble() {
     435        public function peekDouble() {
    436436                $pos = $this->pos;
    437437                $val = $this->readDouble();
     
    440440        }
    441441
    442         function peekUTF() {
     442        public function peekUTF() {
    443443                $pos = $this->pos;
    444444                $val = $this->readUTF();
     
    447447        }
    448448
    449         function peekLongUTF() {
     449        public function peekLongUTF() {
    450450                $pos = $this->pos;
    451451                $val = $this->readLongUTF();
     
    456456
    457457class AMFReader {
    458         var $stream;
    459 
    460         function AMFReader(&$stream) {
     458        public $stream;
     459
     460        public function AMFReader(&$stream) {
    461461                $this->stream =& $stream;
    462462        }
    463463
    464         function readData() {
     464        public function readData() {
    465465                $value = null;
    466466
     
    532532        }
    533533
    534         function readDouble() {
     534        public function readDouble() {
    535535                return $this->stream->readDouble();
    536536        }
    537537
    538         function readBoolean() {
     538        public function readBoolean() {
    539539                return $this->stream->readByte() == 1;
    540540        }
    541541
    542         function readString() {
     542        public function readString() {
    543543                return $this->stream->readUTF();
    544544        }
    545545
    546         function readObject() {
     546        public function readObject() {
    547547                // Get highest numerical index - ignored
    548548//              $highestIndex = $this->stream->readLong();
     
    561561        }
    562562
    563         function readMixedArray() {
     563        public function readMixedArray() {
    564564                // Get highest numerical index - ignored
    565565                $highestIndex = $this->stream->readLong();
     
    582582        }
    583583
    584         function readArray() {
     584        public function readArray() {
    585585                $length = $this->stream->readLong();
    586586                $data = array();
     
    592592        }
    593593
    594         function readDate() {
     594        public function readDate() {
    595595                $timestamp = $this->stream->readDouble();
    596596                $timezone = $this->stream->readInt();
     
    598598        }
    599599
    600         function readLongString() {
     600        public function readLongString() {
    601601                return $this->stream->readLongUTF();
    602602        }
    603603
    604         function readXML() {
     604        public function readXML() {
    605605                return $this->stream->readLongUTF();
    606606        }
    607607
    608         function readTypedObject() {
     608        public function readTypedObject() {
    609609                $className = $this->stream->readUTF();
    610610                return $this->readObject();
     
    613613
    614614class AVCSequenceParameterSetReader {
    615         var $sps;
    616         var $start = 0;
    617         var $currentBytes = 0;
    618         var $currentBits = 0;
    619         var $width;
    620         var $height;
    621 
    622         function AVCSequenceParameterSetReader($sps) {
     615        public $sps;
     616        public $start = 0;
     617        public $currentBytes = 0;
     618        public $currentBits = 0;
     619        public $width;
     620        public $height;
     621
     622        public function AVCSequenceParameterSetReader($sps) {
    623623                $this->sps = $sps;
    624624        }
    625625
    626         function readData() {
     626        public function readData() {
    627627                $this->skipBits(8);
    628628                $this->skipBits(8);
     
    676676        }
    677677
    678         function skipBits($bits) {
     678        public function skipBits($bits) {
    679679                $newBits = $this->currentBits + $bits;
    680680                $this->currentBytes += (int)floor($newBits / 8);
     
    682682        }
    683683
    684         function getBit() {
     684        public function getBit() {
    685685                $result = (getid3_lib::BigEndian2Int(substr($this->sps, $this->currentBytes, 1)) >> (7 - $this->currentBits)) & 0x01;
    686686                $this->skipBits(1);
     
    688688        }
    689689
    690         function getBits($bits) {
     690        public function getBits($bits) {
    691691                $result = 0;
    692692                for ($i = 0; $i < $bits; $i++) {
     
    696696        }
    697697
    698         function expGolombUe() {
     698        public function expGolombUe() {
    699699                $significantBits = 0;
    700700                $bit = $this->getBit();
     
    711711        }
    712712
    713         function expGolombSe() {
     713        public function expGolombSe() {
    714714                $result = $this->expGolombUe();
    715715                if (($result & 0x01) == 0) {
     
    720720        }
    721721
    722         function getWidth() {
     722        public function getWidth() {
    723723                return $this->width;
    724724        }
    725725
    726         function getHeight() {
     726        public function getHeight() {
    727727                return $this->height;
    728728        }
    729729}
    730 
    731 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.matroska.php

    r62460 r71835  
    1515
    1616
    17 // from: http://www.matroska.org/technical/specs/index.html
    1817define('EBML_ID_CHAPTERS',                  0x0043A770); // [10][43][A7][70] -- A system to define basic menus and partition data. For more detailed information, look at the Chapters Explanation.
    1918define('EBML_ID_SEEKHEAD',                  0x014D9B74); // [11][4D][9B][74] -- Contains the position of other level 1 elements.
     
    9190define('EBML_ID_SEEKID',                        0x13AB); //         [53][AB] -- The binary ID corresponding to the element name.
    9291define('EBML_ID_SEEKPOSITION',                  0x13AC); //         [53][AC] -- The position of the element in the segment in octets (0 = first level 1 element).
    93 define('EBML_ID_STEREOMODE',                    0x13B8); //         [53][B8] -- Stereo-3D video mode on 2 bits (0: mono, 1: right eye, 2: left eye, 3: both eyes).
     92define('EBML_ID_STEREOMODE',                    0x13B8); //         [53][B8] -- Stereo-3D video mode.
     93define('EBML_ID_OLDSTEREOMODE',                 0x13B9); //         [53][B9] -- Bogus StereoMode value used in old versions of libmatroska. DO NOT USE. (0: mono, 1: right eye, 2: left eye, 3: both eyes).
    9494define('EBML_ID_PIXELCROPBOTTOM',               0x14AA); //         [54][AA] -- The number of video pixels to remove at the bottom of the image (for HDTV content).
    9595define('EBML_ID_DISPLAYWIDTH',                  0x14B0); //         [54][B0] -- Width of the video frames to display.
     
    207207
    208208
     209/**
     210* @tutorial http://www.matroska.org/technical/specs/index.html
     211*
     212* @todo Rewrite EBML parser to reduce it's size and honor default element values
     213* @todo After rewrite implement stream size calculation, that will provide additional useful info and enable AAC/FLAC audio bitrate detection
     214*/
    209215class getid3_matroska extends getid3_handler
    210216{
    211217        // public options
    212         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]
    213     public static $parse_whole_file   = false; // true to parse the whole file, not only header [default: FALSE]
     218        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]
     219    public static $parse_whole_file = false; // true to parse the whole file, not only header [default: FALSE]
    214220
    215221    // private parser settings/placeholders
     
    219225    private $current_offset    = 0;
    220226    private $unuseful_elements = array(EBML_ID_CRC32, EBML_ID_VOID);
    221    
     227
    222228        public function Analyze()
    223229        {
     
    227233                try {
    228234                        $this->parseEBML($info);
    229                 }
    230                 catch (Exception $e) {
     235                } catch (Exception $e) {
    231236                        $info['error'][] = 'EBML parser: '.$e->getMessage();
    232237                }
     
    253258                if (isset($info['matroska']['tracks']['tracks']) && is_array($info['matroska']['tracks']['tracks'])) {
    254259                        foreach ($info['matroska']['tracks']['tracks'] as $key => $trackarray) {
    255                                
     260
    256261                                $track_info = array();
    257                                 $track_info['dataformat'] = self::MatroskaCodecIDtoCommonName($trackarray['CodecID']);
     262                                $track_info['dataformat'] = self::CodecIDtoCommonName($trackarray['CodecID']);
    258263                                $track_info['default'] = (isset($trackarray['FlagDefault']) ? $trackarray['FlagDefault'] : true);
    259264                                if (isset($trackarray['Name'])) { $track_info['name'] = $trackarray['Name']; }
    260                                
     265
    261266                                switch ($trackarray['TrackType']) {
    262                                        
     267
    263268                                        case 1: // Video
    264269                                                $track_info['resolution_x'] = $trackarray['PixelWidth'];
    265270                                                $track_info['resolution_y'] = $trackarray['PixelHeight'];
    266                                                 if (isset($trackarray['DisplayWidth']))    { $track_info['display_x']  = $trackarray['DisplayWidth']; }
    267                                                 if (isset($trackarray['DisplayHeight']))   { $track_info['display_y']  = $trackarray['DisplayHeight']; }
    268                                                 if (isset($trackarray['DefaultDuration'])) { $track_info['frame_rate'] = round(1000000000 / $trackarray['DefaultDuration'], 3); }
    269                                                 //if (isset($trackarray['CodecName']))       { $track_info['codec']      = $trackarray['CodecName']; }
    270                                                
     271                                                $track_info['display_unit'] = self::displayUnit(isset($trackarray['DisplayUnit']) ? $trackarray['DisplayUnit'] : 0);
     272                                                $track_info['display_x']    = (isset($trackarray['DisplayWidth']) ? $trackarray['DisplayWidth'] : $trackarray['PixelWidth']);
     273                                                $track_info['display_y']    = (isset($trackarray['DisplayHeight']) ? $trackarray['DisplayHeight'] : $trackarray['PixelHeight']);
     274
     275                                                if (isset($trackarray['PixelCropBottom'])) { $track_info['crop_bottom'] = $trackarray['PixelCropBottom']; }
     276                                                if (isset($trackarray['PixelCropTop']))    { $track_info['crop_top']    = $trackarray['PixelCropTop']; }
     277                                                if (isset($trackarray['PixelCropLeft']))   { $track_info['crop_left']   = $trackarray['PixelCropLeft']; }
     278                                                if (isset($trackarray['PixelCropRight']))  { $track_info['crop_right']  = $trackarray['PixelCropRight']; }
     279                                                if (isset($trackarray['DefaultDuration'])) { $track_info['frame_rate']  = round(1000000000 / $trackarray['DefaultDuration'], 3); }
     280                                                if (isset($trackarray['CodecName']))       { $track_info['codec']       = $trackarray['CodecName']; }
     281
    271282                                                switch ($trackarray['CodecID']) {
    272283                                                        case 'V_MS/VFW/FOURCC':
    273284                                                                if (!getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.riff.php', __FILE__, false)) {
    274                                                                         $this->getid3->warning('Unable to parse codec private data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio-video.riff.php"');
     285                                                                        $this->warning('Unable to parse codec private data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio-video.riff.php"');
    275286                                                                        break;
    276287                                                                }
    277288                                                                $parsed = getid3_riff::ParseBITMAPINFOHEADER($trackarray['CodecPrivate']);
    278                                                                 $track_info['codec'] = getid3_riff::RIFFfourccLookup($parsed['fourcc']);
     289                                                                $track_info['codec'] = getid3_riff::fourccLookup($parsed['fourcc']);
    279290                                                                $info['matroska']['track_codec_parsed'][$trackarray['TrackNumber']] = $parsed;
    280291                                                                break;
     292
     293                                                        /*case 'V_MPEG4/ISO/AVC':
     294                                                                $h264['profile']    = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], 1, 1));
     295                                                                $h264['level']      = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], 3, 1));
     296                                                                $rn                 = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], 4, 1));
     297                                                                $h264['NALUlength'] = ($rn & 3) + 1;
     298                                                                $rn                 = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], 5, 1));
     299                                                                $nsps               = ($rn & 31);
     300                                                                $offset             = 6;
     301                                                                for ($i = 0; $i < $nsps; $i ++) {
     302                                                                        $length        = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], $offset, 2));
     303                                                                        $h264['SPS'][] = substr($trackarray['CodecPrivate'], $offset + 2, $length);
     304                                                                        $offset       += 2 + $length;
     305                                                                }
     306                                                                $npps               = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], $offset, 1));
     307                                                                $offset            += 1;
     308                                                                for ($i = 0; $i < $npps; $i ++) {
     309                                                                        $length        = getid3_lib::BigEndian2Int(substr($trackarray['CodecPrivate'], $offset, 2));
     310                                                                        $h264['PPS'][] = substr($trackarray['CodecPrivate'], $offset + 2, $length);
     311                                                                        $offset       += 2 + $length;
     312                                                                }
     313                                                                $info['matroska']['track_codec_parsed'][$trackarray['TrackNumber']] = $h264;
     314                                                                break;*/
    281315                                                }
    282                                                
     316
    283317                                                $info['video']['streams'][] = $track_info;
    284318                                                break;
    285                                        
     319
    286320                                        case 2: // Audio
    287321                                                $track_info['sample_rate'] = (isset($trackarray['SamplingFrequency']) ? $trackarray['SamplingFrequency'] : 8000.0);
     
    289323                                                $track_info['language']    = (isset($trackarray['Language']) ? $trackarray['Language'] : 'eng');
    290324                                                if (isset($trackarray['BitDepth']))  { $track_info['bits_per_sample'] = $trackarray['BitDepth']; }
    291                                                 //if (isset($trackarray['CodecName'])) { $track_info['codec']           = $trackarray['CodecName']; }
    292                                                
     325                                                if (isset($trackarray['CodecName'])) { $track_info['codec']           = $trackarray['CodecName']; }
     326
    293327                                                switch ($trackarray['CodecID']) {
    294328                                                        case 'A_PCM/INT/LIT':
     
    300334                                                        case 'A_DTS':
    301335                                                        case 'A_MPEG/L3':
    302                                                         //case 'A_FLAC':
    303                                                                 if (!getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.'.$track_info['dataformat'].'.php', __FILE__, false)) {
    304                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio.'.$track_info['dataformat'].'.php"');
     336                                                        case 'A_MPEG/L2':
     337                                                        case 'A_FLAC':
     338                                                                if (!getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.'.($track_info['dataformat'] == 'mp2' ? 'mp3' : $track_info['dataformat']).'.php', __FILE__, false)) {
     339                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio.'.$track_info['dataformat'].'.php"');
    305340                                                                        break;
    306341                                                                }
    307342
    308343                                                                if (!isset($info['matroska']['track_data_offsets'][$trackarray['TrackNumber']])) {
    309                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because $info[matroska][track_data_offsets]['.$trackarray['TrackNumber'].'] not set');
     344                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because $info[matroska][track_data_offsets]['.$trackarray['TrackNumber'].'] not set');
    310345                                                                        break;
    311346                                                                }
     
    313348                                                                // create temp instance
    314349                                                                $getid3_temp = new getID3();
    315                                                                 $getid3_temp->openfile($this->getid3->filename);
     350                                                                if ($track_info['dataformat'] != 'flac') {
     351                                                                        $getid3_temp->openfile($this->getid3->filename);
     352                                                                }
    316353                                                                $getid3_temp->info['avdataoffset'] = $info['matroska']['track_data_offsets'][$trackarray['TrackNumber']]['offset'];
    317                                                                 if ($track_info['dataformat'] == 'mp3' || $track_info['dataformat'] == 'flac') {
     354                                                                if ($track_info['dataformat'][0] == 'm' || $track_info['dataformat'] == 'flac') {
    318355                                                                        $getid3_temp->info['avdataend'] = $info['matroska']['track_data_offsets'][$trackarray['TrackNumber']]['offset'] + $info['matroska']['track_data_offsets'][$trackarray['TrackNumber']]['length'];
    319356                                                                }
    320357
    321358                                                                // analyze
    322                                                                 $class = 'getid3_'.$track_info['dataformat'];
    323                                                                 $header_data_key = $track_info['dataformat'] == 'mp3' ? 'mpeg' : $track_info['dataformat'];
    324                                                                 $getid3_audio = new $class($getid3_temp);
    325                                                                 if ($track_info['dataformat'] == 'mp3') {
    326                                                                         $getid3_audio->allow_bruteforce = true;
    327                                                                 }
     359                                                                $class = 'getid3_'.($track_info['dataformat'] == 'mp2' ? 'mp3' : $track_info['dataformat']);
     360                                                                $header_data_key = $track_info['dataformat'][0] == 'm' ? 'mpeg' : $track_info['dataformat'];
     361                                                                $getid3_audio = new $class($getid3_temp, __CLASS__);
    328362                                                                if ($track_info['dataformat'] == 'flac') {
    329363                                                                        $getid3_audio->AnalyzeString($trackarray['CodecPrivate']);
     
    333367                                                                }
    334368                                                                if (!empty($getid3_temp->info[$header_data_key])) {
    335                                                                         unset($getid3_temp->info[$header_data_key]['GETID3_VERSION']);
    336369                                                                        $info['matroska']['track_codec_parsed'][$trackarray['TrackNumber']] = $getid3_temp->info[$header_data_key];
    337370                                                                        if (isset($getid3_temp->info['audio']) && is_array($getid3_temp->info['audio'])) {
     
    342375                                                                }
    343376                                                                else {
    344                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because '.$class.'::Analyze() failed at offset '.$getid3_temp->info['avdataoffset']);
     377                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because '.$class.'::Analyze() failed at offset '.$getid3_temp->info['avdataoffset']);
    345378                                                                }
    346379
     
    348381                                                                if (!empty($getid3_temp->info['error'])) {
    349382                                                                        foreach ($getid3_temp->info['error'] as $newerror) {
    350                                                                                 $this->getid3->warning($class.'() says: ['.$newerror.']');
     383                                                                                $this->warning($class.'() says: ['.$newerror.']');
    351384                                                                        }
    352385                                                                }
     
    357390                                                                                        continue;
    358391                                                                                }
    359                                                                                 $this->getid3->warning($class.'() says: ['.$newerror.']');
     392                                                                                $this->warning($class.'() says: ['.$newerror.']');
    360393                                                                        }
    361394                                                                }
     
    365398                                                        case 'A_AAC':
    366399                                                        case 'A_AAC/MPEG2/LC':
     400                                                        case 'A_AAC/MPEG2/LC/SBR':
    367401                                                        case 'A_AAC/MPEG4/LC':
    368402                                                        case 'A_AAC/MPEG4/LC/SBR':
    369                                                             $this->getid3->warning($trackarray['CodecID'].' audio data contains no header, audio/video bitrates can\'t be calculated');
     403                                                            $this->warning($trackarray['CodecID'].' audio data contains no header, audio/video bitrates can\'t be calculated');
    370404                                                                break;
    371405
    372406                                                        case 'A_VORBIS':
    373407                                                                if (!isset($trackarray['CodecPrivate'])) {
    374                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because CodecPrivate data not set');
     408                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because CodecPrivate data not set');
    375409                                                                        break;
    376410                                                                }
    377411                                                                $vorbis_offset = strpos($trackarray['CodecPrivate'], 'vorbis', 1);
    378412                                                                if ($vorbis_offset === false) {
    379                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because CodecPrivate data does not contain "vorbis" keyword');
     413                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because CodecPrivate data does not contain "vorbis" keyword');
    380414                                                                        break;
    381415                                                                }
     
    383417
    384418                                                                if (!getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.ogg.php', __FILE__, false)) {
    385                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio.ogg.php"');
     419                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio.ogg.php"');
     420                                                                        break;
    386421                                                                }
    387422
    388423                                                                // create temp instance
    389424                                                                $getid3_temp = new getID3();
    390                                                                 $getid3_temp->openfile($this->getid3->filename);
    391425
    392426                                                                // analyze
     
    402436                                                                        }
    403437                                                                }
    404                                                                
     438
    405439                                                                // copy errors and warnings
    406440                                                                if (!empty($getid3_temp->info['error'])) {
    407441                                                                        foreach ($getid3_temp->info['error'] as $newerror) {
    408                                                                                 $this->getid3->warning('getid3_ogg() says: ['.$newerror.']');
     442                                                                                $this->warning('getid3_ogg() says: ['.$newerror.']');
    409443                                                                        }
    410444                                                                }
    411445                                                                if (!empty($getid3_temp->info['warning'])) {
    412446                                                                        foreach ($getid3_temp->info['warning'] as $newerror) {
    413                                                                                 $this->getid3->warning('getid3_ogg() says: ['.$newerror.']');
     447                                                                                $this->warning('getid3_ogg() says: ['.$newerror.']');
    414448                                                                        }
    415449                                                                }
    416                                                                
     450
    417451                                                                if (!empty($getid3_temp->info['ogg']['bitrate_nominal'])) {
    418452                                                                        $track_info['bitrate'] = $getid3_temp->info['ogg']['bitrate_nominal'];
     
    423457                                                        case 'A_MS/ACM':
    424458                                                                if (!getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.riff.php', __FILE__, false)) {
    425                                                                         $this->getid3->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio-video.riff.php"');
     459                                                                        $this->warning('Unable to parse audio data ['.basename(__FILE__).':'.__LINE__.'] because cannot include "module.audio-video.riff.php"');
    426460                                                                        break;
    427461                                                                }
    428                                                                
    429                                                                 $parsed = getid3_riff::RIFFparseWAVEFORMATex($trackarray['CodecPrivate']);
     462
     463                                                                $parsed = getid3_riff::parseWAVEFORMATex($trackarray['CodecPrivate']);
    430464                                                                foreach ($parsed as $key => $value) {
    431465                                                                        if ($key != 'raw') {
     
    435469                                                                $info['matroska']['track_codec_parsed'][$trackarray['TrackNumber']] = $parsed;
    436470                                                                break;
    437                                                                
     471
    438472                                                        default:
    439                                                                 $this->getid3->warning('Unhandled audio type "'.(isset($trackarray['CodecID']) ? $trackarray['CodecID'] : '').'"');
     473                                                                $this->warning('Unhandled audio type "'.(isset($trackarray['CodecID']) ? $trackarray['CodecID'] : '').'"');
    440474                                                }
    441475
     
    444478                                }
    445479                        }
    446                
     480
    447481                        if (!empty($info['video']['streams'])) {
    448482                                $info['video'] = self::getDefaultStreamInfo($info['video']['streams']);
     
    450484                        if (!empty($info['audio']['streams'])) {
    451485                                $info['audio'] = self::getDefaultStreamInfo($info['audio']['streams']);
     486                        }
     487                }
     488
     489                // process attachments
     490                if (isset($info['matroska']['attachments']) && $this->getid3->option_save_attachments !== getID3::ATTACHMENTS_NONE) {
     491                        foreach ($info['matroska']['attachments'] as $i => $entry) {
     492                                if (strpos($entry['FileMimeType'], 'image/') === 0 && !empty($entry['FileData'])) {
     493                                        $info['matroska']['comments']['picture'][] = array('data' => $entry['FileData'], 'image_mime' => $entry['FileMimeType'], 'filename' => $entry['FileName']);
     494                                }
    452495                        }
    453496                }
     
    465508        }
    466509
    467 
    468 ///////////////////////////////////////
    469 
    470     private function parseEBML(&$info)
    471     {
     510    private function parseEBML(&$info) {
    472511                // http://www.matroska.org/technical/specs/index.html#EBMLBasics
    473512                $this->current_offset = $info['avdataoffset'];
     
    565604                                                                                case EBML_ID_TRACKENTRY: //subelements: Describes a track with all elements.
    566605
    567                                                                                         while ($this->getEBMLelement($subelement, $track_entry['end'], array(EBML_ID_VIDEO, EBML_ID_AUDIO, EBML_ID_CONTENTENCODINGS))) {
     606                                                                                        while ($this->getEBMLelement($subelement, $track_entry['end'], array(EBML_ID_VIDEO, EBML_ID_AUDIO, EBML_ID_CONTENTENCODINGS, EBML_ID_CODECPRIVATE))) {
    568607                                                                                                switch ($subelement['id']) {
    569608
     
    588627                                                                                                                $track_entry[$subelement['id_name']] = getid3_lib::trimNullByte($subelement['data']);
    589628                                                                                                                break;
    590                                                                                                                
     629
    591630                                                                                                        case EBML_ID_CODECPRIVATE:
    592                                                                                                                 $track_entry[$subelement['id_name']] = $subelement['data'];
     631                                                                                                                $track_entry[$subelement['id_name']] = $this->readEBMLelementData($subelement['length'], true);
    593632                                                                                                                break;
    594633
     
    608647                                                                                                                                case EBML_ID_PIXELWIDTH:
    609648                                                                                                                                case EBML_ID_PIXELHEIGHT:
    610                                                                                                                                 case EBML_ID_STEREOMODE:
    611649                                                                                                                                case EBML_ID_PIXELCROPBOTTOM:
    612650                                                                                                                                case EBML_ID_PIXELCROPTOP:
     
    617655                                                                                                                                case EBML_ID_DISPLAYUNIT:
    618656                                                                                                                                case EBML_ID_ASPECTRATIOTYPE:
     657                                                                                                                                case EBML_ID_STEREOMODE:
     658                                                                                                                                case EBML_ID_OLDSTEREOMODE:
    619659                                                                                                                                        $track_entry[$sub_subelement['id_name']] = getid3_lib::BigEndian2Int($sub_subelement['data']);
    620660                                                                                                                                        break;
     
    753793                                                                        switch ($subelement['id']) {
    754794
    755                                                                                 case EBML_ID_CHAPTERTRANSLATEEDITIONUID:
    756                                                                                 case EBML_ID_CHAPTERTRANSLATECODEC:
    757795                                                                                case EBML_ID_TIMECODESCALE:
    758796                                                                                        $info_entry[$subelement['id_name']] = getid3_lib::BigEndian2Int($subelement['data']);
     
    771809                                                                                case EBML_ID_PREVUID:
    772810                                                                                case EBML_ID_NEXTUID:
     811                                                                                        $info_entry[$subelement['id_name']] = getid3_lib::trimNullByte($subelement['data']);
     812                                                                                        break;
     813
    773814                                                                                case EBML_ID_SEGMENTFAMILY:
    774                                                                                 case EBML_ID_CHAPTERTRANSLATEID:
    775                                                                                         $info_entry[$subelement['id_name']] = getid3_lib::trimNullByte($subelement['data']);
     815                                                                                        $info_entry[$subelement['id_name']][] = getid3_lib::trimNullByte($subelement['data']);
    776816                                                                                        break;
    777817
     
    786826                                                                                        break;
    787827
     828                                                                                case EBML_ID_CHAPTERTRANSLATE:
     829                                                                                        $chaptertranslate_entry = array();
     830
     831                                                                                        while ($this->getEBMLelement($sub_subelement, $subelement['end'], true)) {
     832                                                                                                switch ($sub_subelement['id']) {
     833
     834                                                                                                        case EBML_ID_CHAPTERTRANSLATEEDITIONUID:
     835                                                                                                                $chaptertranslate_entry[$sub_subelement['id_name']][] = getid3_lib::BigEndian2Int($sub_subelement['data']);
     836                                                                                                                break;
     837
     838                                                                                                        case EBML_ID_CHAPTERTRANSLATECODEC:
     839                                                                                                                $chaptertranslate_entry[$sub_subelement['id_name']] = getid3_lib::BigEndian2Int($sub_subelement['data']);
     840                                                                                                                break;
     841
     842                                                                                                        case EBML_ID_CHAPTERTRANSLATEID:
     843                                                                                                                $chaptertranslate_entry[$sub_subelement['id_name']] = getid3_lib::trimNullByte($sub_subelement['data']);
     844                                                                                                                break;
     845
     846                                                                                                        default:
     847                                                                                                                $this->unhandledElement('info.chaptertranslate', __LINE__, $sub_subelement);
     848                                                                                                }
     849                                                                                        }
     850                                                                                        $info_entry[$subelement['id_name']] = $chaptertranslate_entry;
     851                                                                                        break;
     852
    788853                                                                                default:
    789854                                                                                        $this->unhandledElement('info', __LINE__, $subelement);
     
    811876                                                                                                        case EBML_ID_CUETRACKPOSITIONS:
    812877                                                        $cuetrackpositions_entry = array();
    813                                                                                                        
     878
    814879                                                                                                                while ($this->getEBMLelement($sub_sub_subelement, $sub_subelement['end'], true)) {
    815880                                                                                                                        switch ($sub_sub_subelement['id']) {
     
    849914                                                        case EBML_ID_TAGS: // Element containing elements specific to Tracks/Chapters.
    850915                                $tags_entry = array();
    851                                                        
     916
    852917                                                                while ($this->getEBMLelement($subelement, $element_data['end'], false)) {
    853918                                                                        switch ($subelement['id']) {
     
    855920                                                                                case EBML_ID_TAG:
    856921                                                                                        $tag_entry = array();
    857                                                                                
     922
    858923                                                                                        while ($this->getEBMLelement($sub_subelement, $subelement['end'], false)) {
    859924                                                                                                switch ($sub_subelement['id']) {
     
    867932                                                                                                                                case EBML_ID_TARGETTYPEVALUE:
    868933                                                                                                                                        $targets_entry[$sub_sub_subelement['id_name']] = getid3_lib::BigEndian2Int($sub_sub_subelement['data']);
    869                                                                                                                                         $targets_entry[strtolower($sub_sub_subelement['id_name']).'_long'] = self::MatroskaTargetTypeValue($targets_entry[$sub_sub_subelement['id_name']]);
     934                                                                                                                                        $targets_entry[strtolower($sub_sub_subelement['id_name']).'_long'] = self::TargetTypeValue($targets_entry[$sub_sub_subelement['id_name']]);
    870935                                                                                                                                        break;
    871936
     
    873938                                                                                                                                        $targets_entry[$sub_sub_subelement['id_name']] = $sub_sub_subelement['data'];
    874939                                                                                                                                        break;
    875                                                                                                                                
    876                                                                                                                                 case EBML_ID_TAGTRACKUID:       
     940
     941                                                                                                                                case EBML_ID_TAGTRACKUID:
    877942                                                                                                                                case EBML_ID_TAGEDITIONUID:
    878943                                                                                                                                case EBML_ID_TAGCHAPTERUID:
     
    927992                                                                                                                $attachedfile_entry['data_length'] = $sub_subelement['length'];
    928993
    929                                                                                                                 $this->getid3->saveAttachment(
    930                                                                                                                         $attachedfile_entry[$sub_subelement['id_name']],
     994                                                                                                                $attachedfile_entry[$sub_subelement['id_name']] = $this->saveAttachment(
    931995                                                                                                                        $attachedfile_entry['FileName'],
    932996                                                                                                                        $attachedfile_entry['data_offset'],
    933997                                                                                                                        $attachedfile_entry['data_length']);
    934 
    935                                                                                                                 if (@$attachedfile_entry[$sub_subelement['id_name']] && is_file($attachedfile_entry[$sub_subelement['id_name']])) {
    936                                                                                                                         $attachedfile_entry[$sub_subelement['id_name'].'_filename'] = $attachedfile_entry[$sub_subelement['id_name']];
    937                                                                                                                         unset($attachedfile_entry[$sub_subelement['id_name']]);
    938                                                                                                                 }
    939998
    940999                                                                                                                $this->current_offset = $sub_subelement['end'];
     
    9491008                                                                                                }
    9501009                                                                                        }
    951                                                                                         if (!empty($attachedfile_entry['FileData']) && !empty($attachedfile_entry['FileMimeType']) && preg_match('#^image/#i', $attachedfile_entry['FileMimeType'])) {
    952                                                                                                 if ($this->getid3->option_save_attachments === getID3::ATTACHMENTS_INLINE) {
    953                                                                                                         $attachedfile_entry['data']       = $attachedfile_entry['FileData'];
    954                                                                                                         $attachedfile_entry['image_mime'] = $attachedfile_entry['FileMimeType'];
    955                                                                                                         $info['matroska']['comments']['picture'][] = array('data' => $attachedfile_entry['data'], 'image_mime' => $attachedfile_entry['image_mime'], 'filename' => (!empty($attachedfile_entry['FileName']) ? $attachedfile_entry['FileName'] : ''));
    956                                                                                                         unset($attachedfile_entry['FileData'], $attachedfile_entry['FileMimeType']);
    957                                                                                                 }
    958                                                                                         }
    959                                                                                         if (!empty($attachedfile_entry['image_mime']) && preg_match('#^image/#i', $attachedfile_entry['image_mime'])) {
    960                                                                                                 // don't add a second copy of attached images, which are grouped under the standard location [comments][picture]
    961                                                                                         } else {
    962                                                                                                 $info['matroska']['attachments'][] = $attachedfile_entry;
    963                                                                                         }
     1010                                                                                        $info['matroska']['attachments'][] = $attachedfile_entry;
    9641011                                                                                        break;
    9651012
     
    11161163                                                                                                                $cluster_block_group[$sub_subelement['id_name']][] = getid3_lib::BigEndian2Int($sub_subelement['data'], false, true);
    11171164                                                                                                                break;
    1118                                                                                                        
     1165
    11191166                                                                                                        case EBML_ID_CLUSTERCODECSTATE:
    11201167                                                                                                                $cluster_block_group[$sub_subelement['id_name']] = getid3_lib::trimNullByte($sub_subelement['data']);
     
    11451192                                                                        if (isset($info['matroska']['info']) && is_array($info['matroska']['info'])) {
    11461193                                                                                if (isset($info['matroska']['tracks']['tracks']) && is_array($info['matroska']['tracks']['tracks'])) {
    1147                                                                                         return;
     1194                                                                                        if (count($info['matroska']['track_data_offsets']) == count($info['matroska']['tracks']['tracks'])) {
     1195                                                                                                return;
     1196                                                                                        }
    11481197                                                                                }
    11491198                                                                        }
     
    11631212    }
    11641213
    1165         private function EnsureBufferHasEnoughData($min_data = 1024)
    1166         {
     1214        private function EnsureBufferHasEnoughData($min_data=1024) {
    11671215                if (($this->current_offset - $this->EBMLbuffer_offset) >= ($this->EBMLbuffer_length - $min_data)) {
    1168 
    1169                         if (!getid3_lib::intValueSupported($this->current_offset + $this->getid3->fread_buffer_size())) {
    1170                                 $this->getid3->info['error'][] = 'EBML parser: cannot read past '.$this->current_offset;
     1216                        $read_bytes = max($min_data, $this->getid3->fread_buffer_size());
     1217
     1218                        try {
     1219                                $this->fseek($this->current_offset);
     1220                                $this->EBMLbuffer_offset = $this->current_offset;
     1221                                $this->EBMLbuffer        = $this->fread($read_bytes);
     1222                                $this->EBMLbuffer_length = strlen($this->EBMLbuffer);
     1223                        } catch (getid3_exception $e) {
     1224                                $this->warning('EBML parser: '.$e->getMessage());
    11711225                                return false;
    11721226                        }
    11731227
    1174                         fseek($this->getid3->fp, $this->current_offset, SEEK_SET);
    1175                         $this->EBMLbuffer_offset = $this->current_offset;
    1176                         $this->EBMLbuffer = fread($this->getid3->fp, max($min_data, $this->getid3->fread_buffer_size()));
    1177                         $this->EBMLbuffer_length = strlen($this->EBMLbuffer);
    1178 
    1179                         if ($this->EBMLbuffer_length == 0 && feof($this->getid3->fp)) {
    1180                                 $this->getid3->info['error'][] = 'EBML parser: ran out of file at offset '.$this->current_offset;
    1181                                 return false;
     1228                        if ($this->EBMLbuffer_length == 0 && $this->feof()) {
     1229                                return $this->error('EBML parser: ran out of file at offset '.$this->current_offset);
    11821230                        }
    11831231                }
    1184 
    11851232                return true;
    11861233        }
    11871234
    1188         private function readEBMLint()
    1189         {
     1235        private function readEBMLint() {
    11901236                $actual_offset = $this->current_offset - $this->EBMLbuffer_offset;
    11911237
    11921238                // get length of integer
    11931239                $first_byte_int = ord($this->EBMLbuffer[$actual_offset]);
    1194                 if (0x80 & $first_byte_int) {
     1240                if       (0x80 & $first_byte_int) {
    11951241                        $length = 1;
    11961242                } elseif (0x40 & $first_byte_int) {
     
    12191265        }
    12201266
    1221         private function readEBMLelementData($length)
    1222         {
     1267        private function readEBMLelementData($length, $check_buffer=false) {
     1268                if ($check_buffer && !$this->EnsureBufferHasEnoughData($length)) {
     1269                        return false;
     1270                }
    12231271                $data = substr($this->EBMLbuffer, $this->current_offset - $this->EBMLbuffer_offset, $length);
    12241272                $this->current_offset += $length;
    1225 
    12261273                return $data;
    12271274        }
    12281275
    1229         private function getEBMLelement(&$element, $parent_end, $get_data = false)
    1230         {
     1276        private function getEBMLelement(&$element, $parent_end, $get_data=false) {
    12311277                if ($this->current_offset >= $parent_end) {
    12321278                        return false;
     
    12641310        }
    12651311
    1266         private function unhandledElement($type, $line, $element)
    1267         {
     1312        private function unhandledElement($type, $line, $element) {
    12681313                // warn only about unknown and missed elements, not about unuseful
    12691314                if (!in_array($element['id'], $this->unuseful_elements)) {
    1270                         $this->getid3->warning('Unhandled '.$type.' element ['.basename(__FILE__).':'.$line.'] ('.$element['id'].'::'.$element['id_name'].' ['.$element['length'].' bytes]) at '.$element['offset']);
     1315                        $this->warning('Unhandled '.$type.' element ['.basename(__FILE__).':'.$line.'] ('.$element['id'].'::'.$element['id_name'].' ['.$element['length'].' bytes]) at '.$element['offset']);
    12711316                }
    12721317
     
    12771322        }
    12781323
    1279         private function ExtractCommentsSimpleTag($SimpleTagArray)
    1280         {
     1324        private function ExtractCommentsSimpleTag($SimpleTagArray) {
    12811325                if (!empty($SimpleTagArray['SimpleTag'])) {
    12821326                        foreach ($SimpleTagArray['SimpleTag'] as $SimpleTagKey => $SimpleTagData) {
     
    12931337        }
    12941338
    1295         private function HandleEMBLSimpleTag($parent_end)
    1296         {
     1339        private function HandleEMBLSimpleTag($parent_end) {
    12971340                $simpletag_entry = array();
    12981341
     
    13231366        }
    13241367
    1325         private function HandleEMBLClusterBlock($element, $block_type, &$info)
    1326         {
     1368        private function HandleEMBLClusterBlock($element, $block_type, &$info) {
    13271369                // http://www.matroska.org/technical/specs/index.html#block_structure
    13281370                // http://www.matroska.org/technical/specs/index.html#simpleblock_structure
    13291371
    1330                 $cluster_block_data = array();
    1331                 $cluster_block_data['tracknumber'] = $this->readEBMLint();
    1332                 $cluster_block_data['timecode']    = getid3_lib::BigEndian2Int($this->readEBMLelementData(2));
    1333                 $cluster_block_data['flags_raw']   = getid3_lib::BigEndian2Int($this->readEBMLelementData(1));
     1372                $block_data = array();
     1373                $block_data['tracknumber'] = $this->readEBMLint();
     1374                $block_data['timecode']    = getid3_lib::BigEndian2Int($this->readEBMLelementData(2), false, true);
     1375                $block_data['flags_raw']   = getid3_lib::BigEndian2Int($this->readEBMLelementData(1));
    13341376
    13351377                if ($block_type == EBML_ID_CLUSTERSIMPLEBLOCK) {
    1336                         $cluster_block_data['flags']['keyframe']  = (($cluster_block_data['flags_raw'] & 0x80) >> 7);
    1337                         //$cluster_block_data['flags']['reserved1'] = (($cluster_block_data['flags_raw'] & 0x70) >> 4);
     1378                        $block_data['flags']['keyframe']  = (($block_data['flags_raw'] & 0x80) >> 7);
     1379                        //$block_data['flags']['reserved1'] = (($block_data['flags_raw'] & 0x70) >> 4);
    13381380                }
    13391381                else {
    1340                         //$cluster_block_data['flags']['reserved1'] = (($cluster_block_data['flags_raw'] & 0xF0) >> 4);
    1341                 }
    1342                 $cluster_block_data['flags']['invisible'] = (bool)(($cluster_block_data['flags_raw'] & 0x08) >> 3);
    1343                 $cluster_block_data['flags']['lacing']    =       (($cluster_block_data['flags_raw'] & 0x06) >> 1);  // 00=no lacing; 01=Xiph lacing; 11=EBML lacing; 10=fixed-size lacing
     1382                        //$block_data['flags']['reserved1'] = (($block_data['flags_raw'] & 0xF0) >> 4);
     1383                }
     1384                $block_data['flags']['invisible'] = (bool)(($block_data['flags_raw'] & 0x08) >> 3);
     1385                $block_data['flags']['lacing']    =       (($block_data['flags_raw'] & 0x06) >> 1);  // 00=no lacing; 01=Xiph lacing; 11=EBML lacing; 10=fixed-size lacing
    13441386                if ($block_type == EBML_ID_CLUSTERSIMPLEBLOCK) {
    1345                         $cluster_block_data['flags']['discardable'] = (($cluster_block_data['flags_raw'] & 0x01));
     1387                        $block_data['flags']['discardable'] = (($block_data['flags_raw'] & 0x01));
    13461388                }
    13471389                else {
    1348                         //$cluster_block_data['flags']['reserved2'] = (($cluster_block_data['flags_raw'] & 0x01) >> 0);
    1349                 }
    1350                 $cluster_block_data['flags']['lacing_type'] = self::MatroskaBlockLacingType($cluster_block_data['flags']['lacing']);
     1390                        //$block_data['flags']['reserved2'] = (($block_data['flags_raw'] & 0x01) >> 0);
     1391                }
     1392                $block_data['flags']['lacing_type'] = self::BlockLacingType($block_data['flags']['lacing']);
    13511393
    13521394        // Lace (when lacing bit is set)
    1353                 if ($cluster_block_data['flags']['lacing'] > 0) {
    1354                         $cluster_block_data['lace_frames'] = getid3_lib::BigEndian2Int($this->readEBMLelementData(1)) + 1; // Number of frames in the lace-1 (uint8)
    1355                         if ($cluster_block_data['flags']['lacing'] != 0x02) { // Lace-coded size of each frame of the lace, except for the last one (multiple uint8). *This is not used with Fixed-size lacing as it is calculated automatically from (total size of lace) / (number of frames in lace).
    1356                                 for ($i = 1; $i < $cluster_block_data['lace_frames']; $i ++) {
    1357                                         if ($cluster_block_data['flags']['lacing'] == 0x03) { // EBML lacing
    1358                                                 // TODO: read size correctly, calc size for the last frame. For now offsets are deteminded OK with readEBMLint() and that's the most important thing.
    1359                                                 $cluster_block_data['lace_frames_size'][$i] = $this->readEBMLint();
     1395                if ($block_data['flags']['lacing'] > 0) {
     1396                        $block_data['lace_frames'] = getid3_lib::BigEndian2Int($this->readEBMLelementData(1)) + 1; // Number of frames in the lace-1 (uint8)
     1397                        if ($block_data['flags']['lacing'] != 0x02) {
     1398                                for ($i = 1; $i < $block_data['lace_frames']; $i ++) { // Lace-coded size of each frame of the lace, except for the last one (multiple uint8). *This is not used with Fixed-size lacing as it is calculated automatically from (total size of lace) / (number of frames in lace).
     1399                                        if ($block_data['flags']['lacing'] == 0x03) { // EBML lacing
     1400                                                $block_data['lace_frames_size'][$i] = $this->readEBMLint(); // TODO: read size correctly, calc size for the last frame. For now offsets are deteminded OK with readEBMLint() and that's the most important thing.
    13601401                                        }
    13611402                                        else { // Xiph lacing
    1362                                                 $cluster_block_data['lace_frames_size'][$i] = getid3_lib::BigEndian2Int($this->readEBMLelementData(1));
     1403                                                $block_data['lace_frames_size'][$i] = 0;
     1404                                                do {
     1405                                                        $size = getid3_lib::BigEndian2Int($this->readEBMLelementData(1));
     1406                                                        $block_data['lace_frames_size'][$i] += $size;
     1407                                                }
     1408                                                while ($size == 255);
    13631409                                        }
    13641410                                }
     1411                                if ($block_data['flags']['lacing'] == 0x01) { // calc size of the last frame only for Xiph lacing, till EBML sizes are now anyway determined incorrectly
     1412                                        $block_data['lace_frames_size'][] = $element['end'] - $this->current_offset - array_sum($block_data['lace_frames_size']);
     1413                                }
    13651414                        }
    13661415                }
    13671416
    1368                 if (!isset($info['matroska']['track_data_offsets'][$cluster_block_data['tracknumber']])) {
    1369                         $info['matroska']['track_data_offsets'][$cluster_block_data['tracknumber']]['offset'] = $this->current_offset;
    1370                         $info['matroska']['track_data_offsets'][$cluster_block_data['tracknumber']]['length'] = $element['end'] - $this->current_offset;
    1371                 }
     1417                if (!isset($info['matroska']['track_data_offsets'][$block_data['tracknumber']])) {
     1418                        $info['matroska']['track_data_offsets'][$block_data['tracknumber']]['offset'] = $this->current_offset;
     1419                        $info['matroska']['track_data_offsets'][$block_data['tracknumber']]['length'] = $element['end'] - $this->current_offset;
     1420                        //$info['matroska']['track_data_offsets'][$block_data['tracknumber']]['total_length'] = 0;
     1421                }
     1422                //$info['matroska']['track_data_offsets'][$block_data['tracknumber']]['total_length'] += $info['matroska']['track_data_offsets'][$block_data['tracknumber']]['length'];
     1423                //$info['matroska']['track_data_offsets'][$block_data['tracknumber']]['duration']      = $block_data['timecode'] * ((isset($info['matroska']['info'][0]['TimecodeScale']) ? $info['matroska']['info'][0]['TimecodeScale'] : 1000000) / 1000000000);
    13721424
    13731425                // set offset manually
    13741426                $this->current_offset = $element['end'];
    13751427
    1376                 return $cluster_block_data;
     1428                return $block_data;
    13771429        }
    13781430
     
    14251477        }
    14261478
    1427         public static function MatroskaTargetTypeValue($target_type) {
     1479        public static function TargetTypeValue($target_type) {
    14281480                // http://www.matroska.org/technical/specs/tagging/index.html
    1429                 static $MatroskaTargetTypeValue = array();
    1430                 if (empty($MatroskaTargetTypeValue)) {
    1431                         $MatroskaTargetTypeValue[10] = 'A: ~ V:shot';                                           // the lowest hierarchy found in music or movies
    1432                         $MatroskaTargetTypeValue[20] = 'A:subtrack/part/movement ~ V:scene';                    // corresponds to parts of a track for audio (like a movement)
    1433                         $MatroskaTargetTypeValue[30] = 'A:track/song ~ V:chapter';                              // the common parts of an album or a movie
    1434                         $MatroskaTargetTypeValue[40] = 'A:part/session ~ V:part/session';                       // when an album or episode has different logical parts
    1435                         $MatroskaTargetTypeValue[50] = 'A:album/opera/concert ~ V:movie/episode/concert';       // the most common grouping level of music and video (equals to an episode for TV series)
    1436                         $MatroskaTargetTypeValue[60] = 'A:edition/issue/volume/opus ~ V:season/sequel/volume';  // a list of lower levels grouped together
    1437                         $MatroskaTargetTypeValue[70] = 'A:collection ~ V:collection';                           // the high hierarchy consisting of many different lower items
    1438                 }
    1439                 return (isset($MatroskaTargetTypeValue[$target_type]) ? $MatroskaTargetTypeValue[$target_type] : $target_type);
     1481                static $TargetTypeValue = array();
     1482                if (empty($TargetTypeValue)) {
     1483                        $TargetTypeValue[10] = 'A: ~ V:shot';                                           // the lowest hierarchy found in music or movies
     1484                        $TargetTypeValue[20] = 'A:subtrack/part/movement ~ V:scene';                    // corresponds to parts of a track for audio (like a movement)
     1485                        $TargetTypeValue[30] = 'A:track/song ~ V:chapter';                              // the common parts of an album or a movie
     1486                        $TargetTypeValue[40] = 'A:part/session ~ V:part/session';                       // when an album or episode has different logical parts
     1487                        $TargetTypeValue[50] = 'A:album/opera/concert ~ V:movie/episode/concert';       // the most common grouping level of music and video (equals to an episode for TV series)
     1488                        $TargetTypeValue[60] = 'A:edition/issue/volume/opus ~ V:season/sequel/volume';  // a list of lower levels grouped together
     1489                        $TargetTypeValue[70] = 'A:collection ~ V:collection';                           // the high hierarchy consisting of many different lower items
     1490                }
     1491                return (isset($TargetTypeValue[$target_type]) ? $TargetTypeValue[$target_type] : $target_type);
    14401492        }
    14411493
    1442         public static function MatroskaBlockLacingType($lacingtype) {
     1494        public static function BlockLacingType($lacingtype) {
    14431495                // http://matroska.org/technical/specs/index.html#block_structure
    1444                 static $MatroskaBlockLacingType = array();
    1445                 if (empty($MatroskaBlockLacingType)) {
    1446                         $MatroskaBlockLacingType[0x00] = 'no lacing';
    1447                         $MatroskaBlockLacingType[0x01] = 'Xiph lacing';
    1448                         $MatroskaBlockLacingType[0x02] = 'fixed-size lacing';
    1449                         $MatroskaBlockLacingType[0x03] = 'EBML lacing';
    1450                 }
    1451                 return (isset($MatroskaBlockLacingType[$lacingtype]) ? $MatroskaBlockLacingType[$lacingtype] : $lacingtype);
     1496                static $BlockLacingType = array();
     1497                if (empty($BlockLacingType)) {
     1498                        $BlockLacingType[0x00] = 'no lacing';
     1499                        $BlockLacingType[0x01] = 'Xiph lacing';
     1500                        $BlockLacingType[0x02] = 'fixed-size lacing';
     1501                        $BlockLacingType[0x03] = 'EBML lacing';
     1502                }
     1503                return (isset($BlockLacingType[$lacingtype]) ? $BlockLacingType[$lacingtype] : $lacingtype);
    14521504        }
    14531505
    1454         public static function MatroskaCodecIDtoCommonName($codecid) {
     1506        public static function CodecIDtoCommonName($codecid) {
    14551507                // http://www.matroska.org/technical/specs/codecid/index.html
    1456                 static $MatroskaCodecIDlist = array();
    1457                 if (empty($MatroskaCodecIDlist)) {
    1458                         $MatroskaCodecIDlist['A_AAC']            = 'aac';
    1459                         $MatroskaCodecIDlist['A_AAC/MPEG2/LC']   = 'aac';
    1460                         $MatroskaCodecIDlist['A_AC3']            = 'ac3';
    1461                         $MatroskaCodecIDlist['A_DTS']            = 'dts';
    1462                         $MatroskaCodecIDlist['A_FLAC']           = 'flac';
    1463                         $MatroskaCodecIDlist['A_MPEG/L1']        = 'mp1';
    1464                         $MatroskaCodecIDlist['A_MPEG/L2']        = 'mp2';
    1465                         $MatroskaCodecIDlist['A_MPEG/L3']        = 'mp3';
    1466                         $MatroskaCodecIDlist['A_PCM/INT/LIT']    = 'pcm';       // PCM Integer Little Endian
    1467                         $MatroskaCodecIDlist['A_PCM/INT/BIG']    = 'pcm';       // PCM Integer Big Endian
    1468                         $MatroskaCodecIDlist['A_QUICKTIME/QDMC'] = 'quicktime'; // Quicktime: QDesign Music
    1469                         $MatroskaCodecIDlist['A_QUICKTIME/QDM2'] = 'quicktime'; // Quicktime: QDesign Music v2
    1470                         $MatroskaCodecIDlist['A_VORBIS']         = 'vorbis';
    1471                         $MatroskaCodecIDlist['V_MPEG1']          = 'mpeg';
    1472                         $MatroskaCodecIDlist['V_THEORA']         = 'theora';
    1473                         $MatroskaCodecIDlist['V_REAL/RV40']      = 'real';
    1474                         $MatroskaCodecIDlist['V_REAL/RV10']      = 'real';
    1475                         $MatroskaCodecIDlist['V_REAL/RV20']      = 'real';
    1476                         $MatroskaCodecIDlist['V_REAL/RV30']      = 'real';
    1477                         $MatroskaCodecIDlist['V_QUICKTIME']      = 'quicktime'; // Quicktime
    1478                         $MatroskaCodecIDlist['V_MPEG4/ISO/AP']   = 'mpeg4';
    1479                         $MatroskaCodecIDlist['V_MPEG4/ISO/ASP']  = 'mpeg4';
    1480                         $MatroskaCodecIDlist['V_MPEG4/ISO/AVC']  = 'h264';
    1481                         $MatroskaCodecIDlist['V_MPEG4/ISO/SP']   = 'mpeg4';
    1482                         $MatroskaCodecIDlist['V_VP8']            = 'vp8';
    1483                         $MatroskaCodecIDlist['V_MS/VFW/FOURCC']  = 'riff';
    1484                         $MatroskaCodecIDlist['A_MS/ACM']         = 'riff';
    1485                 }
    1486                 return (isset($MatroskaCodecIDlist[$codecid]) ? $MatroskaCodecIDlist[$codecid] : $codecid);
     1508                static $CodecIDlist = array();
     1509                if (empty($CodecIDlist)) {
     1510                        $CodecIDlist['A_AAC']            = 'aac';
     1511                        $CodecIDlist['A_AAC/MPEG2/LC']   = 'aac';
     1512                        $CodecIDlist['A_AC3']            = 'ac3';
     1513                        $CodecIDlist['A_DTS']            = 'dts';
     1514                        $CodecIDlist['A_FLAC']           = 'flac';
     1515                        $CodecIDlist['A_MPEG/L1']        = 'mp1';
     1516                        $CodecIDlist['A_MPEG/L2']        = 'mp2';
     1517                        $CodecIDlist['A_MPEG/L3']        = 'mp3';
     1518                        $CodecIDlist['A_PCM/INT/LIT']    = 'pcm';       // PCM Integer Little Endian
     1519                        $CodecIDlist['A_PCM/INT/BIG']    = 'pcm';       // PCM Integer Big Endian
     1520                        $CodecIDlist['A_QUICKTIME/QDMC'] = 'quicktime'; // Quicktime: QDesign Music
     1521                        $CodecIDlist['A_QUICKTIME/QDM2'] = 'quicktime'; // Quicktime: QDesign Music v2
     1522                        $CodecIDlist['A_VORBIS']         = 'vorbis';
     1523                        $CodecIDlist['V_MPEG1']          = 'mpeg';
     1524                        $CodecIDlist['V_THEORA']         = 'theora';
     1525                        $CodecIDlist['V_REAL/RV40']      = 'real';
     1526                        $CodecIDlist['V_REAL/RV10']      = 'real';
     1527                        $CodecIDlist['V_REAL/RV20']      = 'real';
     1528                        $CodecIDlist['V_REAL/RV30']      = 'real';
     1529                        $CodecIDlist['V_QUICKTIME']      = 'quicktime'; // Quicktime
     1530                        $CodecIDlist['V_MPEG4/ISO/AP']   = 'mpeg4';
     1531                        $CodecIDlist['V_MPEG4/ISO/ASP']  = 'mpeg4';
     1532                        $CodecIDlist['V_MPEG4/ISO/AVC']  = 'h264';
     1533                        $CodecIDlist['V_MPEG4/ISO/SP']   = 'mpeg4';
     1534                        $CodecIDlist['V_VP8']            = 'vp8';
     1535                        $CodecIDlist['V_MS/VFW/FOURCC']  = 'riff';
     1536                        $CodecIDlist['A_MS/ACM']         = 'riff';
     1537                }
     1538                return (isset($CodecIDlist[$codecid]) ? $CodecIDlist[$codecid] : $codecid);
    14871539        }
    14881540
     
    16481700                        $EBMLidList[EBML_ID_CLUSTERSLICES]              = 'ClusterSlices';
    16491701                        $EBMLidList[EBML_ID_STEREOMODE]                 = 'StereoMode';
     1702                        $EBMLidList[EBML_ID_OLDSTEREOMODE]              = 'OldStereoMode';
    16501703                        $EBMLidList[EBML_ID_TAG]                        = 'Tag';
    16511704                        $EBMLidList[EBML_ID_TAGATTACHMENTUID]           = 'TagAttachmentUID';
     
    16831736                return (isset($EBMLidList[$value]) ? $EBMLidList[$value] : dechex($value));
    16841737        }
    1685        
     1738
     1739        public static function displayUnit($value) {
     1740                // http://www.matroska.org/technical/specs/index.html#DisplayUnit
     1741                static $units = array(
     1742                        0 => 'pixels',
     1743                        1 => 'centimeters',
     1744                        2 => 'inches',
     1745                        3 => 'Display Aspect Ratio');
     1746
     1747                return (isset($units[$value]) ? $units[$value] : 'unknown');
     1748        }
     1749
    16861750        private static function getDefaultStreamInfo($streams)
    16871751        {
     
    16911755                        }
    16921756                }
    1693                 unset($stream['default']);
    1694                 if (isset($stream['name'])) {
    1695                         unset($stream['name']);
    1696                 }
    1697                
     1757
     1758                $unset = array('default', 'name');
     1759                foreach ($unset as $u) {
     1760                        if (isset($stream[$u])) {
     1761                                unset($stream[$u]);
     1762                        }
     1763                }
     1764
    16981765                $info = $stream;
    16991766                $info['streams'] = $streams;
    1700                
     1767
    17011768                return $info;
    17021769        }
    17031770
    17041771}
    1705 
    1706 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.mpeg.php

    r51852 r71835  
    2929{
    3030
    31         function Analyze() {
     31        public function Analyze() {
    3232                $info = &$this->getid3->info;
    3333
     
    227227
    228228
    229         function MPEGsystemNonOverheadPercentage($VideoBitrate, $AudioBitrate) {
     229        public function MPEGsystemNonOverheadPercentage($VideoBitrate, $AudioBitrate) {
    230230                $OverheadPercentage = 0;
    231231
     
    279279
    280280
    281         function MPEGvideoFramerateLookup($rawframerate) {
     281        public function MPEGvideoFramerateLookup($rawframerate) {
    282282                $MPEGvideoFramerateLookup = array(0, 23.976, 24, 25, 29.97, 30, 50, 59.94, 60);
    283283                return (isset($MPEGvideoFramerateLookup[$rawframerate]) ? (float) $MPEGvideoFramerateLookup[$rawframerate] : (float) 0);
    284284        }
    285285
    286         function MPEGvideoAspectRatioLookup($rawaspectratio) {
     286        public function MPEGvideoAspectRatioLookup($rawaspectratio) {
    287287                $MPEGvideoAspectRatioLookup = array(0, 1, 0.6735, 0.7031, 0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815, 1.0255, 1.0695, 1.0950, 1.1575, 1.2015, 0);
    288288                return (isset($MPEGvideoAspectRatioLookup[$rawaspectratio]) ? (float) $MPEGvideoAspectRatioLookup[$rawaspectratio] : (float) 0);
    289289        }
    290290
    291         function MPEGvideoAspectRatioTextLookup($rawaspectratio) {
     291        public function MPEGvideoAspectRatioTextLookup($rawaspectratio) {
    292292                $MPEGvideoAspectRatioTextLookup = array('forbidden', 'square pixels', '0.6735', '16:9, 625 line, PAL', '0.7615', '0.8055', '16:9, 525 line, NTSC', '0.8935', '4:3, 625 line, PAL, CCIR601', '0.9815', '1.0255', '1.0695', '4:3, 525 line, NTSC, CCIR601', '1.1575', '1.2015', 'reserved');
    293293                return (isset($MPEGvideoAspectRatioTextLookup[$rawaspectratio]) ? $MPEGvideoAspectRatioTextLookup[$rawaspectratio] : '');
     
    295295
    296296}
    297 
    298 
    299 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.nsv.php

    r51852 r71835  
    1818{
    1919
    20         function Analyze() {
     20        public function Analyze() {
    2121                $info = &$this->getid3->info;
    2222
     
    5959        }
    6060
    61         function getNSVsHeaderFilepointer($fileoffset) {
     61        public function getNSVsHeaderFilepointer($fileoffset) {
    6262                $info = &$this->getid3->info;
    6363                fseek($this->getid3->fp, $fileoffset, SEEK_SET);
     
    132132        }
    133133
    134         function getNSVfHeaderFilepointer($fileoffset, $getTOCoffsets=false) {
     134        public function getNSVfHeaderFilepointer($fileoffset, $getTOCoffsets=false) {
    135135                $info = &$this->getid3->info;
    136136                fseek($this->getid3->fp, $fileoffset, SEEK_SET);
     
    206206
    207207
    208         static function NSVframerateLookup($framerateindex) {
     208        public static function NSVframerateLookup($framerateindex) {
    209209                if ($framerateindex <= 127) {
    210210                        return (float) $framerateindex;
     
    222222
    223223}
    224 
    225 
    226 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.quicktime.php

    r62460 r71835  
    1919{
    2020
    21         var $ReturnAtomData        = true;
    22         var $ParseAllPossibleAtoms = false;
    23 
    24         function Analyze() {
     21        public $ReturnAtomData        = true;
     22        public $ParseAllPossibleAtoms = false;
     23
     24        public function Analyze() {
    2525                $info = &$this->getid3->info;
    2626
     
    166166        }
    167167
    168         function QuicktimeParseAtom($atomname, $atomsize, $atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
     168        public function QuicktimeParseAtom($atomname, $atomsize, $atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
    169169                // http://developer.apple.com/techpubs/quicktime/qtdevdocs/APIREF/INDEX/atomalphaindex.htm
    170170
     
    383383                                                        $boxtype =                           substr($atom_data, $atomoffset + 4, 4);
    384384                                                        $boxdata =                           substr($atom_data, $atomoffset + 8, $boxsize - 8);
     385                                                        if ($boxsize <= 1) {
     386                                                                $info['warning'][] = 'Invalid QuickTime atom box size "'.$boxsize.'" in atom "'.$atomname.'" at offset: '.($atom_structure['offset'] + $atomoffset);
     387                                                                $atom_structure['data'] = null;
     388                                                                $atomoffset = strlen($atom_data);
     389                                                                break;
     390                                                        }
     391                                                        $atomoffset += $boxsize;
    385392
    386393                                                        switch ($boxtype) {
     
    459466
    460467                                                        }
    461                                                         $atomoffset += $boxsize;
    462468                                                }
    463469                                        }
     
    11451151                                        $info['quicktime']['video']['resolution_y'] = $info['video']['resolution_y'];
    11461152                                } else {
    1147                                         if (isset($info['video']['resolution_x'])) { unset($info['video']['resolution_x']); }
    1148                                         if (isset($info['video']['resolution_y'])) { unset($info['video']['resolution_y']); }
    1149                                         if (isset($info['quicktime']['video']))    { unset($info['quicktime']['video']);    }
     1153                                        // see: http://www.getid3.org/phpBB3/viewtopic.php?t=1295
     1154                                        //if (isset($info['video']['resolution_x'])) { unset($info['video']['resolution_x']); }
     1155                                        //if (isset($info['video']['resolution_y'])) { unset($info['video']['resolution_y']); }
     1156                                        //if (isset($info['quicktime']['video']))    { unset($info['quicktime']['video']);    }
    11501157                                }
    11511158                                break;
     
    13311338
    13321339                        default:
    1333                                 $info['warning'][] = 'Unknown QuickTime atom type: "'.getid3_lib::PrintHexBytes($atomname).'" at offset '.$baseoffset;
     1340                                $info['warning'][] = 'Unknown QuickTime atom type: "'.$atomname.'" ('.trim(getid3_lib::PrintHexBytes($atomname)).') at offset '.$baseoffset;
    13341341                                $atom_structure['data'] = $atom_data;
    13351342                                break;
     
    13391346        }
    13401347
    1341         function QuicktimeParseContainerAtom($atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
     1348        public function QuicktimeParseContainerAtom($atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
    13421349//echo 'QuicktimeParseContainerAtom('.substr($atom_data, 4, 4).') @ '.$baseoffset.'<br><br>';
    13431350                $atom_structure  = false;
     
    13671374
    13681375
    1369         function quicktime_read_mp4_descr_length($data, &$offset) {
     1376        public function quicktime_read_mp4_descr_length($data, &$offset) {
    13701377                // http://libquicktime.sourcearchive.com/documentation/2:1.0.2plus-pdebian-2build1/esds_8c-source.html
    13711378                $num_bytes = 0;
     
    13791386
    13801387
    1381         function QuicktimeLanguageLookup($languageid) {
     1388        public function QuicktimeLanguageLookup($languageid) {
    13821389                static $QuicktimeLanguageLookup = array();
    13831390                if (empty($QuicktimeLanguageLookup)) {
     
    14961503        }
    14971504
    1498         function QuicktimeVideoCodecLookup($codecid) {
     1505        public function QuicktimeVideoCodecLookup($codecid) {
    14991506                static $QuicktimeVideoCodecLookup = array();
    15001507                if (empty($QuicktimeVideoCodecLookup)) {
     
    15551562        }
    15561563
    1557         function QuicktimeAudioCodecLookup($codecid) {
     1564        public function QuicktimeAudioCodecLookup($codecid) {
    15581565                static $QuicktimeAudioCodecLookup = array();
    15591566                if (empty($QuicktimeAudioCodecLookup)) {
     
    16001607        }
    16011608
    1602         function QuicktimeDCOMLookup($compressionid) {
     1609        public function QuicktimeDCOMLookup($compressionid) {
    16031610                static $QuicktimeDCOMLookup = array();
    16041611                if (empty($QuicktimeDCOMLookup)) {
     
    16091616        }
    16101617
    1611         function QuicktimeColorNameLookup($colordepthid) {
     1618        public function QuicktimeColorNameLookup($colordepthid) {
    16121619                static $QuicktimeColorNameLookup = array();
    16131620                if (empty($QuicktimeColorNameLookup)) {
     
    16271634        }
    16281635
    1629         function QuicktimeSTIKLookup($stik) {
     1636        public function QuicktimeSTIKLookup($stik) {
    16301637                static $QuicktimeSTIKLookup = array();
    16311638                if (empty($QuicktimeSTIKLookup)) {
     
    16441651        }
    16451652
    1646         function QuicktimeIODSaudioProfileName($audio_profile_id) {
     1653        public function QuicktimeIODSaudioProfileName($audio_profile_id) {
    16471654                static $QuicktimeIODSaudioProfileNameLookup = array();
    16481655                if (empty($QuicktimeIODSaudioProfileNameLookup)) {
     
    17041711
    17051712
    1706         function QuicktimeIODSvideoProfileName($video_profile_id) {
     1713        public function QuicktimeIODSvideoProfileName($video_profile_id) {
    17071714                static $QuicktimeIODSvideoProfileNameLookup = array();
    17081715                if (empty($QuicktimeIODSvideoProfileNameLookup)) {
     
    17761783
    17771784
    1778         function QuicktimeContentRatingLookup($rtng) {
     1785        public function QuicktimeContentRatingLookup($rtng) {
    17791786                static $QuicktimeContentRatingLookup = array();
    17801787                if (empty($QuicktimeContentRatingLookup)) {
     
    17861793        }
    17871794
    1788         function QuicktimeStoreAccountTypeLookup($akid) {
     1795        public function QuicktimeStoreAccountTypeLookup($akid) {
    17891796                static $QuicktimeStoreAccountTypeLookup = array();
    17901797                if (empty($QuicktimeStoreAccountTypeLookup)) {
     
    17951802        }
    17961803
    1797         function QuicktimeStoreFrontCodeLookup($sfid) {
     1804        public function QuicktimeStoreFrontCodeLookup($sfid) {
    17981805                static $QuicktimeStoreFrontCodeLookup = array();
    17991806                if (empty($QuicktimeStoreFrontCodeLookup)) {
     
    18241831        }
    18251832
    1826         function QuicktimeParseNikonNCTG($atom_data) {
     1833        public function QuicktimeParseNikonNCTG($atom_data) {
    18271834                // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html#NCTG
    18281835                // Nikon-specific QuickTime tags found in the NCDT atom of MOV videos from some Nikon cameras such as the Coolpix S8000 and D5100
     
    20032010
    20042011
    2005         function CopyToAppropriateCommentsSection($keyname, $data, $boxname='') {
     2012        public function CopyToAppropriateCommentsSection($keyname, $data, $boxname='') {
    20062013                static $handyatomtranslatorarray = array();
    20072014                if (empty($handyatomtranslatorarray)) {
     
    20782085
    20792086                        // boxnames:
     2087                        /*
    20802088                        $handyatomtranslatorarray['iTunSMPB']                    = 'iTunSMPB';
    20812089                        $handyatomtranslatorarray['iTunNORM']                    = 'iTunNORM';
     
    20902098                        $handyatomtranslatorarray['MusicBrainz Track Id']        = 'MusicBrainz Track Id';
    20912099                        $handyatomtranslatorarray['MusicBrainz Disc Id']         = 'MusicBrainz Disc Id';
     2100
     2101                        // http://age.hobba.nl/audio/tag_frame_reference.html
     2102                        $handyatomtranslatorarray['PLAY_COUNTER']                = 'play_counter'; // Foobar2000 - http://www.getid3.org/phpBB3/viewtopic.php?t=1355
     2103                        $handyatomtranslatorarray['MEDIATYPE']                   = 'mediatype';    // Foobar2000 - http://www.getid3.org/phpBB3/viewtopic.php?t=1355
     2104                        */
    20922105                }
    20932106                $info = &$this->getid3->info;
    20942107                $comment_key = '';
    2095                 if ($boxname && ($boxname != $keyname) && isset($handyatomtranslatorarray[$boxname])) {
    2096                         $comment_key = $handyatomtranslatorarray[$boxname];
     2108                if ($boxname && ($boxname != $keyname)) {
     2109                        $comment_key = (isset($handyatomtranslatorarray[$boxname]) ? $handyatomtranslatorarray[$boxname] : $boxname);
    20972110                } elseif (isset($handyatomtranslatorarray[$keyname])) {
    20982111                        $comment_key = $handyatomtranslatorarray[$keyname];
     
    21192132        }
    21202133
    2121         function NoNullString($nullterminatedstring) {
     2134        public function NoNullString($nullterminatedstring) {
    21222135                // remove the single null terminator on null terminated strings
    21232136                if (substr($nullterminatedstring, strlen($nullterminatedstring) - 1, 1) === "\x00") {
     
    21272140        }
    21282141
    2129         function Pascal2String($pascalstring) {
     2142        public function Pascal2String($pascalstring) {
    21302143                // Pascal strings have 1 unsigned byte at the beginning saying how many chars (1-255) are in the string
    21312144                return substr($pascalstring, 1);
     
    21332146
    21342147}
    2135 
    2136 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.real.php

    r51852 r71835  
    1919{
    2020
    21         function Analyze() {
     21        public function Analyze() {
    2222                $info = &$this->getid3->info;
    2323
     
    203203                                                                //$thisfile_real_chunks_currentchunk_videoinfo['unknown9']          = getid3_lib::BigEndian2Int(substr($thisfile_real_chunks_currentchunk_typespecificdata, 36, 2));
    204204
    205                                                                 $thisfile_real_chunks_currentchunk_videoinfo['codec'] = getid3_riff::RIFFfourccLookup($thisfile_real_chunks_currentchunk_videoinfo['fourcc2']);
     205                                                                $thisfile_real_chunks_currentchunk_videoinfo['codec'] = getid3_riff::fourccLookup($thisfile_real_chunks_currentchunk_videoinfo['fourcc2']);
    206206
    207207                                                                $info['video']['resolution_x']    =         $thisfile_real_chunks_currentchunk_videoinfo['width'];
     
    371371
    372372
    373         function ParseOldRAheader($OldRAheaderData, &$ParsedArray) {
     373        public function ParseOldRAheader($OldRAheaderData, &$ParsedArray) {
    374374                // http://www.freelists.org/archives/matroska-devel/07-2003/msg00010.html
    375375
     
    485485        }
    486486
    487         function RealAudioCodecFourCClookup($fourcc, $bitrate) {
     487        public function RealAudioCodecFourCClookup($fourcc, $bitrate) {
    488488                static $RealAudioCodecFourCClookup = array();
    489489                if (empty($RealAudioCodecFourCClookup)) {
     
    526526
    527527}
    528 
    529 
    530 ?>
  • _plugins_/getID3/trunk/getid3/module.audio-video.riff.php

    r62460 r71835  
    1313//    Wave, AVI, AIFF/AIFC, (MP3,AC3)/RIFF, Wavpack v3, 8SVX   //
    1414// dependencies: module.audio.mp3.php                          //
    15 //               module.audio.ac3.php (optional)               //
    16 //               module.audio.dts.php (optional)               //
     15//               module.audio.ac3.php                          //
     16//               module.audio.dts.php                          //
    1717//                                                            ///
    1818/////////////////////////////////////////////////////////////////
    1919
     20/**
     21* @todo Parse AC-3/DTS audio inside WAVE correctly
     22* @todo Rewrite RIFF parser totally
     23*/
     24
    2025getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.mp3.php', __FILE__, true);
     26getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.ac3.php', __FILE__, true);
     27getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.dts.php', __FILE__, true);
    2128
    2229class getid3_riff extends getid3_handler
    2330{
    2431
    25         function Analyze() {
     32        public function Analyze() {
    2633                $info = &$this->getid3->info;
    2734
     
    3946                $thisfile_riff_video       = &$thisfile_riff['video'];
    4047
    41 
    4248                $Original['avdataoffset'] = $info['avdataoffset'];
    4349                $Original['avdataend']    = $info['avdataend'];
    4450
    45                 fseek($this->getid3->fp, $info['avdataoffset'], SEEK_SET);
    46                 $RIFFheader = fread($this->getid3->fp, 12);
     51                $this->fseek($info['avdataoffset']);
     52                $RIFFheader = $this->fread(12);
     53                $offset = $this->ftell();
     54                $RIFFtype    = substr($RIFFheader, 0, 4);
     55                $RIFFsize    = substr($RIFFheader, 4, 4);
    4756                $RIFFsubtype = substr($RIFFheader, 8, 4);
    48                 switch (substr($RIFFheader, 0, 4)) {
    49                         case 'FORM':
     57
     58                switch ($RIFFtype) {
     59
     60                        case 'FORM':  // AIFF, AIFC
    5061                                $info['fileformat']   = 'aiff';
    51                                 $thisfile_riff['header_size'] = $this->EitherEndian2Int(substr($RIFFheader, 4, 4));
    52                                 $thisfile_riff[$RIFFsubtype]  = $this->ParseRIFF($info['avdataoffset'] + 12, $info['avdataoffset'] + $thisfile_riff['header_size']);
     62                                $thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
     63                                $thisfile_riff[$RIFFsubtype]  = $this->ParseRIFF($offset, ($offset + $thisfile_riff['header_size'] - 4));
    5364                                break;
    5465
     
    5768                        case 'RMP3':  // RMP3 is identical to RIFF, just renamed. Used by [unknown program] when creating RIFF-MP3s
    5869                                $info['fileformat']   = 'riff';
    59                                 $thisfile_riff['header_size'] = $this->EitherEndian2Int(substr($RIFFheader, 4, 4));
     70                                $thisfile_riff['header_size'] = $this->EitherEndian2Int($RIFFsize);
    6071                                if ($RIFFsubtype == 'RMP3') {
    6172                                        // RMP3 is identical to WAVE, just renamed. Used by [unknown program] when creating RIFF-MP3s
    6273                                        $RIFFsubtype = 'WAVE';
    6374                                }
    64                                 $thisfile_riff[$RIFFsubtype]  = $this->ParseRIFF($info['avdataoffset'] + 12, $info['avdataoffset'] + $thisfile_riff['header_size']);
     75                                $thisfile_riff[$RIFFsubtype]  = $this->ParseRIFF($offset, ($offset + $thisfile_riff['header_size'] - 4));
    6576                                if (($info['avdataend'] - $info['filesize']) == 1) {
    6677                                        // LiteWave appears to incorrectly *not* pad actual output file
     
    7283                                $nextRIFFoffset = $Original['avdataoffset'] + 8 + $thisfile_riff['header_size']; // 8 = "RIFF" + 32-bit offset
    7384                                while ($nextRIFFoffset < min($info['filesize'], $info['avdataend'])) {
    74                                         if (!getid3_lib::intValueSupported($nextRIFFoffset + 1024)) {
    75                                                 $info['error'][]   = 'AVI extends beyond '.round(PHP_INT_MAX / 1073741824).'GB and PHP filesystem functions cannot read that far, playtime is probably wrong';
    76                                                 $info['warning'][] = '[avdataend] value may be incorrect, multiple AVIX chunks may be present';
    77                                                 break;
    78                                         } else {
    79                                                 fseek($this->getid3->fp, $nextRIFFoffset, SEEK_SET);
    80                                                 $nextRIFFheader = fread($this->getid3->fp, 12);
    81                                                 if ($nextRIFFoffset == ($info['avdataend'] - 1)) {
    82                                                         if (substr($nextRIFFheader, 0, 1) == "\x00") {
    83                                                                 // RIFF padded to WORD boundary, we're actually already at the end
    84                                                                 break;
     85                                        try {
     86                                                $this->fseek($nextRIFFoffset);
     87                                        } catch (getid3_exception $e) {
     88                                                if ($e->getCode() == 10) {
     89                                                        //$this->warning('RIFF parser: '.$e->getMessage());
     90                                                        $this->error('AVI extends beyond '.round(PHP_INT_MAX / 1073741824).'GB and PHP filesystem functions cannot read that far, playtime may be wrong');
     91                                                        $this->warning('[avdataend] value may be incorrect, multiple AVIX chunks may be present');
     92                                                        break;
     93                                                } else {
     94                                                        throw $e;
     95                                                }
     96                                        }
     97                                        $nextRIFFheader = $this->fread(12);
     98                                        if ($nextRIFFoffset == ($info['avdataend'] - 1)) {
     99                                                if (substr($nextRIFFheader, 0, 1) == "\x00") {
     100                                                        // RIFF padded to WORD boundary, we're actually already at the end
     101                                                        break;
     102                                                }
     103                                        }
     104                                        $nextRIFFheaderID =                         substr($nextRIFFheader, 0, 4);
     105                                        $nextRIFFsize     = $this->EitherEndian2Int(substr($nextRIFFheader, 4, 4));
     106                                        $nextRIFFtype     =                         substr($nextRIFFheader, 8, 4);
     107                                        $chunkdata = array();
     108                                        $chunkdata['offset'] = $nextRIFFoffset + 8;
     109                                        $chunkdata['size']   = $nextRIFFsize;
     110                                        $nextRIFFoffset = $chunkdata['offset'] + $chunkdata['size'];
     111
     112                                        switch ($nextRIFFheaderID) {
     113
     114                                                case 'RIFF':
     115                                                        $chunkdata['chunks'] = $this->ParseRIFF($chunkdata['offset'] + 4, $nextRIFFoffset);
     116
     117                                                        if (!isset($thisfile_riff[$nextRIFFtype])) {
     118                                                                $thisfile_riff[$nextRIFFtype] = array();
    85119                                                        }
    86                                                 }
    87                                                 $nextRIFFheaderID =                         substr($nextRIFFheader, 0, 4);
    88                                                 $nextRIFFsize     = $this->EitherEndian2Int(substr($nextRIFFheader, 4, 4));
    89                                                 $nextRIFFtype     =                         substr($nextRIFFheader, 8, 4);
    90                                                 $chunkdata = array();
    91                                                 $chunkdata['offset'] = $nextRIFFoffset + 8;
    92                                                 $chunkdata['size']   = $nextRIFFsize;
    93                                                 $nextRIFFoffset = $chunkdata['offset'] + $chunkdata['size'];
    94                                                 switch ($nextRIFFheaderID) {
    95                                                         case 'RIFF':
    96                                                                 $info['avdataend'] = $nextRIFFoffset;
    97                                                                 if (!getid3_lib::intValueSupported($info['avdataend'])) {
    98                                                                         $info['error'][]   = 'AVI extends beyond '.round(PHP_INT_MAX / 1073741824).'GB and PHP filesystem functions cannot read that far, playtime is probably wrong';
    99                                                                         $info['warning'][] = '[avdataend] value may be incorrect, multiple AVIX chunks may be present';
     120                                                        $thisfile_riff[$nextRIFFtype][] = $chunkdata;
     121                                                        break;
     122
     123                                                case 'JUNK':
     124                                                        // ignore
     125                                                        $thisfile_riff[$nextRIFFheaderID][] = $chunkdata;
     126                                                        break;
     127
     128                                                case 'IDVX':
     129                                              &n