WordPress.org
Get WordPress

Make WordPress Core

Changeset 46112


Ignore:
Timestamp:
09/14/2019 07:06:09 PM (5 years ago)
Author:
jorbin
Message:

Update getID3 library to fix issues with PHP7.4

Updates to trunk version that includes fixes for PHP7.4

Changelog:
​https://github.com/JamesHeinrich/getID3/compare/v1.9.14...00f3fbfd77e583099ca70a3cf0bc092e113d2b20

See: #47751,#47783.
Fixes: #48040.

Location:
trunk/src/wp-includes/ID3
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/ID3/getid3.lib.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
    88//                                                             //
    99// getid3.lib.php - part of getID3()                           //
    10 // See readme.txt for more details                             //
     10//  see readme.txt for more details                            //
    1111//                                                            ///
    1212/////////////////////////////////////////////////////////////////
    … …  
    1515class getid3_lib
    1616{
    17 
     17    /**
     18     * @param string $string
     19     * @param bool   $hex
     20     * @param bool   $spaces
     21     * @param string $htmlencoding
     22     *
     23     * @return string
     24     */
    1825    public static function PrintHexBytes($string, $hex=true, $spaces=true, $htmlencoding='UTF-8') {
    1926        $returnstring = '';
    2027        for ($i = 0; $i < strlen($string); $i++) {
    2128            if ($hex) {
    22                 $returnstring .= str_pad(dechex(ord($string{$i})), 2, '0', STR_PAD_LEFT);
     29                $returnstring .= str_pad(dechex(ord($string[$i])), 2, '0', STR_PAD_LEFT);
    2330            } else {
    24                 $returnstring .= ' '.(preg_match("#[\x20-\x7E]#", $string{$i}) ? $string{$i} : '¤');
     31                $returnstring .= ' '.(preg_match("#[\x20-\x7E]#", $string[$i]) ? $string[$i] : '¤');
    2532            }
    2633            if ($spaces) {
    … …  
    3744    }
    3845
     46    /**
     47     * Truncates a floating-point number at the decimal point.
     48     *
     49     * @param float $floatnumber
     50     *
     51     * @return float|int returns int (if possible, otherwise float)
     52     */
    3953    public static function trunc($floatnumber) {
    40         // truncates a floating-point number at the decimal point
    41         // returns int (if possible, otherwise float)
    4254        if ($floatnumber >= 1) {
    4355            $truncatednumber = floor($floatnumber);
    … …  
    5365    }
    5466
    55 
     67    /**
     68     * @param int|null $variable
     69     * @param int      $increment
     70     *
     71     * @return bool
     72     */
    5673    public static function safe_inc(&$variable, $increment=1) {
    5774        if (isset($variable)) {
    … …  
    6380    }
    6481
     82    /**
     83     * @param int|float $floatnum
     84     *
     85     * @return int|float
     86     */
    6587    public static function CastAsInt($floatnum) {
    6688        // convert to float if not already
    … …  
    78100    }
    79101
     102    /**
     103     * @param int $num
     104     *
     105     * @return bool
     106     */
    80107    public static function intValueSupported($num) {
    81108        // check if integers are 64-bit
    … …  
    94121    }
    95122
     123    /**
     124     * @param string $fraction
     125     *
     126     * @return float
     127     */
    96128    public static function DecimalizeFraction($fraction) {
    97129        list($numerator, $denominator) = explode('/', $fraction);
    … …  
    99131    }
    100132
    101 
     133    /**
     134     * @param string $binarynumerator
     135     *
     136     * @return float
     137     */
    102138    public static function DecimalBinary2Float($binarynumerator) {
    103139        $numerator   = self::Bin2Dec($binarynumerator);
    … …  
    106142    }
    107143
    108 
     144    /**
     145     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
     146     *
     147     * @param string $binarypointnumber
     148     * @param int    $maxbits
     149     *
     150     * @return array
     151     */
    109152    public static function NormalizeBinaryPoint($binarypointnumber, $maxbits=52) {
    110         // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
    111153        if (strpos($binarypointnumber, '.') === false) {
    112154            $binarypointnumber = '0.'.$binarypointnumber;
    113         } elseif ($binarypointnumber{0} == '.') {
     155        } elseif ($binarypointnumber[0] == '.') {
    114156            $binarypointnumber = '0'.$binarypointnumber;
    115157        }
    116158        $exponent = 0;
    117         while (($binarypointnumber{0} != '1') || (substr($binarypointnumber, 1, 1) != '.')) {
     159        while (($binarypointnumber[0] != '1') || (substr($binarypointnumber, 1, 1) != '.')) {
    118160            if (substr($binarypointnumber, 1, 1) == '.') {
    119161                $exponent--;
    … …  
    123165                $exponent += ($pointpos - 1);
    124166                $binarypointnumber = str_replace('.', '', $binarypointnumber);
    125                 $binarypointnumber = $binarypointnumber{0}.'.'.substr($binarypointnumber, 1);
     167                $binarypointnumber = $binarypointnumber[0].'.'.substr($binarypointnumber, 1);
    126168            }
    127169        }
    … …  
    130172    }
    131173
    132 
     174    /**
     175     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
     176     *
     177     * @param float $floatvalue
     178     *
     179     * @return string
     180     */
    133181    public static function Float2BinaryDecimal($floatvalue) {
    134         // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
    135182        $maxbits = 128; // to how many bits of precision should the calculations be taken?
    136183        $intpart   = self::trunc($floatvalue);
    … …  
    146193    }
    147194
    148 
     195    /**
     196     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
     197     *
     198     * @param float $floatvalue
     199     * @param int $bits
     200     *
     201     * @return string|false
     202     */
    149203    public static function Float2String($floatvalue, $bits) {
    150         // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
     204        $exponentbits = 0;
     205        $fractionbits = 0;
    151206        switch ($bits) {
    152207            case 32:
    … …  
    177232    }
    178233
    179 
     234    /**
     235     * @param string $byteword
     236     *
     237     * @return float|false
     238     */
    180239    public static function LittleEndian2Float($byteword) {
    181240        return self::BigEndian2Float(strrev($byteword));
    182241    }
    183242
    184 
     243    /**
     244     * ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
     245     *
     246     * @link http://www.psc.edu/general/software/packages/ieee/ieee.html
     247     * @link http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
     248     *
     249     * @param string $byteword
     250     *
     251     * @return float|false
     252     */
    185253    public static function BigEndian2Float($byteword) {
    186         // ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
    187         // http://www.psc.edu/general/software/packages/ieee/ieee.html
    188         // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
    189 
    190254        $bitword = self::BigEndian2Bin($byteword);
    191255        if (!$bitword) {
    192256            return 0;
    193257        }
    194         $signbit = $bitword{0};
     258        $signbit = $bitword[0];
     259        $floatvalue = 0;
     260        $exponentbits = 0;
     261        $fractionbits = 0;
    195262
    196263        switch (strlen($byteword) * 8) {
    … …  
    209276                // http://www.mactech.com/articles/mactech/Vol.06/06.01/SANENormalized/
    210277                $exponentstring = substr($bitword, 1, 15);
    211                 $isnormalized = intval($bitword{16});
     278                $isnormalized = intval($bitword[16]);
    212279                $fractionstring = substr($bitword, 17, 63);
    213280                $exponent = pow(2, self::Bin2Dec($exponentstring) - 16383);
    … …  
    260327    }
    261328
    262 
     329    /**
     330     * @param string $byteword
     331     * @param bool   $synchsafe
     332     * @param bool   $signed
     333     *
     334     * @return int|float|false
     335     * @throws Exception
     336     */
    263337    public static function BigEndian2Int($byteword, $synchsafe=false, $signed=false) {
    264338        $intvalue = 0;
    … …  
    270344            if ($synchsafe) { // disregard MSB, effectively 7-bit bytes
    271345                //$intvalue = $intvalue | (ord($byteword{$i}) & 0x7F) << (($bytewordlen - 1 - $i) * 7); // faster, but runs into problems past 2^31 on 32-bit systems
    272                 $intvalue += (ord($byteword{$i}) & 0x7F) * pow(2, ($bytewordlen - 1 - $i) * 7);
     346                $intvalue += (ord($byteword[$i]) & 0x7F) * pow(2, ($bytewordlen - 1 - $i) * 7);
    273347            } else {
    274                 $intvalue += ord($byteword{$i}) * pow(256, ($bytewordlen - 1 - $i));
     348                $intvalue += ord($byteword[$i]) * pow(256, ($bytewordlen - 1 - $i));
    275349            }
    276350        }
    … …  
    289363    }
    290364
    291 
     365    /**
     366     * @param string $byteword
     367     * @param bool   $signed
     368     *
     369     * @return int|float|false
     370     */
    292371    public static function LittleEndian2Int($byteword, $signed=false) {
    293372        return self::BigEndian2Int(strrev($byteword), false, $signed);
    294373    }
    295374
     375    /**
     376     * @param string $byteword
     377     *
     378     * @return string
     379     */
    296380    public static function LittleEndian2Bin($byteword) {
    297381        return self::BigEndian2Bin(strrev($byteword));
    298382    }
    299383
     384    /**
     385     * @param string $byteword
     386     *
     387     * @return string
     388     */
    300389    public static function BigEndian2Bin($byteword) {
    301390        $binvalue = '';
    302391        $bytewordlen = strlen($byteword);
    303392        for ($i = 0; $i < $bytewordlen; $i++) {
    304             $binvalue .= str_pad(decbin(ord($byteword{$i})), 8, '0', STR_PAD_LEFT);
     393            $binvalue .= str_pad(decbin(ord($byteword[$i])), 8, '0', STR_PAD_LEFT);
    305394        }
    306395        return $binvalue;
    307396    }
    308397
    309 
     398    /**
     399     * @param int  $number
     400     * @param int  $minbytes
     401     * @param bool $synchsafe
     402     * @param bool $signed
     403     *
     404     * @return string
     405     * @throws Exception
     406     */
    310407    public static function BigEndian2String($number, $minbytes=1, $synchsafe=false, $signed=false) {
    311408        if ($number < 0) {
    … …  
    328425    }
    329426
    330 
     427    /**
     428     * @param int $number
     429     *
     430     * @return string
     431     */
    331432    public static function Dec2Bin($number) {
    332433        while ($number >= 256) {
    … …  
    342443    }
    343444
    344 
     445    /**
     446     * @param string $binstring
     447     * @param bool   $signed
     448     *
     449     * @return int|float
     450     */
    345451    public static function Bin2Dec($binstring, $signed=false) {
    346452        $signmult = 1;
    347453        if ($signed) {
    348             if ($binstring{0} == '1') {
     454            if ($binstring[0] == '1') {
    349455                $signmult = -1;
    350456            }
    … …  
    358464    }
    359465
    360 
     466    /**
     467     * @param string $binstring
     468     *
     469     * @return string
     470     */
    361471    public static function Bin2String($binstring) {
    362472        // return 'hi' for input of '0110100001101001'
    … …  
    369479    }
    370480
    371 
     481    /**
     482     * @param int  $number
     483     * @param int  $minbytes
     484     * @param bool $synchsafe
     485     *
     486     * @return string
     487     */
    372488    public static function LittleEndian2String($number, $minbytes=1, $synchsafe=false) {
    373489        $intstring = '';
    … …  
    384500    }
    385501
    386 
     502    /**
     503     * @param array $array1
     504     * @param array $array2
     505     *
     506     * @return array|false
     507     */
    387508    public static function array_merge_clobber($array1, $array2) {
    388509        // written by kcØhireability*com
    … …  
    402523    }
    403524
    404 
     525    /**
     526     * @param array $array1
     527     * @param array $array2
     528     *
     529     * @return array|false
     530     */
    405531    public static function array_merge_noclobber($array1, $array2) {
    406532        if (!is_array($array1) || !is_array($array2)) {
    … …  
    418544    }
    419545
     546    /**
     547     * @param array $array1
     548     * @param array $array2
     549     *
     550     * @return array|false|null
     551     */
    420552    public static function flipped_array_merge_noclobber($array1, $array2) {
    421553        if (!is_array($array1) || !is_array($array2)) {
    … …  
    432564    }
    433565
    434 
     566    /**
     567     * @param array $theArray
     568     *
     569     * @return bool
     570     */
    435571    public static function ksort_recursive(&$theArray) {
    436572        ksort($theArray);
    … …  
    443579    }
    444580
     581    /**
     582     * @param string $filename
     583     * @param int    $numextensions
     584     *
     585     * @return string
     586     */
    445587    public static function fileextension($filename, $numextensions=1) {
    446588        if (strstr($filename, '.')) {
    … …  
    458600    }
    459601
    460 
     602    /**
     603     * @param int $seconds
     604     *
     605     * @return string
     606     */
    461607    public static function PlaytimeString($seconds) {
    462608        $sign = (($seconds < 0) ? '-' : '');
    … …  
    468614    }
    469615
    470 
     616    /**
     617     * @param int $macdate
     618     *
     619     * @return int|float
     620     */
    471621    public static function DateMac2Unix($macdate) {
    472622        // Macintosh timestamp: seconds since 00:00h January 1, 1904
    … …  
    475625    }
    476626
    477 
     627    /**
     628     * @param string $rawdata
     629     *
     630     * @return float
     631     */
    478632    public static function FixedPoint8_8($rawdata) {
    479633        return self::BigEndian2Int(substr($rawdata, 0, 1)) + (float) (self::BigEndian2Int(substr($rawdata, 1, 1)) / pow(2, 8));
    480634    }
    481635
    482 
     636    /**
     637     * @param string $rawdata
     638     *
     639     * @return float
     640     */
    483641    public static function FixedPoint16_16($rawdata) {
    484642        return self::BigEndian2Int(substr($rawdata, 0, 2)) + (float) (self::BigEndian2Int(substr($rawdata, 2, 2)) / pow(2, 16));
    485643    }
    486644
    487 
     645    /**
     646     * @param string $rawdata
     647     *
     648     * @return float
     649     */
    488650    public static function FixedPoint2_30($rawdata) {
    489651        $binarystring = self::BigEndian2Bin($rawdata);
    … …  
    492654
    493655
     656    /**
     657     * @param string $ArrayPath
     658     * @param string $Separator
     659     * @param mixed $Value
     660     *
     661     * @return array
     662     */
    494663    public static function CreateDeepArray($ArrayPath, $Separator, $Value) {
    495664        // assigns $Value to a nested array path:
    … …  
    508677    }
    509678
     679    /**
     680     * @param array $arraydata
     681     * @param bool  $returnkey
     682     *
     683     * @return int|false
     684     */
    510685    public static function array_max($arraydata, $returnkey=false) {
    511686        $maxvalue = false;
    … …  
    522697    }
    523698
     699    /**
     700     * @param array $arraydata
     701     * @param bool  $returnkey
     702     *
     703     * @return int|false
     704     */
    524705    public static function array_min($arraydata, $returnkey=false) {
    525706        $minvalue = false;
    … …  
    536717    }
    537718
     719    /**
     720     * @param string $XMLstring
     721     *
     722     * @return array|false
     723     */
    538724    public static function XML2array($XMLstring) {
    539725        if (function_exists('simplexml_load_string') && function_exists('libxml_disable_entity_loader')) {
    … …  
    549735    }
    550736
     737    /**
     738    * @param SimpleXMLElement|array $XMLobject
     739    *
     740    * @return array
     741    */
    551742    public static function SimpleXMLelement2array($XMLobject) {
    552743        if (!is_object($XMLobject) && !is_array($XMLobject)) {
    553744            return $XMLobject;
    554745        }
    555         $XMLarray = (is_object($XMLobject) ? get_object_vars($XMLobject) : $XMLobject);
     746        $XMLarray = $XMLobject instanceof SimpleXMLElement ? get_object_vars($XMLobject) : $XMLobject;
    556747        foreach ($XMLarray as $key => $value) {
    557748            $XMLarray[$key] = self::SimpleXMLelement2array($value);
    … …  
    560751    }
    561752
    562 
    563     // Allan Hansen <ahØartemis*dk>
    564     // self::md5_data() - returns md5sum for a file from startuing position to absolute end position
     753    /**
     754     * Returns checksum for a file from starting position to absolute end position.
     755     *
     756     * @param string $file
     757     * @param int    $offset
     758     * @param int    $end
     759     * @param string $algorithm
     760     *
     761     * @return string|false
     762     * @throws getid3_exception
     763     */
    565764    public static function hash_data($file, $offset, $end, $algorithm) {
    566         static $tempdir = '';
    567765        if (!self::intValueSupported($end)) {
    568766            return false;
    569767        }
    570         switch ($algorithm) {
    571             case 'md5':
    572                 $hash_function = 'md5_file';
    573                 $unix_call     = 'md5sum';
    574                 $windows_call  = 'md5sum.exe';
    575                 $hash_length   = 32;
    576                 break;
    577 
    578             case 'sha1':
    579                 $hash_function = 'sha1_file';
    580                 $unix_call     = 'sha1sum';
    581                 $windows_call  = 'sha1sum.exe';
    582                 $hash_length   = 40;
    583                 break;
    584 
    585             default:
    586                 throw new Exception('Invalid algorithm ('.$algorithm.') in self::hash_data()');
    587                 break;
    588         }
     768        if (!in_array($algorithm, array('md5', 'sha1'))) {
     769            throw new getid3_exception('Invalid algorithm ('.$algorithm.') in self::hash_data()');
     770        }
     771
    589772        $size = $end - $offset;
    590         while (true) {
    591             if (GETID3_OS_ISWINDOWS) {
    592 
    593                 // It seems that sha1sum.exe for Windows only works on physical files, does not accept piped data
    594                 // Fall back to create-temp-file method:
    595                 if ($algorithm == 'sha1') {
    596                     break;
    597                 }
    598 
    599                 $RequiredFiles = array('cygwin1.dll', 'head.exe', 'tail.exe', $windows_call);
    600                 foreach ($RequiredFiles as $required_file) {
    601                     if (!is_readable(GETID3_HELPERAPPSDIR.$required_file)) {
    602                         // helper apps not available - fall back to old method
    603                         break 2;
    604                     }
    605                 }
    606                 $commandline  = GETID3_HELPERAPPSDIR.'head.exe -c '.$end.' '.escapeshellarg(str_replace('/', DIRECTORY_SEPARATOR, $file)).' | ';
    607                 $commandline .= GETID3_HELPERAPPSDIR.'tail.exe -c '.$size.' | ';
    608                 $commandline .= GETID3_HELPERAPPSDIR.$windows_call;
    609 
    610             } else {
    611 
    612                 $commandline  = 'head -c'.$end.' '.escapeshellarg($file).' | ';
    613                 $commandline .= 'tail -c'.$size.' | ';
    614                 $commandline .= $unix_call;
    615 
    616             }
    617             if (preg_match('#(1|ON)#i', ini_get('safe_mode'))) {
    618                 //throw new Exception('PHP running in Safe Mode - backtick operator not available, using slower non-system-call '.$algorithm.' algorithm');
    619                 break;
    620             }
    621             return substr(`$commandline`, 0, $hash_length);
    622         }
    623 
    624         if (empty($tempdir)) {
    625             // yes this is ugly, feel free to suggest a better way
    626             require_once(dirname(__FILE__).'/getid3.php');
    627             $getid3_temp = new getID3();
    628             $tempdir = $getid3_temp->tempdir;
    629             unset($getid3_temp);
    630         }
    631         // try to create a temporary file in the system temp directory - invalid dirname should force to system temp dir
    632         if (($data_filename = tempnam($tempdir, 'gI3')) === false) {
    633             // can't find anywhere to create a temp file, just fail
    634             return false;
    635         }
    636 
    637         // Init
    638         $result = false;
    639 
    640         // copy parts of file
    641         try {
    642             self::CopyFileParts($file, $data_filename, $offset, $end - $offset);
    643             $result = $hash_function($data_filename);
    644         } catch (Exception $e) {
    645             throw new Exception('self::CopyFileParts() failed in getid_lib::hash_data(): '.$e->getMessage());
    646         }
    647         unlink($data_filename);
    648         return $result;
    649     }
    650 
     773
     774        $fp = fopen($file, 'rb');
     775        fseek($fp, $offset);
     776        $ctx = hash_init($algorithm);
     777        while ($size > 0) {
     778            $buffer = fread($fp, min($size, getID3::FREAD_BUFFER_SIZE));
     779            hash_update($ctx, $buffer);
     780            $size -= getID3::FREAD_BUFFER_SIZE;
     781        }
     782        $hash = hash_final($ctx);
     783        fclose($fp);
     784
     785        return $hash;
     786    }
     787
     788    /**
     789     * @param string $filename_source
     790     * @param string $filename_dest
     791     * @param int    $offset
     792     * @param int    $length
     793     *
     794     * @return bool
     795     * @throws Exception
     796     *
     797     * @deprecated Unused, may be removed in future versions of getID3
     798     */
    651799    public static function CopyFileParts($filename_source, $filename_dest, $offset, $length) {
    652800        if (!self::intValueSupported($offset + $length)) {
    … …  
    661809                        $byteslefttowrite -= $byteswritten;
    662810                    }
     811                    fclose($fp_dest);
    663812                    return true;
    664813                } else {
     814                    fclose($fp_src);
    665815                    throw new Exception('failed to seek to offset '.$offset.' in '.$filename_source);
    666816                }
    667                 fclose($fp_dest);
    668817            } else {
    669818                throw new Exception('failed to create file for writing '.$filename_dest);
    670819            }
    671             fclose($fp_src);
    672820        } else {
    673821            throw new Exception('failed to open file for reading '.$filename_source);
    674822        }
    675         return false;
    676     }
    677 
     823    }
     824
     825    /**
     826     * @param int $charval
     827     *
     828     * @return string
     829     */
    678830    public static function iconv_fallback_int_utf8($charval) {
    679831        if ($charval < 128) {
    … …  
    699851    }
    700852
    701     // ISO-8859-1 => UTF-8
     853    /**
     854     * ISO-8859-1 => UTF-8
     855     *
     856     * @param string $string
     857     * @param bool   $bom
     858     *
     859     * @return string
     860     */
    702861    public static function iconv_fallback_iso88591_utf8($string, $bom=false) {
    703862        if (function_exists('utf8_encode')) {
    … …  
    710869        }
    711870        for ($i = 0; $i < strlen($string); $i++) {
    712             $charval = ord($string{$i});
     871            $charval = ord($string[$i]);
    713872            $newcharstring .= self::iconv_fallback_int_utf8($charval);
    714873        }
    … …  
    716875    }
    717876
    718     // ISO-8859-1 => UTF-16BE
     877    /**
     878     * ISO-8859-1 => UTF-16BE
     879     *
     880     * @param string $string
     881     * @param bool   $bom
     882     *
     883     * @return string
     884     */
    719885    public static function iconv_fallback_iso88591_utf16be($string, $bom=false) {
    720886        $newcharstring = '';
    … …  
    723889        }
    724890        for ($i = 0; $i < strlen($string); $i++) {
    725             $newcharstring .= "\x00".$string{$i};
     891            $newcharstring .= "\x00".$string[$i];
    726892        }
    727893        return $newcharstring;
    728894    }
    729895
    730     // ISO-8859-1 => UTF-16LE
     896    /**
     897     * ISO-8859-1 => UTF-16LE
     898     *
     899     * @param string $string
     900     * @param bool   $bom
     901     *
     902     * @return string
     903     */
    731904    public static function iconv_fallback_iso88591_utf16le($string, $bom=false) {
    732905        $newcharstring = '';
    … …  
    735908        }
    736909        for ($i = 0; $i < strlen($string); $i++) {
    737             $newcharstring .= $string{$i}."\x00";
     910            $newcharstring .= $string[$i]."\x00";
    738911        }
    739912        return $newcharstring;
    740913    }
    741914
    742     // ISO-8859-1 => UTF-16LE (BOM)
     915    /**
     916     * ISO-8859-1 => UTF-16LE (BOM)
     917     *
     918     * @param string $string
     919     *
     920     * @return string
     921     */
    743922    public static function iconv_fallback_iso88591_utf16($string) {
    744923        return self::iconv_fallback_iso88591_utf16le($string, true);
    745924    }
    746925
    747     // UTF-8 => ISO-8859-1
     926    /**
     927     * UTF-8 => ISO-8859-1
     928     *
     929     * @param string $string
     930     *
     931     * @return string
     932     */
    748933    public static function iconv_fallback_utf8_iso88591($string) {
    749934        if (function_exists('utf8_decode')) {
    … …  
    755940        $stringlength = strlen($string);
    756941        while ($offset < $stringlength) {
    757             if ((ord($string{$offset}) | 0x07) == 0xF7) {
     942            if ((ord($string[$offset]) | 0x07) == 0xF7) {
    758943                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
    759                 $charval = ((ord($string{($offset + 0)}) & 0x07) << 18) &
    760                            ((ord($string{($offset + 1)}) & 0x3F) << 12) &
    761                            ((ord($string{($offset + 2)}) & 0x3F) <<  6) &
    762                             (ord($string{($offset + 3)}) & 0x3F);
     944                $charval = ((ord($string[($offset + 0)]) & 0x07) << 18) &
     945                           ((ord($string[($offset + 1)]) & 0x3F) << 12) &
     946                           ((ord($string[($offset + 2)]) & 0x3F) <<  6) &
     947                            (ord($string[($offset + 3)]) & 0x3F);
    763948                $offset += 4;
    764             } elseif ((ord($string{$offset}) | 0x0F) == 0xEF) {
     949            } elseif ((ord($string[$offset]) | 0x0F) == 0xEF) {
    765950                // 1110bbbb 10bbbbbb 10bbbbbb
    766                 $charval = ((ord($string{($offset + 0)}) & 0x0F) << 12) &
    767                            ((ord($string{($offset + 1)}) & 0x3F) <<  6) &
    768                             (ord($string{($offset + 2)}) & 0x3F);
     951                $charval = ((ord($string[($offset + 0)]) & 0x0F) << 12) &
     952                           ((ord($string[($offset + 1)]) & 0x3F) <<  6) &
     953                            (ord($string[($offset + 2)]) & 0x3F);
    769954                $offset += 3;
    770             } elseif ((ord($string{$offset}) | 0x1F) == 0xDF) {
     955            } elseif ((ord($string[$offset]) | 0x1F) == 0xDF) {
    771956                // 110bbbbb 10bbbbbb
    772                 $charval = ((ord($string{($offset + 0)}) & 0x1F) <<  6) &
    773                             (ord($string{($offset + 1)}) & 0x3F);
     957                $charval = ((ord($string[($offset + 0)]) & 0x1F) <<  6) &
     958                            (ord($string[($offset + 1)]) & 0x3F);
    774959                $offset += 2;
    775             } elseif ((ord($string{$offset}) | 0x7F) == 0x7F) {
     960            } elseif ((ord($string[$offset]) | 0x7F) == 0x7F) {
    776961                // 0bbbbbbb
    777                 $charval = ord($string{$offset});
     962                $charval = ord($string[$offset]);
    778963                $offset += 1;
    779964            } else {
    … …  
    789974    }
    790975
    791     // UTF-8 => UTF-16BE
     976    /**
     977     * UTF-8 => UTF-16BE
     978     *
     979     * @param string $string
     980     * @param bool   $bom
     981     *
     982     * @return string
     983     */
    792984    public static function iconv_fallback_utf8_utf16be($string, $bom=false) {
    793985        $newcharstring = '';
    … …  
    798990        $stringlength = strlen($string);
    799991        while ($offset < $stringlength) {
    800             if ((ord($string{$offset}) | 0x07) == 0xF7) {
     992            if ((ord($string[$offset]) | 0x07) == 0xF7) {
    801993                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
    802                 $charval = ((ord($string{($offset + 0)}) & 0x07) << 18) &
    803                            ((ord($string{($offset + 1)}) & 0x3F) << 12) &
    804                            ((ord($string{($offset + 2)}) & 0x3F) <<  6) &
    805                             (ord($string{($offset + 3)}) & 0x3F);
     994                $charval = ((ord($string[($offset + 0)]) & 0x07) << 18) &
     995                           ((ord($string[($offset + 1)]) & 0x3F) << 12) &
     996                           ((ord($string[($offset + 2)]) & 0x3F) <<  6) &
     997                            (ord($string[($offset + 3)]) & 0x3F);
    806998                $offset += 4;
    807             } elseif ((ord($string{$offset}) | 0x0F) == 0xEF) {
     999            } elseif ((ord($string[$offset]) | 0x0F) == 0xEF) {
    8081000                // 1110bbbb 10bbbbbb 10bbbbbb
    809                 $charval = ((ord($string{($offset + 0)}) & 0x0F) << 12) &
    810                            ((ord($string{($offset + 1)}) & 0x3F) <<  6) &
    811                             (ord($string{($offset + 2)}) & 0x3F);
     1001                $charval = ((ord($string[($offset + 0)]) & 0x0F) << 12) &
     1002                           ((ord($string[($offset + 1)]) & 0x3F) <<  6) &
     1003                            (ord($string[($offset + 2)]) & 0x3F);
    8121004                $offset += 3;
    813             } elseif ((ord($string{$offset}) | 0x1F) == 0xDF) {
     1005            } elseif ((ord($string[$offset]) | 0x1F) == 0xDF) {
    8141006                // 110bbbbb 10bbbbbb
    815                 $charval = ((ord($string{($offset + 0)}) & 0x1F) <<  6) &
    816                             (ord($string{($offset + 1)}) & 0x3F);
     1007                $charval = ((ord($string[($offset + 0)]) & 0x1F) <<  6) &
     1008                            (ord($string[($offset + 1)]) & 0x3F);
    8171009                $offset += 2;
    818             } elseif ((ord($string{$offset}) | 0x7F) == 0x7F) {
     1010            } elseif ((ord($string[$offset]) | 0x7F) == 0x7F) {
    8191011                // 0bbbbbbb
    820                 $charval = ord($string{$offset});
     1012                $charval = ord($string[$offset]);
    8211013                $offset += 1;
    8221014            } else {
    … …  
    8321024    }
    8331025
    834     // UTF-8 => UTF-16LE
     1026    /**
     1027     * UTF-8 => UTF-16LE
     1028     *
     1029     * @param string $string
     1030     * @param bool   $bom
     1031     *
     1032     * @return string
     1033     */
    8351034    public static function iconv_fallback_utf8_utf16le($string, $bom=false) {
    8361035        $newcharstring = '';
    … …  
    8411040        $stringlength = strlen($string);
    8421041        while ($offset < $stringlength) {
    843             if ((ord($string{$offset}) | 0x07) == 0xF7) {
     1042            if ((ord($string[$offset]) | 0x07) == 0xF7) {
    8441043                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
    845                 $charval = ((ord($string{($offset + 0)}) & 0x07) << 18) &
    846                            ((ord($string{($offset + 1)}) & 0x3F) << 12) &
    847                            ((ord($string{($offset + 2)}) & 0x3F) <<  6) &
    848                             (ord($string{($offset + 3)}) & 0x3F);
     1044                $charval = ((ord($string[($offset + 0)]) & 0x07) << 18) &
     1045                           ((ord($string[($offset + 1)]) & 0x3F) << 12) &
     1046                           ((ord($string[($offset + 2)]) & 0x3F) <<  6) &
     1047                            (ord($string[($offset + 3)]) & 0x3F);
    8491048                $offset += 4;
    850             } elseif ((ord($string{$offset}) | 0x0F) == 0xEF) {
     1049            } elseif ((ord($string[$offset]) | 0x0F) == 0xEF) {
    8511050                // 1110bbbb 10bbbbbb 10bbbbbb
    852                 $charval = ((ord($string{($offset + 0)}) & 0x0F) << 12) &
    853                            ((ord($string{($offset + 1)}) & 0x3F) <<  6) &
    854                             (ord($string{($offset + 2)}) & 0x3F);
     1051                $charval = ((ord($string[($offset + 0)]) & 0x0F) << 12) &
     1052                           ((ord($string[($offset + 1)]) & 0x3F) <<  6) &
     1053                            (ord($string[($offset + 2)]) & 0x3F);
    8551054                $offset += 3;
    856             } elseif ((ord($string{$offset}) | 0x1F) == 0xDF) {
     1055            } elseif ((ord($string[$offset]) | 0x1F) == 0xDF) {
    8571056                // 110bbbbb 10bbbbbb
    858                 $charval = ((ord($string{($offset + 0)}) & 0x1F) <<  6) &
    859                             (ord($string{($offset + 1)}) & 0x3F);
     1057                $charval = ((ord($string[($offset + 0)]) & 0x1F) <<  6) &
     1058                            (ord($string[($offset + 1)]) & 0x3F);
    8601059                $offset += 2;
    861             } elseif ((ord($string{$offset}) | 0x7F) == 0x7F) {
     1060            } elseif ((ord($string[$offset]) | 0x7F) == 0x7F) {
    8621061                // 0bbbbbbb
    863                 $charval = ord($string{$offset});
     1062                $charval = ord($string[$offset]);
    8641063                $offset += 1;
    8651064            } else {
    … …  
    8751074    }
    8761075
    877     // UTF-8 => UTF-16LE (BOM)
     1076    /**
     1077     * UTF-8 => UTF-16LE (BOM)
     1078     *
     1079     * @param string $string
     1080     *
     1081     * @return string
     1082     */
    8781083    public static function iconv_fallback_utf8_utf16($string) {
    8791084        return self::iconv_fallback_utf8_utf16le($string, true);
    8801085    }
    8811086
    882     // UTF-16BE => UTF-8
     1087    /**
     1088     * UTF-16BE => UTF-8
     1089     *
     1090     * @param string $string
     1091     *
     1092     * @return string
     1093     */
    8831094    public static function iconv_fallback_utf16be_utf8($string) {
    8841095        if (substr($string, 0, 2) == "\xFE\xFF") {
    … …  
    8941105    }
    8951106
    896     // UTF-16LE => UTF-8
     1107    /**
     1108     * UTF-16LE => UTF-8
     1109     *
     1110     * @param string $string
     1111     *
     1112     * @return string
     1113     */
    8971114    public static function iconv_fallback_utf16le_utf8($string) {
    8981115        if (substr($string, 0, 2) == "\xFF\xFE") {
    … …  
    9081125    }
    9091126
    910     // UTF-16BE => ISO-8859-1
     1127    /**
     1128     * UTF-16BE => ISO-8859-1
     1129     *
     1130     * @param string $string
     1131     *
     1132     * @return string
     1133     */
    9111134    public static function iconv_fallback_utf16be_iso88591($string) {
    9121135        if (substr($string, 0, 2) == "\xFE\xFF") {
    … …  
    9221145    }
    9231146
    924     // UTF-16LE => ISO-8859-1
     1147    /**
     1148     * UTF-16LE => ISO-8859-1
     1149     *
     1150     * @param string $string
     1151     *
     1152     * @return string
     1153     */
    9251154    public static function iconv_fallback_utf16le_iso88591($string) {
    9261155        if (substr($string, 0, 2) == "\xFF\xFE") {
    … …  
    9361165    }
    9371166
    938     // UTF-16 (BOM) => ISO-8859-1
     1167    /**
     1168     * UTF-16 (BOM) => ISO-8859-1
     1169     *
     1170     * @param string $string
     1171     *
     1172     * @return string
     1173     */
    9391174    public static function iconv_fallback_utf16_iso88591($string) {
    9401175        $bom = substr($string, 0, 2);
    … …  
    9471182    }
    9481183
    949     // UTF-16 (BOM) => UTF-8
     1184    /**
     1185     * UTF-16 (BOM) => UTF-8
     1186     *
     1187     * @param string $string
     1188     *
     1189     * @return string
     1190     */
    9501191    public static function iconv_fallback_utf16_utf8($string) {
    9511192        $bom = substr($string, 0, 2);
    … …  
    9581199    }
    9591200
     1201    /**
     1202     * @param string $in_charset
     1203     * @param string $out_charset
     1204     * @param string $string
     1205     *
     1206     * @return string
     1207     * @throws Exception
     1208     */
    9601209    public static function iconv_fallback($in_charset, $out_charset, $string) {
    9611210
    … …  
    9641213        }
    9651214
    966         // mb_convert_encoding() availble
     1215        // mb_convert_encoding() available
    9671216        if (function_exists('mb_convert_encoding')) {
     1217            if ((strtoupper($in_charset) == 'UTF-16') && (substr($string, 0, 2) != "\xFE\xFF") && (substr($string, 0, 2) != "\xFF\xFE")) {
     1218                // if BOM missing, mb_convert_encoding will mishandle the conversion, assume UTF-16BE and prepend appropriate BOM
     1219                $string = "\xFF\xFE".$string;
     1220            }
     1221            if ((strtoupper($in_charset) == 'UTF-16') && (strtoupper($out_charset) == 'UTF-8')) {
     1222                if (($string == "\xFF\xFE") || ($string == "\xFE\xFF")) {
     1223                    // if string consists of only BOM, mb_convert_encoding will return the BOM unmodified
     1224                    return '';
     1225                }
     1226            }
    9681227            if ($converted_string = @mb_convert_encoding($string, $out_charset, $in_charset)) {
    9691228                switch ($out_charset) {
    … …  
    9751234            }
    9761235            return $string;
    977         }
    978         // iconv() availble
    979         else if (function_exists('iconv')) {
     1236
     1237        // iconv() available
     1238        } elseif (function_exists('iconv')) {
    9801239            if ($converted_string = @iconv($in_charset, $out_charset.'//TRANSLIT', $string)) {
    9811240                switch ($out_charset) {
    … …  
    10181277    }
    10191278
     1279    /**
     1280     * @param mixed  $data
     1281     * @param string $charset
     1282     *
     1283     * @return mixed
     1284     */
    10201285    public static function recursiveMultiByteCharString2HTML($data, $charset='ISO-8859-1') {
    10211286        if (is_string($data)) {
    … …  
    10321297    }
    10331298
     1299    /**
     1300     * @param string|int|float $string
     1301     * @param string           $charset
     1302     *
     1303     * @return string
     1304     */
    10341305    public static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
    10351306        $string = (string) $string; // in case trying to pass a numeric (float, int) string, would otherwise return an empty string
    … …  
    10701341                $strlen = strlen($string);
    10711342                for ($i = 0; $i < $strlen; $i++) {
    1072                     $char_ord_val = ord($string{$i});
     1343                    $char_ord_val = ord($string[$i]);
    10731344                    $charval = 0;
    10741345                    if ($char_ord_val < 0x80) {
    … …  
    10761347                    } elseif ((($char_ord_val & 0xF0) >> 4) == 0x0F  &&  $i+3 < $strlen) {
    10771348                        $charval  = (($char_ord_val & 0x07) << 18);
    1078                         $charval += ((ord($string{++$i}) & 0x3F) << 12);
    1079                         $charval += ((ord($string{++$i}) & 0x3F) << 6);
    1080                         $charval +=  (ord($string{++$i}) & 0x3F);
     1349                        $charval += ((ord($string[++$i]) & 0x3F) << 12);
     1350                        $charval += ((ord($string[++$i]) & 0x3F) << 6);
     1351                        $charval +=  (ord($string[++$i]) & 0x3F);
    10811352                    } elseif ((($char_ord_val & 0xE0) >> 5) == 0x07  &&  $i+2 < $strlen) {
    10821353                        $charval  = (($char_ord_val & 0x0F) << 12);
    1083                         $charval += ((ord($string{++$i}) & 0x3F) << 6);
    1084                         $charval +=  (ord($string{++$i}) & 0x3F);
     1354                        $charval += ((ord($string[++$i]) & 0x3F) << 6);
     1355                        $charval +=  (ord($string[++$i]) & 0x3F);
    10851356                    } elseif ((($char_ord_val & 0xC0) >> 6) == 0x03  &&  $i+1 < $strlen) {
    10861357                        $charval  = (($char_ord_val & 0x1F) << 6);
    1087                         $charval += (ord($string{++$i}) & 0x3F);
     1358                        $charval += (ord($string[++$i]) & 0x3F);
    10881359                    }
    10891360                    if (($charval >= 32) && ($charval <= 127)) {
    … …  
    11241395    }
    11251396
    1126 
    1127 
     1397    /**
     1398     * @param int $namecode
     1399     *
     1400     * @return string
     1401     */
    11281402    public static function RGADnameLookup($namecode) {
    11291403        static $RGADname = array();
    … …  
    11371411    }
    11381412
    1139 
     1413    /**
     1414     * @param int $originatorcode
     1415     *
     1416     * @return string
     1417     */
    11401418    public static function RGADoriginatorLookup($originatorcode) {
    11411419        static $RGADoriginator = array();
    … …  
    11501428    }
    11511429
    1152 
     1430    /**
     1431     * @param int $rawadjustment
     1432     * @param int $signbit
     1433     *
     1434     * @return float
     1435     */
    11531436    public static function RGADadjustmentLookup($rawadjustment, $signbit) {
    1154         $adjustment = $rawadjustment / 10;
     1437        $adjustment = (float) $rawadjustment / 10;
    11551438        if ($signbit == 1) {
    11561439            $adjustment *= -1;
    11571440        }
    1158         return (float) $adjustment;
    1159     }
    1160 
    1161 
     1441        return $adjustment;
     1442    }
     1443
     1444    /**
     1445     * @param int $namecode
     1446     * @param int $originatorcode
     1447     * @param int $replaygain
     1448     *
     1449     * @return string
     1450     */
    11621451    public static function RGADgainString($namecode, $originatorcode, $replaygain) {
    11631452        if ($replaygain < 0) {
    … …  
    11751464    }
    11761465
     1466    /**
     1467     * @param float $amplitude
     1468     *
     1469     * @return float
     1470     */
    11771471    public static function RGADamplitude2dB($amplitude) {
    11781472        return 20 * log10($amplitude);
    11791473    }
    11801474
    1181 
     1475    /**
     1476     * @param string $imgData
     1477     * @param array  $imageinfo
     1478     *
     1479     * @return array|false
     1480     */
    11821481    public static function GetDataImageSize($imgData, &$imageinfo=array()) {
    11831482        static $tempdir = '';
    … …  
    12141513    }
    12151514
     1515    /**
     1516     * @param string $mime_type
     1517     *
     1518     * @return string
     1519     */
    12161520    public static function ImageExtFromMime($mime_type) {
    12171521        // temporary way, works OK for now, but should be reworked in the future
    … …  
    12191523    }
    12201524
    1221     public static function ImageTypesLookup($imagetypeid) {
    1222         static $ImageTypesLookup = array();
    1223         if (empty($ImageTypesLookup)) {
    1224             $ImageTypesLookup[1]  = 'gif';
    1225             $ImageTypesLookup[2]  = 'jpeg';
    1226             $ImageTypesLookup[3]  = 'png';
    1227             $ImageTypesLookup[4]  = 'swf';
    1228             $ImageTypesLookup[5]  = 'psd';
    1229             $ImageTypesLookup[6]  = 'bmp';
    1230             $ImageTypesLookup[7]  = 'tiff (little-endian)';
    1231             $ImageTypesLookup[8]  = 'tiff (big-endian)';
    1232             $ImageTypesLookup[9]  = 'jpc';
    1233             $ImageTypesLookup[10] = 'jp2';
    1234             $ImageTypesLookup[11] = 'jpx';
    1235             $ImageTypesLookup[12] = 'jb2';
    1236             $ImageTypesLookup[13] = 'swc';
    1237             $ImageTypesLookup[14] = 'iff';
    1238         }
    1239         return (isset($ImageTypesLookup[$imagetypeid]) ? $ImageTypesLookup[$imagetypeid] : '');
    1240     }
    1241 
     1525    /**
     1526     * @param array $ThisFileInfo
     1527     *
     1528     * @return bool
     1529     */
    12421530    public static function CopyTagsToComments(&$ThisFileInfo) {
    12431531
    … …  
    13271615    }
    13281616
    1329 
     1617    /**
     1618     * @param string $key
     1619     * @param int    $begin
     1620     * @param int    $end
     1621     * @param string $file
     1622     * @param string $name
     1623     *
     1624     * @return string
     1625     */
    13301626    public static function EmbeddedLookup($key, $begin, $end, $file, $name) {
    13311627
    … …  
    13741670    }
    13751671
     1672    /**
     1673     * @param string $filename
     1674     * @param string $sourcefile
     1675     * @param bool   $DieOnFailure
     1676     *
     1677     * @return bool
     1678     * @throws Exception
     1679     */
    13761680    public static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
    13771681        global $GETID3_ERRORARRAY;
    … …  
    13941698    }
    13951699
     1700    /**
     1701     * @param string $string
     1702     *
     1703     * @return string
     1704     */
    13961705    public static function trimNullByte($string) {
    13971706        return trim($string, "\x00");
    13981707    }
    13991708
     1709    /**
     1710     * @param string $path
     1711     *
     1712     * @return float|bool
     1713     */
    14001714    public static function getFileSizeSyscall($path) {
    14011715        $filesize = false;
    … …  
    14221736    }
    14231737
    1424 
    1425     /**
    1426     * Workaround for Bug #37268 (https://bugs.php.net/bug.php?id=37268)
    1427     * @param string $path A path.
    1428     * @param string $suffix If the name component ends in suffix this will also be cut off.
    1429     * @return string
    1430     */
     1738    /**
     1739     * @param string $filename
     1740     *
     1741     * @return string|false
     1742     */
     1743    public static function truepath($filename) {
     1744        // 2017-11-08: this could use some improvement, patches welcome
     1745        if (preg_match('#^(\\\\\\\\|//)[a-z0-9]#i', $filename, $matches)) {
     1746            // PHP's built-in realpath function does not work on UNC Windows shares
     1747            $goodpath = array();
     1748            foreach (explode('/', str_replace('\\', '/', $filename)) as $part) {
     1749                if ($part == '.') {
     1750                    continue;
     1751                }
     1752                if ($part == '..') {
     1753                    if (count($goodpath)) {
     1754                        array_pop($goodpath);
     1755                    } else {
     1756                        // cannot step above this level, already at top level
     1757                        return false;
     1758                    }
     1759                } else {
     1760                    $goodpath[] = $part;
     1761                }
     1762            }
     1763            return implode(DIRECTORY_SEPARATOR, $goodpath);
     1764        }
     1765        return realpath($filename);
     1766    }
     1767
     1768    /**
     1769     * Workaround for Bug #37268 (https://bugs.php.net/bug.php?id=37268)
     1770     *
     1771     * @param string $path A path.
     1772     * @param string $suffix If the name component ends in suffix this will also be cut off.
     1773     *
     1774     * @return string
     1775     */
    14311776    public static function mb_basename($path, $suffix = null) {
    14321777        $splited = preg_split('#/#', rtrim($path, '/ '));

  • trunk/src/wp-includes/ID3/getid3.php

    r41196 r46112  
    22/////////////////////////////////////////////////////////////////
    33/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
     4//  available at https://github.com/JamesHeinrich/getID3       //
     5//            or https://www.getid3.org                        //
     6//            or http://getid3.sourceforge.net                 //
    87//                                                             //
    98// Please see readme.txt for more information                  //
    … …  
    2625    define('ENT_SUBSTITUTE', (defined('ENT_IGNORE') ? ENT_IGNORE : 8));
    2726}
     27
     28/*
     29https://www.getid3.org/phpBB3/viewtopic.php?t=2114
     30If you are running into a the problem where filenames with special characters are being handled
     31incorrectly by external helper programs (e.g. metaflac), notably with the special characters removed,
     32and you are passing in the filename in UTF8 (typically via a HTML form), try uncommenting this line:
     33*/
     34//setlocale(LC_CTYPE, 'en_US.UTF-8');
    2835
    2936// attempt to define temp dir as something flexible but reliable
    … …  
    7582class getID3
    7683{
    77     // public: Settings
    78     public $encoding        = 'UTF-8';        // CASE SENSITIVE! - i.e. (must be supported by iconv()). Examples:  ISO-8859-1  UTF-8  UTF-16  UTF-16BE
    79     public $encoding_id3v1  = 'ISO-8859-1';   // Should always be 'ISO-8859-1', but some tags may be written in other encodings such as 'EUC-CN' or 'CP1252'
    80 
    81     // public: Optional tag checks - disable for speed.
    82     public $option_tag_id3v1         = true;  // Read and process ID3v1 tags
    83     public $option_tag_id3v2         = true;  // Read and process ID3v2 tags
    84     public $option_tag_lyrics3       = true;  // Read and process Lyrics3 tags
    85     public $option_tag_apetag        = true;  // Read and process APE tags
    86     public $option_tags_process      = true;  // Copy tags to root key 'tags' and encode to $this->encoding
    87     public $option_tags_html         = true;  // Copy tags to root key 'tags_html' properly translated from various encodings to HTML entities
    88 
    89     // public: Optional tag/comment calucations
    90     public $option_extra_info        = true;  // Calculate additional info such as bitrate, channelmode etc
    91 
    92     // public: Optional handling of embedded attachments (e.g. images)
    93     public $option_save_attachments  = true; // defaults to true (ATTACHMENTS_INLINE) for backward compatibility
    94 
    95     // public: Optional calculations
    96     public $option_md5_data          = false; // Get MD5 sum of data part - slow
    97     public $option_md5_data_source   = false; // Use MD5 of source file if availble - only FLAC and OptimFROG
    98     public $option_sha1_data         = false; // Get SHA1 sum of data part - slow
    99     public $option_max_2gb_check     = null;  // Check whether file is larger than 2GB and thus not supported by 32-bit PHP (null: auto-detect based on PHP_INT_MAX)
    100 
    101     // public: Read buffer size in bytes
     84    /*
     85     * Settings
     86     */
     87
     88    /**
     89     * CASE SENSITIVE! - i.e. (must be supported by iconv()). Examples:  ISO-8859-1  UTF-8  UTF-16  UTF-16BE
     90     *
     91     * @var string
     92     */
     93    public $encoding        = 'UTF-8';
     94
     95    /**
     96     * Should always be 'ISO-8859-1', but some tags may be written in other encodings such as 'EUC-CN' or 'CP1252'
     97     *
     98     * @var string
     99     */
     100    public $encoding_id3v1  = 'ISO-8859-1';
     101
     102    /*
     103     * Optional tag checks - disable for speed.
     104     */
     105
     106    /**
     107     * Read and process ID3v1 tags
     108     *
     109     * @var bool
     110     */
     111    public $option_tag_id3v1         = true;
     112
     113    /**
     114     * Read and process ID3v2 tags
     115     *
     116     * @var bool
     117     */
     118    public $option_tag_id3v2         = true;
     119
     120    /**
     121     * Read and process Lyrics3 tags
     122     *
     123     * @var bool
     124     */
     125    public $option_tag_lyrics3       = true;
     126
     127    /**
     128     * Read and process APE tags
     129     *
     130     * @var bool
     131     */
     132    public $option_tag_apetag        = true;
     133
     134    /**
     135     * Copy tags to root key 'tags' and encode to $this->encoding
     136     *
     137     * @var bool
     138     */
     139    public $option_tags_process      = true;
     140
     141    /**
     142     * Copy tags to root key 'tags_html' properly translated from various encodings to HTML entities
     143     *
     144     * @var bool
     145     */
     146    public $option_tags_html         = true;
     147
     148    /*
     149     * Optional tag/comment calculations
     150     */
     151
     152    /**
     153     * Calculate additional info such as bitrate, channelmode etc
     154     *
     155     * @var bool
     156     */
     157    public $option_extra_info        = true;
     158
     159    /*
     160     * Optional handling of embedded attachments (e.g. images)
     161     */
     162
     163    /**
     164     * Defaults to true (ATTACHMENTS_INLINE) for backward compatibility
     165     *
     166     * @var bool|string
     167     */
     168    public $option_save_attachments  = true;
     169
     170    /*
     171     * Optional calculations
     172     */
     173
     174    /**
     175     * Get MD5 sum of data part - slow
     176     *
     177     * @var bool
     178     */
     179    public $option_md5_data          = false;
     180
     181    /**
     182     * Use MD5 of source file if availble - only FLAC and OptimFROG
     183     *
     184     * @var bool
     185     */
     186    public $option_md5_data_source   = false;
     187
     188    /**
     189     * Get SHA1 sum of data part - slow
     190     *
     191     * @var bool
     192     */
     193    public $option_sha1_data         = false;
     194
     195    /**
     196     * Check whether file is larger than 2GB and thus not supported by 32-bit PHP (null: auto-detect based on
     197     * PHP_INT_MAX)
     198     *
     199     * @var bool|null
     200     */
     201    public $option_max_2gb_check;
     202
     203    /**
     204     * Read buffer size in bytes
     205     *
     206     * @var int
     207     */
    102208    public $option_fread_buffer_size = 32768;
    103209
    104210    // Public variables
    105     public $filename;                         // Filename of file being analysed.
    106     public $fp;                               // Filepointer to file being analysed.
    107     public $info;                             // Result array.
     211
     212    /**
     213     * Filename of file being analysed.
     214     *
     215     * @var string
     216     */
     217    public $filename;
     218
     219    /**
     220     * Filepointer to file being analysed.
     221     *
     222     * @var resource
     223     */
     224    public $fp;
     225
     226    /**
     227     * Result array.
     228     *
     229     * @var array
     230     */
     231    public $info;
     232
     233    /**
     234     * @var string
     235     */
    108236    public $tempdir = GETID3_TEMP_DIR;
     237
     238    /**
     239     * @var int
     240     */
    109241    public $memory_limit = 0;
    110242
    111     // Protected variables
     243    /**
     244     * @var string
     245     */
    112246    protected $startup_error   = '';
     247
     248    /**
     249     * @var string
     250     */
    113251    protected $startup_warning = '';
    114252
    115     const VERSION           = '1.9.14-201706111222';
     253    const VERSION           = '1.9.17-201907240906';
    116254    const FREAD_BUFFER_SIZE = 32768;
    117255
    … …  
    119257    const ATTACHMENTS_INLINE = true;
    120258
    121     // public: constructor
    122259    public function __construct() {
     260
     261        // Check for PHP version
     262        $required_php_version = '5.3.0';
     263        if (version_compare(PHP_VERSION, $required_php_version, '<')) {
     264            $this->startup_error .= 'getID3() requires PHP v'.$required_php_version.' or higher - you are running v'.PHP_VERSION."\n";
     265            return;
     266        }
    123267
    124268        // Check memory
    … …  
    177321        // Needed for Windows only:
    178322        // Define locations of helper applications for Shorten, VorbisComment, MetaFLAC
    179         //   as well as other helper functions such as head, tail, md5sum, etc
     323        //   as well as other helper functions such as head, etc
    180324        // This path cannot contain spaces, but the below code will attempt to get the
    181325        //   8.3-equivalent path automatically
    … …  
    220364            throw new getid3_exception($this->startup_error);
    221365        }
    222 
    223         return true;
    224     }
    225 
     366    }
     367
     368    /**
     369     * @return string
     370     */
    226371    public function version() {
    227372        return self::VERSION;
    228373    }
    229374
     375    /**
     376     * @return int
     377     */
    230378    public function fread_buffer_size() {
    231379        return $this->option_fread_buffer_size;
    232380    }
    233381
    234 
    235     // public: setOption
     382    /**
     383     * @param array $optArray
     384     *
     385     * @return bool
     386     */
    236387    public function setOption($optArray) {
    237388        if (!is_array($optArray) || empty($optArray)) {
    … …  
    247398    }
    248399
    249 
    250     public function openfile($filename, $filesize=null) {
     400    /**
     401     * @param string $filename
     402     * @param int    $filesize
     403     *
     404     * @return bool
     405     *
     406     * @throws getid3_exception
     407     */
     408    public function openfile($filename, $filesize=null, $fp=null) {
    251409        try {
    252410            if (!empty($this->startup_error)) {
    … …  
    271429
    272430            $filename = str_replace('/', DIRECTORY_SEPARATOR, $filename);
    273             $filename = preg_replace('#(?<!gs:)('.preg_quote(DIRECTORY_SEPARATOR).'{2,})#', DIRECTORY_SEPARATOR, $filename);
     431            //$filename = preg_replace('#(?<!gs:)('.preg_quote(DIRECTORY_SEPARATOR).'{2,})#', DIRECTORY_SEPARATOR, $filename);
    274432
    275433            // open local file
    276             //if (is_readable($filename) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) { // see http://www.getid3.org/phpBB3/viewtopic.php?t=1720
    277             if ((is_readable($filename) || file_exists($filename)) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) {
     434            //if (is_readable($filename) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) { // see https://www.getid3.org/phpBB3/viewtopic.php?t=1720
     435            if (($fp != null) && ((get_resource_type($fp) == 'file') || (get_resource_type($fp) == 'stream'))) {
     436                $this->fp = $fp;
     437            } elseif ((is_readable($filename) || file_exists($filename)) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) {
    278438                // great
    279439            } else {
    … …  
    332492                            unset($this->info['filesize']);
    333493                            fclose($this->fp);
    334                             throw new getid3_exception('PHP seems to think the file is larger than '.round(PHP_INT_MAX / 1073741824).'GB, but filesystem reports it as '.number_format($real_filesize, 3).'GB, please report to info@getid3.org');
     494                            throw new getid3_exception('PHP seems to think the file is larger than '.round(PHP_INT_MAX / 1073741824).'GB, but filesystem reports it as '.number_format($real_filesize / 1073741824, 3).'GB, please report to info@getid3.org');
    335495                        }
    336496                        $this->info['filesize'] = $real_filesize;
    337                         $this->warning('File is larger than '.round(PHP_INT_MAX / 1073741824).'GB (filesystem reports it as '.number_format($real_filesize, 3).'GB) and is not properly supported by PHP.');
     497                        $this->warning('File is larger than '.round(PHP_INT_MAX / 1073741824).'GB (filesystem reports it as '.number_format($real_filesize / 1073741824, 3).'GB) and is not properly supported by PHP.');
    338498                }
    339499            }
    … …  
    347507    }
    348508
    349     // public: analyze file
    350     public function analyze($filename, $filesize=null, $original_filename='') {
     509    /**
     510     * analyze file
     511     *
     512     * @param string $filename
     513     * @param int    $filesize
     514     * @param string $original_filename
     515     *
     516     * @return array
     517     */
     518    public function analyze($filename, $filesize=null, $original_filename='', $fp=null) {
    351519        try {
    352             if (!$this->openfile($filename, $filesize)) {
     520            if (!$this->openfile($filename, $filesize, $fp)) {
    353521                return $this->info;
    354522            }
    … …  
    384552                if ((substr($header, 0, 3) == 'ID3') && (strlen($header) == 10)) {
    385553                    $this->info['id3v2']['header']        = true;
    386                     $this->info['id3v2']['majorversion']  = ord($header{3});
    387                     $this->info['id3v2']['minorversion']  = ord($header{4});
     554                    $this->info['id3v2']['majorversion']  = ord($header[3]);
     555                    $this->info['id3v2']['minorversion']  = ord($header[4]);
    388556                    $this->info['avdataoffset']          += getid3_lib::BigEndian2Int(substr($header, 6, 4), 1) + 10; // length of ID3v2 tag in 10-byte header doesn't include 10-byte header length
    389557                }
    … …  
    498666
    499667
    500     // private: error handling
     668    /**
     669     * Error handling.
     670     *
     671     * @param string $message
     672     *
     673     * @return array
     674     */
    501675    public function error($message) {
    502676        $this->CleanUp();
    … …  
    509683
    510684
    511     // private: warning handling
     685    /**
     686     * Warning handling.
     687     *
     688     * @param string $message
     689     *
     690     * @return bool
     691     */
    512692    public function warning($message) {
    513693        $this->info['warning'][] = $message;
    … …  
    516696
    517697
    518     // private: CleanUp
     698    /**
     699     * @return bool
     700     */
    519701    private function CleanUp() {
    520702
    … …  
    563745    }
    564746
    565 
    566     // return array containing information about all supported formats
     747    /**
     748     * Return array containing information about all supported formats.
     749     *
     750     * @return array
     751     */
    567752    public function GetFileFormatArray() {
    568753        static $format_info = array();
    … …  
    585770                            'group'     => 'audio',
    586771                            'module'    => 'aac',
    587                             'mime_type' => 'application/octet-stream',
     772                            'mime_type' => 'audio/aac',
    588773                            'fail_ape'  => 'WARNING',
    589774                        ),
    … …  
    603788                            'group'     => 'audio',
    604789                            'module'    => 'aac',
    605                             'mime_type' => 'application/octet-stream',
     790                            'mime_type' => 'audio/aac',
    606791                            'fail_ape'  => 'WARNING',
    607792                        ),
    … …  
    650835                // DSS  - audio       - Digital Speech Standard
    651836                'dss'  => array(
    652                             'pattern'   => '^[\\x02-\\x06]ds[s2]',
     837                            'pattern'   => '^[\\x02-\\x08]ds[s2]',
    653838                            'group'     => 'audio',
    654839                            'module'    => 'dss',
    … …  
    669854                            'group'     => 'audio',
    670855                            'module'    => 'flac',
    671                             'mime_type' => 'audio/x-flac',
     856                            'mime_type' => 'audio/flac',
    672857                        ),
    673858
    … …  
    701886                            'group'     => 'audio',
    702887                            'module'    => 'monkey',
    703                             'mime_type' => 'application/octet-stream',
     888                            'mime_type' => 'audio/x-monkeys-audio',
    704889                        ),
    705890
    … …  
    8901075                            'group'     => 'audio-video',
    8911076                            'module'    => 'riff',
    892                             'mime_type' => 'audio/x-wav',
     1077                            'mime_type' => 'audio/wav',
    8931078                            'fail_ape'  => 'WARNING',
    8941079                        ),
    … …  
    10541239                            'group'     => 'archive',
    10551240                            'module'    => 'gzip',
    1056                             'mime_type' => 'application/x-gzip',
     1241                            'mime_type' => 'application/gzip',
    10571242                            'fail_id3'  => 'ERROR',
    10581243                            'fail_ape'  => 'ERROR',
    … …  
    10691254                        ),
    10701255
     1256                // XZ   - data         - XZ compressed data
     1257                'xz'  => array(
     1258                            'pattern'   => '^\\xFD7zXZ\\x00',
     1259                            'group'     => 'archive',
     1260                            'module'    => 'xz',
     1261                            'mime_type' => 'application/x-xz',
     1262                            'fail_id3'  => 'ERROR',
     1263                            'fail_ape'  => 'ERROR',
     1264                        ),
     1265
    10711266
    10721267                // Misc other formats
    … …  
    11161311    }
    11171312
    1118 
    1119 
     1313    /**
     1314     * @param string $filedata
     1315     * @param string $filename
     1316     *
     1317     * @return mixed|false
     1318     */
    11201319    public function GetFileFormat(&$filedata, $filename='') {
    11211320        // this function will determine the format of a file based on usually
    … …  
    11361335
    11371336        if (preg_match('#\\.mp[123a]$#i', $filename)) {
    1138             // Too many mp3 encoders on the market put gabage in front of mpeg files
     1337            // Too many mp3 encoders on the market put garbage in front of mpeg files
    11391338            // use assume format on these if format detection failed
    11401339            $GetFileFormatArray = $this->GetFileFormatArray();
    … …  
    11551354    }
    11561355
    1157 
    1158     // converts array to $encoding charset from $this->encoding
     1356    /**
     1357     * Converts array to $encoding charset from $this->encoding.
     1358     *
     1359     * @param array  $array
     1360     * @param string $encoding
     1361     */
    11591362    public function CharConvert(&$array, $encoding) {
    11601363
    … …  
    11791382    }
    11801383
    1181 
     1384    /**
     1385     * @return bool
     1386     */
    11821387    public function HandleAllTags() {
    11831388
    … …  
    12341439                    }
    12351440                    if ($tag_key == 'picture') {
     1441                        // pictures can take up a lot of space, and we don't need multiple copies of them; let there be a single copy in [comments][picture], and not elsewhere
    12361442                        unset($this->info[$comment_name]['comments'][$tag_key]);
    12371443                    }
    … …  
    12471453                if ($this->option_tags_html) {
    12481454                    foreach ($this->info['tags'][$tag_name] as $tag_key => $valuearray) {
     1455                        if ($tag_key == 'picture') {
     1456                            // Do not to try to convert binary picture data to HTML
     1457                            // https://github.com/JamesHeinrich/getID3/issues/178
     1458                            continue;
     1459                        }
    12491460                        $this->info['tags_html'][$tag_name][$tag_key] = getid3_lib::recursiveMultiByteCharString2HTML($valuearray, $this->info[$comment_name]['encoding']);
    12501461                    }
    … …  
    12551466        }
    12561467
    1257         // pictures can take up a lot of space, and we don't need multiple copies of them
    1258         // let there be a single copy in [comments][picture], and not elsewhere
     1468        // pictures can take up a lot of space, and we don't need multiple copies of them; let there be a single copy in [comments][picture], and not elsewhere
    12591469        if (!empty($this->info['tags'])) {
    12601470            $unset_keys = array('tags', 'tags_html');
    … …  
    13021512    }
    13031513
     1514    /**
     1515     * @param string $algorithm
     1516     *
     1517     * @return array|bool
     1518     */
    13041519    public function getHashdata($algorithm) {
    13051520        switch ($algorithm) {
    … …  
    13661581                } else {
    13671582
    1368                     $commandline = 'vorbiscomment -w -c "'.$empty.'" "'.$file.'" "'.$temp.'" 2>&1';
    13691583                    $commandline = 'vorbiscomment -w -c '.escapeshellarg($empty).' '.escapeshellarg($file).' '.escapeshellarg($temp).' 2>&1';
    13701584                    $VorbisCommentError = `$commandline`;
    … …  
    14241638        return true;
    14251639    }
    1426 
    14271640
    14281641    public function ChannelsBitratePlaytimeCalculations() {
    … …  
    14901703    }
    14911704
    1492 
     1705    /**
     1706     * @return bool
     1707     */
    14931708    public function CalculateCompressionRatioVideo() {
    14941709        if (empty($this->info['video'])) {
    … …  
    15381753    }
    15391754
    1540 
     1755    /**
     1756     * @return bool
     1757     */
    15411758    public function CalculateCompressionRatioAudio() {
    15421759        if (empty($this->info['audio']['bitrate']) || empty($this->info['audio']['channels']) || empty($this->info['audio']['sample_rate']) || !is_numeric($this->info['audio']['sample_rate'])) {
    … …  
    15551772    }
    15561773
    1557 
     1774    /**
     1775     * @return bool
     1776     */
    15581777    public function CalculateReplayGain() {
    15591778        if (isset($this->info['replay_gain'])) {
    15601779            if (!isset($this->info['replay_gain']['reference_volume'])) {
    1561                 $this->info['replay_gain']['reference_volume'] = (double) 89.0;
     1780                $this->info['replay_gain']['reference_volume'] = 89.0;
    15621781            }
    15631782            if (isset($this->info['replay_gain']['track']['adjustment'])) {
    … …  
    15781797    }
    15791798
     1799    /**
     1800     * @return bool
     1801     */
    15801802    public function ProcessAudioStreams() {
    15811803        if (!empty($this->info['audio']['bitrate']) || !empty($this->info['audio']['channels']) || !empty($this->info['audio']['sample_rate'])) {
    … …  
    15911813    }
    15921814
     1815    /**
     1816     * @return string|bool
     1817     */
    15931818    public function getid3_tempnam() {
    15941819        return tempnam($this->tempdir, 'gI3');
    15951820    }
    15961821
     1822    /**
     1823     * @param string $name
     1824     *
     1825     * @return bool
     1826     *
     1827     * @throws getid3_exception
     1828     */
    15971829    public function include_module($name) {
    15981830        //if (!file_exists($this->include_path.'module.'.$name.'.php')) {
    … …  
    16041836    }
    16051837
    1606     public static function is_writable ($filename) {
    1607         $ret = is_writable($filename);
    1608 
    1609         if (!$ret) {
    1610             $perms = fileperms($filename);
    1611             $ret = ($perms & 0x0080) || ($perms & 0x0010) || ($perms & 0x0002);
    1612         }
    1613 
    1614         return $ret;
    1615     }
     1838    /**
     1839     * @param string $filename
     1840     *
     1841     * @return bool
     1842     */
     1843    public static function is_writable ($filename) {
     1844        $ret = is_writable($filename);
     1845        if (!$ret) {
     1846            $perms = fileperms($filename);
     1847            $ret = ($perms & 0x0080) || ($perms & 0x0010) || ($perms & 0x0002);
     1848        }
     1849        return $ret;
     1850    }
    16161851
    16171852}
    16181853
    16191854
    1620 abstract class getid3_handler {
     1855abstract class getid3_handler
     1856{
    16211857
    16221858    /**
    … …  
    16251861    protected $getid3;                       // pointer
    16261862
    1627     protected $data_string_flag     = false; // analyzing filepointer or string
    1628     protected $data_string          = '';    // string to analyze
    1629     protected $data_string_position = 0;     // seek position in string
    1630     protected $data_string_length   = 0;     // string length
    1631 
    1632     private $dependency_to = null;
    1633 
    1634 
     1863    /**
     1864     * Analyzing filepointer or string.
     1865     *
     1866     * @var bool
     1867     */
     1868    protected $data_string_flag     = false;
     1869
     1870    /**
     1871     * String to analyze.
     1872     *
     1873     * @var string
     1874     */
     1875    protected $data_string          = '';
     1876
     1877    /**
     1878     * Seek position in string.
     1879     *
     1880     * @var int
     1881     */
     1882    protected $data_string_position = 0;
     1883
     1884    /**
     1885     * String length.
     1886     *
     1887     * @var int
     1888     */
     1889    protected $data_string_length   = 0;
     1890
     1891    /**
     1892     * @var string
     1893     */
     1894    private $dependency_to;
     1895
     1896    /**
     1897     * getid3_handler constructor.
     1898     *
     1899     * @param getID3 $getid3
     1900     * @param string $call_module
     1901     */
    16351902    public function __construct(getID3 $getid3, $call_module=null) {
    16361903        $this->getid3 = $getid3;
    … …  
    16411908    }
    16421909
    1643 
    1644     // Analyze from file pointer
     1910    /**
     1911     * Analyze from file pointer.
     1912     *
     1913     * @return bool
     1914     */
    16451915    abstract public function Analyze();
    16461916
    1647 
    1648     // Analyze from string instead
     1917    /**
     1918     * Analyze from string instead.
     1919     *
     1920     * @param string $string
     1921     */
    16491922    public function AnalyzeString($string) {
    16501923        // Enter string mode
    … …  
    16721945    }
    16731946
     1947    /**
     1948     * @param string $string
     1949     */
    16741950    public function setStringMode($string) {
    16751951        $this->data_string_flag   = true;
    … …  
    16781954    }
    16791955
     1956    /**
     1957     * @return int|bool
     1958     */
    16801959    protected function ftell() {
    16811960        if ($this->data_string_flag) {
    … …  
    16851964    }
    16861965
     1966    /**
     1967     * @param int $bytes
     1968     *
     1969     * @return string|false
     1970     *
     1971     * @throws getid3_exception
     1972     */
    16871973    protected function fread($bytes) {
    16881974        if ($this->data_string_flag) {
    … …  
    16971983        //return fread($this->getid3->fp, $bytes);
    16981984        /*
    1699         * http://www.getid3.org/phpBB3/viewtopic.php?t=1930
     1985        * https://www.getid3.org/phpBB3/viewtopic.php?t=1930
    17001986        * "I found out that the root cause for the problem was how getID3 uses the PHP system function fread().
    17011987        * It seems to assume that fread() would always return as many bytes as were requested.
    … …  
    17051991        $contents = '';
    17061992        do {
     1993            //if (($this->getid3->memory_limit > 0) && ($bytes > $this->getid3->memory_limit)) {
     1994            if (($this->getid3->memory_limit > 0) && (($bytes / $this->getid3->memory_limit) > 0.99)) { // enable a more-fuzzy match to prevent close misses generating errors like "PHP Fatal error: Allowed memory size of 33554432 bytes exhausted (tried to allocate 33554464 bytes)"
     1995                throw new getid3_exception('cannot fread('.$bytes.' from '.$this->ftell().') that is more than available PHP memory ('.$this->getid3->memory_limit.')', 10);
     1996            }
    17071997            $part = fread($this->getid3->fp, $bytes);
    17081998            $partLength  = strlen($part);
    … …  
    17132003    }
    17142004
     2005    /**
     2006     * @param int $bytes
     2007     * @param int $whence
     2008     *
     2009     * @return int
     2010     *
     2011     * @throws getid3_exception
     2012     */
    17152013    protected function fseek($bytes, $whence=SEEK_SET) {
    17162014        if ($this->data_string_flag) {
    … …  
    17432041    }
    17442042
     2043    /**
     2044     * @return bool
     2045     */
    17452046    protected function feof() {
    17462047        if ($this->data_string_flag) {
    … …  
    17502051    }
    17512052
     2053    /**
     2054     * @param string $module
     2055     *
     2056     * @return bool
     2057     */
    17522058    final protected function isDependencyFor($module) {
    17532059        return $this->dependency_to == $module;
    17542060    }
    17552061
     2062    /**
     2063     * @param string $text
     2064     *
     2065     * @return bool
     2066     */
    17562067    protected function error($text) {
    17572068        $this->getid3->info['error'][] = $text;
    … …  
    17602071    }
    17612072
     2073    /**
     2074     * @param string $text
     2075     *
     2076     * @return bool
     2077     */
    17622078    protected function warning($text) {
    17632079        return $this->getid3->warning($text);
    17642080    }
    17652081
     2082    /**
     2083     * @param string $text
     2084     */
    17662085    protected function notice($text) {
    17672086        // does nothing for now
    17682087    }
    17692088
     2089    /**
     2090     * @param string $name
     2091     * @param int    $offset
     2092     * @param int    $length
     2093     * @param string $image_mime
     2094     *
     2095     * @return string|null
     2096     *
     2097     * @throws Exception
     2098     * @throws getid3_exception
     2099     */
    17702100    public function saveAttachment($name, $offset, $length, $image_mime=null) {
    17712101        try {
    … …  
    18212151            if (isset($fp_dest) && is_resource($fp_dest)) {
    18222152                fclose($fp_dest);
     2153            }
     2154
     2155            if (isset($dest) && file_exists($dest)) {
    18232156                unlink($dest);
    18242157            }

  • trunk/src/wp-includes/ID3/license.txt

    r32979 r46112  
    22/// getID3() by James Heinrich <info@getid3.org>               //
    33//  available at http://getid3.sourceforge.net                 //
    4 //            or http://www.getid3.org                         //
     4//            or https://www.getid3.org                        //
    55//          also https://github.com/JamesHeinrich/getID3       //
    66/////////////////////////////////////////////////////////////////
    … …  
    1919GNU LGPL: https://gnu.org/licenses/lgpl.html                 (v3)
    2020
    21 Mozilla MPL: http://www.mozilla.org/MPL/2.0/                 (v2)
     21Mozilla MPL: https://www.mozilla.org/MPL/2.0/                (v2)
    2222
    23 getID3 Commercial License: http://getid3.org/#gCL (payment required)
     23getID3 Commercial License: https://www.getid3.org/#gCL (payment required)
    2424
    2525*****************************************************************

  • trunk/src/wp-includes/ID3/module.audio-video.asf.php

    r41196 r46112  
    22/////////////////////////////////////////////////////////////////
    33/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     4//  available at https://github.com/JamesHeinrich/getID3       //
     5//            or https://www.getid3.org                        //
     6//            or http://getid3.sourceforge.net                 //
     7//  see readme.txt for more details                            //
    98/////////////////////////////////////////////////////////////////
    109//                                                             //
    … …  
    1716getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.riff.php', __FILE__, true);
    1817
    19 class getid3_asf extends getid3_handler {
    20 
     18class getid3_asf extends getid3_handler
     19{
     20    /**
     21     * @param getID3 $getid3
     22     */
    2123    public function __construct(getID3 $getid3) {
    2224        parent::__construct($getid3);  // extends getid3_handler::__construct()
    … …  
    3133    }
    3234
     35    /**
     36     * @return bool
     37     */
    3338    public function Analyze() {
    3439        $info = &$this->getid3->info;
    … …  
    8489        $ASFHeaderData = $this->fread($thisfile_asf_headerobject['objectsize'] - 30);
    8590        $offset = 0;
     91        $thisfile_asf_streambitratepropertiesobject = array();
     92        $thisfile_asf_codeclistobject = array();
    8693
    8794        for ($HeaderObjectsCounter = 0; $HeaderObjectsCounter < $thisfile_asf_headerobject['headerobjects']; $HeaderObjectsCounter++) {
    … …  
    791798                            case 'tracknumber':
    792799                                // be careful casting to int: casting unicode strings to int gives unexpected results (stops parsing at first non-numeric character)
    793                                 $thisfile_asf_comments['track'] = array($this->TrimTerm($thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value']));
    794                                 foreach ($thisfile_asf_comments['track'] as $key => $value) {
     800                                $thisfile_asf_comments['track_number'] = array($this->TrimTerm($thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value']));
     801                                foreach ($thisfile_asf_comments['track_number'] as $key => $value) {
    795802                                    if (preg_match('/^[0-9\x00]+$/', $value)) {
    796                                         $thisfile_asf_comments['track'][$key] = intval(str_replace("\x00", '', $value));
     803                                        $thisfile_asf_comments['track_number'][$key] = intval(str_replace("\x00", '', $value));
    797804                                    }
    798805                                }
    … …  
    800807
    801808                            case 'wm/track':
    802                                 if (empty($thisfile_asf_comments['track'])) {
    803                                     $thisfile_asf_comments['track'] = array(1 + $this->TrimConvert($thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value']));
     809                                if (empty($thisfile_asf_comments['track_number'])) {
     810                                    $thisfile_asf_comments['track_number'] = array(1 + $this->TrimConvert($thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value']));
    804811                                }
    805812                                break;
    … …  
    971978            }
    972979        }
    973         if (isset($thisfile_asf_streambitrateproperties['bitrate_records_count'])) {
     980        if (isset($thisfile_asf_streambitratepropertiesobject['bitrate_records_count'])) {
    974981            $ASFbitrateAudio = 0;
    975982            $ASFbitrateVideo = 0;
    976             for ($BitrateRecordsCounter = 0; $BitrateRecordsCounter < $thisfile_asf_streambitrateproperties['bitrate_records_count']; $BitrateRecordsCounter++) {
     983            for ($BitrateRecordsCounter = 0; $BitrateRecordsCounter < $thisfile_asf_streambitratepropertiesobject['bitrate_records_count']; $BitrateRecordsCounter++) {
    977984                if (isset($thisfile_asf_codeclistobject['codec_entries'][$BitrateRecordsCounter])) {
    978985                    switch ($thisfile_asf_codeclistobject['codec_entries'][$BitrateRecordsCounter]['type_raw']) {
    979986                        case 1:
    980                             $ASFbitrateVideo += $thisfile_asf_streambitrateproperties['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
     987                            $ASFbitrateVideo += $thisfile_asf_streambitratepropertiesobject['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
    981988                            break;
    982989
    983990                        case 2:
    984                             $ASFbitrateAudio += $thisfile_asf_streambitrateproperties['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
     991                            $ASFbitrateAudio += $thisfile_asf_streambitratepropertiesobject['bitrate_records'][$BitrateRecordsCounter]['bitrate'];
    985992                            break;
    986993
    … …  
    14411448    }
    14421449
     1450    /**
     1451     * @param int $CodecListType
     1452     *
     1453     * @return string
     1454     */
    14431455    public static function codecListObjectTypeLookup($CodecListType) {
    14441456        static $lookup = array(
    … …  
    14511463    }
    14521464
     1465    /**
     1466     * @return array
     1467     */
    14531468    public static function KnownGUIDs() {
    14541469        static $GUIDarray = array(
    … …  
    15651580    }
    15661581
     1582    /**
     1583     * @param string $GUIDstring
     1584     *
     1585     * @return string|false
     1586     */
    15671587    public static function GUIDname($GUIDstring) {
    15681588        static $GUIDarray = array();
    … …  
    15731593    }
    15741594
     1595    /**
     1596     * @param int $id
     1597     *
     1598     * @return string
     1599     */
    15751600    public static function ASFIndexObjectIndexTypeLookup($id) {
    15761601        static $ASFIndexObjectIndexTypeLookup = array();
    … …  
    15831608    }
    15841609
     1610    /**
     1611     * @param string $GUIDstring
     1612     *
     1613     * @return string
     1614     */
    15851615    public static function GUIDtoBytestring($GUIDstring) {
    15861616        // Microsoft defines these 16-byte (128-bit) GUIDs in the strangest way:
    … …  
    16181648    }
    16191649
     1650    /**
     1651     * @param string $Bytestring
     1652     *
     1653     * @return string
     1654     */
    16201655    public static function BytestringToGUID($Bytestring) {
    1621         $GUIDstring  = str_pad(dechex(ord($Bytestring{3})),  2, '0', STR_PAD_LEFT);
    1622         $GUIDstring .= str_pad(dechex(ord($Bytestring{2})),  2, '0', STR_PAD_LEFT);
    1623         $GUIDstring .= str_pad(dechex(ord($Bytestring{1})),  2, '0', STR_PAD_LEFT);
    1624         $GUIDstring .= str_pad(dechex(ord($Bytestring{0})),  2, '0', STR_PAD_LEFT);
     1656        $GUIDstring  = str_pad(dechex(ord($Bytestring[3])),  2, '0', STR_PAD_LEFT);
     1657        $GUIDstring .= str_pad(dechex(ord($Bytestring[2])),  2, '0', STR_PAD_LEFT);
     1658        $GUIDstring .= str_pad(dechex(ord($Bytestring[1])),  2, '0', STR_PAD_LEFT);
     1659        $GUIDstring .= str_pad(dechex(ord($Bytestring[0])),  2, '0', STR_PAD_LEFT);
    16251660        $GUIDstring .= '-';
    1626         $GUIDstring .= str_pad(dechex(ord($Bytestring{5})),  2, '0', STR_PAD_LEFT);
    1627         $GUIDstring .= str_pad(dechex(ord($Bytestring{4})),  2, '0', STR_PAD_LEFT);
     1661        $GUIDstring .= str_pad(dechex(ord($Bytestring[5])),  2, '0', STR_PAD_LEFT);
     1662        $GUIDstring .= str_pad(dechex(ord($Bytestring[4])),  2, '0', STR_PAD_LEFT);
    16281663        $GUIDstring .= '-';
    1629         $GUIDstring .= str_pad(dechex(ord($Bytestring{7})),  2, '0', STR_PAD_LEFT);
    1630         $GUIDstring .= str_pad(dechex(ord($Bytestring{6})),  2, '0', STR_PAD_LEFT);
     1664        $GUIDstring .= str_pad(dechex(ord($Bytestring[7])),  2, '0', STR_PAD_LEFT);
     1665        $GUIDstring .= str_pad(dechex(ord($Bytestring[6])),  2, '0', STR_PAD_LEFT);
    16311666        $GUIDstring .= '-';
    1632         $GUIDstring .= str_pad(dechex(ord($Bytestring{8})),  2, '0', STR_PAD_LEFT);
    1633         $GUIDstring .= str_pad(dechex(ord($Bytestring{9})),  2, '0', STR_PAD_LEFT);
     1667        $GUIDstring .= str_pad(dechex(ord($Bytestring[8])),  2, '0', STR_PAD_LEFT);
     1668        $GUIDstring .= str_pad(dechex(ord($Bytestring[9])),  2, '0', STR_PAD_LEFT);
    16341669        $GUIDstring .= '-';
    1635         $GUIDstring .= str_pad(dechex(ord($Bytestring{10})), 2, '0', STR_PAD_LEFT);
    1636         $GUIDstring .= str_pad(dechex(ord($Bytestring{11})), 2, '0', STR_PAD_LEFT);
    1637         $GUIDstring .= str_pad(dechex(ord($Bytestring{12})), 2, '0', STR_PAD_LEFT);
    1638         $GUIDstring .= str_pad(dechex(ord($Bytestring{13})), 2, '0', STR_PAD_LEFT);
    1639         $GUIDstring .= str_pad(dechex(ord($Bytestring{14})), 2, '0', STR_PAD_LEFT);
    1640         $GUIDstring .= str_pad(dechex(ord($Bytestring{15})), 2, '0', STR_PAD_LEFT);
     1670        $GUIDstring .= str_pad(dechex(ord($Bytestring[10])), 2, '0', STR_PAD_LEFT);
     1671        $GUIDstring .= str_pad(dechex(ord($Bytestring[11])), 2, '0', STR_PAD_LEFT);
     1672        $GUIDstring .= str_pad(dechex(ord($Bytestring[12])), 2, '0', STR_PAD_LEFT);
     1673        $GUIDstring .= str_pad(dechex(ord($Bytestring[13])), 2, '0', STR_PAD_LEFT);
     1674        $GUIDstring .= str_pad(dechex(ord($Bytestring[14])), 2, '0', STR_PAD_LEFT);
     1675        $GUIDstring .= str_pad(dechex(ord($Bytestring[15])), 2, '0', STR_PAD_LEFT);
    16411676
    16421677        return strtoupper($GUIDstring);
    16431678    }
    16441679
     1680    /**
     1681     * @param int  $FILETIME
     1682     * @param bool $round
     1683     *
     1684     * @return float|int
     1685     */
    16451686    public static function FILETIMEtoUNIXtime($FILETIME, $round=true) {
    16461687        // FILETIME is a 64-bit unsigned integer representing
    … …  
    16541695    }
    16551696
     1697    /**
     1698     * @param int $WMpictureType
     1699     *
     1700     * @return string
     1701     */
    16561702    public static function WMpictureTypeLookup($WMpictureType) {
    16571703        static $lookup = null;
    … …  
    16851731    }
    16861732
     1733    /**
     1734     * @param string $asf_header_extension_object_data
     1735     * @param int    $unhandled_sections
     1736     *
     1737     * @return array
     1738     */
    16871739    public function HeaderExtensionObjectDataParse(&$asf_header_extension_object_data, &$unhandled_sections) {
    16881740        // http://msdn.microsoft.com/en-us/library/bb643323.aspx
    … …  
    19311983    }
    19321984
    1933 
     1985    /**
     1986     * @param int $id
     1987     *
     1988     * @return string
     1989     */
    19341990    public static function metadataLibraryObjectDataTypeLookup($id) {
    19351991        static $lookup = array(
    … …  
    19452001    }
    19462002
     2003    /**
     2004     * @param string $data
     2005     *
     2006     * @return array
     2007     */
    19472008    public function ASF_WMpicture(&$data) {
    19482009        //typedef struct _WMPicture{
    … …  
    19952056    }
    19962057
    1997 
    1998     // Remove terminator 00 00 and convert UTF-16LE to Latin-1
     2058    /**
     2059     * Remove terminator 00 00 and convert UTF-16LE to Latin-1.
     2060     *
     2061     * @param string $string
     2062     *
     2063     * @return string
     2064     */
    19992065    public static function TrimConvert($string) {
    20002066        return trim(getid3_lib::iconv_fallback('UTF-16LE', 'ISO-8859-1', self::TrimTerm($string)), ' ');
    20012067    }
    20022068
    2003 
    2004     // Remove terminator 00 00
     2069    /**
     2070     * Remove terminator 00 00.
     2071     *
     2072     * @param string $string
     2073     *
     2074     * @return string
     2075     */
    20052076    public static function TrimTerm($string) {
    20062077        // remove terminator, only if present (it should be, but...)

  • trunk/src/wp-includes/ID3/module.audio-video.flv.php

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

  • trunk/src/wp-includes/ID3/module.audio-video.matroska.php

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

  • trunk/src/wp-includes/ID3/module.audio-video.quicktime.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    2525    public $ParseAllPossibleAtoms = false;
    2626
     27    /**
     28     * @return bool
     29     */
    2730    public function Analyze() {
    2831        $info = &$this->getid3->info;
    … …  
    3639        $offset      = 0;
    3740        $atomcounter = 0;
    38         $atom_data_read_buffer_size = max($this->getid3->option_fread_buffer_size * 1024, ($info['php_memory_limit'] ? round($info['php_memory_limit'] / 4) : 1024)); // set read buffer to 25% of PHP memory limit (if one is specified), otherwise use option_fread_buffer_size [default: 32MB]
     41        $atom_data_read_buffer_size = $info['php_memory_limit'] ? round($info['php_memory_limit'] / 4) : $this->getid3->option_fread_buffer_size * 1024; // set read buffer to 25% of PHP memory limit (if one is specified), otherwise use option_fread_buffer_size [default: 32MB]
    3942        while ($offset < $info['avdataend']) {
    4043            if (!getid3_lib::intValueSupported($offset)) {
    … …  
    163166            $info['audio']['bitrate'] = $info['bitrate'];
    164167        }
     168        if (!empty($info['bitrate']) && !empty($info['audio']['bitrate']) && empty($info['video']['bitrate']) && !empty($info['video']['frame_rate']) && !empty($info['video']['resolution_x']) && ($info['bitrate'] > $info['audio']['bitrate'])) {
     169            $info['video']['bitrate'] = $info['bitrate'] - $info['audio']['bitrate'];
     170        }
    165171        if (!empty($info['playtime_seconds']) && !isset($info['video']['frame_rate']) && !empty($info['quicktime']['stts_framecount'])) {
    166172            foreach ($info['quicktime']['stts_framecount'] as $key => $samples_count) {
    … …  
    194200            $info['video']['dataformat'] = 'quicktime';
    195201        }
     202        if (isset($info['video']) && ($info['mime_type'] == 'audio/mp4') && empty($info['video']['resolution_x']) && empty($info['video']['resolution_y']))  {
     203            unset($info['video']);
     204        }
    196205
    197206        return true;
    198207    }
    199208
     209    /**
     210     * @param string $atomname
     211     * @param int    $atomsize
     212     * @param string $atom_data
     213     * @param int    $baseoffset
     214     * @param array  $atomHierarchy
     215     * @param bool   $ParseAllPossibleAtoms
     216     *
     217     * @return array|false
     218     */
    200219    public function QuicktimeParseAtom($atomname, $atomsize, $atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
    201220        // http://developer.apple.com/techpubs/quicktime/qtdevdocs/APIREF/INDEX/atomalphaindex.htm
    … …  
    204223        $info = &$this->getid3->info;
    205224
    206         $atom_parent = end($atomHierarchy); // not array_pop($atomHierarchy); see http://www.getid3.org/phpBB3/viewtopic.php?t=1717
     225        $atom_parent = end($atomHierarchy); // not array_pop($atomHierarchy); see https://www.getid3.org/phpBB3/viewtopic.php?t=1717
    207226        array_push($atomHierarchy, $atomname);
    208227        $atom_structure['hierarchy'] = implode(' ', $atomHierarchy);
    … …  
    210229        $atom_structure['size']      = $atomsize;
    211230        $atom_structure['offset']    = $baseoffset;
    212         switch ($atomname) {
    213             case 'moov': // MOVie container atom
    214             case 'trak': // TRAcK container atom
    215             case 'clip': // CLIPping container atom
    216             case 'matt': // track MATTe container atom
    217             case 'edts': // EDiTS container atom
    218             case 'tref': // Track REFerence container atom
    219             case 'mdia': // MeDIA container atom
    220             case 'minf': // Media INFormation container atom
    221             case 'dinf': // Data INFormation container atom
    222             case 'udta': // User DaTA container atom
    223             case 'cmov': // Compressed MOVie container atom
    224             case 'rmra': // Reference Movie Record Atom
    225             case 'rmda': // Reference Movie Descriptor Atom
    226             case 'gmhd': // Generic Media info HeaDer atom (seen on QTVR)
    227                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    228                 break;
    229 
    230             case 'ilst': // Item LiST container atom
    231                 if ($atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms)) {
    232                     // some "ilst" atoms contain data atoms that have a numeric name, and the data is far more accessible if the returned array is compacted
    233                     $allnumericnames = true;
    234                     foreach ($atom_structure['subatoms'] as $subatomarray) {
    235                         if (!is_integer($subatomarray['name']) || (count($subatomarray['subatoms']) != 1)) {
    236                             $allnumericnames = false;
    237                             break;
    238                         }
    239                     }
    240                     if ($allnumericnames) {
    241                         $newData = array();
     231        if (substr($atomname, 0, 3) == "\x00\x00\x00") {
     232            // https://github.com/JamesHeinrich/getID3/issues/139
     233            $atomname = getid3_lib::BigEndian2Int($atomname);
     234            $atom_structure['name'] = $atomname;
     235            $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     236        } else {
     237            switch ($atomname) {
     238                case 'moov': // MOVie container atom
     239                case 'trak': // TRAcK container atom
     240                case 'clip': // CLIPping container atom
     241                case 'matt': // track MATTe container atom
     242                case 'edts': // EDiTS container atom
     243                case 'tref': // Track REFerence container atom
     244                case 'mdia': // MeDIA container atom
     245                case 'minf': // Media INFormation container atom
     246                case 'dinf': // Data INFormation container atom
     247                case 'udta': // User DaTA container atom
     248                case 'cmov': // Compressed MOVie container atom
     249                case 'rmra': // Reference Movie Record Atom
     250                case 'rmda': // Reference Movie Descriptor Atom
     251                case 'gmhd': // Generic Media info HeaDer atom (seen on QTVR)
     252                    $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     253                    break;
     254
     255                case 'ilst': // Item LiST container atom
     256                    if ($atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms)) {
     257                        // some "ilst" atoms contain data atoms that have a numeric name, and the data is far more accessible if the returned array is compacted
     258                        $allnumericnames = true;
    242259                        foreach ($atom_structure['subatoms'] as $subatomarray) {
    243                             foreach ($subatomarray['subatoms'] as $newData_subatomarray) {
    244                                 unset($newData_subatomarray['hierarchy'], $newData_subatomarray['name']);
    245                                 $newData[$subatomarray['name']] = $newData_subatomarray;
     260                            if (!is_integer($subatomarray['name']) || (count($subatomarray['subatoms']) != 1)) {
     261                                $allnumericnames = false;
    246262                                break;
    247263                            }
    248264                        }
    249                         $atom_structure['data'] = $newData;
    250                         unset($atom_structure['subatoms']);
    251                     }
    252                 }
    253                 break;
    254 
    255             case "\x00\x00\x00\x01":
    256             case "\x00\x00\x00\x02":
    257             case "\x00\x00\x00\x03":
    258             case "\x00\x00\x00\x04":
    259             case "\x00\x00\x00\x05":
    260                 $atomname = getid3_lib::BigEndian2Int($atomname);
    261                 $atom_structure['name'] = $atomname;
    262                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    263                 break;
    264 
    265             case 'stbl': // Sample TaBLe container atom
    266                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    267                 $isVideo = false;
    268                 $framerate  = 0;
    269                 $framecount = 0;
    270                 foreach ($atom_structure['subatoms'] as $key => $value_array) {
    271                     if (isset($value_array['sample_description_table'])) {
    272                         foreach ($value_array['sample_description_table'] as $key2 => $value_array2) {
    273                             if (isset($value_array2['data_format'])) {
    274                                 switch ($value_array2['data_format']) {
    275                                     case 'avc1':
    276                                     case 'mp4v':
    277                                         // video data
    278                                         $isVideo = true;
    279                                         break;
    280                                     case 'mp4a':
    281                                         // audio data
    282                                         break;
     265                        if ($allnumericnames) {
     266                            $newData = array();
     267                            foreach ($atom_structure['subatoms'] as $subatomarray) {
     268                                foreach ($subatomarray['subatoms'] as $newData_subatomarray) {
     269                                    unset($newData_subatomarray['hierarchy'], $newData_subatomarray['name']);
     270                                    $newData[$subatomarray['name']] = $newData_subatomarray;
     271                                    break;
     272                                }
     273                            }
     274                            $atom_structure['data'] = $newData;
     275                            unset($atom_structure['subatoms']);
     276                        }
     277                    }
     278                    break;
     279
     280                case 'stbl': // Sample TaBLe container atom
     281                    $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     282                    $isVideo = false;
     283                    $framerate  = 0;
     284                    $framecount = 0;
     285                    foreach ($atom_structure['subatoms'] as $key => $value_array) {
     286                        if (isset($value_array['sample_description_table'])) {
     287                            foreach ($value_array['sample_description_table'] as $key2 => $value_array2) {
     288                                if (isset($value_array2['data_format'])) {
     289                                    switch ($value_array2['data_format']) {
     290                                        case 'avc1':
     291                                        case 'mp4v':
     292                                            // video data
     293                                            $isVideo = true;
     294                                            break;
     295                                        case 'mp4a':
     296                                            // audio data
     297                                            break;
     298                                    }
     299                                }
     300                            }
     301                        } elseif (isset($value_array['time_to_sample_table'])) {
     302                            foreach ($value_array['time_to_sample_table'] as $key2 => $value_array2) {
     303                                if (isset($value_array2['sample_count']) && isset($value_array2['sample_duration']) && ($value_array2['sample_duration'] > 0)) {
     304                                    $framerate  = round($info['quicktime']['time_scale'] / $value_array2['sample_duration'], 3);
     305                                    $framecount = $value_array2['sample_count'];
    283306                                }
    284307                            }
    285308                        }
    286                     } elseif (isset($value_array['time_to_sample_table'])) {
    287                         foreach ($value_array['time_to_sample_table'] as $key2 => $value_array2) {
    288                             if (isset($value_array2['sample_count']) && isset($value_array2['sample_duration']) && ($value_array2['sample_duration'] > 0)) {
    289                                 $framerate  = round($info['quicktime']['time_scale'] / $value_array2['sample_duration'], 3);
    290                                 $framecount = $value_array2['sample_count'];
    291                             }
    292                         }
    293                     }
    294                 }
    295                 if ($isVideo && $framerate) {
    296                     $info['quicktime']['video']['frame_rate'] = $framerate;
    297                     $info['video']['frame_rate'] = $info['quicktime']['video']['frame_rate'];
    298                 }
    299                 if ($isVideo && $framecount) {
    300                     $info['quicktime']['video']['frame_count'] = $framecount;
    301                 }
    302                 break;
    303 
    304 
    305             case "\xA9".'alb': // ALBum
    306             case "\xA9".'ART': //
    307             case "\xA9".'art': // ARTist
    308             case "\xA9".'aut': //
    309             case "\xA9".'cmt': // CoMmenT
    310             case "\xA9".'com': // COMposer
    311             case "\xA9".'cpy': //
    312             case "\xA9".'day': // content created year
    313             case "\xA9".'dir': //
    314             case "\xA9".'ed1': //
    315             case "\xA9".'ed2': //
    316             case "\xA9".'ed3': //
    317             case "\xA9".'ed4': //
    318             case "\xA9".'ed5': //
    319             case "\xA9".'ed6': //
    320             case "\xA9".'ed7': //
    321             case "\xA9".'ed8': //
    322             case "\xA9".'ed9': //
    323             case "\xA9".'enc': //
    324             case "\xA9".'fmt': //
    325             case "\xA9".'gen': // GENre
    326             case "\xA9".'grp': // GRouPing
    327             case "\xA9".'hst': //
    328             case "\xA9".'inf': //
    329             case "\xA9".'lyr': // LYRics
    330             case "\xA9".'mak': //
    331             case "\xA9".'mod': //
    332             case "\xA9".'nam': // full NAMe
    333             case "\xA9".'ope': //
    334             case "\xA9".'PRD': //
    335             case "\xA9".'prf': //
    336             case "\xA9".'req': //
    337             case "\xA9".'src': //
    338             case "\xA9".'swr': //
    339             case "\xA9".'too': // encoder
    340             case "\xA9".'trk': // TRacK
    341             case "\xA9".'url': //
    342             case "\xA9".'wrn': //
    343             case "\xA9".'wrt': // WRiTer
    344             case '----': // itunes specific
    345             case 'aART': // Album ARTist
    346             case 'akID': // iTunes store account type
    347             case 'apID': // Purchase Account
    348             case 'atID': //
    349             case 'catg': // CaTeGory
    350             case 'cmID': //
    351             case 'cnID': //
    352             case 'covr': // COVeR artwork
    353             case 'cpil': // ComPILation
    354             case 'cprt': // CoPyRighT
    355             case 'desc': // DESCription
    356             case 'disk': // DISK number
    357             case 'egid': // Episode Global ID
    358             case 'geID': //
    359             case 'gnre': // GeNRE
    360             case 'hdvd': // HD ViDeo
    361             case 'keyw': // KEYWord
    362             case 'ldes': // Long DEScription
    363             case 'pcst': // PodCaST
    364             case 'pgap': // GAPless Playback
    365             case 'plID': //
    366             case 'purd': // PURchase Date
    367             case 'purl': // Podcast URL
    368             case 'rati': //
    369             case 'rndu': //
    370             case 'rpdu': //
    371             case 'rtng': // RaTiNG
    372             case 'sfID': // iTunes store country
    373             case 'soaa': // SOrt Album Artist
    374             case 'soal': // SOrt ALbum
    375             case 'soar': // SOrt ARtist
    376             case 'soco': // SOrt COmposer
    377             case 'sonm': // SOrt NaMe
    378             case 'sosn': // SOrt Show Name
    379             case 'stik': //
    380             case 'tmpo': // TeMPO (BPM)
    381             case 'trkn': // TRacK Number
    382             case 'tven': // tvEpisodeID
    383             case 'tves': // TV EpiSode
    384             case 'tvnn': // TV Network Name
    385             case 'tvsh': // TV SHow Name
    386             case 'tvsn': // TV SeasoN
    387                 if ($atom_parent == 'udta') {
    388                     // User data atom handler
    389                     $atom_structure['data_length'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
    390                     $atom_structure['language_id'] = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2));
    391                     $atom_structure['data']        =                           substr($atom_data, 4);
    392 
    393                     $atom_structure['language']    = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
    394                     if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
    395                         $info['comments']['language'][] = $atom_structure['language'];
    396                     }
    397                 } else {
    398                     // Apple item list box atom handler
    399                     $atomoffset = 0;
    400                     if (substr($atom_data, 2, 2) == "\x10\xB5") {
    401                         // not sure what it means, but observed on iPhone4 data.
    402                         // Each $atom_data has 2 bytes of datasize, plus 0x10B5, then data
    403                         while ($atomoffset < strlen($atom_data)) {
    404                             $boxsmallsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset,     2));
    405                             $boxsmalltype =                           substr($atom_data, $atomoffset + 2, 2);
    406                             $boxsmalldata =                           substr($atom_data, $atomoffset + 4, $boxsmallsize);
    407                             if ($boxsmallsize <= 1) {
    408                                 $this->warning('Invalid QuickTime atom smallbox size "'.$boxsmallsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
    409                                 $atom_structure['data'] = null;
    410                                 $atomoffset = strlen($atom_data);
    411                                 break;
    412                             }
    413                             switch ($boxsmalltype) {
    414                                 case "\x10\xB5":
    415                                     $atom_structure['data'] = $boxsmalldata;
    416                                     break;
    417                                 default:
    418                                     $this->warning('Unknown QuickTime smallbox type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $boxsmalltype).'" ('.trim(getid3_lib::PrintHexBytes($boxsmalltype)).') at offset '.$baseoffset);
    419                                     $atom_structure['data'] = $atom_data;
    420                                     break;
    421                             }
    422                             $atomoffset += (4 + $boxsmallsize);
     309                    }
     310                    if ($isVideo && $framerate) {
     311                        $info['quicktime']['video']['frame_rate'] = $framerate;
     312                        $info['video']['frame_rate'] = $info['quicktime']['video']['frame_rate'];
     313                    }
     314                    if ($isVideo && $framecount) {
     315                        $info['quicktime']['video']['frame_count'] = $framecount;
     316                    }
     317                    break;
     318
     319
     320                case "\xA9".'alb': // ALBum
     321                case "\xA9".'ART': //
     322                case "\xA9".'art': // ARTist
     323                case "\xA9".'aut': //
     324                case "\xA9".'cmt': // CoMmenT
     325                case "\xA9".'com': // COMposer
     326                case "\xA9".'cpy': //
     327                case "\xA9".'day': // content created year
     328                case "\xA9".'dir': //
     329                case "\xA9".'ed1': //
     330                case "\xA9".'ed2': //
     331                case "\xA9".'ed3': //
     332                case "\xA9".'ed4': //
     333                case "\xA9".'ed5': //
     334                case "\xA9".'ed6': //
     335                case "\xA9".'ed7': //
     336                case "\xA9".'ed8': //
     337                case "\xA9".'ed9': //
     338                case "\xA9".'enc': //
     339                case "\xA9".'fmt': //
     340                case "\xA9".'gen': // GENre
     341                case "\xA9".'grp': // GRouPing
     342                case "\xA9".'hst': //
     343                case "\xA9".'inf': //
     344                case "\xA9".'lyr': // LYRics
     345                case "\xA9".'mak': //
     346                case "\xA9".'mod': //
     347                case "\xA9".'nam': // full NAMe
     348                case "\xA9".'ope': //
     349                case "\xA9".'PRD': //
     350                case "\xA9".'prf': //
     351                case "\xA9".'req': //
     352                case "\xA9".'src': //
     353                case "\xA9".'swr': //
     354                case "\xA9".'too': // encoder
     355                case "\xA9".'trk': // TRacK
     356                case "\xA9".'url': //
     357                case "\xA9".'wrn': //
     358                case "\xA9".'wrt': // WRiTer
     359                case '----': // itunes specific
     360                case 'aART': // Album ARTist
     361                case 'akID': // iTunes store account type
     362                case 'apID': // Purchase Account
     363                case 'atID': //
     364                case 'catg': // CaTeGory
     365                case 'cmID': //
     366                case 'cnID': //
     367                case 'covr': // COVeR artwork
     368                case 'cpil': // ComPILation
     369                case 'cprt': // CoPyRighT
     370                case 'desc': // DESCription
     371                case 'disk': // DISK number
     372                case 'egid': // Episode Global ID
     373                case 'geID': //
     374                case 'gnre': // GeNRE
     375                case 'hdvd': // HD ViDeo
     376                case 'keyw': // KEYWord
     377                case 'ldes': // Long DEScription
     378                case 'pcst': // PodCaST
     379                case 'pgap': // GAPless Playback
     380                case 'plID': //
     381                case 'purd': // PURchase Date
     382                case 'purl': // Podcast URL
     383                case 'rati': //
     384                case 'rndu': //
     385                case 'rpdu': //
     386                case 'rtng': // RaTiNG
     387                case 'sfID': // iTunes store country
     388                case 'soaa': // SOrt Album Artist
     389                case 'soal': // SOrt ALbum
     390                case 'soar': // SOrt ARtist
     391                case 'soco': // SOrt COmposer
     392                case 'sonm': // SOrt NaMe
     393                case 'sosn': // SOrt Show Name
     394                case 'stik': //
     395                case 'tmpo': // TeMPO (BPM)
     396                case 'trkn': // TRacK Number
     397                case 'tven': // tvEpisodeID
     398                case 'tves': // TV EpiSode
     399                case 'tvnn': // TV Network Name
     400                case 'tvsh': // TV SHow Name
     401                case 'tvsn': // TV SeasoN
     402                    if ($atom_parent == 'udta') {
     403                        // User data atom handler
     404                        $atom_structure['data_length'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
     405                        $atom_structure['language_id'] = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2));
     406                        $atom_structure['data']        =                           substr($atom_data, 4);
     407
     408                        $atom_structure['language']    = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
     409                        if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
     410                            $info['comments']['language'][] = $atom_structure['language'];
    423411                        }
    424412                    } else {
    425                         while ($atomoffset < strlen($atom_data)) {
    426                             $boxsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset, 4));
    427                             $boxtype =                           substr($atom_data, $atomoffset + 4, 4);
    428                             $boxdata =                           substr($atom_data, $atomoffset + 8, $boxsize - 8);
    429                             if ($boxsize <= 1) {
    430                                 $this->warning('Invalid QuickTime atom box size "'.$boxsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
    431                                 $atom_structure['data'] = null;
    432                                 $atomoffset = strlen($atom_data);
    433                                 break;
     413                        // Apple item list box atom handler
     414                        $atomoffset = 0;
     415                        if (substr($atom_data, 2, 2) == "\x10\xB5") {
     416                            // not sure what it means, but observed on iPhone4 data.
     417                            // Each $atom_data has 2 bytes of datasize, plus 0x10B5, then data
     418                            while ($atomoffset < strlen($atom_data)) {
     419                                $boxsmallsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset,     2));
     420                                $boxsmalltype =                           substr($atom_data, $atomoffset + 2, 2);
     421                                $boxsmalldata =                           substr($atom_data, $atomoffset + 4, $boxsmallsize);
     422                                if ($boxsmallsize <= 1) {
     423                                    $this->warning('Invalid QuickTime atom smallbox size "'.$boxsmallsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
     424                                    $atom_structure['data'] = null;
     425                                    $atomoffset = strlen($atom_data);
     426                                    break;
     427                                }
     428                                switch ($boxsmalltype) {
     429                                    case "\x10\xB5":
     430                                        $atom_structure['data'] = $boxsmalldata;
     431                                        break;
     432                                    default:
     433                                        $this->warning('Unknown QuickTime smallbox type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $boxsmalltype).'" ('.trim(getid3_lib::PrintHexBytes($boxsmalltype)).') at offset '.$baseoffset);
     434                                        $atom_structure['data'] = $atom_data;
     435                                        break;
     436                                }
     437                                $atomoffset += (4 + $boxsmallsize);
    434438                            }
    435                             $atomoffset += $boxsize;
    436 
    437                             switch ($boxtype) {
    438                                 case 'mean':
    439                                 case 'name':
    440                                     $atom_structure[$boxtype] = substr($boxdata, 4);
     439                        } else {
     440                            while ($atomoffset < strlen($atom_data)) {
     441                                $boxsize = getid3_lib::BigEndian2Int(substr($atom_data, $atomoffset, 4));
     442                                $boxtype =                           substr($atom_data, $atomoffset + 4, 4);
     443                                $boxdata =                           substr($atom_data, $atomoffset + 8, $boxsize - 8);
     444                                if ($boxsize <= 1) {
     445                                    $this->warning('Invalid QuickTime atom box size "'.$boxsize.'" in atom "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" at offset: '.($atom_structure['offset'] + $atomoffset));
     446                                    $atom_structure['data'] = null;
     447                                    $atomoffset = strlen($atom_data);
    441448                                    break;
    442 
    443                                 case 'data':
    444                                     $atom_structure['version']   = getid3_lib::BigEndian2Int(substr($boxdata,  0, 1));
    445                                     $atom_structure['flags_raw'] = getid3_lib::BigEndian2Int(substr($boxdata,  1, 3));
    446                                     switch ($atom_structure['flags_raw']) {
    447                                         case  0: // data flag
    448                                         case 21: // tmpo/cpil flag
    449                                             switch ($atomname) {
    450                                                 case 'cpil':
    451                                                 case 'hdvd':
    452                                                 case 'pcst':
    453                                                 case 'pgap':
    454                                                     // 8-bit integer (boolean)
    455                                                     $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
    456                                                     break;
    457 
    458                                                 case 'tmpo':
    459                                                     // 16-bit integer
    460                                                     $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 2));
    461                                                     break;
    462 
    463                                                 case 'disk':
    464                                                 case 'trkn':
    465                                                     // binary
    466                                                     $num       = getid3_lib::BigEndian2Int(substr($boxdata, 10, 2));
    467                                                     $num_total = getid3_lib::BigEndian2Int(substr($boxdata, 12, 2));
    468                                                     $atom_structure['data']  = empty($num) ? '' : $num;
    469                                                     $atom_structure['data'] .= empty($num_total) ? '' : '/'.$num_total;
    470                                                     break;
    471 
    472                                                 case 'gnre':
    473                                                     // enum
    474                                                     $GenreID = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
    475                                                     $atom_structure['data']    = getid3_id3v1::LookupGenreName($GenreID - 1);
    476                                                     break;
    477 
    478                                                 case 'rtng':
    479                                                     // 8-bit integer
    480                                                     $atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
    481                                                     $atom_structure['data']    = $this->QuicktimeContentRatingLookup($atom_structure[$atomname]);
    482                                                     break;
    483 
    484                                                 case 'stik':
    485                                                     // 8-bit integer (enum)
    486                                                     $atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
    487                                                     $atom_structure['data']    = $this->QuicktimeSTIKLookup($atom_structure[$atomname]);
    488                                                     break;
    489 
    490                                                 case 'sfID':
    491                                                     // 32-bit integer
    492                                                     $atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
    493                                                     $atom_structure['data']    = $this->QuicktimeStoreFrontCodeLookup($atom_structure[$atomname]);
    494                                                     break;
    495 
    496                                                 case 'egid':
    497                                                 case 'purl':
    498                                                     $atom_structure['data'] = substr($boxdata, 8);
    499                                                     break;
    500 
    501                                                 case 'plID':
    502                                                     // 64-bit integer
    503                                                     $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 8));
    504                                                     break;
    505 
    506                                                 case 'covr':
    507                                                     $atom_structure['data'] = substr($boxdata, 8);
     449                                }
     450                                $atomoffset += $boxsize;
     451
     452                                switch ($boxtype) {
     453                                    case 'mean':
     454                                    case 'name':
     455                                        $atom_structure[$boxtype] = substr($boxdata, 4);
     456                                        break;
     457
     458                                    case 'data':
     459                                        $atom_structure['version']   = getid3_lib::BigEndian2Int(substr($boxdata,  0, 1));
     460                                        $atom_structure['flags_raw'] = getid3_lib::BigEndian2Int(substr($boxdata,  1, 3));
     461                                        switch ($atom_structure['flags_raw']) {
     462                                            case  0: // data flag
     463                                            case 21: // tmpo/cpil flag
     464                                                switch ($atomname) {
     465                                                    case 'cpil':
     466                                                    case 'hdvd':
     467                                                    case 'pcst':
     468                                                    case 'pgap':
     469                                                        // 8-bit integer (boolean)
     470                                                        $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
     471                                                        break;
     472
     473                                                    case 'tmpo':
     474                                                        // 16-bit integer
     475                                                        $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 2));
     476                                                        break;
     477
     478                                                    case 'disk':
     479                                                    case 'trkn':
     480                                                        // binary
     481                                                        $num       = getid3_lib::BigEndian2Int(substr($boxdata, 10, 2));
     482                                                        $num_total = getid3_lib::BigEndian2Int(substr($boxdata, 12, 2));
     483                                                        $atom_structure['data']  = empty($num) ? '' : $num;
     484                                                        $atom_structure['data'] .= empty($num_total) ? '' : '/'.$num_total;
     485                                                        break;
     486
     487                                                    case 'gnre':
     488                                                        // enum
     489                                                        $GenreID = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
     490                                                        $atom_structure['data']    = getid3_id3v1::LookupGenreName($GenreID - 1);
     491                                                        break;
     492
     493                                                    case 'rtng':
     494                                                        // 8-bit integer
     495                                                        $atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
     496                                                        $atom_structure['data']    = $this->QuicktimeContentRatingLookup($atom_structure[$atomname]);
     497                                                        break;
     498
     499                                                    case 'stik':
     500                                                        // 8-bit integer (enum)
     501                                                        $atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 1));
     502                                                        $atom_structure['data']    = $this->QuicktimeSTIKLookup($atom_structure[$atomname]);
     503                                                        break;
     504
     505                                                    case 'sfID':
     506                                                        // 32-bit integer
     507                                                        $atom_structure[$atomname] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
     508                                                        $atom_structure['data']    = $this->QuicktimeStoreFrontCodeLookup($atom_structure[$atomname]);
     509                                                        break;
     510
     511                                                    case 'egid':
     512                                                    case 'purl':
     513                                                        $atom_structure['data'] = substr($boxdata, 8);
     514                                                        break;
     515
     516                                                    case 'plID':
     517                                                        // 64-bit integer
     518                                                        $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 8));
     519                                                        break;
     520
     521                                                    case 'covr':
     522                                                        $atom_structure['data'] = substr($boxdata, 8);
     523                                                        // not a foolproof check, but better than nothing
     524                                                        if (preg_match('#^\\xFF\\xD8\\xFF#', $atom_structure['data'])) {
     525                                                            $atom_structure['image_mime'] = 'image/jpeg';
     526                                                        } elseif (preg_match('#^\\x89\\x50\\x4E\\x47\\x0D\\x0A\\x1A\\x0A#', $atom_structure['data'])) {
     527                                                            $atom_structure['image_mime'] = 'image/png';
     528                                                        } elseif (preg_match('#^GIF#', $atom_structure['data'])) {
     529                                                            $atom_structure['image_mime'] = 'image/gif';
     530                                                        }
     531                                                        break;
     532
     533                                                    case 'atID':
     534                                                    case 'cnID':
     535                                                    case 'geID':
     536                                                    case 'tves':
     537                                                    case 'tvsn':
     538                                                    default:
     539                                                        // 32-bit integer
     540                                                        $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
     541                                                }
     542                                                break;
     543
     544                                            case  1: // text flag
     545                                            case 13: // image flag
     546                                            default:
     547                                                $atom_structure['data'] = substr($boxdata, 8);
     548                                                if ($atomname == 'covr') {
    508549                                                    // not a foolproof check, but better than nothing
    509550                                                    if (preg_match('#^\\xFF\\xD8\\xFF#', $atom_structure['data'])) {
    … …  
    514555                                                        $atom_structure['image_mime'] = 'image/gif';
    515556                                                    }
    516                                                     break;
    517 
    518                                                 case 'atID':
    519                                                 case 'cnID':
    520                                                 case 'geID':
    521                                                 case 'tves':
    522                                                 case 'tvsn':
    523                                                 default:
    524                                                     // 32-bit integer
    525                                                     $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($boxdata, 8, 4));
    526                                             }
    527                                             break;
    528 
    529                                         case  1: // text flag
    530                                         case 13: // image flag
    531                                         default:
    532                                             $atom_structure['data'] = substr($boxdata, 8);
    533                                             if ($atomname == 'covr') {
    534                                                 // not a foolproof check, but better than nothing
    535                                                 if (preg_match('#^\\xFF\\xD8\\xFF#', $atom_structure['data'])) {
    536                                                     $atom_structure['image_mime'] = 'image/jpeg';
    537                                                 } elseif (preg_match('#^\\x89\\x50\\x4E\\x47\\x0D\\x0A\\x1A\\x0A#', $atom_structure['data'])) {
    538                                                     $atom_structure['image_mime'] = 'image/png';
    539                                                 } elseif (preg_match('#^GIF#', $atom_structure['data'])) {
    540                                                     $atom_structure['image_mime'] = 'image/gif';
    541557                                                }
    542                                             }
    543                                             break;
    544 
    545                                     }
    546                                     break;
    547 
    548                                 default:
    549                                     $this->warning('Unknown QuickTime box type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $boxtype).'" ('.trim(getid3_lib::PrintHexBytes($boxtype)).') at offset '.$baseoffset);
    550                                     $atom_structure['data'] = $atom_data;
    551 
     558                                                break;
     559
     560                                        }
     561                                        break;
     562
     563                                    default:
     564                                        $this->warning('Unknown QuickTime box type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $boxtype).'" ('.trim(getid3_lib::PrintHexBytes($boxtype)).') at offset '.$baseoffset);
     565                                        $atom_structure['data'] = $atom_data;
     566
     567                                }
    552568                            }
    553569                        }
    554570                    }
    555                 }
    556                 $this->CopyToAppropriateCommentsSection($atomname, $atom_structure['data'], $atom_structure['name']);
    557                 break;
    558 
    559 
    560             case 'play': // auto-PLAY atom
    561                 $atom_structure['autoplay'] = (bool) getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    562 
    563                 $info['quicktime']['autoplay'] = $atom_structure['autoplay'];
    564                 break;
    565 
    566 
    567             case 'WLOC': // Window LOCation atom
    568                 $atom_structure['location_x']  = getid3_lib::BigEndian2Int(substr($atom_data,  0, 2));
    569                 $atom_structure['location_y']  = getid3_lib::BigEndian2Int(substr($atom_data,  2, 2));
    570                 break;
    571 
    572 
    573             case 'LOOP': // LOOPing atom
    574             case 'SelO': // play SELection Only atom
    575             case 'AllF': // play ALL Frames atom
    576                 $atom_structure['data'] = getid3_lib::BigEndian2Int($atom_data);
    577                 break;
    578 
    579 
    580             case 'name': //
    581             case 'MCPS': // Media Cleaner PRo
    582             case '@PRM': // adobe PReMiere version
    583             case '@PRQ': // adobe PRemiere Quicktime version
    584                 $atom_structure['data'] = $atom_data;
    585                 break;
    586 
    587 
    588             case 'cmvd': // Compressed MooV Data atom
    589                 // Code by ubergeekØubergeek*tv based on information from
    590                 // http://developer.apple.com/quicktime/icefloe/dispatch012.html
    591                 $atom_structure['unCompressedSize'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 4));
    592 
    593                 $CompressedFileData = substr($atom_data, 4);
    594                 if ($UncompressedHeader = @gzuncompress($CompressedFileData)) {
    595                     $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($UncompressedHeader, 0, $atomHierarchy, $ParseAllPossibleAtoms);
    596                 } else {
    597                     $this->warning('Error decompressing compressed MOV atom at offset '.$atom_structure['offset']);
    598                 }
    599                 break;
    600 
    601 
    602             case 'dcom': // Data COMpression atom
    603                 $atom_structure['compression_id']   = $atom_data;
    604                 $atom_structure['compression_text'] = $this->QuicktimeDCOMLookup($atom_data);
    605                 break;
    606 
    607 
    608             case 'rdrf': // Reference movie Data ReFerence atom
    609                 $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    610                 $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
    611                 $atom_structure['flags']['internal_data'] = (bool) ($atom_structure['flags_raw'] & 0x000001);
    612 
    613                 $atom_structure['reference_type_name']    =                           substr($atom_data,  4, 4);
    614                 $atom_structure['reference_length']       = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    615                 switch ($atom_structure['reference_type_name']) {
    616                     case 'url ':
    617                         $atom_structure['url']            =       $this->NoNullString(substr($atom_data, 12));
    618                         break;
    619 
    620                     case 'alis':
    621                         $atom_structure['file_alias']     =                           substr($atom_data, 12);
    622                         break;
    623 
    624                     case 'rsrc':
    625                         $atom_structure['resource_alias'] =                           substr($atom_data, 12);
    626                         break;
    627 
    628                     default:
    629                         $atom_structure['data']           =                           substr($atom_data, 12);
    630                         break;
    631                 }
    632                 break;
    633 
    634 
    635             case 'rmqu': // Reference Movie QUality atom
    636                 $atom_structure['movie_quality'] = getid3_lib::BigEndian2Int($atom_data);
    637                 break;
    638 
    639 
    640             case 'rmcs': // Reference Movie Cpu Speed atom
    641                 $atom_structure['version']          = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    642                 $atom_structure['flags_raw']        = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    643                 $atom_structure['cpu_speed_rating'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
    644                 break;
    645 
    646 
    647             case 'rmvc': // Reference Movie Version Check atom
    648                 $atom_structure['version']            = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    649                 $atom_structure['flags_raw']          = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    650                 $atom_structure['gestalt_selector']   =                           substr($atom_data,  4, 4);
    651                 $atom_structure['gestalt_value_mask'] = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    652                 $atom_structure['gestalt_value']      = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
    653                 $atom_structure['gestalt_check_type'] = getid3_lib::BigEndian2Int(substr($atom_data, 14, 2));
    654                 break;
    655 
    656 
    657             case 'rmcd': // Reference Movie Component check atom
    658                 $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    659                 $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    660                 $atom_structure['component_type']         =                           substr($atom_data,  4, 4);
    661                 $atom_structure['component_subtype']      =                           substr($atom_data,  8, 4);
    662                 $atom_structure['component_manufacturer'] =                           substr($atom_data, 12, 4);
    663                 $atom_structure['component_flags_raw']    = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
    664                 $atom_structure['component_flags_mask']   = getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
    665                 $atom_structure['component_min_version']  = getid3_lib::BigEndian2Int(substr($atom_data, 24, 4));
    666                 break;
    667 
    668 
    669             case 'rmdr': // Reference Movie Data Rate atom
    670                 $atom_structure['version']       = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    671                 $atom_structure['flags_raw']     = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    672                 $atom_structure['data_rate']     = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    673 
    674                 $atom_structure['data_rate_bps'] = $atom_structure['data_rate'] * 10;
    675                 break;
    676 
    677 
    678             case 'rmla': // Reference Movie Language Atom
    679                 $atom_structure['version']     = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    680                 $atom_structure['flags_raw']   = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    681                 $atom_structure['language_id'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
    682 
    683                 $atom_structure['language']    = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
    684                 if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
    685                     $info['comments']['language'][] = $atom_structure['language'];
    686                 }
    687                 break;
    688 
    689 
    690             case 'rmla': // Reference Movie Language Atom
    691                 $atom_structure['version']   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    692                 $atom_structure['flags_raw'] = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    693                 $atom_structure['track_id']  = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
    694                 break;
    695 
    696 
    697             case 'ptv ': // Print To Video - defines a movie's full screen mode
    698                 // http://developer.apple.com/documentation/QuickTime/APIREF/SOURCESIV/at_ptv-_pg.htm
    699                 $atom_structure['display_size_raw']  = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
    700                 $atom_structure['reserved_1']        = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2)); // hardcoded: 0x0000
    701                 $atom_structure['reserved_2']        = getid3_lib::BigEndian2Int(substr($atom_data, 4, 2)); // hardcoded: 0x0000
    702                 $atom_structure['slide_show_flag']   = getid3_lib::BigEndian2Int(substr($atom_data, 6, 1));
    703                 $atom_structure['play_on_open_flag'] = getid3_lib::BigEndian2Int(substr($atom_data, 7, 1));
    704 
    705                 $atom_structure['flags']['play_on_open'] = (bool) $atom_structure['play_on_open_flag'];
    706                 $atom_structure['flags']['slide_show']   = (bool) $atom_structure['slide_show_flag'];
    707 
    708                 $ptv_lookup[0] = 'normal';
    709                 $ptv_lookup[1] = 'double';
    710                 $ptv_lookup[2] = 'half';
    711                 $ptv_lookup[3] = 'full';
    712                 $ptv_lookup[4] = 'current';
    713                 if (isset($ptv_lookup[$atom_structure['display_size_raw']])) {
    714                     $atom_structure['display_size'] = $ptv_lookup[$atom_structure['display_size_raw']];
    715                 } else {
    716                     $this->warning('unknown "ptv " display constant ('.$atom_structure['display_size_raw'].')');
    717                 }
    718                 break;
    719 
    720 
    721             case 'stsd': // Sample Table Sample Description atom
    722                 $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    723                 $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    724                 $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    725 
    726                 // see: https://github.com/JamesHeinrich/getID3/issues/111
    727                 // Some corrupt files have been known to have high bits set in the number_entries field
    728                 // This field shouldn't really need to be 32-bits, values stores are likely in the range 1-100000
    729                 // Workaround: mask off the upper byte and throw a warning if it's nonzero
    730                 if ($atom_structure['number_entries'] > 0x000FFFFF) {
    731                     if ($atom_structure['number_entries'] > 0x00FFFFFF) {
    732                         $this->warning('"stsd" atom contains improbably large number_entries (0x'.getid3_lib::PrintHexBytes(substr($atom_data, 4, 4), true, false).' = '.$atom_structure['number_entries'].'), probably in error. Ignoring upper byte and interpreting this as 0x'.getid3_lib::PrintHexBytes(substr($atom_data, 5, 3), true, false).' = '.($atom_structure['number_entries'] & 0x00FFFFFF));
    733                         $atom_structure['number_entries'] = ($atom_structure['number_entries'] & 0x00FFFFFF);
     571                    $this->CopyToAppropriateCommentsSection($atomname, $atom_structure['data'], $atom_structure['name']);
     572                    break;
     573
     574
     575                case 'play': // auto-PLAY atom
     576                    $atom_structure['autoplay'] = (bool) getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     577
     578                    $info['quicktime']['autoplay'] = $atom_structure['autoplay'];
     579                    break;
     580
     581
     582                case 'WLOC': // Window LOCation atom
     583                    $atom_structure['location_x']  = getid3_lib::BigEndian2Int(substr($atom_data,  0, 2));
     584                    $atom_structure['location_y']  = getid3_lib::BigEndian2Int(substr($atom_data,  2, 2));
     585                    break;
     586
     587
     588                case 'LOOP': // LOOPing atom
     589                case 'SelO': // play SELection Only atom
     590                case 'AllF': // play ALL Frames atom
     591                    $atom_structure['data'] = getid3_lib::BigEndian2Int($atom_data);
     592                    break;
     593
     594
     595                case 'name': //
     596                case 'MCPS': // Media Cleaner PRo
     597                case '@PRM': // adobe PReMiere version
     598                case '@PRQ': // adobe PRemiere Quicktime version
     599                    $atom_structure['data'] = $atom_data;
     600                    break;
     601
     602
     603                case 'cmvd': // Compressed MooV Data atom
     604                    // Code by ubergeekØubergeek*tv based on information from
     605                    // http://developer.apple.com/quicktime/icefloe/dispatch012.html
     606                    $atom_structure['unCompressedSize'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 4));
     607
     608                    $CompressedFileData = substr($atom_data, 4);
     609                    if ($UncompressedHeader = @gzuncompress($CompressedFileData)) {
     610                        $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($UncompressedHeader, 0, $atomHierarchy, $ParseAllPossibleAtoms);
    734611                    } else {
    735                         $this->warning('"stsd" atom contains improbably large number_entries (0x'.getid3_lib::PrintHexBytes(substr($atom_data, 4, 4), true, false).' = '.$atom_structure['number_entries'].'), probably in error. Please report this to info@getid3.org referencing bug report #111');
    736                     }
    737                 }
    738 
    739                 $stsdEntriesDataOffset = 8;
    740                 for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    741                     $atom_structure['sample_description_table'][$i]['size']             = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 4));
    742                     $stsdEntriesDataOffset += 4;
    743                     $atom_structure['sample_description_table'][$i]['data_format']      =                           substr($atom_data, $stsdEntriesDataOffset, 4);
    744                     $stsdEntriesDataOffset += 4;
    745                     $atom_structure['sample_description_table'][$i]['reserved']         = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 6));
    746                     $stsdEntriesDataOffset += 6;
    747                     $atom_structure['sample_description_table'][$i]['reference_index']  = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 2));
    748                     $stsdEntriesDataOffset += 2;
    749                     $atom_structure['sample_description_table'][$i]['data']             =                           substr($atom_data, $stsdEntriesDataOffset, ($atom_structure['sample_description_table'][$i]['size'] - 4 - 4 - 6 - 2));
    750                     $stsdEntriesDataOffset += ($atom_structure['sample_description_table'][$i]['size'] - 4 - 4 - 6 - 2);
    751 
    752                     $atom_structure['sample_description_table'][$i]['encoder_version']  = getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  0, 2));
    753                     $atom_structure['sample_description_table'][$i]['encoder_revision'] = getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  2, 2));
    754                     $atom_structure['sample_description_table'][$i]['encoder_vendor']   =                           substr($atom_structure['sample_description_table'][$i]['data'],  4, 4);
    755 
    756                     switch ($atom_structure['sample_description_table'][$i]['encoder_vendor']) {
    757 
    758                         case "\x00\x00\x00\x00":
    759                             // audio tracks
    760                             $atom_structure['sample_description_table'][$i]['audio_channels']       =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  8,  2));
    761                             $atom_structure['sample_description_table'][$i]['audio_bit_depth']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 10,  2));
    762                             $atom_structure['sample_description_table'][$i]['audio_compression_id'] =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 12,  2));
    763                             $atom_structure['sample_description_table'][$i]['audio_packet_size']    =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 14,  2));
    764                             $atom_structure['sample_description_table'][$i]['audio_sample_rate']    = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 16,  4));
    765 
    766                             // video tracks
    767                             // http://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap3/qtff3.html
    768                             $atom_structure['sample_description_table'][$i]['temporal_quality'] =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  8,  4));
    769                             $atom_structure['sample_description_table'][$i]['spatial_quality']  =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 12,  4));
    770                             $atom_structure['sample_description_table'][$i]['width']            =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 16,  2));
    771                             $atom_structure['sample_description_table'][$i]['height']           =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 18,  2));
    772                             $atom_structure['sample_description_table'][$i]['resolution_x']     = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 24,  4));
    773                             $atom_structure['sample_description_table'][$i]['resolution_y']     = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 28,  4));
    774                             $atom_structure['sample_description_table'][$i]['data_size']        =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 32,  4));
    775                             $atom_structure['sample_description_table'][$i]['frame_count']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 36,  2));
    776                             $atom_structure['sample_description_table'][$i]['compressor_name']  =                             substr($atom_structure['sample_description_table'][$i]['data'], 38,  4);
    777                             $atom_structure['sample_description_table'][$i]['pixel_depth']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 42,  2));
    778                             $atom_structure['sample_description_table'][$i]['color_table_id']   =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 44,  2));
    779 
    780                             switch ($atom_structure['sample_description_table'][$i]['data_format']) {
    781                                 case '2vuY':
    782                                 case 'avc1':
    783                                 case 'cvid':
    784                                 case 'dvc ':
    785                                 case 'dvcp':
    786                                 case 'gif ':
    787                                 case 'h263':
    788                                 case 'jpeg':
    789                                 case 'kpcd':
    790                                 case 'mjpa':
    791                                 case 'mjpb':
    792                                 case 'mp4v':
    793                                 case 'png ':
    794                                 case 'raw ':
    795                                 case 'rle ':
    796                                 case 'rpza':
    797                                 case 'smc ':
    798                                 case 'SVQ1':
    799                                 case 'SVQ3':
    800                                 case 'tiff':
    801                                 case 'v210':
    802                                 case 'v216':
    803                                 case 'v308':
    804                                 case 'v408':
    805                                 case 'v410':
    806                                 case 'yuv2':
    807                                     $info['fileformat'] = 'mp4';
    808                                     $info['video']['fourcc'] = $atom_structure['sample_description_table'][$i]['data_format'];
    809 // http://www.getid3.org/phpBB3/viewtopic.php?t=1550
    810 //if ((!empty($atom_structure['sample_description_table'][$i]['width']) && !empty($atom_structure['sample_description_table'][$i]['width'])) && (empty($info['video']['resolution_x']) || empty($info['video']['resolution_y']) || (number_format($info['video']['resolution_x'], 6) != number_format(round($info['video']['resolution_x']), 6)) || (number_format($info['video']['resolution_y'], 6) != number_format(round($info['video']['resolution_y']), 6)))) { // ugly check for floating point numbers
    811 if (!empty($atom_structure['sample_description_table'][$i]['width']) && !empty($atom_structure['sample_description_table'][$i]['height'])) {
    812     // assume that values stored here are more important than values stored in [tkhd] atom
    813     $info['video']['resolution_x'] = $atom_structure['sample_description_table'][$i]['width'];
    814     $info['video']['resolution_y'] = $atom_structure['sample_description_table'][$i]['height'];
    815     $info['quicktime']['video']['resolution_x'] = $info['video']['resolution_x'];
    816     $info['quicktime']['video']['resolution_y'] = $info['video']['resolution_y'];
    817 }
    818                                     break;
    819 
    820                                 case 'qtvr':
    821                                     $info['video']['dataformat'] = 'quicktimevr';
    822                                     break;
    823 
    824                                 case 'mp4a':
    825                                 default:
    826                                     $info['quicktime']['audio']['codec']       = $this->QuicktimeAudioCodecLookup($atom_structure['sample_description_table'][$i]['data_format']);
    827                                     $info['quicktime']['audio']['sample_rate'] = $atom_structure['sample_description_table'][$i]['audio_sample_rate'];
    828                                     $info['quicktime']['audio']['channels']    = $atom_structure['sample_description_table'][$i]['audio_channels'];
    829                                     $info['quicktime']['audio']['bit_depth']   = $atom_structure['sample_description_table'][$i]['audio_bit_depth'];
    830                                     $info['audio']['codec']                    = $info['quicktime']['audio']['codec'];
    831                                     $info['audio']['sample_rate']              = $info['quicktime']['audio']['sample_rate'];
    832                                     $info['audio']['channels']                 = $info['quicktime']['audio']['channels'];
    833                                     $info['audio']['bits_per_sample']          = $info['quicktime']['audio']['bit_depth'];
    834                                     switch ($atom_structure['sample_description_table'][$i]['data_format']) {
    835                                         case 'raw ': // PCM
    836                                         case 'alac': // Apple Lossless Audio Codec
    837                                             $info['audio']['lossless'] = true;
    838                                             break;
    839                                         default:
    840                                             $info['audio']['lossless'] = false;
    841                                             break;
    842                                     }
    843                                     break;
    844                             }
     612                        $this->warning('Error decompressing compressed MOV atom at offset '.$atom_structure['offset']);
     613                    }
     614                    break;
     615
     616
     617                case 'dcom': // Data COMpression atom
     618                    $atom_structure['compression_id']   = $atom_data;
     619                    $atom_structure['compression_text'] = $this->QuicktimeDCOMLookup($atom_data);
     620                    break;
     621
     622
     623                case 'rdrf': // Reference movie Data ReFerence atom
     624                    $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     625                    $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
     626                    $atom_structure['flags']['internal_data'] = (bool) ($atom_structure['flags_raw'] & 0x000001);
     627
     628                    $atom_structure['reference_type_name']    =                           substr($atom_data,  4, 4);
     629                    $atom_structure['reference_length']       = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     630                    switch ($atom_structure['reference_type_name']) {
     631                        case 'url ':
     632                            $atom_structure['url']            =       $this->NoNullString(substr($atom_data, 12));
    845633                            break;
    846634
     635                        case 'alis':
     636                            $atom_structure['file_alias']     =                           substr($atom_data, 12);
     637                            break;
     638
     639                        case 'rsrc':
     640                            $atom_structure['resource_alias'] =                           substr($atom_data, 12);
     641                            break;
     642
    847643                        default:
    848                             switch ($atom_structure['sample_description_table'][$i]['data_format']) {
    849                                 case 'mp4s':
    850                                     $info['fileformat'] = 'mp4';
    851                                     break;
    852 
    853                                 default:
    854                                     // video atom
    855                                     $atom_structure['sample_description_table'][$i]['video_temporal_quality']  =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  8,  4));
    856                                     $atom_structure['sample_description_table'][$i]['video_spatial_quality']   =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 12,  4));
    857                                     $atom_structure['sample_description_table'][$i]['video_frame_width']       =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 16,  2));
    858                                     $atom_structure['sample_description_table'][$i]['video_frame_height']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 18,  2));
    859                                     $atom_structure['sample_description_table'][$i]['video_resolution_x']      = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 20,  4));
    860                                     $atom_structure['sample_description_table'][$i]['video_resolution_y']      = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 24,  4));
    861                                     $atom_structure['sample_description_table'][$i]['video_data_size']         =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 28,  4));
    862                                     $atom_structure['sample_description_table'][$i]['video_frame_count']       =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 32,  2));
    863                                     $atom_structure['sample_description_table'][$i]['video_encoder_name_len']  =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 34,  1));
    864                                     $atom_structure['sample_description_table'][$i]['video_encoder_name']      =                             substr($atom_structure['sample_description_table'][$i]['data'], 35, $atom_structure['sample_description_table'][$i]['video_encoder_name_len']);
    865                                     $atom_structure['sample_description_table'][$i]['video_pixel_color_depth'] =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 66,  2));
    866                                     $atom_structure['sample_description_table'][$i]['video_color_table_id']    =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 68,  2));
    867 
    868                                     $atom_structure['sample_description_table'][$i]['video_pixel_color_type']  = (($atom_structure['sample_description_table'][$i]['video_pixel_color_depth'] > 32) ? 'grayscale' : 'color');
    869                                     $atom_structure['sample_description_table'][$i]['video_pixel_color_name']  = $this->QuicktimeColorNameLookup($atom_structure['sample_description_table'][$i]['video_pixel_color_depth']);
    870 
    871                                     if ($atom_structure['sample_description_table'][$i]['video_pixel_color_name'] != 'invalid') {
    872                                         $info['quicktime']['video']['codec_fourcc']        = $atom_structure['sample_description_table'][$i]['data_format'];
    873                                         $info['quicktime']['video']['codec_fourcc_lookup'] = $this->QuicktimeVideoCodecLookup($atom_structure['sample_description_table'][$i]['data_format']);
    874                                         $info['quicktime']['video']['codec']               = (($atom_structure['sample_description_table'][$i]['video_encoder_name_len'] > 0) ? $atom_structure['sample_description_table'][$i]['video_encoder_name'] : $atom_structure['sample_description_table'][$i]['data_format']);
    875                                         $info['quicktime']['video']['color_depth']         = $atom_structure['sample_description_table'][$i]['video_pixel_color_depth'];
    876                                         $info['quicktime']['video']['color_depth_name']    = $atom_structure['sample_description_table'][$i]['video_pixel_color_name'];
    877 
    878                                         $info['video']['codec']           = $info['quicktime']['video']['codec'];
    879                                         $info['video']['bits_per_sample'] = $info['quicktime']['video']['color_depth'];
    880                                     }
    881                                     $info['video']['lossless']           = false;
    882                                     $info['video']['pixel_aspect_ratio'] = (float) 1;
    883                                     break;
    884                             }
     644                            $atom_structure['data']           =                           substr($atom_data, 12);
    885645                            break;
    886646                    }
    887                     switch (strtolower($atom_structure['sample_description_table'][$i]['data_format'])) {
    888                         case 'mp4a':
    889                             $info['audio']['dataformat']         = 'mp4';
    890                             $info['quicktime']['audio']['codec'] = 'mp4';
    891                             break;
    892 
    893                         case '3ivx':
    894                         case '3iv1':
    895                         case '3iv2':
    896                             $info['video']['dataformat'] = '3ivx';
    897                             break;
    898 
    899                         case 'xvid':
    900                             $info['video']['dataformat'] = 'xvid';
    901                             break;
    902 
    903                         case 'mp4v':
    904                             $info['video']['dataformat'] = 'mpeg4';
    905                             break;
    906 
    907                         case 'divx':
    908                         case 'div1':
    909                         case 'div2':
    910                         case 'div3':
    911                         case 'div4':
    912                         case 'div5':
    913                         case 'div6':
    914                             $info['video']['dataformat'] = 'divx';
    915                             break;
    916 
    917                         default:
    918                             // do nothing
    919                             break;
    920                     }
    921                     unset($atom_structure['sample_description_table'][$i]['data']);
    922                 }
    923                 break;
    924 
    925 
    926             case 'stts': // Sample Table Time-to-Sample atom
    927                 $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    928                 $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    929                 $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    930                 $sttsEntriesDataOffset = 8;
    931                 //$FrameRateCalculatorArray = array();
    932                 $frames_count = 0;
    933 
    934                 $max_stts_entries_to_scan = ($info['php_memory_limit'] ? min(floor($this->getid3->memory_limit / 10000), $atom_structure['number_entries']) : $atom_structure['number_entries']);
    935                 if ($max_stts_entries_to_scan < $atom_structure['number_entries']) {
    936                     $this->warning('QuickTime atom "stts" has '.$atom_structure['number_entries'].' but only scanning the first '.$max_stts_entries_to_scan.' entries due to limited PHP memory available ('.floor($atom_structure['number_entries'] / 1048576).'MB).');
    937                 }
    938                 for ($i = 0; $i < $max_stts_entries_to_scan; $i++) {
    939                     $atom_structure['time_to_sample_table'][$i]['sample_count']    = getid3_lib::BigEndian2Int(substr($atom_data, $sttsEntriesDataOffset, 4));
    940                     $sttsEntriesDataOffset += 4;
    941                     $atom_structure['time_to_sample_table'][$i]['sample_duration'] = getid3_lib::BigEndian2Int(substr($atom_data, $sttsEntriesDataOffset, 4));
    942                     $sttsEntriesDataOffset += 4;
    943 
    944                     $frames_count += $atom_structure['time_to_sample_table'][$i]['sample_count'];
    945 
    946                     // THIS SECTION REPLACED WITH CODE IN "stbl" ATOM
    947                     //if (!empty($info['quicktime']['time_scale']) && ($atom_structure['time_to_sample_table'][$i]['sample_duration'] > 0)) {
    948                     //  $stts_new_framerate = $info['quicktime']['time_scale'] / $atom_structure['time_to_sample_table'][$i]['sample_duration'];
    949                     //  if ($stts_new_framerate <= 60) {
    950                     //      // some atoms have durations of "1" giving a very large framerate, which probably is not right
    951                     //      $info['video']['frame_rate'] = max($info['video']['frame_rate'], $stts_new_framerate);
    952                     //  }
    953                     //}
    954                     //
    955                     //$FrameRateCalculatorArray[($info['quicktime']['time_scale'] / $atom_structure['time_to_sample_table'][$i]['sample_duration'])] += $atom_structure['time_to_sample_table'][$i]['sample_count'];
    956                 }
    957                 $info['quicktime']['stts_framecount'][] = $frames_count;
    958                 //$sttsFramesTotal  = 0;
    959                 //$sttsSecondsTotal = 0;
    960                 //foreach ($FrameRateCalculatorArray as $frames_per_second => $frame_count) {
    961                 //  if (($frames_per_second > 60) || ($frames_per_second < 1)) {
    962                 //      // not video FPS information, probably audio information
    963                 //      $sttsFramesTotal  = 0;
    964                 //      $sttsSecondsTotal = 0;
    965                 //      break;
    966                 //  }
    967                 //  $sttsFramesTotal  += $frame_count;
    968                 //  $sttsSecondsTotal += $frame_count / $frames_per_second;
    969                 //}
    970                 //if (($sttsFramesTotal > 0) && ($sttsSecondsTotal > 0)) {
    971                 //  if (($sttsFramesTotal / $sttsSecondsTotal) > $info['video']['frame_rate']) {
    972                 //      $info['video']['frame_rate'] = $sttsFramesTotal / $sttsSecondsTotal;
    973                 //  }
    974                 //}
    975                 break;
    976 
    977 
    978             case 'stss': // Sample Table Sync Sample (key frames) atom
    979                 if ($ParseAllPossibleAtoms) {
     647                    break;
     648
     649
     650                case 'rmqu': // Reference Movie QUality atom
     651                    $atom_structure['movie_quality'] = getid3_lib::BigEndian2Int($atom_data);
     652                    break;
     653
     654
     655                case 'rmcs': // Reference Movie Cpu Speed atom
     656                    $atom_structure['version']          = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     657                    $atom_structure['flags_raw']        = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     658                    $atom_structure['cpu_speed_rating'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
     659                    break;
     660
     661
     662                case 'rmvc': // Reference Movie Version Check atom
     663                    $atom_structure['version']            = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     664                    $atom_structure['flags_raw']          = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     665                    $atom_structure['gestalt_selector']   =                           substr($atom_data,  4, 4);
     666                    $atom_structure['gestalt_value_mask'] = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     667                    $atom_structure['gestalt_value']      = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
     668                    $atom_structure['gestalt_check_type'] = getid3_lib::BigEndian2Int(substr($atom_data, 14, 2));
     669                    break;
     670
     671
     672                case 'rmcd': // Reference Movie Component check atom
     673                    $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     674                    $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     675                    $atom_structure['component_type']         =                           substr($atom_data,  4, 4);
     676                    $atom_structure['component_subtype']      =                           substr($atom_data,  8, 4);
     677                    $atom_structure['component_manufacturer'] =                           substr($atom_data, 12, 4);
     678                    $atom_structure['component_flags_raw']    = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
     679                    $atom_structure['component_flags_mask']   = getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
     680                    $atom_structure['component_min_version']  = getid3_lib::BigEndian2Int(substr($atom_data, 24, 4));
     681                    break;
     682
     683
     684                case 'rmdr': // Reference Movie Data Rate atom
     685                    $atom_structure['version']       = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     686                    $atom_structure['flags_raw']     = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     687                    $atom_structure['data_rate']     = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     688
     689                    $atom_structure['data_rate_bps'] = $atom_structure['data_rate'] * 10;
     690                    break;
     691
     692
     693                case 'rmla': // Reference Movie Language Atom
     694                    $atom_structure['version']     = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     695                    $atom_structure['flags_raw']   = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     696                    $atom_structure['language_id'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
     697
     698                    $atom_structure['language']    = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
     699                    if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
     700                        $info['comments']['language'][] = $atom_structure['language'];
     701                    }
     702                    break;
     703
     704
     705                case 'ptv ': // Print To Video - defines a movie's full screen mode
     706                    // http://developer.apple.com/documentation/QuickTime/APIREF/SOURCESIV/at_ptv-_pg.htm
     707                    $atom_structure['display_size_raw']  = getid3_lib::BigEndian2Int(substr($atom_data, 0, 2));
     708                    $atom_structure['reserved_1']        = getid3_lib::BigEndian2Int(substr($atom_data, 2, 2)); // hardcoded: 0x0000
     709                    $atom_structure['reserved_2']        = getid3_lib::BigEndian2Int(substr($atom_data, 4, 2)); // hardcoded: 0x0000
     710                    $atom_structure['slide_show_flag']   = getid3_lib::BigEndian2Int(substr($atom_data, 6, 1));
     711                    $atom_structure['play_on_open_flag'] = getid3_lib::BigEndian2Int(substr($atom_data, 7, 1));
     712
     713                    $atom_structure['flags']['play_on_open'] = (bool) $atom_structure['play_on_open_flag'];
     714                    $atom_structure['flags']['slide_show']   = (bool) $atom_structure['slide_show_flag'];
     715
     716                    $ptv_lookup[0] = 'normal';
     717                    $ptv_lookup[1] = 'double';
     718                    $ptv_lookup[2] = 'half';
     719                    $ptv_lookup[3] = 'full';
     720                    $ptv_lookup[4] = 'current';
     721                    if (isset($ptv_lookup[$atom_structure['display_size_raw']])) {
     722                        $atom_structure['display_size'] = $ptv_lookup[$atom_structure['display_size_raw']];
     723                    } else {
     724                        $this->warning('unknown "ptv " display constant ('.$atom_structure['display_size_raw'].')');
     725                    }
     726                    break;
     727
     728
     729                case 'stsd': // Sample Table Sample Description atom
    980730                    $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    981731                    $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    982732                    $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    983                     $stssEntriesDataOffset = 8;
     733
     734                    // see: https://github.com/JamesHeinrich/getID3/issues/111
     735                    // Some corrupt files have been known to have high bits set in the number_entries field
     736                    // This field shouldn't really need to be 32-bits, values stores are likely in the range 1-100000
     737                    // Workaround: mask off the upper byte and throw a warning if it's nonzero
     738                    if ($atom_structure['number_entries'] > 0x000FFFFF) {
     739                        if ($atom_structure['number_entries'] > 0x00FFFFFF) {
     740                            $this->warning('"stsd" atom contains improbably large number_entries (0x'.getid3_lib::PrintHexBytes(substr($atom_data, 4, 4), true, false).' = '.$atom_structure['number_entries'].'), probably in error. Ignoring upper byte and interpreting this as 0x'.getid3_lib::PrintHexBytes(substr($atom_data, 5, 3), true, false).' = '.($atom_structure['number_entries'] & 0x00FFFFFF));
     741                            $atom_structure['number_entries'] = ($atom_structure['number_entries'] & 0x00FFFFFF);
     742                        } else {
     743                            $this->warning('"stsd" atom contains improbably large number_entries (0x'.getid3_lib::PrintHexBytes(substr($atom_data, 4, 4), true, false).' = '.$atom_structure['number_entries'].'), probably in error. Please report this to info@getid3.org referencing bug report #111');
     744                        }
     745                    }
     746
     747                    $stsdEntriesDataOffset = 8;
    984748                    for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    985                         $atom_structure['time_to_sample_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stssEntriesDataOffset, 4));
    986                         $stssEntriesDataOffset += 4;
    987                     }
    988                 }
    989                 break;
    990 
    991 
    992             case 'stsc': // Sample Table Sample-to-Chunk atom
    993                 if ($ParseAllPossibleAtoms) {
     749                        $atom_structure['sample_description_table'][$i]['size']             = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 4));
     750                        $stsdEntriesDataOffset += 4;
     751                        $atom_structure['sample_description_table'][$i]['data_format']      =                           substr($atom_data, $stsdEntriesDataOffset, 4);
     752                        $stsdEntriesDataOffset += 4;
     753                        $atom_structure['sample_description_table'][$i]['reserved']         = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 6));
     754                        $stsdEntriesDataOffset += 6;
     755                        $atom_structure['sample_description_table'][$i]['reference_index']  = getid3_lib::BigEndian2Int(substr($atom_data, $stsdEntriesDataOffset, 2));
     756                        $stsdEntriesDataOffset += 2;
     757                        $atom_structure['sample_description_table'][$i]['data']             =                           substr($atom_data, $stsdEntriesDataOffset, ($atom_structure['sample_description_table'][$i]['size'] - 4 - 4 - 6 - 2));
     758                        $stsdEntriesDataOffset += ($atom_structure['sample_description_table'][$i]['size'] - 4 - 4 - 6 - 2);
     759
     760                        $atom_structure['sample_description_table'][$i]['encoder_version']  = getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  0, 2));
     761                        $atom_structure['sample_description_table'][$i]['encoder_revision'] = getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  2, 2));
     762                        $atom_structure['sample_description_table'][$i]['encoder_vendor']   =                           substr($atom_structure['sample_description_table'][$i]['data'],  4, 4);
     763
     764                        switch ($atom_structure['sample_description_table'][$i]['encoder_vendor']) {
     765
     766                            case "\x00\x00\x00\x00":
     767                                // audio tracks
     768                                $atom_structure['sample_description_table'][$i]['audio_channels']       =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  8,  2));
     769                                $atom_structure['sample_description_table'][$i]['audio_bit_depth']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 10,  2));
     770                                $atom_structure['sample_description_table'][$i]['audio_compression_id'] =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 12,  2));
     771                                $atom_structure['sample_description_table'][$i]['audio_packet_size']    =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 14,  2));
     772                                $atom_structure['sample_description_table'][$i]['audio_sample_rate']    = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 16,  4));
     773
     774                                // video tracks
     775                                // http://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap3/qtff3.html
     776                                $atom_structure['sample_description_table'][$i]['temporal_quality'] =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  8,  4));
     777                                $atom_structure['sample_description_table'][$i]['spatial_quality']  =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 12,  4));
     778                                $atom_structure['sample_description_table'][$i]['width']            =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 16,  2));
     779                                $atom_structure['sample_description_table'][$i]['height']           =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 18,  2));
     780                                $atom_structure['sample_description_table'][$i]['resolution_x']     = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 24,  4));
     781                                $atom_structure['sample_description_table'][$i]['resolution_y']     = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 28,  4));
     782                                $atom_structure['sample_description_table'][$i]['data_size']        =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 32,  4));
     783                                $atom_structure['sample_description_table'][$i]['frame_count']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 36,  2));
     784                                $atom_structure['sample_description_table'][$i]['compressor_name']  =                             substr($atom_structure['sample_description_table'][$i]['data'], 38,  4);
     785                                $atom_structure['sample_description_table'][$i]['pixel_depth']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 42,  2));
     786                                $atom_structure['sample_description_table'][$i]['color_table_id']   =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 44,  2));
     787
     788                                switch ($atom_structure['sample_description_table'][$i]['data_format']) {
     789                                    case '2vuY':
     790                                    case 'avc1':
     791                                    case 'cvid':
     792                                    case 'dvc ':
     793                                    case 'dvcp':
     794                                    case 'gif ':
     795                                    case 'h263':
     796                                    case 'jpeg':
     797                                    case 'kpcd':
     798                                    case 'mjpa':
     799                                    case 'mjpb':
     800                                    case 'mp4v':
     801                                    case 'png ':
     802                                    case 'raw ':
     803                                    case 'rle ':
     804                                    case 'rpza':
     805                                    case 'smc ':
     806                                    case 'SVQ1':
     807                                    case 'SVQ3':
     808                                    case 'tiff':
     809                                    case 'v210':
     810                                    case 'v216':
     811                                    case 'v308':
     812                                    case 'v408':
     813                                    case 'v410':
     814                                    case 'yuv2':
     815                                        $info['fileformat'] = 'mp4';
     816                                        $info['video']['fourcc'] = $atom_structure['sample_description_table'][$i]['data_format'];
     817                                        if ($this->QuicktimeVideoCodecLookup($info['video']['fourcc'])) {
     818                                            $info['video']['fourcc_lookup'] = $this->QuicktimeVideoCodecLookup($info['video']['fourcc']);
     819                                        }
     820
     821                                        // https://www.getid3.org/phpBB3/viewtopic.php?t=1550
     822                                        //if ((!empty($atom_structure['sample_description_table'][$i]['width']) && !empty($atom_structure['sample_description_table'][$i]['width'])) && (empty($info['video']['resolution_x']) || empty($info['video']['resolution_y']) || (number_format($info['video']['resolution_x'], 6) != number_format(round($info['video']['resolution_x']), 6)) || (number_format($info['video']['resolution_y'], 6) != number_format(round($info['video']['resolution_y']), 6)))) { // ugly check for floating point numbers
     823                                        if (!empty($atom_structure['sample_description_table'][$i]['width']) && !empty($atom_structure['sample_description_table'][$i]['height'])) {
     824                                            // assume that values stored here are more important than values stored in [tkhd] atom
     825                                            $info['video']['resolution_x'] = $atom_structure['sample_description_table'][$i]['width'];
     826                                            $info['video']['resolution_y'] = $atom_structure['sample_description_table'][$i]['height'];
     827                                            $info['quicktime']['video']['resolution_x'] = $info['video']['resolution_x'];
     828                                            $info['quicktime']['video']['resolution_y'] = $info['video']['resolution_y'];
     829                                        }
     830                                        break;
     831
     832                                    case 'qtvr':
     833                                        $info['video']['dataformat'] = 'quicktimevr';
     834                                        break;
     835
     836                                    case 'mp4a':
     837                                    default:
     838                                        $info['quicktime']['audio']['codec']       = $this->QuicktimeAudioCodecLookup($atom_structure['sample_description_table'][$i]['data_format']);
     839                                        $info['quicktime']['audio']['sample_rate'] = $atom_structure['sample_description_table'][$i]['audio_sample_rate'];
     840                                        $info['quicktime']['audio']['channels']    = $atom_structure['sample_description_table'][$i]['audio_channels'];
     841                                        $info['quicktime']['audio']['bit_depth']   = $atom_structure['sample_description_table'][$i]['audio_bit_depth'];
     842                                        $info['audio']['codec']                    = $info['quicktime']['audio']['codec'];
     843                                        $info['audio']['sample_rate']              = $info['quicktime']['audio']['sample_rate'];
     844                                        $info['audio']['channels']                 = $info['quicktime']['audio']['channels'];
     845                                        $info['audio']['bits_per_sample']          = $info['quicktime']['audio']['bit_depth'];
     846                                        switch ($atom_structure['sample_description_table'][$i]['data_format']) {
     847                                            case 'raw ': // PCM
     848                                            case 'alac': // Apple Lossless Audio Codec
     849                                            case 'sowt': // signed/two's complement (Little Endian)
     850                                            case 'twos': // signed/two's complement (Big Endian)
     851                                            case 'in24': // 24-bit Integer
     852                                            case 'in32': // 32-bit Integer
     853                                            case 'fl32': // 32-bit Floating Point
     854                                            case 'fl64': // 64-bit Floating Point
     855                                                $info['audio']['lossless'] = $info['quicktime']['audio']['lossless'] = true;
     856                                                $info['audio']['bitrate']  = $info['quicktime']['audio']['bitrate']  = $info['audio']['channels'] * $info['audio']['bits_per_sample'] * $info['audio']['sample_rate'];
     857                                                break;
     858                                            default:
     859                                                $info['audio']['lossless'] = false;
     860                                                break;
     861                                        }
     862                                        break;
     863                                }
     864                                break;
     865
     866                            default:
     867                                switch ($atom_structure['sample_description_table'][$i]['data_format']) {
     868                                    case 'mp4s':
     869                                        $info['fileformat'] = 'mp4';
     870                                        break;
     871
     872                                    default:
     873                                        // video atom
     874                                        $atom_structure['sample_description_table'][$i]['video_temporal_quality']  =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'],  8,  4));
     875                                        $atom_structure['sample_description_table'][$i]['video_spatial_quality']   =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 12,  4));
     876                                        $atom_structure['sample_description_table'][$i]['video_frame_width']       =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 16,  2));
     877                                        $atom_structure['sample_description_table'][$i]['video_frame_height']      =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 18,  2));
     878                                        $atom_structure['sample_description_table'][$i]['video_resolution_x']      = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 20,  4));
     879                                        $atom_structure['sample_description_table'][$i]['video_resolution_y']      = getid3_lib::FixedPoint16_16(substr($atom_structure['sample_description_table'][$i]['data'], 24,  4));
     880                                        $atom_structure['sample_description_table'][$i]['video_data_size']         =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 28,  4));
     881                                        $atom_structure['sample_description_table'][$i]['video_frame_count']       =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 32,  2));
     882                                        $atom_structure['sample_description_table'][$i]['video_encoder_name_len']  =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 34,  1));
     883                                        $atom_structure['sample_description_table'][$i]['video_encoder_name']      =                             substr($atom_structure['sample_description_table'][$i]['data'], 35, $atom_structure['sample_description_table'][$i]['video_encoder_name_len']);
     884                                        $atom_structure['sample_description_table'][$i]['video_pixel_color_depth'] =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 66,  2));
     885                                        $atom_structure['sample_description_table'][$i]['video_color_table_id']    =   getid3_lib::BigEndian2Int(substr($atom_structure['sample_description_table'][$i]['data'], 68,  2));
     886
     887                                        $atom_structure['sample_description_table'][$i]['video_pixel_color_type']  = (($atom_structure['sample_description_table'][$i]['video_pixel_color_depth'] > 32) ? 'grayscale' : 'color');
     888                                        $atom_structure['sample_description_table'][$i]['video_pixel_color_name']  = $this->QuicktimeColorNameLookup($atom_structure['sample_description_table'][$i]['video_pixel_color_depth']);
     889
     890                                        if ($atom_structure['sample_description_table'][$i]['video_pixel_color_name'] != 'invalid') {
     891                                            $info['quicktime']['video']['codec_fourcc']        = $atom_structure['sample_description_table'][$i]['data_format'];
     892                                            $info['quicktime']['video']['codec_fourcc_lookup'] = $this->QuicktimeVideoCodecLookup($atom_structure['sample_description_table'][$i]['data_format']);
     893                                            $info['quicktime']['video']['codec']               = (($atom_structure['sample_description_table'][$i]['video_encoder_name_len'] > 0) ? $atom_structure['sample_description_table'][$i]['video_encoder_name'] : $atom_structure['sample_description_table'][$i]['data_format']);
     894                                            $info['quicktime']['video']['color_depth']         = $atom_structure['sample_description_table'][$i]['video_pixel_color_depth'];
     895                                            $info['quicktime']['video']['color_depth_name']    = $atom_structure['sample_description_table'][$i]['video_pixel_color_name'];
     896
     897                                            $info['video']['codec']           = $info['quicktime']['video']['codec'];
     898                                            $info['video']['bits_per_sample'] = $info['quicktime']['video']['color_depth'];
     899                                        }
     900                                        $info['video']['lossless']           = false;
     901                                        $info['video']['pixel_aspect_ratio'] = (float) 1;
     902                                        break;
     903                                }
     904                                break;
     905                        }
     906                        switch (strtolower($atom_structure['sample_description_table'][$i]['data_format'])) {
     907                            case 'mp4a':
     908                                $info['audio']['dataformat']         = 'mp4';
     909                                $info['quicktime']['audio']['codec'] = 'mp4';
     910                                break;
     911
     912                            case '3ivx':
     913                            case '3iv1':
     914                            case '3iv2':
     915                                $info['video']['dataformat'] = '3ivx';
     916                                break;
     917
     918                            case 'xvid':
     919                                $info['video']['dataformat'] = 'xvid';
     920                                break;
     921
     922                            case 'mp4v':
     923                                $info['video']['dataformat'] = 'mpeg4';
     924                                break;
     925
     926                            case 'divx':
     927                            case 'div1':
     928                            case 'div2':
     929                            case 'div3':
     930                            case 'div4':
     931                            case 'div5':
     932                            case 'div6':
     933                                $info['video']['dataformat'] = 'divx';
     934                                break;
     935
     936                            default:
     937                                // do nothing
     938                                break;
     939                        }
     940                        unset($atom_structure['sample_description_table'][$i]['data']);
     941                    }
     942                    break;
     943
     944
     945                case 'stts': // Sample Table Time-to-Sample atom
    994946                    $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    995947                    $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    996948                    $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    997                     $stscEntriesDataOffset = 8;
    998                     for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    999                         $atom_structure['sample_to_chunk_table'][$i]['first_chunk']        = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
    1000                         $stscEntriesDataOffset += 4;
    1001                         $atom_structure['sample_to_chunk_table'][$i]['samples_per_chunk']  = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
    1002                         $stscEntriesDataOffset += 4;
    1003                         $atom_structure['sample_to_chunk_table'][$i]['sample_description'] = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
    1004                         $stscEntriesDataOffset += 4;
    1005                     }
    1006                 }
    1007                 break;
    1008 
    1009 
    1010             case 'stsz': // Sample Table SiZe atom
    1011                 if ($ParseAllPossibleAtoms) {
    1012                     $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1013                     $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1014                     $atom_structure['sample_size']    = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1015                     $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    1016                     $stszEntriesDataOffset = 12;
    1017                     if ($atom_structure['sample_size'] == 0) {
     949                    $sttsEntriesDataOffset = 8;
     950                    //$FrameRateCalculatorArray = array();
     951                    $frames_count = 0;
     952
     953                    $max_stts_entries_to_scan = ($info['php_memory_limit'] ? min(floor($this->getid3->memory_limit / 10000), $atom_structure['number_entries']) : $atom_structure['number_entries']);
     954                    if ($max_stts_entries_to_scan < $atom_structure['number_entries']) {
     955                        $this->warning('QuickTime atom "stts" has '.$atom_structure['number_entries'].' but only scanning the first '.$max_stts_entries_to_scan.' entries due to limited PHP memory available ('.floor($this->getid3->memory_limit / 1048576).'MB).');
     956                    }
     957                    for ($i = 0; $i < $max_stts_entries_to_scan; $i++) {
     958                        $atom_structure['time_to_sample_table'][$i]['sample_count']    = getid3_lib::BigEndian2Int(substr($atom_data, $sttsEntriesDataOffset, 4));
     959                        $sttsEntriesDataOffset += 4;
     960                        $atom_structure['time_to_sample_table'][$i]['sample_duration'] = getid3_lib::BigEndian2Int(substr($atom_data, $sttsEntriesDataOffset, 4));
     961                        $sttsEntriesDataOffset += 4;
     962
     963                        $frames_count += $atom_structure['time_to_sample_table'][$i]['sample_count'];
     964
     965                        // THIS SECTION REPLACED WITH CODE IN "stbl" ATOM
     966                        //if (!empty($info['quicktime']['time_scale']) && ($atom_structure['time_to_sample_table'][$i]['sample_duration'] > 0)) {
     967                        //  $stts_new_framerate = $info['quicktime']['time_scale'] / $atom_structure['time_to_sample_table'][$i]['sample_duration'];
     968                        //  if ($stts_new_framerate <= 60) {
     969                        //      // some atoms have durations of "1" giving a very large framerate, which probably is not right
     970                        //      $info['video']['frame_rate'] = max($info['video']['frame_rate'], $stts_new_framerate);
     971                        //  }
     972                        //}
     973                        //
     974                        //$FrameRateCalculatorArray[($info['quicktime']['time_scale'] / $atom_structure['time_to_sample_table'][$i]['sample_duration'])] += $atom_structure['time_to_sample_table'][$i]['sample_count'];
     975                    }
     976                    $info['quicktime']['stts_framecount'][] = $frames_count;
     977                    //$sttsFramesTotal  = 0;
     978                    //$sttsSecondsTotal = 0;
     979                    //foreach ($FrameRateCalculatorArray as $frames_per_second => $frame_count) {
     980                    //  if (($frames_per_second > 60) || ($frames_per_second < 1)) {
     981                    //      // not video FPS information, probably audio information
     982                    //      $sttsFramesTotal  = 0;
     983                    //      $sttsSecondsTotal = 0;
     984                    //      break;
     985                    //  }
     986                    //  $sttsFramesTotal  += $frame_count;
     987                    //  $sttsSecondsTotal += $frame_count / $frames_per_second;
     988                    //}
     989                    //if (($sttsFramesTotal > 0) && ($sttsSecondsTotal > 0)) {
     990                    //  if (($sttsFramesTotal / $sttsSecondsTotal) > $info['video']['frame_rate']) {
     991                    //      $info['video']['frame_rate'] = $sttsFramesTotal / $sttsSecondsTotal;
     992                    //  }
     993                    //}
     994                    break;
     995
     996
     997                case 'stss': // Sample Table Sync Sample (key frames) atom
     998                    if ($ParseAllPossibleAtoms) {
     999                        $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1000                        $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1001                        $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1002                        $stssEntriesDataOffset = 8;
    10181003                        for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    1019                             $atom_structure['sample_size_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stszEntriesDataOffset, 4));
    1020                             $stszEntriesDataOffset += 4;
     1004                            $atom_structure['time_to_sample_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stssEntriesDataOffset, 4));
     1005                            $stssEntriesDataOffset += 4;
    10211006                        }
    10221007                    }
    1023                 }
    1024                 break;
    1025 
    1026 
    1027             case 'stco': // Sample Table Chunk Offset atom
    1028                 if ($ParseAllPossibleAtoms) {
     1008                    break;
     1009
     1010
     1011                case 'stsc': // Sample Table Sample-to-Chunk atom
     1012                    if ($ParseAllPossibleAtoms) {
     1013                        $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1014                        $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1015                        $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1016                        $stscEntriesDataOffset = 8;
     1017                        for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
     1018                            $atom_structure['sample_to_chunk_table'][$i]['first_chunk']        = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
     1019                            $stscEntriesDataOffset += 4;
     1020                            $atom_structure['sample_to_chunk_table'][$i]['samples_per_chunk']  = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
     1021                            $stscEntriesDataOffset += 4;
     1022                            $atom_structure['sample_to_chunk_table'][$i]['sample_description'] = getid3_lib::BigEndian2Int(substr($atom_data, $stscEntriesDataOffset, 4));
     1023                            $stscEntriesDataOffset += 4;
     1024                        }
     1025                    }
     1026                    break;
     1027
     1028
     1029                case 'stsz': // Sample Table SiZe atom
     1030                    if ($ParseAllPossibleAtoms) {
     1031                        $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1032                        $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1033                        $atom_structure['sample_size']    = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1034                        $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     1035                        $stszEntriesDataOffset = 12;
     1036                        if ($atom_structure['sample_size'] == 0) {
     1037                            for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
     1038                                $atom_structure['sample_size_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stszEntriesDataOffset, 4));
     1039                                $stszEntriesDataOffset += 4;
     1040                            }
     1041                        }
     1042                    }
     1043                    break;
     1044
     1045
     1046                case 'stco': // Sample Table Chunk Offset atom
     1047                    if ($ParseAllPossibleAtoms) {
     1048                        $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1049                        $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1050                        $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1051                        $stcoEntriesDataOffset = 8;
     1052                        for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
     1053                            $atom_structure['chunk_offset_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stcoEntriesDataOffset, 4));
     1054                            $stcoEntriesDataOffset += 4;
     1055                        }
     1056                    }
     1057                    break;
     1058
     1059
     1060                case 'co64': // Chunk Offset 64-bit (version of "stco" that supports > 2GB files)
     1061                    if ($ParseAllPossibleAtoms) {
     1062                        $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1063                        $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1064                        $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1065                        $stcoEntriesDataOffset = 8;
     1066                        for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
     1067                            $atom_structure['chunk_offset_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stcoEntriesDataOffset, 8));
     1068                            $stcoEntriesDataOffset += 8;
     1069                        }
     1070                    }
     1071                    break;
     1072
     1073
     1074                case 'dref': // Data REFerence atom
    10291075                    $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    10301076                    $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    10311077                    $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1032                     $stcoEntriesDataOffset = 8;
     1078                    $drefDataOffset = 8;
    10331079                    for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    1034                         $atom_structure['chunk_offset_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stcoEntriesDataOffset, 4));
    1035                         $stcoEntriesDataOffset += 4;
    1036                     }
    1037                 }
    1038                 break;
    1039 
    1040 
    1041             case 'co64': // Chunk Offset 64-bit (version of "stco" that supports > 2GB files)
    1042                 if ($ParseAllPossibleAtoms) {
     1080                        $atom_structure['data_references'][$i]['size']                    = getid3_lib::BigEndian2Int(substr($atom_data, $drefDataOffset, 4));
     1081                        $drefDataOffset += 4;
     1082                        $atom_structure['data_references'][$i]['type']                    =                           substr($atom_data, $drefDataOffset, 4);
     1083                        $drefDataOffset += 4;
     1084                        $atom_structure['data_references'][$i]['version']                 = getid3_lib::BigEndian2Int(substr($atom_data,  $drefDataOffset, 1));
     1085                        $drefDataOffset += 1;
     1086                        $atom_structure['data_references'][$i]['flags_raw']               = getid3_lib::BigEndian2Int(substr($atom_data,  $drefDataOffset, 3)); // hardcoded: 0x0000
     1087                        $drefDataOffset += 3;
     1088                        $atom_structure['data_references'][$i]['data']                    =                           substr($atom_data, $drefDataOffset, ($atom_structure['data_references'][$i]['size'] - 4 - 4 - 1 - 3));
     1089                        $drefDataOffset += ($atom_structure['data_references'][$i]['size'] - 4 - 4 - 1 - 3);
     1090
     1091                        $atom_structure['data_references'][$i]['flags']['self_reference'] = (bool) ($atom_structure['data_references'][$i]['flags_raw'] & 0x001);
     1092                    }
     1093                    break;
     1094
     1095
     1096                case 'gmin': // base Media INformation atom
     1097                    $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1098                    $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1099                    $atom_structure['graphics_mode']          = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
     1100                    $atom_structure['opcolor_red']            = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
     1101                    $atom_structure['opcolor_green']          = getid3_lib::BigEndian2Int(substr($atom_data,  8, 2));
     1102                    $atom_structure['opcolor_blue']           = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2));
     1103                    $atom_structure['balance']                = getid3_lib::BigEndian2Int(substr($atom_data, 12, 2));
     1104                    $atom_structure['reserved']               = getid3_lib::BigEndian2Int(substr($atom_data, 14, 2));
     1105                    break;
     1106
     1107
     1108                case 'smhd': // Sound Media information HeaDer atom
     1109                    $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1110                    $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1111                    $atom_structure['balance']                = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
     1112                    $atom_structure['reserved']               = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
     1113                    break;
     1114
     1115
     1116                case 'vmhd': // Video Media information HeaDer atom
     1117                    $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1118                    $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
     1119                    $atom_structure['graphics_mode']          = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
     1120                    $atom_structure['opcolor_red']            = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
     1121                    $atom_structure['opcolor_green']          = getid3_lib::BigEndian2Int(substr($atom_data,  8, 2));
     1122                    $atom_structure['opcolor_blue']           = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2));
     1123
     1124                    $atom_structure['flags']['no_lean_ahead'] = (bool) ($atom_structure['flags_raw'] & 0x001);
     1125                    break;
     1126
     1127
     1128                case 'hdlr': // HanDLeR reference atom
     1129                    $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1130                    $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1131                    $atom_structure['component_type']         =                           substr($atom_data,  4, 4);
     1132                    $atom_structure['component_subtype']      =                           substr($atom_data,  8, 4);
     1133                    $atom_structure['component_manufacturer'] =                           substr($atom_data, 12, 4);
     1134                    $atom_structure['component_flags_raw']    = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
     1135                    $atom_structure['component_flags_mask']   = getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
     1136                    $atom_structure['component_name']         =      $this->Pascal2String(substr($atom_data, 24));
     1137
     1138                    if (($atom_structure['component_subtype'] == 'STpn') && ($atom_structure['component_manufacturer'] == 'zzzz')) {
     1139                        $info['video']['dataformat'] = 'quicktimevr';
     1140                    }
     1141                    break;
     1142
     1143
     1144                case 'mdhd': // MeDia HeaDer atom
     1145                    $atom_structure['version']               = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1146                    $atom_structure['flags_raw']             = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1147                    $atom_structure['creation_time']         = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1148                    $atom_structure['modify_time']           = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     1149                    $atom_structure['time_scale']            = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
     1150                    $atom_structure['duration']              = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
     1151                    $atom_structure['language_id']           = getid3_lib::BigEndian2Int(substr($atom_data, 20, 2));
     1152                    $atom_structure['quality']               = getid3_lib::BigEndian2Int(substr($atom_data, 22, 2));
     1153
     1154                    if ($atom_structure['time_scale'] == 0) {
     1155                        $this->error('Corrupt Quicktime file: mdhd.time_scale == zero');
     1156                        return false;
     1157                    }
     1158                    $info['quicktime']['time_scale'] = ((isset($info['quicktime']['time_scale']) && ($info['quicktime']['time_scale'] < 1000)) ? max($info['quicktime']['time_scale'], $atom_structure['time_scale']) : $atom_structure['time_scale']);
     1159
     1160                    $atom_structure['creation_time_unix']    = getid3_lib::DateMac2Unix($atom_structure['creation_time']);
     1161                    $atom_structure['modify_time_unix']      = getid3_lib::DateMac2Unix($atom_structure['modify_time']);
     1162                    $atom_structure['playtime_seconds']      = $atom_structure['duration'] / $atom_structure['time_scale'];
     1163                    $atom_structure['language']              = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
     1164                    if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
     1165                        $info['comments']['language'][] = $atom_structure['language'];
     1166                    }
     1167                    break;
     1168
     1169
     1170                case 'pnot': // Preview atom
     1171                    $atom_structure['modification_date']      = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4)); // "standard Macintosh format"
     1172                    $atom_structure['version_number']         = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2)); // hardcoded: 0x00
     1173                    $atom_structure['atom_type']              =                           substr($atom_data,  6, 4);        // usually: 'PICT'
     1174                    $atom_structure['atom_index']             = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2)); // usually: 0x01
     1175
     1176                    $atom_structure['modification_date_unix'] = getid3_lib::DateMac2Unix($atom_structure['modification_date']);
     1177                    break;
     1178
     1179
     1180                case 'crgn': // Clipping ReGioN atom
     1181                    $atom_structure['region_size']   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 2)); // The Region size, Region boundary box,
     1182                    $atom_structure['boundary_box']  = getid3_lib::BigEndian2Int(substr($atom_data,  2, 8)); // and Clipping region data fields
     1183                    $atom_structure['clipping_data'] =                           substr($atom_data, 10);           // constitute a QuickDraw region.
     1184                    break;
     1185
     1186
     1187                case 'load': // track LOAD settings atom
     1188                    $atom_structure['preload_start_time'] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
     1189                    $atom_structure['preload_duration']   = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1190                    $atom_structure['preload_flags_raw']  = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     1191                    $atom_structure['default_hints_raw']  = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
     1192
     1193                    $atom_structure['default_hints']['double_buffer'] = (bool) ($atom_structure['default_hints_raw'] & 0x0020);
     1194                    $atom_structure['default_hints']['high_quality']  = (bool) ($atom_structure['default_hints_raw'] & 0x0100);
     1195                    break;
     1196
     1197
     1198                case 'tmcd': // TiMe CoDe atom
     1199                case 'chap': // CHAPter list atom
     1200                case 'sync': // SYNChronization atom
     1201                case 'scpt': // tranSCriPT atom
     1202                case 'ssrc': // non-primary SouRCe atom
     1203                    for ($i = 0; $i < strlen($atom_data); $i += 4) {
     1204                        @$atom_structure['track_id'][] = getid3_lib::BigEndian2Int(substr($atom_data, $i, 4));
     1205                    }
     1206                    break;
     1207
     1208
     1209                case 'elst': // Edit LiST atom
    10431210                    $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    10441211                    $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    10451212                    $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1046                     $stcoEntriesDataOffset = 8;
    1047                     for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    1048                         $atom_structure['chunk_offset_table'][$i] = getid3_lib::BigEndian2Int(substr($atom_data, $stcoEntriesDataOffset, 8));
    1049                         $stcoEntriesDataOffset += 8;
    1050                     }
    1051                 }
    1052                 break;
    1053 
    1054 
    1055             case 'dref': // Data REFerence atom
    1056                 $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1057                 $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1058                 $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1059                 $drefDataOffset = 8;
    1060                 for ($i = 0; $i < $atom_structure['number_entries']; $i++) {
    1061                     $atom_structure['data_references'][$i]['size']                    = getid3_lib::BigEndian2Int(substr($atom_data, $drefDataOffset, 4));
    1062                     $drefDataOffset += 4;
    1063                     $atom_structure['data_references'][$i]['type']                    =                           substr($atom_data, $drefDataOffset, 4);
    1064                     $drefDataOffset += 4;
    1065                     $atom_structure['data_references'][$i]['version']                 = getid3_lib::BigEndian2Int(substr($atom_data,  $drefDataOffset, 1));
    1066                     $drefDataOffset += 1;
    1067                     $atom_structure['data_references'][$i]['flags_raw']               = getid3_lib::BigEndian2Int(substr($atom_data,  $drefDataOffset, 3)); // hardcoded: 0x0000
    1068                     $drefDataOffset += 3;
    1069                     $atom_structure['data_references'][$i]['data']                    =                           substr($atom_data, $drefDataOffset, ($atom_structure['data_references'][$i]['size'] - 4 - 4 - 1 - 3));
    1070                     $drefDataOffset += ($atom_structure['data_references'][$i]['size'] - 4 - 4 - 1 - 3);
    1071 
    1072                     $atom_structure['data_references'][$i]['flags']['self_reference'] = (bool) ($atom_structure['data_references'][$i]['flags_raw'] & 0x001);
    1073                 }
    1074                 break;
    1075 
    1076 
    1077             case 'gmin': // base Media INformation atom
    1078                 $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1079                 $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1080                 $atom_structure['graphics_mode']          = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
    1081                 $atom_structure['opcolor_red']            = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
    1082                 $atom_structure['opcolor_green']          = getid3_lib::BigEndian2Int(substr($atom_data,  8, 2));
    1083                 $atom_structure['opcolor_blue']           = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2));
    1084                 $atom_structure['balance']                = getid3_lib::BigEndian2Int(substr($atom_data, 12, 2));
    1085                 $atom_structure['reserved']               = getid3_lib::BigEndian2Int(substr($atom_data, 14, 2));
    1086                 break;
    1087 
    1088 
    1089             case 'smhd': // Sound Media information HeaDer atom
    1090                 $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1091                 $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1092                 $atom_structure['balance']                = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
    1093                 $atom_structure['reserved']               = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
    1094                 break;
    1095 
    1096 
    1097             case 'vmhd': // Video Media information HeaDer atom
    1098                 $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1099                 $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
    1100                 $atom_structure['graphics_mode']          = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2));
    1101                 $atom_structure['opcolor_red']            = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2));
    1102                 $atom_structure['opcolor_green']          = getid3_lib::BigEndian2Int(substr($atom_data,  8, 2));
    1103                 $atom_structure['opcolor_blue']           = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2));
    1104 
    1105                 $atom_structure['flags']['no_lean_ahead'] = (bool) ($atom_structure['flags_raw'] & 0x001);
    1106                 break;
    1107 
    1108 
    1109             case 'hdlr': // HanDLeR reference atom
    1110                 $atom_structure['version']                = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1111                 $atom_structure['flags_raw']              = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1112                 $atom_structure['component_type']         =                           substr($atom_data,  4, 4);
    1113                 $atom_structure['component_subtype']      =                           substr($atom_data,  8, 4);
    1114                 $atom_structure['component_manufacturer'] =                           substr($atom_data, 12, 4);
    1115                 $atom_structure['component_flags_raw']    = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
    1116                 $atom_structure['component_flags_mask']   = getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
    1117                 $atom_structure['component_name']         =      $this->Pascal2String(substr($atom_data, 24));
    1118 
    1119                 if (($atom_structure['component_subtype'] == 'STpn') && ($atom_structure['component_manufacturer'] == 'zzzz')) {
    1120                     $info['video']['dataformat'] = 'quicktimevr';
    1121                 }
    1122                 break;
    1123 
    1124 
    1125             case 'mdhd': // MeDia HeaDer atom
    1126                 $atom_structure['version']               = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1127                 $atom_structure['flags_raw']             = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1128                 $atom_structure['creation_time']         = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1129                 $atom_structure['modify_time']           = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    1130                 $atom_structure['time_scale']            = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
    1131                 $atom_structure['duration']              = getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
    1132                 $atom_structure['language_id']           = getid3_lib::BigEndian2Int(substr($atom_data, 20, 2));
    1133                 $atom_structure['quality']               = getid3_lib::BigEndian2Int(substr($atom_data, 22, 2));
    1134 
    1135                 if ($atom_structure['time_scale'] == 0) {
    1136                     $this->error('Corrupt Quicktime file: mdhd.time_scale == zero');
    1137                     return false;
    1138                 }
    1139                 $info['quicktime']['time_scale'] = ((isset($info['quicktime']['time_scale']) && ($info['quicktime']['time_scale'] < 1000)) ? max($info['quicktime']['time_scale'], $atom_structure['time_scale']) : $atom_structure['time_scale']);
    1140 
    1141                 $atom_structure['creation_time_unix']    = getid3_lib::DateMac2Unix($atom_structure['creation_time']);
    1142                 $atom_structure['modify_time_unix']      = getid3_lib::DateMac2Unix($atom_structure['modify_time']);
    1143                 $atom_structure['playtime_seconds']      = $atom_structure['duration'] / $atom_structure['time_scale'];
    1144                 $atom_structure['language']              = $this->QuicktimeLanguageLookup($atom_structure['language_id']);
    1145                 if (empty($info['comments']['language']) || (!in_array($atom_structure['language'], $info['comments']['language']))) {
    1146                     $info['comments']['language'][] = $atom_structure['language'];
    1147                 }
    1148                 break;
    1149 
    1150 
    1151             case 'pnot': // Preview atom
    1152                 $atom_structure['modification_date']      = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4)); // "standard Macintosh format"
    1153                 $atom_structure['version_number']         = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2)); // hardcoded: 0x00
    1154                 $atom_structure['atom_type']              =                           substr($atom_data,  6, 4);        // usually: 'PICT'
    1155                 $atom_structure['atom_index']             = getid3_lib::BigEndian2Int(substr($atom_data, 10, 2)); // usually: 0x01
    1156 
    1157                 $atom_structure['modification_date_unix'] = getid3_lib::DateMac2Unix($atom_structure['modification_date']);
    1158                 break;
    1159 
    1160 
    1161             case 'crgn': // Clipping ReGioN atom
    1162                 $atom_structure['region_size']   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 2)); // The Region size, Region boundary box,
    1163                 $atom_structure['boundary_box']  = getid3_lib::BigEndian2Int(substr($atom_data,  2, 8)); // and Clipping region data fields
    1164                 $atom_structure['clipping_data'] =                           substr($atom_data, 10);           // constitute a QuickDraw region.
    1165                 break;
    1166 
    1167 
    1168             case 'load': // track LOAD settings atom
    1169                 $atom_structure['preload_start_time'] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
    1170                 $atom_structure['preload_duration']   = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1171                 $atom_structure['preload_flags_raw']  = getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    1172                 $atom_structure['default_hints_raw']  = getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
    1173 
    1174                 $atom_structure['default_hints']['double_buffer'] = (bool) ($atom_structure['default_hints_raw'] & 0x0020);
    1175                 $atom_structure['default_hints']['high_quality']  = (bool) ($atom_structure['default_hints_raw'] & 0x0100);
    1176                 break;
    1177 
    1178 
    1179             case 'tmcd': // TiMe CoDe atom
    1180             case 'chap': // CHAPter list atom
    1181             case 'sync': // SYNChronization atom
    1182             case 'scpt': // tranSCriPT atom
    1183             case 'ssrc': // non-primary SouRCe atom
    1184                 for ($i = 0; $i < strlen($atom_data); $i += 4) {
    1185                     @$atom_structure['track_id'][] = getid3_lib::BigEndian2Int(substr($atom_data, $i, 4));
    1186                 }
    1187                 break;
    1188 
    1189 
    1190             case 'elst': // Edit LiST atom
    1191                 $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1192                 $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1193                 $atom_structure['number_entries'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1194                 for ($i = 0; $i < $atom_structure['number_entries']; $i++ ) {
    1195                     $atom_structure['edit_list'][$i]['track_duration'] =   getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($i * 12) + 0, 4));
    1196                     $atom_structure['edit_list'][$i]['media_time']     =   getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($i * 12) + 4, 4));
    1197                     $atom_structure['edit_list'][$i]['media_rate']     = getid3_lib::FixedPoint16_16(substr($atom_data, 8 + ($i * 12) + 8, 4));
    1198                 }
    1199                 break;
    1200 
    1201 
    1202             case 'kmat': // compressed MATte atom
    1203                 $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1204                 $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
    1205                 $atom_structure['matte_data_raw'] =               substr($atom_data,  4);
    1206                 break;
    1207 
    1208 
    1209             case 'ctab': // Color TABle atom
    1210                 $atom_structure['color_table_seed']   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4)); // hardcoded: 0x00000000
    1211                 $atom_structure['color_table_flags']  = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2)); // hardcoded: 0x8000
    1212                 $atom_structure['color_table_size']   = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2)) + 1;
    1213                 for ($colortableentry = 0; $colortableentry < $atom_structure['color_table_size']; $colortableentry++) {
    1214                     $atom_structure['color_table'][$colortableentry]['alpha'] = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 0, 2));
    1215                     $atom_structure['color_table'][$colortableentry]['red']   = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 2, 2));
    1216                     $atom_structure['color_table'][$colortableentry]['green'] = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 4, 2));
    1217                     $atom_structure['color_table'][$colortableentry]['blue']  = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 6, 2));
    1218                 }
    1219                 break;
    1220 
    1221 
    1222             case 'mvhd': // MoVie HeaDer atom
    1223                 $atom_structure['version']            =   getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1224                 $atom_structure['flags_raw']          =   getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
    1225                 $atom_structure['creation_time']      =   getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1226                 $atom_structure['modify_time']        =   getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    1227                 $atom_structure['time_scale']         =   getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
    1228                 $atom_structure['duration']           =   getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
    1229                 $atom_structure['preferred_rate']     = getid3_lib::FixedPoint16_16(substr($atom_data, 20, 4));
    1230                 $atom_structure['preferred_volume']   =   getid3_lib::FixedPoint8_8(substr($atom_data, 24, 2));
    1231                 $atom_structure['reserved']           =                             substr($atom_data, 26, 10);
    1232                 $atom_structure['matrix_a']           = getid3_lib::FixedPoint16_16(substr($atom_data, 36, 4));
    1233                 $atom_structure['matrix_b']           = getid3_lib::FixedPoint16_16(substr($atom_data, 40, 4));
    1234                 $atom_structure['matrix_u']           =  getid3_lib::FixedPoint2_30(substr($atom_data, 44, 4));
    1235                 $atom_structure['matrix_c']           = getid3_lib::FixedPoint16_16(substr($atom_data, 48, 4));
    1236                 $atom_structure['matrix_d']           = getid3_lib::FixedPoint16_16(substr($atom_data, 52, 4));
    1237                 $atom_structure['matrix_v']           =  getid3_lib::FixedPoint2_30(substr($atom_data, 56, 4));
    1238                 $atom_structure['matrix_x']           = getid3_lib::FixedPoint16_16(substr($atom_data, 60, 4));
    1239                 $atom_structure['matrix_y']           = getid3_lib::FixedPoint16_16(substr($atom_data, 64, 4));
    1240                 $atom_structure['matrix_w']           =  getid3_lib::FixedPoint2_30(substr($atom_data, 68, 4));
    1241                 $atom_structure['preview_time']       =   getid3_lib::BigEndian2Int(substr($atom_data, 72, 4));
    1242                 $atom_structure['preview_duration']   =   getid3_lib::BigEndian2Int(substr($atom_data, 76, 4));
    1243                 $atom_structure['poster_time']        =   getid3_lib::BigEndian2Int(substr($atom_data, 80, 4));
    1244                 $atom_structure['selection_time']     =   getid3_lib::BigEndian2Int(substr($atom_data, 84, 4));
    1245                 $atom_structure['selection_duration'] =   getid3_lib::BigEndian2Int(substr($atom_data, 88, 4));
    1246                 $atom_structure['current_time']       =   getid3_lib::BigEndian2Int(substr($atom_data, 92, 4));
    1247                 $atom_structure['next_track_id']      =   getid3_lib::BigEndian2Int(substr($atom_data, 96, 4));
    1248 
    1249                 if ($atom_structure['time_scale'] == 0) {
    1250                     $this->error('Corrupt Quicktime file: mvhd.time_scale == zero');
    1251                     return false;
    1252                 }
    1253                 $atom_structure['creation_time_unix']        = getid3_lib::DateMac2Unix($atom_structure['creation_time']);
    1254                 $atom_structure['modify_time_unix']          = getid3_lib::DateMac2Unix($atom_structure['modify_time']);
    1255                 $info['quicktime']['time_scale']    = ((isset($info['quicktime']['time_scale']) && ($info['quicktime']['time_scale'] < 1000)) ? max($info['quicktime']['time_scale'], $atom_structure['time_scale']) : $atom_structure['time_scale']);
    1256                 $info['quicktime']['display_scale'] = $atom_structure['matrix_a'];
    1257                 $info['playtime_seconds']           = $atom_structure['duration'] / $atom_structure['time_scale'];
    1258                 break;
    1259 
    1260 
    1261             case 'tkhd': // TracK HeaDer atom
    1262                 $atom_structure['version']             =   getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1263                 $atom_structure['flags_raw']           =   getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
    1264                 $atom_structure['creation_time']       =   getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1265                 $atom_structure['modify_time']         =   getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
    1266                 $atom_structure['trackid']             =   getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
    1267                 $atom_structure['reserved1']           =   getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
    1268                 $atom_structure['duration']            =   getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
    1269                 $atom_structure['reserved2']           =   getid3_lib::BigEndian2Int(substr($atom_data, 24, 8));
    1270                 $atom_structure['layer']               =   getid3_lib::BigEndian2Int(substr($atom_data, 32, 2));
    1271                 $atom_structure['alternate_group']     =   getid3_lib::BigEndian2Int(substr($atom_data, 34, 2));
    1272                 $atom_structure['volume']              =   getid3_lib::FixedPoint8_8(substr($atom_data, 36, 2));
    1273                 $atom_structure['reserved3']           =   getid3_lib::BigEndian2Int(substr($atom_data, 38, 2));
    1274 // http://developer.apple.com/library/mac/#documentation/QuickTime/RM/MovieBasics/MTEditing/K-Chapter/11MatrixFunctions.html
    1275 // http://developer.apple.com/library/mac/#documentation/QuickTime/qtff/QTFFChap4/qtff4.html#//apple_ref/doc/uid/TP40000939-CH206-18737
    1276                 $atom_structure['matrix_a']            = getid3_lib::FixedPoint16_16(substr($atom_data, 40, 4));
    1277                 $atom_structure['matrix_b']            = getid3_lib::FixedPoint16_16(substr($atom_data, 44, 4));
    1278                 $atom_structure['matrix_u']            =  getid3_lib::FixedPoint2_30(substr($atom_data, 48, 4));
    1279                 $atom_structure['matrix_c']            = getid3_lib::FixedPoint16_16(substr($atom_data, 52, 4));
    1280                 $atom_structure['matrix_d']            = getid3_lib::FixedPoint16_16(substr($atom_data, 56, 4));
    1281                 $atom_structure['matrix_v']            =  getid3_lib::FixedPoint2_30(substr($atom_data, 60, 4));
    1282                 $atom_structure['matrix_x']            = getid3_lib::FixedPoint16_16(substr($atom_data, 64, 4));
    1283                 $atom_structure['matrix_y']            = getid3_lib::FixedPoint16_16(substr($atom_data, 68, 4));
    1284                 $atom_structure['matrix_w']            =  getid3_lib::FixedPoint2_30(substr($atom_data, 72, 4));
    1285                 $atom_structure['width']               = getid3_lib::FixedPoint16_16(substr($atom_data, 76, 4));
    1286                 $atom_structure['height']              = getid3_lib::FixedPoint16_16(substr($atom_data, 80, 4));
    1287                 $atom_structure['flags']['enabled']    = (bool) ($atom_structure['flags_raw'] & 0x0001);
    1288                 $atom_structure['flags']['in_movie']   = (bool) ($atom_structure['flags_raw'] & 0x0002);
    1289                 $atom_structure['flags']['in_preview'] = (bool) ($atom_structure['flags_raw'] & 0x0004);
    1290                 $atom_structure['flags']['in_poster']  = (bool) ($atom_structure['flags_raw'] & 0x0008);
    1291                 $atom_structure['creation_time_unix']  = getid3_lib::DateMac2Unix($atom_structure['creation_time']);
    1292                 $atom_structure['modify_time_unix']    = getid3_lib::DateMac2Unix($atom_structure['modify_time']);
    1293 
    1294                 if ($atom_structure['flags']['enabled'] == 1) {
    1295                     if (!isset($info['video']['resolution_x']) || !isset($info['video']['resolution_y'])) {
    1296                         $info['video']['resolution_x'] = $atom_structure['width'];
    1297                         $info['video']['resolution_y'] = $atom_structure['height'];
    1298                     }
    1299                     $info['video']['resolution_x'] = max($info['video']['resolution_x'], $atom_structure['width']);
    1300                     $info['video']['resolution_y'] = max($info['video']['resolution_y'], $atom_structure['height']);
    1301                     $info['quicktime']['video']['resolution_x'] = $info['video']['resolution_x'];
    1302                     $info['quicktime']['video']['resolution_y'] = $info['video']['resolution_y'];
    1303                 } else {
    1304                     // see: http://www.getid3.org/phpBB3/viewtopic.php?t=1295
    1305                     //if (isset($info['video']['resolution_x'])) { unset($info['video']['resolution_x']); }
    1306                     //if (isset($info['video']['resolution_y'])) { unset($info['video']['resolution_y']); }
    1307                     //if (isset($info['quicktime']['video']))    { unset($info['quicktime']['video']);    }
    1308                 }
    1309                 break;
    1310 
    1311 
    1312             case 'iods': // Initial Object DeScriptor atom
    1313                 // http://www.koders.com/c/fid1FAB3E762903DC482D8A246D4A4BF9F28E049594.aspx?s=windows.h
    1314                 // http://libquicktime.sourcearchive.com/documentation/1.0.2plus-pdebian/iods_8c-source.html
    1315                 $offset = 0;
    1316                 $atom_structure['version']                =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1317                 $offset += 1;
    1318                 $atom_structure['flags_raw']              =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 3));
    1319                 $offset += 3;
    1320                 $atom_structure['mp4_iod_tag']            =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1321                 $offset += 1;
    1322                 $atom_structure['length']                 = $this->quicktime_read_mp4_descr_length($atom_data, $offset);
    1323                 //$offset already adjusted by quicktime_read_mp4_descr_length()
    1324                 $atom_structure['object_descriptor_id']   =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 2));
    1325                 $offset += 2;
    1326                 $atom_structure['od_profile_level']       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1327                 $offset += 1;
    1328                 $atom_structure['scene_profile_level']    =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1329                 $offset += 1;
    1330                 $atom_structure['audio_profile_id']       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1331                 $offset += 1;
    1332                 $atom_structure['video_profile_id']       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1333                 $offset += 1;
    1334                 $atom_structure['graphics_profile_level'] =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    1335                 $offset += 1;
    1336 
    1337                 $atom_structure['num_iods_tracks'] = ($atom_structure['length'] - 7) / 6; // 6 bytes would only be right if all tracks use 1-byte length fields
    1338                 for ($i = 0; $i < $atom_structure['num_iods_tracks']; $i++) {
    1339                     $atom_structure['track'][$i]['ES_ID_IncTag'] =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1213                    for ($i = 0; $i < $atom_structure['number_entries']; $i++ ) {
     1214                        $atom_structure['edit_list'][$i]['track_duration'] =   getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($i * 12) + 0, 4));
     1215                        $atom_structure['edit_list'][$i]['media_time']     =   getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($i * 12) + 4, 4));
     1216                        $atom_structure['edit_list'][$i]['media_rate']     = getid3_lib::FixedPoint16_16(substr($atom_data, 8 + ($i * 12) + 8, 4));
     1217                    }
     1218                    break;
     1219
     1220
     1221                case 'kmat': // compressed MATte atom
     1222                    $atom_structure['version']        = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1223                    $atom_structure['flags_raw']      = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3)); // hardcoded: 0x0000
     1224                    $atom_structure['matte_data_raw'] =               substr($atom_data,  4);
     1225                    break;
     1226
     1227
     1228                case 'ctab': // Color TABle atom
     1229                    $atom_structure['color_table_seed']   = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4)); // hardcoded: 0x00000000
     1230                    $atom_structure['color_table_flags']  = getid3_lib::BigEndian2Int(substr($atom_data,  4, 2)); // hardcoded: 0x8000
     1231                    $atom_structure['color_table_size']   = getid3_lib::BigEndian2Int(substr($atom_data,  6, 2)) + 1;
     1232                    for ($colortableentry = 0; $colortableentry < $atom_structure['color_table_size']; $colortableentry++) {
     1233                        $atom_structure['color_table'][$colortableentry]['alpha'] = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 0, 2));
     1234                        $atom_structure['color_table'][$colortableentry]['red']   = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 2, 2));
     1235                        $atom_structure['color_table'][$colortableentry]['green'] = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 4, 2));
     1236                        $atom_structure['color_table'][$colortableentry]['blue']  = getid3_lib::BigEndian2Int(substr($atom_data, 8 + ($colortableentry * 8) + 6, 2));
     1237                    }
     1238                    break;
     1239
     1240
     1241                case 'mvhd': // MoVie HeaDer atom
     1242                    $atom_structure['version']            =   getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1243                    $atom_structure['flags_raw']          =   getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
     1244                    $atom_structure['creation_time']      =   getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1245                    $atom_structure['modify_time']        =   getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     1246                    $atom_structure['time_scale']         =   getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
     1247                    $atom_structure['duration']           =   getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
     1248                    $atom_structure['preferred_rate']     = getid3_lib::FixedPoint16_16(substr($atom_data, 20, 4));
     1249                    $atom_structure['preferred_volume']   =   getid3_lib::FixedPoint8_8(substr($atom_data, 24, 2));
     1250                    $atom_structure['reserved']           =                             substr($atom_data, 26, 10);
     1251                    $atom_structure['matrix_a']           = getid3_lib::FixedPoint16_16(substr($atom_data, 36, 4));
     1252                    $atom_structure['matrix_b']           = getid3_lib::FixedPoint16_16(substr($atom_data, 40, 4));
     1253                    $atom_structure['matrix_u']           =  getid3_lib::FixedPoint2_30(substr($atom_data, 44, 4));
     1254                    $atom_structure['matrix_c']           = getid3_lib::FixedPoint16_16(substr($atom_data, 48, 4));
     1255                    $atom_structure['matrix_d']           = getid3_lib::FixedPoint16_16(substr($atom_data, 52, 4));
     1256                    $atom_structure['matrix_v']           =  getid3_lib::FixedPoint2_30(substr($atom_data, 56, 4));
     1257                    $atom_structure['matrix_x']           = getid3_lib::FixedPoint16_16(substr($atom_data, 60, 4));
     1258                    $atom_structure['matrix_y']           = getid3_lib::FixedPoint16_16(substr($atom_data, 64, 4));
     1259                    $atom_structure['matrix_w']           =  getid3_lib::FixedPoint2_30(substr($atom_data, 68, 4));
     1260                    $atom_structure['preview_time']       =   getid3_lib::BigEndian2Int(substr($atom_data, 72, 4));
     1261                    $atom_structure['preview_duration']   =   getid3_lib::BigEndian2Int(substr($atom_data, 76, 4));
     1262                    $atom_structure['poster_time']        =   getid3_lib::BigEndian2Int(substr($atom_data, 80, 4));
     1263                    $atom_structure['selection_time']     =   getid3_lib::BigEndian2Int(substr($atom_data, 84, 4));
     1264                    $atom_structure['selection_duration'] =   getid3_lib::BigEndian2Int(substr($atom_data, 88, 4));
     1265                    $atom_structure['current_time']       =   getid3_lib::BigEndian2Int(substr($atom_data, 92, 4));
     1266                    $atom_structure['next_track_id']      =   getid3_lib::BigEndian2Int(substr($atom_data, 96, 4));
     1267
     1268                    if ($atom_structure['time_scale'] == 0) {
     1269                        $this->error('Corrupt Quicktime file: mvhd.time_scale == zero');
     1270                        return false;
     1271                    }
     1272                    $atom_structure['creation_time_unix']        = getid3_lib::DateMac2Unix($atom_structure['creation_time']);
     1273                    $atom_structure['modify_time_unix']          = getid3_lib::DateMac2Unix($atom_structure['modify_time']);
     1274                    $info['quicktime']['time_scale']    = ((isset($info['quicktime']['time_scale']) && ($info['quicktime']['time_scale'] < 1000)) ? max($info['quicktime']['time_scale'], $atom_structure['time_scale']) : $atom_structure['time_scale']);
     1275                    $info['quicktime']['display_scale'] = $atom_structure['matrix_a'];
     1276                    $info['playtime_seconds']           = $atom_structure['duration'] / $atom_structure['time_scale'];
     1277                    break;
     1278
     1279
     1280                case 'tkhd': // TracK HeaDer atom
     1281                    $atom_structure['version']             =   getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1282                    $atom_structure['flags_raw']           =   getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
     1283                    $atom_structure['creation_time']       =   getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1284                    $atom_structure['modify_time']         =   getid3_lib::BigEndian2Int(substr($atom_data,  8, 4));
     1285                    $atom_structure['trackid']             =   getid3_lib::BigEndian2Int(substr($atom_data, 12, 4));
     1286                    $atom_structure['reserved1']           =   getid3_lib::BigEndian2Int(substr($atom_data, 16, 4));
     1287                    $atom_structure['duration']            =   getid3_lib::BigEndian2Int(substr($atom_data, 20, 4));
     1288                    $atom_structure['reserved2']           =   getid3_lib::BigEndian2Int(substr($atom_data, 24, 8));
     1289                    $atom_structure['layer']               =   getid3_lib::BigEndian2Int(substr($atom_data, 32, 2));
     1290                    $atom_structure['alternate_group']     =   getid3_lib::BigEndian2Int(substr($atom_data, 34, 2));
     1291                    $atom_structure['volume']              =   getid3_lib::FixedPoint8_8(substr($atom_data, 36, 2));
     1292                    $atom_structure['reserved3']           =   getid3_lib::BigEndian2Int(substr($atom_data, 38, 2));
     1293                    // http://developer.apple.com/library/mac/#documentation/QuickTime/RM/MovieBasics/MTEditing/K-Chapter/11MatrixFunctions.html
     1294                    // http://developer.apple.com/library/mac/#documentation/QuickTime/qtff/QTFFChap4/qtff4.html#//apple_ref/doc/uid/TP40000939-CH206-18737
     1295                    $atom_structure['matrix_a']            = getid3_lib::FixedPoint16_16(substr($atom_data, 40, 4));
     1296                    $atom_structure['matrix_b']            = getid3_lib::FixedPoint16_16(substr($atom_data, 44, 4));
     1297                    $atom_structure['matrix_u']            =  getid3_lib::FixedPoint2_30(substr($atom_data, 48, 4));
     1298                    $atom_structure['matrix_c']            = getid3_lib::FixedPoint16_16(substr($atom_data, 52, 4));
     1299                    $atom_structure['matrix_d']            = getid3_lib::FixedPoint16_16(substr($atom_data, 56, 4));
     1300                    $atom_structure['matrix_v']            =  getid3_lib::FixedPoint2_30(substr($atom_data, 60, 4));
     1301                    $atom_structure['matrix_x']            = getid3_lib::FixedPoint16_16(substr($atom_data, 64, 4));
     1302                    $atom_structure['matrix_y']            = getid3_lib::FixedPoint16_16(substr($atom_data, 68, 4));
     1303                    $atom_structure['matrix_w']            =  getid3_lib::FixedPoint2_30(substr($atom_data, 72, 4));
     1304                    $atom_structure['width']               = getid3_lib::FixedPoint16_16(substr($atom_data, 76, 4));
     1305                    $atom_structure['height']              = getid3_lib::FixedPoint16_16(substr($atom_data, 80, 4));
     1306                    $atom_structure['flags']['enabled']    = (bool) ($atom_structure['flags_raw'] & 0x0001);
     1307                    $atom_structure['flags']['in_movie']   = (bool) ($atom_structure['flags_raw'] & 0x0002);
     1308                    $atom_structure['flags']['in_preview'] = (bool) ($atom_structure['flags_raw'] & 0x0004);
     1309                    $atom_structure['flags']['in_poster']  = (bool) ($atom_structure['flags_raw'] & 0x0008);
     1310                    $atom_structure['creation_time_unix']  = getid3_lib::DateMac2Unix($atom_structure['creation_time']);
     1311                    $atom_structure['modify_time_unix']    = getid3_lib::DateMac2Unix($atom_structure['modify_time']);
     1312
     1313                    // https://www.getid3.org/phpBB3/viewtopic.php?t=1908
     1314                    // attempt to compute rotation from matrix values
     1315                    // 2017-Dec-28: uncertain if 90/270 are correctly oriented; values returned by FixedPoint16_16 should perhaps be -1 instead of 65535(?)
     1316                    $matrixRotation = 0;
     1317                    switch ($atom_structure['matrix_a'].':'.$atom_structure['matrix_b'].':'.$atom_structure['matrix_c'].':'.$atom_structure['matrix_d']) {
     1318                        case '1:0:0:1':         $matrixRotation =   0; break;
     1319                        case '0:1:65535:0':     $matrixRotation =  90; break;
     1320                        case '65535:0:0:65535': $matrixRotation = 180; break;
     1321                        case '0:65535:1:0':     $matrixRotation = 270; break;
     1322                        default: break;
     1323                    }
     1324
     1325                    // https://www.getid3.org/phpBB3/viewtopic.php?t=2468
     1326                    // The rotation matrix can appear in the Quicktime file multiple times, at least once for each track,
     1327                    // and it's possible that only the video track (or, in theory, one of the video tracks) is flagged as
     1328                    // rotated while the other tracks (e.g. audio) is tagged as rotation=0 (behavior noted on iPhone 8 Plus)
     1329                    // The correct solution would be to check if the TrackID associated with the rotation matrix is indeed
     1330                    // a video track (or the main video track) and only set the rotation then, but since information about
     1331                    // what track is what is not trivially there to be examined, the lazy solution is to set the rotation
     1332                    // if it is found to be nonzero, on the assumption that tracks that don't need it will have rotation set
     1333                    // to zero (and be effectively ignored) and the video track will have rotation set correctly, which will
     1334                    // either be zero and automatically correct, or nonzero and be set correctly.
     1335                    if (!isset($info['video']['rotate']) || (($info['video']['rotate'] == 0) && ($matrixRotation > 0))) {
     1336                        $info['quicktime']['video']['rotate'] = $info['video']['rotate'] = $matrixRotation;
     1337                    }
     1338
     1339                    if ($atom_structure['flags']['enabled'] == 1) {
     1340                        if (!isset($info['video']['resolution_x']) || !isset($info['video']['resolution_y'])) {
     1341                            $info['video']['resolution_x'] = $atom_structure['width'];
     1342                            $info['video']['resolution_y'] = $atom_structure['height'];
     1343                        }
     1344                        $info['video']['resolution_x'] = max($info['video']['resolution_x'], $atom_structure['width']);
     1345                        $info['video']['resolution_y'] = max($info['video']['resolution_y'], $atom_structure['height']);
     1346                        $info['quicktime']['video']['resolution_x'] = $info['video']['resolution_x'];
     1347                        $info['quicktime']['video']['resolution_y'] = $info['video']['resolution_y'];
     1348                    } else {
     1349                        // see: https://www.getid3.org/phpBB3/viewtopic.php?t=1295
     1350                        //if (isset($info['video']['resolution_x'])) { unset($info['video']['resolution_x']); }
     1351                        //if (isset($info['video']['resolution_y'])) { unset($info['video']['resolution_y']); }
     1352                        //if (isset($info['quicktime']['video']))    { unset($info['quicktime']['video']);    }
     1353                    }
     1354                    break;
     1355
     1356
     1357                case 'iods': // Initial Object DeScriptor atom
     1358                    // http://www.koders.com/c/fid1FAB3E762903DC482D8A246D4A4BF9F28E049594.aspx?s=windows.h
     1359                    // http://libquicktime.sourcearchive.com/documentation/1.0.2plus-pdebian/iods_8c-source.html
     1360                    $offset = 0;
     1361                    $atom_structure['version']                =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
    13401362                    $offset += 1;
    1341                     $atom_structure['track'][$i]['length']       = $this->quicktime_read_mp4_descr_length($atom_data, $offset);
     1363                    $atom_structure['flags_raw']              =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 3));
     1364                    $offset += 3;
     1365                    $atom_structure['mp4_iod_tag']            =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1366                    $offset += 1;
     1367                    $atom_structure['length']                 = $this->quicktime_read_mp4_descr_length($atom_data, $offset);
    13421368                    //$offset already adjusted by quicktime_read_mp4_descr_length()
    1343                     $atom_structure['track'][$i]['track_id']     =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 4));
    1344                     $offset += 4;
    1345                 }
    1346 
    1347                 $atom_structure['audio_profile_name'] = $this->QuicktimeIODSaudioProfileName($atom_structure['audio_profile_id']);
    1348                 $atom_structure['video_profile_name'] = $this->QuicktimeIODSvideoProfileName($atom_structure['video_profile_id']);
    1349                 break;
    1350 
    1351             case 'ftyp': // FileTYPe (?) atom (for MP4 it seems)
    1352                 $atom_structure['signature'] =                           substr($atom_data,  0, 4);
    1353                 $atom_structure['unknown_1'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1354                 $atom_structure['fourcc']    =                           substr($atom_data,  8, 4);
    1355                 break;
    1356 
    1357             case 'mdat': // Media DATa atom
    1358                 // 'mdat' contains the actual data for the audio/video, possibly also subtitles
    1359 
    1360 /* due to lack of known documentation, this is a kludge implementation. If you know of documentation on how mdat is properly structed, please send it to info@getid3.org */
    1361 
    1362                 // first, skip any 'wide' padding, and second 'mdat' header (with specified size of zero?)
    1363                 $mdat_offset = 0;
    1364                 while (true) {
    1365                     if (substr($atom_data, $mdat_offset, 8) == "\x00\x00\x00\x08".'wide') {
    1366                         $mdat_offset += 8;
    1367                     } elseif (substr($atom_data, $mdat_offset, 8) == "\x00\x00\x00\x00".'mdat') {
    1368                         $mdat_offset += 8;
    1369                     } else {
    1370                         break;
    1371                     }
    1372                 }
    1373 
    1374                 // check to see if it looks like chapter titles, in the form of unterminated strings with a leading 16-bit size field
    1375                 while (($mdat_offset < (strlen($atom_data) - 8))
    1376                     && ($chapter_string_length = getid3_lib::BigEndian2Int(substr($atom_data, $mdat_offset, 2)))
    1377                     && ($chapter_string_length < 1000)
    1378                     && ($chapter_string_length <= (strlen($atom_data) - $mdat_offset - 2))
    1379                     && preg_match('#^([\x00-\xFF]{2})([\x20-\xFF]+)$#', substr($atom_data, $mdat_offset, $chapter_string_length + 2), $chapter_matches)) {
    1380                         list($dummy, $chapter_string_length_hex, $chapter_string) = $chapter_matches;
    1381                         $mdat_offset += (2 + $chapter_string_length);
    1382                         @$info['quicktime']['comments']['chapters'][] = $chapter_string;
    1383 
    1384                         // "encd" atom specifies encoding. In theory could be anything, almost always UTF-8, but may be UTF-16 with BOM (not currently handled)
    1385                         if (substr($atom_data, $mdat_offset, 12) == "\x00\x00\x00\x0C\x65\x6E\x63\x64\x00\x00\x01\x00") { // UTF-8
    1386                             $mdat_offset += 12;
     1369                    $atom_structure['object_descriptor_id']   =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 2));
     1370                    $offset += 2;
     1371                    $atom_structure['od_profile_level']       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1372                    $offset += 1;
     1373                    $atom_structure['scene_profile_level']    =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1374                    $offset += 1;
     1375                    $atom_structure['audio_profile_id']       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1376                    $offset += 1;
     1377                    $atom_structure['video_profile_id']       =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1378                    $offset += 1;
     1379                    $atom_structure['graphics_profile_level'] =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1380                    $offset += 1;
     1381
     1382                    $atom_structure['num_iods_tracks'] = ($atom_structure['length'] - 7) / 6; // 6 bytes would only be right if all tracks use 1-byte length fields
     1383                    for ($i = 0; $i < $atom_structure['num_iods_tracks']; $i++) {
     1384                        $atom_structure['track'][$i]['ES_ID_IncTag'] =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 1));
     1385                        $offset += 1;
     1386                        $atom_structure['track'][$i]['length']       = $this->quicktime_read_mp4_descr_length($atom_data, $offset);
     1387                        //$offset already adjusted by quicktime_read_mp4_descr_length()
     1388                        $atom_structure['track'][$i]['track_id']     =       getid3_lib::BigEndian2Int(substr($atom_data, $offset, 4));
     1389                        $offset += 4;
     1390                    }
     1391
     1392                    $atom_structure['audio_profile_name'] = $this->QuicktimeIODSaudioProfileName($atom_structure['audio_profile_id']);
     1393                    $atom_structure['video_profile_name'] = $this->QuicktimeIODSvideoProfileName($atom_structure['video_profile_id']);
     1394                    break;
     1395
     1396                case 'ftyp': // FileTYPe (?) atom (for MP4 it seems)
     1397                    $atom_structure['signature'] =                           substr($atom_data,  0, 4);
     1398                    $atom_structure['unknown_1'] = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1399                    $atom_structure['fourcc']    =                           substr($atom_data,  8, 4);
     1400                    break;
     1401
     1402                case 'mdat': // Media DATa atom
     1403                    // 'mdat' contains the actual data for the audio/video, possibly also subtitles
     1404
     1405    /* due to lack of known documentation, this is a kludge implementation. If you know of documentation on how mdat is properly structed, please send it to info@getid3.org */
     1406
     1407                    // first, skip any 'wide' padding, and second 'mdat' header (with specified size of zero?)
     1408                    $mdat_offset = 0;
     1409                    while (true) {
     1410                        if (substr($atom_data, $mdat_offset, 8) == "\x00\x00\x00\x08".'wide') {
     1411                            $mdat_offset += 8;
     1412                        } elseif (substr($atom_data, $mdat_offset, 8) == "\x00\x00\x00\x00".'mdat') {
     1413                            $mdat_offset += 8;
     1414                        } else {
     1415                            break;
    13871416                        }
    1388                 }
    1389 
    1390 
    1391                 if (($atomsize > 8) && (!isset($info['avdataend_tmp']) || ($info['quicktime'][$atomname]['size'] > ($info['avdataend_tmp'] - $info['avdataoffset'])))) {
    1392 
    1393                     $info['avdataoffset'] = $atom_structure['offset'] + 8;                       // $info['quicktime'][$atomname]['offset'] + 8;
    1394                     $OldAVDataEnd         = $info['avdataend'];
    1395                     $info['avdataend']    = $atom_structure['offset'] + $atom_structure['size']; // $info['quicktime'][$atomname]['offset'] + $info['quicktime'][$atomname]['size'];
    1396 
    1397                     $getid3_temp = new getID3();
    1398                     $getid3_temp->openfile($this->getid3->filename);
    1399                     $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
    1400                     $getid3_temp->info['avdataend']    = $info['avdataend'];
    1401                     $getid3_mp3 = new getid3_mp3($getid3_temp);
    1402                     if ($getid3_mp3->MPEGaudioHeaderValid($getid3_mp3->MPEGaudioHeaderDecode($this->fread(4)))) {
    1403                         $getid3_mp3->getOnlyMPEGaudioInfo($getid3_temp->info['avdataoffset'], false);
    1404                         if (!empty($getid3_temp->info['warning'])) {
    1405                             foreach ($getid3_temp->info['warning'] as $value) {
    1406                                 $this->warning($value);
     1417                    }
     1418                    if (substr($atom_data, $mdat_offset, 4) == 'GPRO') {
     1419                        $GOPRO_chunk_length = getid3_lib::LittleEndian2Int(substr($atom_data, $mdat_offset + 4, 4));
     1420                        $GOPRO_offset = 8;
     1421                        $atom_structure['GPRO']['raw'] = substr($atom_data, $mdat_offset + 8, $GOPRO_chunk_length - 8);
     1422                        $atom_structure['GPRO']['firmware'] = substr($atom_structure['GPRO']['raw'],  0, 15);
     1423                        $atom_structure['GPRO']['unknown1'] = substr($atom_structure['GPRO']['raw'], 15, 16);
     1424                        $atom_structure['GPRO']['unknown2'] = substr($atom_structure['GPRO']['raw'], 31, 32);
     1425                        $atom_structure['GPRO']['unknown3'] = substr($atom_structure['GPRO']['raw'], 63, 16);
     1426                        $atom_structure['GPRO']['camera']   = substr($atom_structure['GPRO']['raw'], 79, 32);
     1427                        $info['quicktime']['camera']['model'] = rtrim($atom_structure['GPRO']['camera'], "\x00");
     1428                    }
     1429
     1430                    // check to see if it looks like chapter titles, in the form of unterminated strings with a leading 16-bit size field
     1431                    while (($mdat_offset < (strlen($atom_data) - 8))
     1432                        && ($chapter_string_length = getid3_lib::BigEndian2Int(substr($atom_data, $mdat_offset, 2)))
     1433                        && ($chapter_string_length < 1000)
     1434                        && ($chapter_string_length <= (strlen($atom_data) - $mdat_offset - 2))
     1435                        && preg_match('#^([\x00-\xFF]{2})([\x20-\xFF]+)$#', substr($atom_data, $mdat_offset, $chapter_string_length + 2), $chapter_matches)) {
     1436                            list($dummy, $chapter_string_length_hex, $chapter_string) = $chapter_matches;
     1437                            $mdat_offset += (2 + $chapter_string_length);
     1438                            @$info['quicktime']['comments']['chapters'][] = $chapter_string;
     1439
     1440                            // "encd" atom specifies encoding. In theory could be anything, almost always UTF-8, but may be UTF-16 with BOM (not currently handled)
     1441                            if (substr($atom_data, $mdat_offset, 12) == "\x00\x00\x00\x0C\x65\x6E\x63\x64\x00\x00\x01\x00") { // UTF-8
     1442                                $mdat_offset += 12;
     1443                            }
     1444                    }
     1445
     1446                    if (($atomsize > 8) && (!isset($info['avdataend_tmp']) || ($info['quicktime'][$atomname]['size'] > ($info['avdataend_tmp'] - $info['avdataoffset'])))) {
     1447
     1448                        $info['avdataoffset'] = $atom_structure['offset'] + 8;                       // $info['quicktime'][$atomname]['offset'] + 8;
     1449                        $OldAVDataEnd         = $info['avdataend'];
     1450                        $info['avdataend']    = $atom_structure['offset'] + $atom_structure['size']; // $info['quicktime'][$atomname]['offset'] + $info['quicktime'][$atomname]['size'];
     1451
     1452                        $getid3_temp = new getID3();
     1453                        $getid3_temp->openfile($this->getid3->filename);
     1454                        $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
     1455                        $getid3_temp->info['avdataend']    = $info['avdataend'];
     1456                        $getid3_mp3 = new getid3_mp3($getid3_temp);
     1457                        if ($getid3_mp3->MPEGaudioHeaderValid($getid3_mp3->MPEGaudioHeaderDecode($this->fread(4)))) {
     1458                            $getid3_mp3->getOnlyMPEGaudioInfo($getid3_temp->info['avdataoffset'], false);
     1459                            if (!empty($getid3_temp->info['warning'])) {
     1460                                foreach ($getid3_temp->info['warning'] as $value) {
     1461                                    $this->warning($value);
     1462                                }
     1463                            }
     1464                            if (!empty($getid3_temp->info['mpeg'])) {
     1465                                $info['mpeg'] = $getid3_temp->info['mpeg'];
     1466                                if (isset($info['mpeg']['audio'])) {
     1467                                    $info['audio']['dataformat']   = 'mp3';
     1468                                    $info['audio']['codec']        = (!empty($info['mpeg']['audio']['encoder']) ? $info['mpeg']['audio']['encoder'] : (!empty($info['mpeg']['audio']['codec']) ? $info['mpeg']['audio']['codec'] : (!empty($info['mpeg']['audio']['LAME']) ? 'LAME' :'mp3')));
     1469                                    $info['audio']['sample_rate']  = $info['mpeg']['audio']['sample_rate'];
     1470                                    $info['audio']['channels']     = $info['mpeg']['audio']['channels'];
     1471                                    $info['audio']['bitrate']      = $info['mpeg']['audio']['bitrate'];
     1472                                    $info['audio']['bitrate_mode'] = strtolower($info['mpeg']['audio']['bitrate_mode']);
     1473                                    $info['bitrate']               = $info['audio']['bitrate'];
     1474                                }
    14071475                            }
    14081476                        }
    1409                         if (!empty($getid3_temp->info['mpeg'])) {
    1410                             $info['mpeg'] = $getid3_temp->info['mpeg'];
    1411                             if (isset($info['mpeg']['audio'])) {
    1412                                 $info['audio']['dataformat']   = 'mp3';
    1413                                 $info['audio']['codec']        = (!empty($info['mpeg']['audio']['encoder']) ? $info['mpeg']['audio']['encoder'] : (!empty($info['mpeg']['audio']['codec']) ? $info['mpeg']['audio']['codec'] : (!empty($info['mpeg']['audio']['LAME']) ? 'LAME' :'mp3')));
    1414                                 $info['audio']['sample_rate']  = $info['mpeg']['audio']['sample_rate'];
    1415                                 $info['audio']['channels']     = $info['mpeg']['audio']['channels'];
    1416                                 $info['audio']['bitrate']      = $info['mpeg']['audio']['bitrate'];
    1417                                 $info['audio']['bitrate_mode'] = strtolower($info['mpeg']['audio']['bitrate_mode']);
    1418                                 $info['bitrate']               = $info['audio']['bitrate'];
     1477                        unset($getid3_mp3, $getid3_temp);
     1478                        $info['avdataend'] = $OldAVDataEnd;
     1479                        unset($OldAVDataEnd);
     1480
     1481                    }
     1482
     1483                    unset($mdat_offset, $chapter_string_length, $chapter_matches);
     1484                    break;
     1485
     1486                case 'free': // FREE space atom
     1487                case 'skip': // SKIP atom
     1488                case 'wide': // 64-bit expansion placeholder atom
     1489                    // 'free', 'skip' and 'wide' are just padding, contains no useful data at all
     1490
     1491                    // When writing QuickTime files, it is sometimes necessary to update an atom's size.
     1492                    // It is impossible to update a 32-bit atom to a 64-bit atom since the 32-bit atom
     1493                    // is only 8 bytes in size, and the 64-bit atom requires 16 bytes. Therefore, QuickTime
     1494                    // puts an 8-byte placeholder atom before any atoms it may have to update the size of.
     1495                    // In this way, if the atom needs to be converted from a 32-bit to a 64-bit atom, the
     1496                    // placeholder atom can be overwritten to obtain the necessary 8 extra bytes.
     1497                    // The placeholder atom has a type of kWideAtomPlaceholderType ( 'wide' ).
     1498                    break;
     1499
     1500
     1501                case 'nsav': // NoSAVe atom
     1502                    // http://developer.apple.com/technotes/tn/tn2038.html
     1503                    $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
     1504                    break;
     1505
     1506                case 'ctyp': // Controller TYPe atom (seen on QTVR)
     1507                    // http://homepages.slingshot.co.nz/~helmboy/quicktime/formats/qtm-layout.txt
     1508                    // some controller names are:
     1509                    //   0x00 + 'std' for linear movie
     1510                    //   'none' for no controls
     1511                    $atom_structure['ctyp'] = substr($atom_data, 0, 4);
     1512                    $info['quicktime']['controller'] = $atom_structure['ctyp'];
     1513                    switch ($atom_structure['ctyp']) {
     1514                        case 'qtvr':
     1515                            $info['video']['dataformat'] = 'quicktimevr';
     1516                            break;
     1517                    }
     1518                    break;
     1519
     1520                case 'pano': // PANOrama track (seen on QTVR)
     1521                    $atom_structure['pano'] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
     1522                    break;
     1523
     1524                case 'hint': // HINT track
     1525                case 'hinf': //
     1526                case 'hinv': //
     1527                case 'hnti': //
     1528                    $info['quicktime']['hinting'] = true;
     1529                    break;
     1530
     1531                case 'imgt': // IMaGe Track reference (kQTVRImageTrackRefType) (seen on QTVR)
     1532                    for ($i = 0; $i < ($atom_structure['size'] - 8); $i += 4) {
     1533                        $atom_structure['imgt'][] = getid3_lib::BigEndian2Int(substr($atom_data, $i, 4));
     1534                    }
     1535                    break;
     1536
     1537
     1538                // Observed-but-not-handled atom types are just listed here to prevent warnings being generated
     1539                case 'FXTC': // Something to do with Adobe After Effects (?)
     1540                case 'PrmA':
     1541                case 'code':
     1542                case 'FIEL': // this is NOT "fiel" (Field Ordering) as describe here: http://developer.apple.com/documentation/QuickTime/QTFF/QTFFChap3/chapter_4_section_2.html
     1543                case 'tapt': // TrackApertureModeDimensionsAID - http://developer.apple.com/documentation/QuickTime/Reference/QT7-1_Update_Reference/Constants/Constants.html
     1544                            // tapt seems to be used to compute the video size [https://www.getid3.org/phpBB3/viewtopic.php?t=838]
     1545                            // * http://lists.apple.com/archives/quicktime-api/2006/Aug/msg00014.html
     1546                            // * http://handbrake.fr/irclogs/handbrake-dev/handbrake-dev20080128_pg2.html
     1547                case 'ctts'://  STCompositionOffsetAID             - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
     1548                case 'cslg'://  STCompositionShiftLeastGreatestAID - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
     1549                case 'sdtp'://  STSampleDependencyAID              - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
     1550                case 'stps'://  STPartialSyncSampleAID             - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
     1551                    //$atom_structure['data'] = $atom_data;
     1552                    break;
     1553
     1554                case "\xA9".'xyz':  // GPS latitude+longitude+altitude
     1555                    $atom_structure['data'] = $atom_data;
     1556                    if (preg_match('#([\\+\\-][0-9\\.]+)([\\+\\-][0-9\\.]+)([\\+\\-][0-9\\.]+)?/$#i', $atom_data, $matches)) {
     1557                        @list($all, $latitude, $longitude, $altitude) = $matches;
     1558                        $info['quicktime']['comments']['gps_latitude'][]  = floatval($latitude);
     1559                        $info['quicktime']['comments']['gps_longitude'][] = floatval($longitude);
     1560                        if (!empty($altitude)) {
     1561                            $info['quicktime']['comments']['gps_altitude'][] = floatval($altitude);
     1562                        }
     1563                    } else {
     1564                        $this->warning('QuickTime atom "©xyz" data does not match expected data pattern at offset '.$baseoffset.'. Please report as getID3() bug.');
     1565                    }
     1566                    break;
     1567
     1568                case 'NCDT':
     1569                    // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
     1570                    // Nikon-specific QuickTime tags found in the NCDT atom of MOV videos from some Nikon cameras such as the Coolpix S8000 and D5100
     1571                    $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 4, $atomHierarchy, $ParseAllPossibleAtoms);
     1572                    break;
     1573                case 'NCTH': // Nikon Camera THumbnail image
     1574                case 'NCVW': // Nikon Camera preVieW image
     1575                    // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
     1576                    if (preg_match('/^\xFF\xD8\xFF/', $atom_data)) {
     1577                        $atom_structure['data'] = $atom_data;
     1578                        $atom_structure['image_mime'] = 'image/jpeg';
     1579                        $atom_structure['description'] = (($atomname == 'NCTH') ? 'Nikon Camera Thumbnail Image' : (($atomname == 'NCVW') ? 'Nikon Camera Preview Image' : 'Nikon preview image'));
     1580                        $info['quicktime']['comments']['picture'][] = array('image_mime'=>$atom_structure['image_mime'], 'data'=>$atom_data, 'description'=>$atom_structure['description']);
     1581                    }
     1582                    break;
     1583                case 'NCTG': // Nikon - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html#NCTG
     1584                    $atom_structure['data'] = $this->QuicktimeParseNikonNCTG($atom_data);
     1585                    break;
     1586                case 'NCHD': // Nikon:MakerNoteVersion  - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
     1587                case 'NCDB': // Nikon                   - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
     1588                case 'CNCV': // Canon:CompressorVersion - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Canon.html
     1589                    $atom_structure['data'] = $atom_data;
     1590                    break;
     1591
     1592                case "\x00\x00\x00\x00":
     1593                    // some kind of metacontainer, may contain a big data dump such as:
     1594                    // mdta keys \005 mdtacom.apple.quicktime.make (mdtacom.apple.quicktime.creationdate ,mdtacom.apple.quicktime.location.ISO6709 $mdtacom.apple.quicktime.software !mdtacom.apple.quicktime.model ilst \01D \001 \015data \001DE\010Apple 0 \002 (data \001DE\0102011-05-11T17:54:04+0200 2 \003 *data \001DE\010+52.4936+013.3897+040.247/ \01D \004 \015data \001DE\0104.3.1 \005 \018data \001DE\010iPhone 4
     1595                    // http://www.geocities.com/xhelmboyx/quicktime/formats/qti-layout.txt
     1596
     1597                    $atom_structure['version']   =          getid3_lib::BigEndian2Int(substr($atom_data, 0, 1));
     1598                    $atom_structure['flags_raw'] =          getid3_lib::BigEndian2Int(substr($atom_data, 1, 3));
     1599                    $atom_structure['subatoms']  = $this->QuicktimeParseContainerAtom(substr($atom_data, 4), $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     1600                    //$atom_structure['subatoms']  = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     1601                    break;
     1602
     1603                case 'meta': // METAdata atom
     1604                    // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
     1605
     1606                    $atom_structure['version']   =          getid3_lib::BigEndian2Int(substr($atom_data, 0, 1));
     1607                    $atom_structure['flags_raw'] =          getid3_lib::BigEndian2Int(substr($atom_data, 1, 3));
     1608                    $atom_structure['subatoms']  = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
     1609                    break;
     1610
     1611                case 'data': // metaDATA atom
     1612                    static $metaDATAkey = 1; // real ugly, but so is the QuickTime structure that stores keys and values in different multinested locations that are hard to relate to each other
     1613                    // seems to be 2 bytes language code (ASCII), 2 bytes unknown (set to 0x10B5 in sample I have), remainder is useful data
     1614                    $atom_structure['language'] =                           substr($atom_data, 4 + 0, 2);
     1615                    $atom_structure['unknown']  = getid3_lib::BigEndian2Int(substr($atom_data, 4 + 2, 2));
     1616                    $atom_structure['data']     =                           substr($atom_data, 4 + 4);
     1617                    $atom_structure['key_name'] = @$info['quicktime']['temp_meta_key_names'][$metaDATAkey++];
     1618
     1619                    if ($atom_structure['key_name'] && $atom_structure['data']) {
     1620                        @$info['quicktime']['comments'][str_replace('com.apple.quicktime.', '', $atom_structure['key_name'])][] = $atom_structure['data'];
     1621                    }
     1622                    break;
     1623
     1624                case 'keys': // KEYS that may be present in the metadata atom.
     1625                    // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW21
     1626                    // The metadata item keys atom holds a list of the metadata keys that may be present in the metadata atom.
     1627                    // This list is indexed starting with 1; 0 is a reserved index value. The metadata item keys atom is a full atom with an atom type of "keys".
     1628                    $atom_structure['version']       = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
     1629                    $atom_structure['flags_raw']     = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
     1630                    $atom_structure['entry_count']   = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
     1631                    $keys_atom_offset = 8;
     1632                    for ($i = 1; $i <= $atom_structure['entry_count']; $i++) {
     1633                        $atom_structure['keys'][$i]['key_size']      = getid3_lib::BigEndian2Int(substr($atom_data, $keys_atom_offset + 0, 4));
     1634                        $atom_structure['keys'][$i]['key_namespace'] =                           substr($atom_data, $keys_atom_offset + 4, 4);
     1635                        $atom_structure['keys'][$i]['key_value']     =                           substr($atom_data, $keys_atom_offset + 8, $atom_structure['keys'][$i]['key_size'] - 8);
     1636                        $keys_atom_offset += $atom_structure['keys'][$i]['key_size']; // key_size includes the 4+4 bytes for key_size and key_namespace
     1637
     1638                        $info['quicktime']['temp_meta_key_names'][$i] = $atom_structure['keys'][$i]['key_value'];
     1639                    }
     1640                    break;
     1641
     1642                case 'gps ':
     1643                    // https://dashcamtalk.com/forum/threads/script-to-extract-gps-data-from-novatek-mp4.20808/page-2#post-291730
     1644                    // The 'gps ' contains simple look up table made up of 8byte rows, that point to the 'free' atoms that contains the actual GPS data.
     1645                    // The first row is version/metadata/notsure, I skip that.
     1646                    // The following rows consist of 4byte address (absolute) and 4byte size (0x1000), these point to the GPS data in the file.
     1647
     1648                    $GPS_rowsize = 8; // 4 bytes for offset, 4 bytes for size
     1649                    if (strlen($atom_data) > 0) {
     1650                        if ((strlen($atom_data) % $GPS_rowsize) == 0) {
     1651                            $atom_structure['gps_toc'] = array();
     1652                            foreach (str_split($atom_data, $GPS_rowsize) as $counter => $datapair) {
     1653                                $atom_structure['gps_toc'][] = unpack('Noffset/Nsize', substr($atom_data, $counter * $GPS_rowsize, $GPS_rowsize));
    14191654                            }
     1655
     1656                            $atom_structure['gps_entries'] = array();
     1657                            $previous_offset = $this->ftell();
     1658                            foreach ($atom_structure['gps_toc'] as $key => $gps_pointer) {
     1659                                if ($key == 0) {
     1660                                    // "The first row is version/metadata/notsure, I skip that."
     1661                                    continue;
     1662                                }
     1663                                $this->fseek($gps_pointer['offset']);
     1664                                $GPS_free_data = $this->fread($gps_pointer['size']);
     1665
     1666                                /*
     1667                                // 2017-05-10: I see some of the data, notably the Hour-Minute-Second, but cannot reconcile the rest of the data. However, the NMEA "GPRMC" line is there and relatively easy to parse, so I'm using that instead
     1668
     1669                                // https://dashcamtalk.com/forum/threads/script-to-extract-gps-data-from-novatek-mp4.20808/page-2#post-291730
     1670                                // The structure of the GPS data atom (the 'free' atoms mentioned above) is following:
     1671                                // hour,minute,second,year,month,day,active,latitude_b,longitude_b,unknown2,latitude,longitude,speed = struct.unpack_from('<IIIIIIssssfff',data, 48)
     1672                                // For those unfamiliar with python struct:
     1673                                // I = int
     1674                                // s = is string (size 1, in this case)
     1675                                // f = float
     1676
     1677                                //$atom_structure['gps_entries'][$key] = unpack('Vhour/Vminute/Vsecond/Vyear/Vmonth/Vday/Vactive/Vlatitude_b/Vlongitude_b/Vunknown2/flatitude/flongitude/fspeed', substr($GPS_free_data, 48));
     1678                                */
     1679
     1680                                // $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
     1681                                // $GPRMC,183731,A,3907.482,N,12102.436,W,000.0,360.0,080301,015.5,E*67
     1682                                // $GPRMC,002454,A,3553.5295,N,13938.6570,E,0.0,43.1,180700,7.1,W,A*3F
     1683                                // $GPRMC,094347.000,A,5342.0061,N,00737.9908,W,0.01,156.75,140217,,,A*7D
     1684                                if (preg_match('#\\$GPRMC,([0-9\\.]*),([AV]),([0-9\\.]*),([NS]),([0-9\\.]*),([EW]),([0-9\\.]*),([0-9\\.]*),([0-9]*),([0-9\\.]*),([EW]?)(,[A])?(\\*[0-9A-F]{2})#', $GPS_free_data, $matches)) {
     1685                                    $GPS_this_GPRMC = array();
     1686                                    list(
     1687                                        $GPS_this_GPRMC['raw']['gprmc'],
     1688                                        $GPS_this_GPRMC['raw']['timestamp'],
     1689                                        $GPS_this_GPRMC['raw']['status'],
     1690                                        $GPS_this_GPRMC['raw']['latitude'],
     1691                                        $GPS_this_GPRMC['raw']['latitude_direction'],
     1692                                        $GPS_this_GPRMC['raw']['longitude'],
     1693                                        $GPS_this_GPRMC['raw']['longitude_direction'],
     1694                                        $GPS_this_GPRMC['raw']['knots'],
     1695                                        $GPS_this_GPRMC['raw']['angle'],
     1696                                        $GPS_this_GPRMC['raw']['datestamp'],
     1697                                        $GPS_this_GPRMC['raw']['variation'],
     1698                                        $GPS_this_GPRMC['raw']['variation_direction'],
     1699                                        $dummy,
     1700                                        $GPS_this_GPRMC['raw']['checksum'],
     1701                                    ) = $matches;
     1702
     1703                                    $hour   = substr($GPS_this_GPRMC['raw']['timestamp'], 0, 2);
     1704                                    $minute = substr($GPS_this_GPRMC['raw']['timestamp'], 2, 2);
     1705                                    $second = substr($GPS_this_GPRMC['raw']['timestamp'], 4, 2);
     1706                                    $ms     = substr($GPS_this_GPRMC['raw']['timestamp'], 6);    // may contain decimal seconds
     1707                                    $day    = substr($GPS_this_GPRMC['raw']['datestamp'], 0, 2);
     1708                                    $month  = substr($GPS_this_GPRMC['raw']['datestamp'], 2, 2);
     1709                                    $year   = substr($GPS_this_GPRMC['raw']['datestamp'], 4, 2);
     1710                                    $year += (($year > 90) ? 1900 : 2000); // complete lack of foresight: datestamps are stored with 2-digit years, take best guess
     1711                                    $GPS_this_GPRMC['timestamp'] = $year.'-'.$month.'-'.$day.' '.$hour.':'.$minute.':'.$second.$ms;
     1712
     1713                                    $GPS_this_GPRMC['active'] = ($GPS_this_GPRMC['raw']['status'] == 'A'); // A=Active,V=Void
     1714
     1715                                    foreach (array('latitude','longitude') as $latlon) {
     1716                                        preg_match('#^([0-9]{1,3})([0-9]{2}\\.[0-9]+)$#', $GPS_this_GPRMC['raw'][$latlon], $matches);
     1717                                        list($dummy, $deg, $min) = $matches;
     1718                                        $GPS_this_GPRMC[$latlon] = $deg + ($min / 60);
     1719                                    }
     1720                                    $GPS_this_GPRMC['latitude']  *= (($GPS_this_GPRMC['raw']['latitude_direction']  == 'S') ? -1 : 1);
     1721                                    $GPS_this_GPRMC['longitude'] *= (($GPS_this_GPRMC['raw']['longitude_direction'] == 'W') ? -1 : 1);
     1722
     1723                                    $GPS_this_GPRMC['heading']    = $GPS_this_GPRMC['raw']['angle'];
     1724                                    $GPS_this_GPRMC['speed_knot'] = $GPS_this_GPRMC['raw']['knots'];
     1725                                    $GPS_this_GPRMC['speed_kmh']  = $GPS_this_GPRMC['raw']['knots'] * 1.852;
     1726                                    if ($GPS_this_GPRMC['raw']['variation']) {
     1727                                        $GPS_this_GPRMC['variation']  = $GPS_this_GPRMC['raw']['variation'];
     1728                                        $GPS_this_GPRMC['variation'] *= (($GPS_this_GPRMC['raw']['variation_direction'] == 'W') ? -1 : 1);
     1729                                    }
     1730
     1731                                    $atom_structure['gps_entries'][$key] = $GPS_this_GPRMC;
     1732
     1733                                    @$info['quicktime']['gps_track'][$GPS_this_GPRMC['timestamp']] = array(
     1734                                        'latitude'  => (float) $GPS_this_GPRMC['latitude'],
     1735                                        'longitude' => (float) $GPS_this_GPRMC['longitude'],
     1736                                        'speed_kmh' => (float) $GPS_this_GPRMC['speed_kmh'],
     1737                                        'heading'   => (float) $GPS_this_GPRMC['heading'],
     1738                                    );
     1739
     1740                                } else {
     1741                                    $this->warning('Unhandled GPS format in "free" atom at offset '.$gps_pointer['offset']);
     1742                                }
     1743                            }
     1744                            $this->fseek($previous_offset);
     1745
     1746                        } else {
     1747                            $this->warning('QuickTime atom "'.$atomname.'" is not mod-8 bytes long ('.$atomsize.' bytes) at offset '.$baseoffset);
    14201748                        }
    1421                     }
    1422                     unset($getid3_mp3, $getid3_temp);
    1423                     $info['avdataend'] = $OldAVDataEnd;
    1424                     unset($OldAVDataEnd);
    1425 
    1426                 }
    1427 
    1428                 unset($mdat_offset, $chapter_string_length, $chapter_matches);
    1429                 break;
    1430 
    1431             case 'free': // FREE space atom
    1432             case 'skip': // SKIP atom
    1433             case 'wide': // 64-bit expansion placeholder atom
    1434                 // 'free', 'skip' and 'wide' are just padding, contains no useful data at all
    1435 
    1436                 // When writing QuickTime files, it is sometimes necessary to update an atom's size.
    1437                 // It is impossible to update a 32-bit atom to a 64-bit atom since the 32-bit atom
    1438                 // is only 8 bytes in size, and the 64-bit atom requires 16 bytes. Therefore, QuickTime
    1439                 // puts an 8-byte placeholder atom before any atoms it may have to update the size of.
    1440                 // In this way, if the atom needs to be converted from a 32-bit to a 64-bit atom, the
    1441                 // placeholder atom can be overwritten to obtain the necessary 8 extra bytes.
    1442                 // The placeholder atom has a type of kWideAtomPlaceholderType ( 'wide' ).
    1443                 break;
    1444 
    1445 
    1446             case 'nsav': // NoSAVe atom
    1447                 // http://developer.apple.com/technotes/tn/tn2038.html
    1448                 $atom_structure['data'] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
    1449                 break;
    1450 
    1451             case 'ctyp': // Controller TYPe atom (seen on QTVR)
    1452                 // http://homepages.slingshot.co.nz/~helmboy/quicktime/formats/qtm-layout.txt
    1453                 // some controller names are:
    1454                 //   0x00 + 'std' for linear movie
    1455                 //   'none' for no controls
    1456                 $atom_structure['ctyp'] = substr($atom_data, 0, 4);
    1457                 $info['quicktime']['controller'] = $atom_structure['ctyp'];
    1458                 switch ($atom_structure['ctyp']) {
    1459                     case 'qtvr':
    1460                         $info['video']['dataformat'] = 'quicktimevr';
    1461                         break;
    1462                 }
    1463                 break;
    1464 
    1465             case 'pano': // PANOrama track (seen on QTVR)
    1466                 $atom_structure['pano'] = getid3_lib::BigEndian2Int(substr($atom_data,  0, 4));
    1467                 break;
    1468 
    1469             case 'hint': // HINT track
    1470             case 'hinf': //
    1471             case 'hinv': //
    1472             case 'hnti': //
    1473                 $info['quicktime']['hinting'] = true;
    1474                 break;
    1475 
    1476             case 'imgt': // IMaGe Track reference (kQTVRImageTrackRefType) (seen on QTVR)
    1477                 for ($i = 0; $i < ($atom_structure['size'] - 8); $i += 4) {
    1478                     $atom_structure['imgt'][] = getid3_lib::BigEndian2Int(substr($atom_data, $i, 4));
    1479                 }
    1480                 break;
    1481 
    1482 
    1483             // Observed-but-not-handled atom types are just listed here to prevent warnings being generated
    1484             case 'FXTC': // Something to do with Adobe After Effects (?)
    1485             case 'PrmA':
    1486             case 'code':
    1487             case 'FIEL': // this is NOT "fiel" (Field Ordering) as describe here: http://developer.apple.com/documentation/QuickTime/QTFF/QTFFChap3/chapter_4_section_2.html
    1488             case 'tapt': // TrackApertureModeDimensionsAID - http://developer.apple.com/documentation/QuickTime/Reference/QT7-1_Update_Reference/Constants/Constants.html
    1489                         // tapt seems to be used to compute the video size [http://www.getid3.org/phpBB3/viewtopic.php?t=838]
    1490                         // * http://lists.apple.com/archives/quicktime-api/2006/Aug/msg00014.html
    1491                         // * http://handbrake.fr/irclogs/handbrake-dev/handbrake-dev20080128_pg2.html
    1492             case 'ctts'://  STCompositionOffsetAID             - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
    1493             case 'cslg'://  STCompositionShiftLeastGreatestAID - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
    1494             case 'sdtp'://  STSampleDependencyAID              - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
    1495             case 'stps'://  STPartialSyncSampleAID             - http://developer.apple.com/documentation/QuickTime/Reference/QTRef_Constants/Reference/reference.html
    1496                 //$atom_structure['data'] = $atom_data;
    1497                 break;
    1498 
    1499             case "\xA9".'xyz':  // GPS latitude+longitude+altitude
    1500                 $atom_structure['data'] = $atom_data;
    1501                 if (preg_match('#([\\+\\-][0-9\\.]+)([\\+\\-][0-9\\.]+)([\\+\\-][0-9\\.]+)?/$#i', $atom_data, $matches)) {
    1502                     @list($all, $latitude, $longitude, $altitude) = $matches;
    1503                     $info['quicktime']['comments']['gps_latitude'][]  = floatval($latitude);
    1504                     $info['quicktime']['comments']['gps_longitude'][] = floatval($longitude);
    1505                     if (!empty($altitude)) {
    1506                         $info['quicktime']['comments']['gps_altitude'][] = floatval($altitude);
    1507                     }
    1508                 } else {
    1509                     $this->warning('QuickTime atom "©xyz" data does not match expected data pattern at offset '.$baseoffset.'. Please report as getID3() bug.');
    1510                 }
    1511                 break;
    1512 
    1513             case 'NCDT':
    1514                 // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
    1515                 // Nikon-specific QuickTime tags found in the NCDT atom of MOV videos from some Nikon cameras such as the Coolpix S8000 and D5100
    1516                 $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 4, $atomHierarchy, $ParseAllPossibleAtoms);
    1517                 break;
    1518             case 'NCTH': // Nikon Camera THumbnail image
    1519             case 'NCVW': // Nikon Camera preVieW image
    1520                 // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
    1521                 if (preg_match('/^\xFF\xD8\xFF/', $atom_data)) {
     1749                    } else {
     1750                        $this->warning('QuickTime atom "'.$atomname.'" is zero bytes long at offset '.$baseoffset);
     1751                    }
     1752                    break;
     1753
     1754                case 'loci':// 3GP location (El Loco)
     1755                    $loffset = 0;
     1756                    $info['quicktime']['comments']['gps_flags']     = array(  getid3_lib::BigEndian2Int(substr($atom_data, 0, 4)));
     1757                    $info['quicktime']['comments']['gps_lang']      = array(  getid3_lib::BigEndian2Int(substr($atom_data, 4, 2)));
     1758                    $info['quicktime']['comments']['gps_location']  = array(          $this->LociString(substr($atom_data, 6), $loffset));
     1759                    $loci_data = substr($atom_data, 6 + $loffset);
     1760                    $info['quicktime']['comments']['gps_role']      = array(  getid3_lib::BigEndian2Int(substr($loci_data, 0, 1)));
     1761                    $info['quicktime']['comments']['gps_longitude'] = array(getid3_lib::FixedPoint16_16(substr($loci_data, 1, 4)));
     1762                    $info['quicktime']['comments']['gps_latitude']  = array(getid3_lib::FixedPoint16_16(substr($loci_data, 5, 4)));
     1763                    $info['quicktime']['comments']['gps_altitude']  = array(getid3_lib::FixedPoint16_16(substr($loci_data, 9, 4)));
     1764                    $info['quicktime']['comments']['gps_body']      = array(          $this->LociString(substr($loci_data, 13           ), $loffset));
     1765                    $info['quicktime']['comments']['gps_notes']     = array(          $this->LociString(substr($loci_data, 13 + $loffset), $loffset));
     1766                    break;
     1767
     1768                case 'chpl': // CHaPter List
     1769                    // https://www.adobe.com/content/dam/Adobe/en/devnet/flv/pdfs/video_file_format_spec_v10.pdf
     1770                    $chpl_version = getid3_lib::BigEndian2Int(substr($atom_data, 4, 1)); // Expected to be 0
     1771                    $chpl_flags   = getid3_lib::BigEndian2Int(substr($atom_data, 5, 3)); // Reserved, set to 0
     1772                    $chpl_count   = getid3_lib::BigEndian2Int(substr($atom_data, 8, 1));
     1773                    $chpl_offset = 9;
     1774                    for ($i = 0; $i < $chpl_count; $i++) {
     1775                        if (($chpl_offset + 9) >= strlen($atom_data)) {
     1776                            $this->warning('QuickTime chapter '.$i.' extends beyond end of "chpl" atom');
     1777                            break;
     1778                        }
     1779                        $info['quicktime']['chapters'][$i]['timestamp'] = getid3_lib::BigEndian2Int(substr($atom_data, $chpl_offset, 8)) / 10000000; // timestamps are stored as 100-nanosecond units
     1780                        $chpl_offset += 8;
     1781                        $chpl_title_size = getid3_lib::BigEndian2Int(substr($atom_data, $chpl_offset, 1));
     1782                        $chpl_offset += 1;
     1783                        $info['quicktime']['chapters'][$i]['title']     =                           substr($atom_data, $chpl_offset, $chpl_title_size);
     1784                        $chpl_offset += $chpl_title_size;
     1785                    }
     1786                    break;
     1787
     1788                case 'FIRM': // FIRMware version(?), seen on GoPro Hero4
     1789                    $info['quicktime']['camera']['firmware'] = $atom_data;
     1790                    break;
     1791
     1792                case 'CAME': // FIRMware version(?), seen on GoPro Hero4
     1793                    $info['quicktime']['camera']['serial_hash'] = unpack('H*', $atom_data);
     1794                    break;
     1795
     1796                case 'dscp':
     1797                case 'rcif':
     1798                    // https://www.getid3.org/phpBB3/viewtopic.php?t=1908
     1799                    if (substr($atom_data, 0, 7) == "\x00\x00\x00\x00\x55\xC4".'{') {
     1800                        if ($json_decoded = @json_decode(rtrim(substr($atom_data, 6), "\x00"), true)) {
     1801                            $info['quicktime']['camera'][$atomname] = $json_decoded;
     1802                            if (($atomname == 'rcif') && isset($info['quicktime']['camera']['rcif']['wxcamera']['rotate'])) {
     1803                                $info['video']['rotate'] = $info['quicktime']['video']['rotate'] = $info['quicktime']['camera']['rcif']['wxcamera']['rotate'];
     1804                            }
     1805                        } else {
     1806                            $this->warning('Failed to JSON decode atom "'.$atomname.'"');
     1807                            $atom_structure['data'] = $atom_data;
     1808                        }
     1809                        unset($json_decoded);
     1810                    } else {
     1811                        $this->warning('Expecting 55 C4 7B at start of atom "'.$atomname.'", found '.getid3_lib::PrintHexBytes(substr($atom_data, 4, 3)).' instead');
     1812                        $atom_structure['data'] = $atom_data;
     1813                    }
     1814                    break;
     1815
     1816                case 'frea':
     1817                    // https://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Kodak.html#frea
     1818                    // may contain "scra" (PreviewImage) and/or "thma" (ThumbnailImage)
     1819                    $atom_structure['subatoms'] = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 4, $atomHierarchy, $ParseAllPossibleAtoms);
     1820                    break;
     1821                case 'tima': // subatom to "frea"
     1822                    // no idea what this does, the one sample file I've seen has a value of 0x00000027
    15221823                    $atom_structure['data'] = $atom_data;
    1523                     $atom_structure['image_mime'] = 'image/jpeg';
    1524                     $atom_structure['description'] = (($atomname == 'NCTH') ? 'Nikon Camera Thumbnail Image' : (($atomname == 'NCVW') ? 'Nikon Camera Preview Image' : 'Nikon preview image'));
    1525                     $info['quicktime']['comments']['picture'][] = array('image_mime'=>$atom_structure['image_mime'], 'data'=>$atom_data, 'description'=>$atom_structure['description']);
    1526                 }
    1527                 break;
    1528             case 'NCTG': // Nikon - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html#NCTG
    1529                 $atom_structure['data'] = $this->QuicktimeParseNikonNCTG($atom_data);
    1530                 break;
    1531             case 'NCHD': // Nikon:MakerNoteVersion  - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
    1532             case 'NCDB': // Nikon                   - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
    1533             case 'CNCV': // Canon:CompressorVersion - http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Canon.html
    1534                 $atom_structure['data'] = $atom_data;
    1535                 break;
    1536 
    1537             case "\x00\x00\x00\x00":
    1538                 // some kind of metacontainer, may contain a big data dump such as:
    1539                 // mdta keys \005 mdtacom.apple.quicktime.make (mdtacom.apple.quicktime.creationdate ,mdtacom.apple.quicktime.location.ISO6709 $mdtacom.apple.quicktime.software !mdtacom.apple.quicktime.model ilst \01D \001 \015data \001DE\010Apple 0 \002 (data \001DE\0102011-05-11T17:54:04+0200 2 \003 *data \001DE\010+52.4936+013.3897+040.247/ \01D \004 \015data \001DE\0104.3.1 \005 \018data \001DE\010iPhone 4
    1540                 // http://www.geocities.com/xhelmboyx/quicktime/formats/qti-layout.txt
    1541 
    1542                 $atom_structure['version']   =          getid3_lib::BigEndian2Int(substr($atom_data, 0, 1));
    1543                 $atom_structure['flags_raw'] =          getid3_lib::BigEndian2Int(substr($atom_data, 1, 3));
    1544                 $atom_structure['subatoms']  = $this->QuicktimeParseContainerAtom(substr($atom_data, 4), $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    1545                 //$atom_structure['subatoms']  = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    1546                 break;
    1547 
    1548             case 'meta': // METAdata atom
    1549                 // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
    1550 
    1551                 $atom_structure['version']   =          getid3_lib::BigEndian2Int(substr($atom_data, 0, 1));
    1552                 $atom_structure['flags_raw'] =          getid3_lib::BigEndian2Int(substr($atom_data, 1, 3));
    1553                 $atom_structure['subatoms']  = $this->QuicktimeParseContainerAtom($atom_data, $baseoffset + 8, $atomHierarchy, $ParseAllPossibleAtoms);
    1554                 break;
    1555 
    1556             case 'data': // metaDATA atom
    1557                 static $metaDATAkey = 1; // real ugly, but so is the QuickTime structure that stores keys and values in different multinested locations that are hard to relate to each other
    1558                 // seems to be 2 bytes language code (ASCII), 2 bytes unknown (set to 0x10B5 in sample I have), remainder is useful data
    1559                 $atom_structure['language'] =                           substr($atom_data, 4 + 0, 2);
    1560                 $atom_structure['unknown']  = getid3_lib::BigEndian2Int(substr($atom_data, 4 + 2, 2));
    1561                 $atom_structure['data']     =                           substr($atom_data, 4 + 4);
    1562                 $atom_structure['key_name'] = @$info['quicktime']['temp_meta_key_names'][$metaDATAkey++];
    1563 
    1564                 if ($atom_structure['key_name'] && $atom_structure['data']) {
    1565                     @$info['quicktime']['comments'][str_replace('com.apple.quicktime.', '', $atom_structure['key_name'])][] = $atom_structure['data'];
    1566                 }
    1567                 break;
    1568 
    1569             case 'keys': // KEYS that may be present in the metadata atom.
    1570                 // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW21
    1571                 // The metadata item keys atom holds a list of the metadata keys that may be present in the metadata atom.
    1572                 // This list is indexed starting with 1; 0 is a reserved index value. The metadata item keys atom is a full atom with an atom type of "keys".
    1573                 $atom_structure['version']       = getid3_lib::BigEndian2Int(substr($atom_data,  0, 1));
    1574                 $atom_structure['flags_raw']     = getid3_lib::BigEndian2Int(substr($atom_data,  1, 3));
    1575                 $atom_structure['entry_count']   = getid3_lib::BigEndian2Int(substr($atom_data,  4, 4));
    1576                 $keys_atom_offset = 8;
    1577                 for ($i = 1; $i <= $atom_structure['entry_count']; $i++) {
    1578                     $atom_structure['keys'][$i]['key_size']      = getid3_lib::BigEndian2Int(substr($atom_data, $keys_atom_offset + 0, 4));
    1579                     $atom_structure['keys'][$i]['key_namespace'] =                           substr($atom_data, $keys_atom_offset + 4, 4);
    1580                     $atom_structure['keys'][$i]['key_value']     =                           substr($atom_data, $keys_atom_offset + 8, $atom_structure['keys'][$i]['key_size'] - 8);
    1581                     $keys_atom_offset += $atom_structure['keys'][$i]['key_size']; // key_size includes the 4+4 bytes for key_size and key_namespace
    1582 
    1583                     $info['quicktime']['temp_meta_key_names'][$i] = $atom_structure['keys'][$i]['key_value'];
    1584                 }
    1585                 break;
    1586 
    1587             case 'gps ':
    1588                 // https://dashcamtalk.com/forum/threads/script-to-extract-gps-data-from-novatek-mp4.20808/page-2#post-291730
    1589                 // The 'gps ' contains simple look up table made up of 8byte rows, that point to the 'free' atoms that contains the actual GPS data.
    1590                 // The first row is version/metadata/notsure, I skip that.
    1591                 // The following rows consist of 4byte address (absolute) and 4byte size (0x1000), these point to the GPS data in the file.
    1592 
    1593                 $GPS_rowsize = 8; // 4 bytes for offset, 4 bytes for size
    1594                 if (strlen($atom_data) > 0) {
    1595                     if ((strlen($atom_data) % $GPS_rowsize) == 0) {
    1596                         $atom_structure['gps_toc'] = array();
    1597                         foreach (str_split($atom_data, $GPS_rowsize) as $counter => $datapair) {
    1598                             $atom_structure['gps_toc'][] = unpack('Noffset/Nsize', substr($atom_data, $counter * $GPS_rowsize, $GPS_rowsize));
    1599                         }
    1600 
    1601                         $atom_structure['gps_entries'] = array();
    1602                         $previous_offset = $this->ftell();
    1603                         foreach ($atom_structure['gps_toc'] as $key => $gps_pointer) {
    1604                             if ($key == 0) {
    1605                                 // "The first row is version/metadata/notsure, I skip that."
    1606                                 continue;
    1607                             }
    1608                             $this->fseek($gps_pointer['offset']);
    1609                             $GPS_free_data = $this->fread($gps_pointer['size']);
    1610 
    1611                             /*
    1612                             // 2017-05-10: I see some of the data, notably the Hour-Minute-Second, but cannot reconcile the rest of the data. However, the NMEA "GPRMC" line is there and relatively easy to parse, so I'm using that instead
    1613 
    1614                             // https://dashcamtalk.com/forum/threads/script-to-extract-gps-data-from-novatek-mp4.20808/page-2#post-291730
    1615                             // The structure of the GPS data atom (the 'free' atoms mentioned above) is following:
    1616                             // hour,minute,second,year,month,day,active,latitude_b,longitude_b,unknown2,latitude,longitude,speed = struct.unpack_from('<IIIIIIssssfff',data, 48)
    1617                             // For those unfamiliar with python struct:
    1618                             // I = int
    1619                             // s = is string (size 1, in this case)
    1620                             // f = float
    1621 
    1622                             //$atom_structure['gps_entries'][$key] = unpack('Vhour/Vminute/Vsecond/Vyear/Vmonth/Vday/Vactive/Vlatitude_b/Vlongitude_b/Vunknown2/flatitude/flongitude/fspeed', substr($GPS_free_data, 48));
    1623                             */
    1624 
    1625                             // $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
    1626                             // $GPRMC,183731,A,3907.482,N,12102.436,W,000.0,360.0,080301,015.5,E*67
    1627                             // $GPRMC,002454,A,3553.5295,N,13938.6570,E,0.0,43.1,180700,7.1,W,A*3F
    1628                             // $GPRMC,094347.000,A,5342.0061,N,00737.9908,W,0.01,156.75,140217,,,A*7D
    1629                             if (preg_match('#\\$GPRMC,([0-9\\.]*),([AV]),([0-9\\.]*),([NS]),([0-9\\.]*),([EW]),([0-9\\.]*),([0-9\\.]*),([0-9]*),([0-9\\.]*),([EW]?)(,[A])?(\\*[0-9A-F]{2})#', $GPS_free_data, $matches)) {
    1630                                 $GPS_this_GPRMC = array();
    1631                                 list(
    1632                                     $GPS_this_GPRMC['raw']['gprmc'],
    1633                                     $GPS_this_GPRMC['raw']['timestamp'],
    1634                                     $GPS_this_GPRMC['raw']['status'],
    1635                                     $GPS_this_GPRMC['raw']['latitude'],
    1636                                     $GPS_this_GPRMC['raw']['latitude_direction'],
    1637                                     $GPS_this_GPRMC['raw']['longitude'],
    1638                                     $GPS_this_GPRMC['raw']['longitude_direction'],
    1639                                     $GPS_this_GPRMC['raw']['knots'],
    1640                                     $GPS_this_GPRMC['raw']['angle'],
    1641                                     $GPS_this_GPRMC['raw']['datestamp'],
    1642                                     $GPS_this_GPRMC['raw']['variation'],
    1643                                     $GPS_this_GPRMC['raw']['variation_direction'],
    1644                                     $dummy,
    1645                                     $GPS_this_GPRMC['raw']['checksum'],
    1646                                 ) = $matches;
    1647 
    1648                                 $hour   = substr($GPS_this_GPRMC['raw']['timestamp'], 0, 2);
    1649                                 $minute = substr($GPS_this_GPRMC['raw']['timestamp'], 2, 2);
    1650                                 $second = substr($GPS_this_GPRMC['raw']['timestamp'], 4, 2);
    1651                                 $ms     = substr($GPS_this_GPRMC['raw']['timestamp'], 6);    // may contain decimal seconds
    1652                                 $day   = substr($GPS_this_GPRMC['raw']['datestamp'], 0, 2);
    1653                                 $month = substr($GPS_this_GPRMC['raw']['datestamp'], 2, 2);
    1654                                 $year  = substr($GPS_this_GPRMC['raw']['datestamp'], 4, 2);
    1655                                 $year += (($year > 90) ? 1900 : 2000); // complete lack of foresight: datestamps are stored with 2-digit years, take best guess
    1656                                 $GPS_this_GPRMC['timestamp'] = $year.'-'.$month.'-'.$day.' '.$hour.':'.$minute.':'.$second.$ms;
    1657 
    1658                                 $GPS_this_GPRMC['active'] = ($GPS_this_GPRMC['raw']['status'] == 'A'); // A=Active,V=Void
    1659 
    1660                                 foreach (array('latitude','longitude') as $latlon) {
    1661                                     preg_match('#^([0-9]{1,3})([0-9]{2}\\.[0-9]+)$#', $GPS_this_GPRMC['raw'][$latlon], $matches);
    1662                                     list($dummy, $deg, $min) = $matches;
    1663                                     $GPS_this_GPRMC[$latlon] = $deg + ($min / 60);
    1664                                 }
    1665                                 $GPS_this_GPRMC['latitude']  *= (($GPS_this_GPRMC['raw']['latitude_direction']  == 'S') ? -1 : 1);
    1666                                 $GPS_this_GPRMC['longitude'] *= (($GPS_this_GPRMC['raw']['longitude_direction'] == 'W') ? -1 : 1);
    1667 
    1668                                 $GPS_this_GPRMC['heading']    = $GPS_this_GPRMC['raw']['angle'];
    1669                                 $GPS_this_GPRMC['speed_knot'] = $GPS_this_GPRMC['raw']['knots'];
    1670                                 $GPS_this_GPRMC['speed_kmh']  = $GPS_this_GPRMC['raw']['knots'] * 1.852;
    1671                                 if ($GPS_this_GPRMC['raw']['variation']) {
    1672                                     $GPS_this_GPRMC['variation']  = $GPS_this_GPRMC['raw']['variation'];
    1673                                     $GPS_this_GPRMC['variation'] *= (($GPS_this_GPRMC['raw']['variation_direction'] == 'W') ? -1 : 1);
    1674                                 }
    1675 
    1676                                 $atom_structure['gps_entries'][$key] = $GPS_this_GPRMC;
    1677 
    1678                                 @$info['quicktime']['gps_track'][$GPS_this_GPRMC['timestamp']] = array(
    1679                                     'latitude'  => $GPS_this_GPRMC['latitude'],
    1680                                     'longitude' => $GPS_this_GPRMC['longitude'],
    1681                                     'speed_kmh' => $GPS_this_GPRMC['speed_kmh'],
    1682                                     'heading'   => $GPS_this_GPRMC['heading'],
    1683                                 );
    1684 
    1685                             } else {
    1686                                 $this->warning('Unhandled GPS format in "free" atom at offset '.$gps_pointer['offset']);
    1687                             }
    1688                         }
    1689                         $this->fseek($previous_offset);
    1690 
    1691                     } else {
    1692                         $this->warning('QuickTime atom "'.$atomname.'" is not mod-8 bytes long ('.$atomsize.' bytes) at offset '.$baseoffset);
    1693                     }
    1694                 } else {
    1695                     $this->warning('QuickTime atom "'.$atomname.'" is zero bytes long at offset '.$baseoffset);
    1696                 }
    1697                 break;
    1698 
    1699             case 'loci':// 3GP location (El Loco)
    1700                                 $info['quicktime']['comments']['gps_flags'] = getid3_lib::BigEndian2Int(substr($atom_data, 0, 4));
    1701                                 $info['quicktime']['comments']['gps_lang'] = getid3_lib::BigEndian2Int(substr($atom_data, 4, 2));
    1702                                 $loffset = 0;
    1703                                 $info['quicktime']['comments']['gps_location'] = $this->LociString(substr($atom_data, 6), $loffset);
    1704                                 $loci_data=substr($atom_data, 6 + $loffset);
    1705                                 $info['quicktime']['comments']['gps_role'] = getid3_lib::BigEndian2Int(substr($loci_data, 0, 1));
    1706                                 $info['quicktime']['comments']['gps_longitude'] = getid3_lib::FixedPoint16_16(substr($loci_data, 1, 4));
    1707                                 $info['quicktime']['comments']['gps_latitude'] = getid3_lib::FixedPoint16_16(substr($loci_data, 5, 4));
    1708                                 $info['quicktime']['comments']['gps_altitude'] = getid3_lib::FixedPoint16_16(substr($loci_data, 9, 4));
    1709                                 $info['quicktime']['comments']['gps_body'] = $this->LociString(substr($loci_data, 13), $loffset);
    1710                                 $info['quicktime']['comments']['gps_notes'] = $this->LociString(substr($loci_data, 13 + $loffset), $loffset);
    1711                                 break;
    1712 
    1713             default:
    1714                 $this->warning('Unknown QuickTime atom type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" ('.trim(getid3_lib::PrintHexBytes($atomname)).') at offset '.$baseoffset);
    1715                 $atom_structure['data'] = $atom_data;
    1716                 break;
     1824                    break;
     1825                case 'ver ': // subatom to "frea"
     1826                    // some kind of version number, the one sample file I've seen has a value of "3.00.073"
     1827                    $atom_structure['data'] = $atom_data;
     1828                    break;
     1829                case 'thma': // subatom to "frea" -- "ThumbnailImage"
     1830                    // https://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Kodak.html#frea
     1831                    if (strlen($atom_data) > 0) {
     1832                        $info['quicktime']['comments']['picture'][] = array('data'=>$atom_data, 'image_mime'=>'image/jpeg');
     1833                    }
     1834                    break;
     1835                case 'scra': // subatom to "frea" -- "PreviewImage"
     1836                    // https://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Kodak.html#frea
     1837                    // but the only sample file I've seen has no useful data here
     1838                    if (strlen($atom_data) > 0) {
     1839                        $info['quicktime']['comments']['picture'][] = array('data'=>$atom_data, 'image_mime'=>'image/jpeg');
     1840                    }
     1841                    break;
     1842
     1843
     1844                default:
     1845                    $this->warning('Unknown QuickTime atom type: "'.preg_replace('#[^a-zA-Z0-9 _\\-]#', '?', $atomname).'" ('.trim(getid3_lib::PrintHexBytes($atomname)).'), '.$atomsize.' bytes at offset '.$baseoffset);
     1846                    $atom_structure['data'] = $atom_data;
     1847                    break;
     1848            }
    17171849        }
    17181850        array_pop($atomHierarchy);
    … …  
    17201852    }
    17211853
     1854    /**
     1855     * @param string $atom_data
     1856     * @param int    $baseoffset
     1857     * @param array  $atomHierarchy
     1858     * @param bool   $ParseAllPossibleAtoms
     1859     *
     1860     * @return array|false
     1861     */
    17221862    public function QuicktimeParseContainerAtom($atom_data, $baseoffset, &$atomHierarchy, $ParseAllPossibleAtoms) {
    1723 //echo 'QuicktimeParseContainerAtom('.substr($atom_data, 4, 4).') @ '.$baseoffset.'<br><br>';
    17241863        $atom_structure  = false;
    17251864        $subatomoffset  = 0;
    … …  
    17421881                return $atom_structure;
    17431882            }
    1744 
    1745             $atom_structure[$subatomcounter] = $this->QuicktimeParseAtom($subatomname, $subatomsize, $subatomdata, $baseoffset + $subatomoffset, $atomHierarchy, $ParseAllPossibleAtoms);
    1746 
     1883            $atom_structure[$subatomcounter++] = $this->QuicktimeParseAtom($subatomname, $subatomsize, $subatomdata, $baseoffset + $subatomoffset, $atomHierarchy, $ParseAllPossibleAtoms);
    17471884            $subatomoffset += $subatomsize;
    1748             $subatomcounter++;
    17491885        }
    17501886        return $atom_structure;
    17511887    }
    17521888
    1753 
     1889    /**
     1890     * @param string $data
     1891     * @param int    $offset
     1892     *
     1893     * @return int
     1894     */
    17541895    public function quicktime_read_mp4_descr_length($data, &$offset) {
    17551896        // http://libquicktime.sourcearchive.com/documentation/2:1.0.2plus-pdebian-2build1/esds_8c-source.html
    … …  
    17631904    }
    17641905
    1765 
     1906    /**
     1907     * @param int $languageid
     1908     *
     1909     * @return string
     1910     */
    17661911    public function QuicktimeLanguageLookup($languageid) {
    17671912        // http://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap4/qtff4.html#//apple_ref/doc/uid/TP40000939-CH206-34353
    … …  
    19012046    }
    19022047
     2048    /**
     2049     * @param string $codecid
     2050     *
     2051     * @return string
     2052     */
    19032053    public function QuicktimeVideoCodecLookup($codecid) {
    19042054        static $QuicktimeVideoCodecLookup = array();
    … …  
    19602110    }
    19612111
     2112    /**
     2113     * @param string $codecid
     2114     *
     2115     * @return mixed|string
     2116     */
    19622117    public function QuicktimeAudioCodecLookup($codecid) {
    19632118        static $QuicktimeAudioCodecLookup = array();
    … …  
    20052160    }
    20062161
     2162    /**
     2163     * @param string $compressionid
     2164     *
     2165     * @return string
     2166     */
    20072167    public function QuicktimeDCOMLookup($compressionid) {
    20082168        static $QuicktimeDCOMLookup = array();
    … …  
    20142174    }
    20152175
     2176    /**
     2177     * @param int $colordepthid
     2178     *
     2179     * @return string
     2180     */
    20162181    public function QuicktimeColorNameLookup($colordepthid) {
    20172182        static $QuicktimeColorNameLookup = array();
    … …  
    20322197    }
    20332198
     2199    /**
     2200     * @param int $stik
     2201     *
     2202     * @return string
     2203     */
    20342204    public function QuicktimeSTIKLookup($stik) {
    20352205        static $QuicktimeSTIKLookup = array();
    … …  
    20492219    }
    20502220
     2221    /**
     2222     * @param int $audio_profile_id
     2223     *
     2224     * @return string
     2225     */
    20512226    public function QuicktimeIODSaudioProfileName($audio_profile_id) {
    20522227        static $QuicktimeIODSaudioProfileNameLookup = array();
    … …  
    21082283    }
    21092284
    2110 
     2285    /**
     2286     * @param int $video_profile_id
     2287     *
     2288     * @return string
     2289     */
    21112290    public function QuicktimeIODSvideoProfileName($video_profile_id) {
    21122291        static $QuicktimeIODSvideoProfileNameLookup = array();
    … …  
    21802359    }
    21812360
    2182 
     2361    /**
     2362     * @param int $rtng
     2363     *
     2364     * @return string
     2365     */
    21832366    public function QuicktimeContentRatingLookup($rtng) {
    21842367        static $QuicktimeContentRatingLookup = array();
    … …  
    21912374    }
    21922375
     2376    /**
     2377     * @param int $akid
     2378     *
     2379     * @return string
     2380     */
    21932381    public function QuicktimeStoreAccountTypeLookup($akid) {
    21942382        static $QuicktimeStoreAccountTypeLookup = array();
    … …  
    22002388    }
    22012389
     2390    /**
     2391     * @param int $sfid
     2392     *
     2393     * @return string
     2394     */
    22022395    public function QuicktimeStoreFrontCodeLookup($sfid) {
    22032396        static $QuicktimeStoreFrontCodeLookup = array();
    … …  
    22292422    }
    22302423
     2424    /**
     2425     * @param string $atom_data
     2426     *
     2427     * @return array
     2428     */
    22312429    public function QuicktimeParseNikonNCTG($atom_data) {
    22322430        // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html#NCTG
    … …  
    22712469
    22722470        $offset = 0;
     2471        $data = null;
    22732472        $datalength = strlen($atom_data);
    22742473        $parsed = array();
    22752474        while ($offset < $datalength) {
    2276 //echo getid3_lib::PrintHexBytes(substr($atom_data, $offset, 4)).'<br>';
    22772475            $record_type       = getid3_lib::BigEndian2Int(substr($atom_data, $offset, 4));  $offset += 4;
    22782476            $data_size_type    = getid3_lib::BigEndian2Int(substr($atom_data, $offset, 2));  $offset += 2;
    … …  
    23292527                    break;
    23302528                default:
    2331 echo 'QuicktimeParseNikonNCTG()::unknown $data_size_type: '.$data_size_type.'<br>';
     2529                    echo 'QuicktimeParseNikonNCTG()::unknown $data_size_type: '.$data_size_type.'<br>';
    23322530                    break 2;
    23332531            }
    … …  
    24072605    }
    24082606
    2409 
     2607    /**
     2608     * @param string $keyname
     2609     * @param string|array $data
     2610     * @param string $boxname
     2611     *
     2612     * @return bool
     2613     */
    24102614    public function CopyToAppropriateCommentsSection($keyname, $data, $boxname='') {
    24112615        static $handyatomtranslatorarray = array();
    … …  
    24512655            $handyatomtranslatorarray["\xA9".'swr'] = 'software';
    24522656            $handyatomtranslatorarray["\xA9".'too'] = 'encoding_tool';       // iTunes 4.0
    2453             $handyatomtranslatorarray["\xA9".'trk'] = 'track';
     2657            $handyatomtranslatorarray["\xA9".'trk'] = 'track_number';
    24542658            $handyatomtranslatorarray["\xA9".'url'] = 'url';
    24552659            $handyatomtranslatorarray["\xA9".'wrn'] = 'warning';
    … …  
    25042708
    25052709            // http://age.hobba.nl/audio/tag_frame_reference.html
    2506             $handyatomtranslatorarray['PLAY_COUNTER']                = 'play_counter'; // Foobar2000 - http://www.getid3.org/phpBB3/viewtopic.php?t=1355
    2507             $handyatomtranslatorarray['MEDIATYPE']                   = 'mediatype';    // Foobar2000 - http://www.getid3.org/phpBB3/viewtopic.php?t=1355
     2710            $handyatomtranslatorarray['PLAY_COUNTER']                = 'play_counter'; // Foobar2000 - https://www.getid3.org/phpBB3/viewtopic.php?t=1355
     2711            $handyatomtranslatorarray['MEDIATYPE']                   = 'mediatype';    // Foobar2000 - https://www.getid3.org/phpBB3/viewtopic.php?t=1355
    25082712            */
    25092713        }
    … …  
    25432747    }
    25442748
    2545     public function LociString($lstring, &$count) {
    2546             // Loci strings are UTF-8 or UTF-16 and null (x00/x0000) terminated. UTF-16 has a BOM
    2547             // Also need to return the number of bytes the string occupied so additional fields can be extracted
    2548             $len = strlen($lstring);
    2549             if ($len == 0) {
    2550                 $count = 0;
    2551                 return '';
    2552             }
    2553             if ($lstring[0] == "\x00") {
    2554                 $count = 1;
    2555                 return '';
    2556             }
    2557             //check for BOM
    2558             if ($len > 2 && (($lstring[0] == "\xFE" && $lstring[1] == "\xFF") || ($lstring[0] == "\xFF" && $lstring[1] == "\xFE"))) {
    2559                 //UTF-16
    2560                 if (preg_match('/(.*)\x00/', $lstring, $lmatches)){
    2561                      $count = strlen($lmatches[1]) * 2 + 2; //account for 2 byte characters and trailing \x0000
    2562                     return getid3_lib::iconv_fallback_utf16_utf8($lmatches[1]);
    2563                 } else {
    2564                     return '';
    2565                 }
    2566             } else {
    2567                 //UTF-8
    2568                 if (preg_match('/(.*)\x00/', $lstring, $lmatches)){
    2569                     $count = strlen($lmatches[1]) + 1; //account for trailing \x00
    2570                     return $lmatches[1];
    2571                 }else {
    2572                     return '';
    2573                 }
    2574 
    2575             }
    2576         }
    2577 
     2749    /**
     2750     * @param string $lstring
     2751     * @param int    $count
     2752     *
     2753     * @return string
     2754     */
     2755    public function LociString($lstring, &$count) {
     2756        // Loci strings are UTF-8 or UTF-16 and null (x00/x0000) terminated. UTF-16 has a BOM
     2757        // Also need to return the number of bytes the string occupied so additional fields can be extracted
     2758        $len = strlen($lstring);
     2759        if ($len == 0) {
     2760            $count = 0;
     2761            return '';
     2762        }
     2763        if ($lstring[0] == "\x00") {
     2764            $count = 1;
     2765            return '';
     2766        }
     2767        // check for BOM
     2768        if (($len > 2) && ((($lstring[0] == "\xFE") && ($lstring[1] == "\xFF")) || (($lstring[0] == "\xFF") && ($lstring[1] == "\xFE")))) {
     2769            // UTF-16
     2770            if (preg_match('/(.*)\x00/', $lstring, $lmatches)) {
     2771                $count = strlen($lmatches[1]) * 2 + 2; //account for 2 byte characters and trailing \x0000
     2772                return getid3_lib::iconv_fallback_utf16_utf8($lmatches[1]);
     2773            } else {
     2774                return '';
     2775            }
     2776        }
     2777        // UTF-8
     2778        if (preg_match('/(.*)\x00/', $lstring, $lmatches)) {
     2779            $count = strlen($lmatches[1]) + 1; //account for trailing \x00
     2780            return $lmatches[1];
     2781        }
     2782        return '';
     2783    }
     2784
     2785    /**
     2786     * @param string $nullterminatedstring
     2787     *
     2788     * @return string
     2789     */
    25782790    public function NoNullString($nullterminatedstring) {
    25792791        // remove the single null terminator on null terminated strings
    … …  
    25842796    }
    25852797
     2798    /**
     2799     * @param string $pascalstring
     2800     *
     2801     * @return string
     2802     */
    25862803    public function Pascal2String($pascalstring) {
    25872804        // Pascal strings have 1 unsigned byte at the beginning saying how many chars (1-255) are in the string
    … …  
    25902807
    25912808
    2592     /*
    2593     // helper functions for m4b audiobook chapters
    2594     // code by Steffen Hartmann 2015-Nov-08
    2595     */
     2809    /**
     2810     * Helper functions for m4b audiobook chapters
     2811     * code by Steffen Hartmann 2015-Nov-08.
     2812     *
     2813     * @param array  $info
     2814     * @param string $tag
     2815     * @param string $history
     2816     * @param array  $result
     2817     */
    25962818    public function search_tag_by_key($info, $tag, $history, &$result) {
    25972819        foreach ($info as $key => $value) {
    … …  
    26072829    }
    26082830
     2831    /**
     2832     * @param array  $info
     2833     * @param string $k
     2834     * @param string $v
     2835     * @param string $history
     2836     * @param array  $result
     2837     */
    26092838    public function search_tag_by_pair($info, $k, $v, $history, &$result) {
    26102839        foreach ($info as $key => $value) {
    … …  
    26202849    }
    26212850
     2851    /**
     2852     * @param array $info
     2853     *
     2854     * @return array
     2855     */
    26222856    public function quicktime_time_to_sample_table($info) {
    26232857        $res = array();
    … …  
    26372871    }
    26382872
    2639     function quicktime_bookmark_time_scale($info) {
     2873    /**
     2874     * @param array $info
     2875     *
     2876     * @return int
     2877     */
     2878    public function quicktime_bookmark_time_scale($info) {
    26402879        $time_scale = '';
    26412880        $ts_prefix_len = 0;
    … …  
    26482887                $ts_res = array();
    26492888                $this->search_tag_by_key($info['quicktime']['moov'], 'time_scale', 'quicktime/moov', $ts_res);
    2650                 foreach ($ts_res as $value) {
    2651                     $prefix = substr($value[0], 0, -12);
     2889                foreach ($ts_res as $sub_value) {
     2890                    $prefix = substr($sub_value[0], 0, -12);
    26522891                    if ((substr($stbl_res[0][0], 0, strlen($prefix)) === $prefix) && ($ts_prefix_len < strlen($prefix))) {
    2653                         $time_scale = $value[1]['time_scale'];
     2892                        $time_scale = $sub_value[1]['time_scale'];
    26542893                        $ts_prefix_len = strlen($prefix);
    26552894                    }

  • trunk/src/wp-includes/ID3/module.audio-video.riff.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    2828getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio.dts.php', __FILE__, true);
    2929
    30 class getid3_riff extends getid3_handler {
    31 
     30class getid3_riff extends getid3_handler
     31{
    3232    protected $container = 'riff'; // default
    3333
     34    /**
     35     * @return bool
     36     *
     37     * @throws getid3_exception
     38     */
    3439    public function Analyze() {
    3540        $info = &$this->getid3->info;
    … …  
    4752        $thisfile_riff_audio       = &$thisfile_riff['audio'];
    4853        $thisfile_riff_video       = &$thisfile_riff['video'];
     54        $thisfile_riff_WAVE        = array();
    4955
    5056        $Original['avdataoffset'] = $info['avdataoffset'];
    … …  
    358364                    $thisfile_riff_WAVE_cart_0['url']              =                 trim(substr($thisfile_riff_WAVE_cart_0['data'],  748, 1024));
    359365                    $thisfile_riff_WAVE_cart_0['tag_text']         = explode("\r\n", trim(substr($thisfile_riff_WAVE_cart_0['data'], 1772)));
     366                    $thisfile_riff['comments']['tag_text'][]       =                      substr($thisfile_riff_WAVE_cart_0['data'], 1772);
    360367
    361368                    $thisfile_riff['comments']['artist'][] = $thisfile_riff_WAVE_cart_0['artist'];
    … …  
    406413                        'category'  =>'genre',
    407414                        'cdtitle'   =>'album',
    408                         'tracktitle'=>'title',
    409415                    );
    410416                    foreach ($tagmapping as $fromkey => $tokey) {
    … …  
    614620                $thisfile_video['dataformat']   = 'avi';
    615621
     622                $thisfile_riff_video_current = array();
     623
    616624                if (isset($thisfile_riff[$RIFFsubtype]['movi']['offset'])) {
    617625                    $info['avdataoffset'] = $thisfile_riff[$RIFFsubtype]['movi']['offset'] + 8;
    … …  
    696704                        'copyrighted'  => 0x00020010,
    697705                    );
    698                     foreach ($flags as $flag => $value) {
     706                    foreach ($flags as $flag => $value) {
    699707                        $thisfile_riff_raw_avih['flags'][$flag] = (bool) ($thisfile_riff_raw_avih['dwFlags'] & $value);
    700708                    }
    … …  
    702710                    // shortcut
    703711                    $thisfile_riff_video[$streamindex] = array();
     712                    /** @var array $thisfile_riff_video_current */
    704713                    $thisfile_riff_video_current = &$thisfile_riff_video[$streamindex];
    705714
    … …  
    868877                            }
    869878
    870                             if (isset($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'])) {
     879                            if (isset($thisfile_riff_raw_strf_strhfccType_streamindex) && isset($thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'])) {
    871880
    872881                                $thisfile_video['fourcc'] = $thisfile_riff_raw_strf_strhfccType_streamindex['fourcc'];
    … …  
    915924            case 'CDDA':
    916925                $info['fileformat'] = 'cda';
    917                 unset($info['mime_type']);
     926                unset($info['mime_type']);
    918927
    919928                $thisfile_audio_dataformat      = 'cda';
    … …  
    935944                    $thisfile_riff_CDDA_fmt_0['start_offset_seconds'] = (float) $thisfile_riff_CDDA_fmt_0['start_offset_frame'] / 75;
    936945                    $thisfile_riff_CDDA_fmt_0['playtime_seconds']     = (float) $thisfile_riff_CDDA_fmt_0['playtime_frames'] / 75;
    937                     $info['comments']['track']                = $thisfile_riff_CDDA_fmt_0['track_num'];
     946                    $info['comments']['track_number']         = $thisfile_riff_CDDA_fmt_0['track_num'];
    938947                    $info['playtime_seconds']                 = $thisfile_riff_CDDA_fmt_0['playtime_seconds'];
    939948
    … …  
    948957                break;
    949958
    950             // http://en.wikipedia.org/wiki/AIFF
     959            // http://en.wikipedia.org/wiki/AIFF
    951960            case 'AIFF':
    952961            case 'AIFC':
    … …  
    10581067                    getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.tag.id3v2.php', __FILE__, true);
    10591068                    $getid3_temp = new getID3();
    1060                     $getid3_temp->openfile($this->getid3->filename);
     1069                    $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    10611070                    $getid3_id3v2 = new getid3_id3v2($getid3_temp);
    10621071                    $getid3_id3v2->StartingOffset = $thisfile_riff[$RIFFsubtype]['ID3 '][0]['offset'] + 8;
    … …  
    10781087                $thisfile_audio['bits_per_sample'] = 8;
    10791088                $thisfile_audio['channels']        = 1; // overridden below, if need be
     1089                $ActualBitsPerSample               = 0;
    10801090
    10811091                if (isset($thisfile_riff[$RIFFsubtype]['BODY'][0]['offset'])) {
    … …  
    11151125
    11161126                        default:
    1117                             $this->warning('Unexpected sCompression value in 8SVX.VHDR chunk - expecting 0 or 1, found "'.sCompression.'"');
     1127                            $this->warning('Unexpected sCompression value in 8SVX.VHDR chunk - expecting 0 or 1, found "'.$thisfile_riff_RIFFsubtype_VHDR_0['sCompression'].'"');
    11181128                            break;
    11191129                    }
    … …  
    11601170
    11611171                    $getid3_temp = new getID3();
    1162                     $getid3_temp->openfile($this->getid3->filename);
     1172                    $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    11631173                    $getid3_mpeg = new getid3_mpeg($getid3_temp);
    11641174                    $getid3_mpeg->Analyze();
    … …  
    12461256
    12471257                    $getid3_temp = new getID3();
    1248                     $getid3_temp->openfile($this->getid3->filename);
     1258                    $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    12491259                    $getid3_id3v2 = new getid3_id3v2($getid3_temp);
    12501260                    $getid3_id3v2->StartingOffset = $thisfile_riff[$RIFFsubtype]['id3 '][0]['offset'] + 8;
    … …  
    13731383    }
    13741384
     1385    /**
     1386     * @param int $startoffset
     1387     * @param int $maxoffset
     1388     *
     1389     * @return array|false
     1390     *
     1391     * @throws Exception
     1392     * @throws getid3_exception
     1393     */
    13751394    public function ParseRIFFAMV($startoffset, $maxoffset) {
    13761395        // AMV files are RIFF-AVI files with parts of the spec deliberately broken, such as chunk size fields hardcoded to zero (because players known in hardware that these fields are always a certain size
    … …  
    14811500    }
    14821501
    1483 
     1502    /**
     1503     * @param int $startoffset
     1504     * @param int $maxoffset
     1505     *
     1506     * @return array|false
     1507     * @throws getid3_exception
     1508     */
    14841509    public function ParseRIFF($startoffset, $maxoffset) {
    14851510        $info = &$this->getid3->info;
    … …  
    15301555                                        if (getid3_mp3::MPEGaudioHeaderBytesValid($FirstFourBytes)) {
    15311556                                            $getid3_temp = new getID3();
    1532                                             $getid3_temp->openfile($this->getid3->filename);
     1557                                            $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    15331558                                            $getid3_temp->info['avdataoffset'] = $this->ftell() - 4;
    15341559                                            $getid3_temp->info['avdataend']    = $this->ftell() + $AudioChunkSize;
    … …  
    15521577                                        // AC3
    15531578                                        $getid3_temp = new getID3();
    1554                                         $getid3_temp->openfile($this->getid3->filename);
     1579                                        $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    15551580                                        $getid3_temp->info['avdataoffset'] = $this->ftell() - 4;
    15561581                                        $getid3_temp->info['avdataend']    = $this->ftell() + $AudioChunkSize;
    … …  
    16131638                                    if (getid3_mp3::MPEGaudioHeaderBytesValid(substr($testData, 0, 4))) {
    16141639                                        $getid3_temp = new getID3();
    1615                                         $getid3_temp->openfile($this->getid3->filename);
     1640                                        $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    16161641                                        $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
    16171642                                        $getid3_temp->info['avdataend']    = $info['avdataend'];
    … …  
    16301655                                    $getid3_temp = new getID3();
    16311656                                    if ($isRegularAC3) {
    1632                                         $getid3_temp->openfile($this->getid3->filename);
     1657                                        $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    16331658                                        $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
    16341659                                        $getid3_temp->info['avdataend']    = $info['avdataend'];
    … …  
    16641689                                    // This is probably DTS data
    16651690                                    $getid3_temp = new getID3();
    1666                                     $getid3_temp->openfile($this->getid3->filename);
     1691                                    $getid3_temp->openfile($this->getid3->filename, null, $this->getid3->fp);
    16671692                                    $getid3_temp->info['avdataoffset'] = $info['avdataoffset'];
    16681693                                    $getid3_dts = new getid3_dts($getid3_temp);
    … …  
    17321757                            //  break;
    17331758
     1759                            case 'scot':
     1760                                // https://cmsdk.com/node-js/adding-scot-chunk-to-wav-file.html
     1761                                $RIFFchunk[$chunkname][$thisindex]['data'] = $this->fread($chunksize);
     1762                                $RIFFchunk[$chunkname][$thisindex]['parsed']['alter']           =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],   0,   1);
     1763                                $RIFFchunk[$chunkname][$thisindex]['parsed']['attrib']          =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],   1,   1);
     1764                                $RIFFchunk[$chunkname][$thisindex]['parsed']['artnum']          = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],   2,   2));
     1765                                $RIFFchunk[$chunkname][$thisindex]['parsed']['title']           =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],   4,  43);  // "name" in other documentation
     1766                                $RIFFchunk[$chunkname][$thisindex]['parsed']['copy']            =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  47,   4);
     1767                                $RIFFchunk[$chunkname][$thisindex]['parsed']['padd']            =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  51,   1);
     1768                                $RIFFchunk[$chunkname][$thisindex]['parsed']['asclen']          =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  52,   5);
     1769                                $RIFFchunk[$chunkname][$thisindex]['parsed']['startseconds']    = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  57,   2));
     1770                                $RIFFchunk[$chunkname][$thisindex]['parsed']['starthundredths'] = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  59,   2));
     1771                                $RIFFchunk[$chunkname][$thisindex]['parsed']['endseconds']      = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  61,   2));
     1772                                $RIFFchunk[$chunkname][$thisindex]['parsed']['endhundreths']    = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  63,   2));
     1773                                $RIFFchunk[$chunkname][$thisindex]['parsed']['sdate']           =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  65,   6);
     1774                                $RIFFchunk[$chunkname][$thisindex]['parsed']['kdate']           =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  71,   6);
     1775                                $RIFFchunk[$chunkname][$thisindex]['parsed']['start_hr']        =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  77,   1);
     1776                                $RIFFchunk[$chunkname][$thisindex]['parsed']['kill_hr']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  78,   1);
     1777                                $RIFFchunk[$chunkname][$thisindex]['parsed']['digital']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  79,   1);
     1778                                $RIFFchunk[$chunkname][$thisindex]['parsed']['sample_rate']     = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  80,   2));
     1779                                $RIFFchunk[$chunkname][$thisindex]['parsed']['stereo']          =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  82,   1);
     1780                                $RIFFchunk[$chunkname][$thisindex]['parsed']['compress']        =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  83,   1);
     1781                                $RIFFchunk[$chunkname][$thisindex]['parsed']['eomstrt']         = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  84,   4));
     1782                                $RIFFchunk[$chunkname][$thisindex]['parsed']['eomlen']          = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  88,   2));
     1783                                $RIFFchunk[$chunkname][$thisindex]['parsed']['attrib2']         = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'],  90,   4));
     1784                                $RIFFchunk[$chunkname][$thisindex]['parsed']['future1']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'],  94,  12);
     1785                                $RIFFchunk[$chunkname][$thisindex]['parsed']['catfontcolor']    = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 106,   4));
     1786                                $RIFFchunk[$chunkname][$thisindex]['parsed']['catcolor']        = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 110,   4));
     1787                                $RIFFchunk[$chunkname][$thisindex]['parsed']['segeompos']       = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 114,   4));
     1788                                $RIFFchunk[$chunkname][$thisindex]['parsed']['vt_startsecs']    = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 118,   2));
     1789                                $RIFFchunk[$chunkname][$thisindex]['parsed']['vt_starthunds']   = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 120,   2));
     1790                                $RIFFchunk[$chunkname][$thisindex]['parsed']['priorcat']        =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 122,   3);
     1791                                $RIFFchunk[$chunkname][$thisindex]['parsed']['priorcopy']       =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 125,   4);
     1792                                $RIFFchunk[$chunkname][$thisindex]['parsed']['priorpadd']       =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 129,   1);
     1793                                $RIFFchunk[$chunkname][$thisindex]['parsed']['postcat']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 130,   3);
     1794                                $RIFFchunk[$chunkname][$thisindex]['parsed']['postcopy']        =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 133,   4);
     1795                                $RIFFchunk[$chunkname][$thisindex]['parsed']['postpadd']        =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 137,   1);
     1796                                $RIFFchunk[$chunkname][$thisindex]['parsed']['hrcanplay']       =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 138,  21);
     1797                                $RIFFchunk[$chunkname][$thisindex]['parsed']['future2']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 159, 108);
     1798                                $RIFFchunk[$chunkname][$thisindex]['parsed']['artist']          =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 267,  34);
     1799                                $RIFFchunk[$chunkname][$thisindex]['parsed']['comment']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 301,  34); // "trivia" in other documentation
     1800                                $RIFFchunk[$chunkname][$thisindex]['parsed']['intro']           =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 335,   2);
     1801                                $RIFFchunk[$chunkname][$thisindex]['parsed']['end']             =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 337,   1);
     1802                                $RIFFchunk[$chunkname][$thisindex]['parsed']['year']            =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 338,   4);
     1803                                $RIFFchunk[$chunkname][$thisindex]['parsed']['obsolete2']       =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 342,   1);
     1804                                $RIFFchunk[$chunkname][$thisindex]['parsed']['rec_hr']          =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 343,   1);
     1805                                $RIFFchunk[$chunkname][$thisindex]['parsed']['rdate']           =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 344,   6);
     1806                                $RIFFchunk[$chunkname][$thisindex]['parsed']['mpeg_bitrate']    = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 350,   2));
     1807                                $RIFFchunk[$chunkname][$thisindex]['parsed']['pitch']           = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 352,   2));
     1808                                $RIFFchunk[$chunkname][$thisindex]['parsed']['playlevel']       = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 354,   2));
     1809                                $RIFFchunk[$chunkname][$thisindex]['parsed']['lenvalid']        =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 356,   1);
     1810                                $RIFFchunk[$chunkname][$thisindex]['parsed']['filelength']      = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 357,   4));
     1811                                $RIFFchunk[$chunkname][$thisindex]['parsed']['newplaylevel']    = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 361,   2));
     1812                                $RIFFchunk[$chunkname][$thisindex]['parsed']['chopsize']        = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 363,   4));
     1813                                $RIFFchunk[$chunkname][$thisindex]['parsed']['vteomovr']        = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 367,   4));
     1814                                $RIFFchunk[$chunkname][$thisindex]['parsed']['desiredlen']      = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 371,   4));
     1815                                $RIFFchunk[$chunkname][$thisindex]['parsed']['triggers']        = getid3_lib::LittleEndian2Int(substr($RIFFchunk[$chunkname][$thisindex]['data'], 375,   4));
     1816                                $RIFFchunk[$chunkname][$thisindex]['parsed']['fillout']         =                              substr($RIFFchunk[$chunkname][$thisindex]['data'], 379,   33);
     1817
     1818                                foreach (array('title', 'artist', 'comment') as $key) {
     1819                                    if (trim($RIFFchunk[$chunkname][$thisindex]['parsed'][$key])) {
     1820                                        $info['riff']['comments'][$key] = array($RIFFchunk[$chunkname][$thisindex]['parsed'][$key]);
     1821                                    }
     1822                                }
     1823                                if ($RIFFchunk[$chunkname][$thisindex]['parsed']['filelength'] && !empty($info['filesize']) && ($RIFFchunk[$chunkname][$thisindex]['parsed']['filelength'] != $info['filesize'])) {
     1824                                    $this->warning('RIFF.WAVE.scot.filelength ('.$RIFFchunk[$chunkname][$thisindex]['parsed']['filelength'].') different from actual filesize ('.$info['filesize'].')');
     1825                                }
     1826                                break;
     1827
    17341828                            default:
    1735                                 if (!empty($LISTchunkParent) && (($RIFFchunk[$chunkname][$thisindex]['offset'] + $RIFFchunk[$chunkname][$thisindex]['size']) <= $LISTchunkMaxOffset)) {
     1829                                if (!empty($LISTchunkParent) && isset($LISTchunkMaxOffset) && (($RIFFchunk[$chunkname][$thisindex]['offset'] + $RIFFchunk[$chunkname][$thisindex]['size']) <= $LISTchunkMaxOffset)) {
    17361830                                    $RIFFchunk[$LISTchunkParent][$chunkname][$thisindex]['offset'] = $RIFFchunk[$chunkname][$thisindex]['offset'];
    17371831                                    $RIFFchunk[$LISTchunkParent][$chunkname][$thisindex]['size']   = $RIFFchunk[$chunkname][$thisindex]['size'];
    … …  
    17681862    }
    17691863
     1864    /**
     1865     * @param string $RIFFdata
     1866     *
     1867     * @return bool
     1868     */
    17701869    public function ParseRIFFdata(&$RIFFdata) {
    17711870        $info = &$this->getid3->info;
    … …  
    18051904    }
    18061905
     1906    /**
     1907     * @param array $RIFFinfoArray
     1908     * @param array $CommentsTargetArray
     1909     *
     1910     * @return bool
     1911     */
    18071912    public static function parseComments(&$RIFFinfoArray, &$CommentsTargetArray) {
    18081913        $RIFFinfoKeyLookup = array(
    … …  
    18641969    }
    18651970
     1971    /**
     1972     * @param string $WaveFormatExData
     1973     *
     1974     * @return array
     1975     */
    18661976    public static function parseWAVEFORMATex($WaveFormatExData) {
    18671977        // shortcut
     1978        $WaveFormatEx        = array();
    18681979        $WaveFormatEx['raw'] = array();
    18691980        $WaveFormatEx_raw    = &$WaveFormatEx['raw'];
    … …  
    18892000    }
    18902001
     2002    /**
     2003     * @param string $WavPackChunkData
     2004     *
     2005     * @return bool
     2006     */
    18912007    public function parseWavPackHeader($WavPackChunkData) {
    18922008        // typedef struct {
    … …  
    19502066    }
    19512067
     2068    /**
     2069     * @param string $BITMAPINFOHEADER
     2070     * @param bool   $littleEndian
     2071     *
     2072     * @return array
     2073     */
    19522074    public static function ParseBITMAPINFOHEADER($BITMAPINFOHEADER, $littleEndian=true) {
    19532075
    … …  
    19692091    }
    19702092
     2093    /**
     2094     * @param string $DIVXTAG
     2095     * @param bool   $raw
     2096     *
     2097     * @return array
     2098     */
    19712099    public static function ParseDIVXTAG($DIVXTAG, $raw=false) {
    19722100        // structure from "IDivX" source, Form1.frm, by "Greg Frazier of Daemonic Software Group", email: gfrazier@icestorm.net, web: http://dsg.cjb.net/
    … …  
    20152143        );
    20162144
     2145        $parsed              = array();
    20172146        $parsed['title']     =        trim(substr($DIVXTAG,   0, 32));
    20182147        $parsed['artist']    =        trim(substr($DIVXTAG,  32, 28));
    … …  
    20302159            unset($parsed['genre_id'], $parsed['rating_id']);
    20312160            foreach ($parsed as $key => $value) {
    2032                 if (!$value === '') {
    2033                     unset($parsed['key']);
     2161                if (empty($value)) {
     2162                    unset($parsed[$key]);
    20342163                }
    20352164            }
    … …  
    20432172    }
    20442173
     2174    /**
     2175     * @param string $tagshortname
     2176     *
     2177     * @return string
     2178     */
    20452179    public static function waveSNDMtagLookup($tagshortname) {
    20462180        $begin = __LINE__;
    … …  
    20662200    }
    20672201
     2202    /**
     2203     * @param int $wFormatTag
     2204     *
     2205     * @return string
     2206     */
    20682207    public static function wFormatTagLookup($wFormatTag) {
    20692208
    … …  
    22352374    }
    22362375
     2376    /**
     2377     * @param string $fourcc
     2378     *
     2379     * @return string
     2380     */
    22372381    public static function fourccLookup($fourcc) {
    22382382
    … …  
    26292773    }
    26302774
     2775    /**
     2776     * @param string $byteword
     2777     * @param bool   $signed
     2778     *
     2779     * @return int|float|false
     2780     */
    26312781    private function EitherEndian2Int($byteword, $signed=false) {
    26322782        if ($this->container == 'riff') {

  • trunk/src/wp-includes/ID3/module.audio.ac3.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    1818class getid3_ac3 extends getid3_handler
    1919{
    20     private $AC3header = array();
    21     private $BSIoffset = 0;
    22 
    23     const syncword = 0x0B77;
    24 
     20    /**
     21     * @var array
     22     */
     23    private $AC3header = array();
     24
     25    /**
     26     * @var int
     27     */
     28    private $BSIoffset = 0;
     29
     30    const syncword = 0x0B77;
     31
     32    /**
     33     * @return bool
     34     */
    2535    public function Analyze() {
    2636        $info = &$this->getid3->info;
    … …  
    188198
    189199
    190 $this->error('E-AC3 parsing is incomplete and experimental in this version of getID3 ('.$this->getid3->version().'). Notably the bitrate calculations are wrong -- value might (or not) be correct, but it is not calculated correctly. Email info@getid3.org if you know how to calculate EAC3 bitrate correctly.');
     200            $this->error('E-AC3 parsing is incomplete and experimental in this version of getID3 ('.$this->getid3->version().'). Notably the bitrate calculations are wrong -- value might (or not) be correct, but it is not calculated correctly. Email info@getid3.org if you know how to calculate EAC3 bitrate correctly.');
    191201            $info['audio']['dataformat'] = 'eac3';
    192202
    … …  
    413423
    414424            $this->error('Bit stream identification is version '.$thisfile_ac3_raw_bsi['bsid'].', but getID3() only understands up to version 16. Please submit a support ticket with a sample file.');
    415             unset($info['ac3']);
     425            unset($info['ac3']);
    416426            return false;
    417427
    … …  
    432442            $thisfile_ac3['bitrate']      = self::bitrateLookup($thisfile_ac3_raw_bsi['frmsizecod']);
    433443        } elseif (!empty($thisfile_ac3_raw_bsi['frmsiz'])) {
    434 // this isn't right, but it's (usually) close, roughly 5% less than it should be.
    435 // but WHERE is the actual bitrate value stored in EAC3?? email info@getid3.org if you know!
     444            // this isn't right, but it's (usually) close, roughly 5% less than it should be.
     445            // but WHERE is the actual bitrate value stored in EAC3?? email info@getid3.org if you know!
    436446            $thisfile_ac3['bitrate']      = ($thisfile_ac3_raw_bsi['frmsiz'] + 1) * 16 * 30; // The frmsiz field shall contain a value one less than the overall size of the coded syncframe in 16-bit words. That is, this field may assume a value ranging from 0 to 2047, and these values correspond to syncframe sizes ranging from 1 to 2048.
    437 // kludge-fix to make it approximately the expected value, still not "right":
    438 $thisfile_ac3['bitrate'] = round(($thisfile_ac3['bitrate'] * 1.05) / 16000) * 16000;
     447            // kludge-fix to make it approximately the expected value, still not "right":
     448            $thisfile_ac3['bitrate'] = round(($thisfile_ac3['bitrate'] * 1.05) / 16000) * 16000;
    439449        }
    440450        $info['audio']['bitrate'] = $thisfile_ac3['bitrate'];
    441451
    442         $thisfile_ac3['service_type'] = self::serviceTypeLookup($thisfile_ac3_raw_bsi['bsmod'], $thisfile_ac3_raw_bsi['acmod']);
     452        if (isset($thisfile_ac3_raw_bsi['bsmod']) && isset($thisfile_ac3_raw_bsi['acmod'])) {
     453            $thisfile_ac3['service_type'] = self::serviceTypeLookup($thisfile_ac3_raw_bsi['bsmod'], $thisfile_ac3_raw_bsi['acmod']);
     454        }
    443455        $ac3_coding_mode = self::audioCodingModeLookup($thisfile_ac3_raw_bsi['acmod']);
    444456        foreach($ac3_coding_mode as $key => $value) {
    … …  
    471483    }
    472484
     485    /**
     486     * @param int $length
     487     *
     488     * @return float|int
     489     */
    473490    private function readHeaderBSI($length) {
    474491        $data = substr($this->AC3header['bsi'], $this->BSIoffset, $length);
    … …  
    478495    }
    479496
     497    /**
     498     * @param int $fscod
     499     *
     500     * @return int|string|false
     501     */
    480502    public static function sampleRateCodeLookup($fscod) {
    481503        static $sampleRateCodeLookup = array(
    … …  
    488510    }
    489511
     512    /**
     513     * @param int $fscod2
     514     *
     515     * @return int|string|false
     516     */
    490517    public static function sampleRateCodeLookup2($fscod2) {
    491518        static $sampleRateCodeLookup2 = array(
    … …  
    498525    }
    499526
     527    /**
     528     * @param int $bsmod
     529     * @param int $acmod
     530     *
     531     * @return string|false
     532     */
    500533    public static function serviceTypeLookup($bsmod, $acmod) {
    501534        static $serviceTypeLookup = array();
    … …  
    519552    }
    520553
     554    /**
     555     * @param int $acmod
     556     *
     557     * @return array|false
     558     */
    521559    public static function audioCodingModeLookup($acmod) {
    522560        // array(channel configuration, # channels (not incl LFE), channel order)
    … …  
    534572    }
    535573
     574    /**
     575     * @param int $cmixlev
     576     *
     577     * @return int|float|string|false
     578     */
    536579    public static function centerMixLevelLookup($cmixlev) {
    537580        static $centerMixLevelLookup;
    … …  
    547590    }
    548591
     592    /**
     593     * @param int $surmixlev
     594     *
     595     * @return int|float|string|false
     596     */
    549597    public static function surroundMixLevelLookup($surmixlev) {
    550598        static $surroundMixLevelLookup;
    … …  
    560608    }
    561609
     610    /**
     611     * @param int $dsurmod
     612     *
     613     * @return string|false
     614     */
    562615    public static function dolbySurroundModeLookup($dsurmod) {
    563616        static $dolbySurroundModeLookup = array(
    … …  
    570623    }
    571624
     625    /**
     626     * @param int  $acmod
     627     * @param bool $lfeon
     628     *
     629     * @return array
     630     */
    572631    public static function channelsEnabledLookup($acmod, $lfeon) {
    573632        $lookup = array(
    574             'ch1'=>(bool) ($acmod == 0),
    575             'ch2'=>(bool) ($acmod == 0),
    576             'left'=>(bool) ($acmod > 1),
    577             'right'=>(bool) ($acmod > 1),
     633            'ch1'=>($acmod == 0),
     634            'ch2'=>($acmod == 0),
     635            'left'=>($acmod > 1),
     636            'right'=>($acmod > 1),
    578637            'center'=>(bool) ($acmod & 0x01),
    579638            'surround_mono'=>false,
    … …  
    595654    }
    596655
     656    /**
     657     * @param int $compre
     658     *
     659     * @return float|int
     660     */
    597661    public static function heavyCompression($compre) {
    598662        // The first four bits indicate gain changes in 6.02dB increments which can be
    … …  
    624688
    625689        $fourbit = str_pad(decbin(($compre & 0xF0) >> 4), 4, '0', STR_PAD_LEFT);
    626         if ($fourbit{0} == '1') {
     690        if ($fourbit[0] == '1') {
    627691            $log_gain = -8 + bindec(substr($fourbit, 1));
    628692        } else {
    … …  
    645709    }
    646710
     711    /**
     712     * @param int $roomtyp
     713     *
     714     * @return string|false
     715     */
    647716    public static function roomTypeLookup($roomtyp) {
    648717        static $roomTypeLookup = array(
    … …  
    655724    }
    656725
     726    /**
     727     * @param int $frmsizecod
     728     * @param int $fscod
     729     *
     730     * @return int|false
     731     */
    657732    public static function frameSizeLookup($frmsizecod, $fscod) {
    658733        // LSB is whether padding is used or not
    … …  
    684759            );
    685760        }
     761        $paddingBytes = 0;
    686762        if (($fscod == 1) && $padding) {
    687763            // frame lengths are padded by 1 word (16 bits) at 44100
    688             $frameSizeLookup[$frmsizecod] += 2;
    689         }
    690         return (isset($frameSizeLookup[$framesizeid][$fscod]) ? $frameSizeLookup[$framesizeid][$fscod] : false);
    691     }
    692 
     764            // (fscode==1) means 44100Hz (see sampleRateCodeLookup)
     765            $paddingBytes = 2;
     766        }
     767        return (isset($frameSizeLookup[$framesizeid][$fscod]) ? $frameSizeLookup[$framesizeid][$fscod] + $paddingBytes : false);
     768    }
     769
     770    /**
     771     * @param int $frmsizecod
     772     *
     773     * @return int|false
     774     */
    693775    public static function bitrateLookup($frmsizecod) {
    694776        // LSB is whether padding is used or not
    … …  
    720802    }
    721803
     804    /**
     805     * @param int $numblkscod
     806     *
     807     * @return int|false
     808     */
    722809    public static function blocksPerSyncFrame($numblkscod) {
    723810        static $blocksPerSyncFrameLookup = array(

  • trunk/src/wp-includes/ID3/module.audio.dts.php

    r32979 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    2222{
    2323    /**
    24     * Default DTS syncword used in native .cpt or .dts formats
    25     */
    26     const syncword = "\x7F\xFE\x80\x01";
    27 
     24     * Default DTS syncword used in native .cpt or .dts formats.
     25     */
     26    const syncword = "\x7F\xFE\x80\x01";
     27
     28    /**
     29     * @var int
     30     */
    2831    private $readBinDataOffset = 0;
    2932
    30     /**
    31     * Possible syncwords indicating bitstream encoding
    32     */
    33     public static $syncwords = array(
    34         0 => "\x7F\xFE\x80\x01",  // raw big-endian
    35         1 => "\xFE\x7F\x01\x80",  // raw little-endian
    36         2 => "\x1F\xFF\xE8\x00",  // 14-bit big-endian
    37         3 => "\xFF\x1F\x00\xE8"); // 14-bit little-endian
    38 
     33    /**
     34     * Possible syncwords indicating bitstream encoding.
     35     */
     36    public static $syncwords = array(
     37        0 => "\x7F\xFE\x80\x01",  // raw big-endian
     38        1 => "\xFE\x7F\x01\x80",  // raw little-endian
     39        2 => "\x1F\xFF\xE8\x00",  // 14-bit big-endian
     40        3 => "\xFF\x1F\x00\xE8"); // 14-bit little-endian
     41
     42    /**
     43     * @return bool
     44     */
    3945    public function Analyze() {
    4046        $info = &$this->getid3->info;
    … …  
    4652        // check syncword
    4753        $sync = substr($DTSheader, 0, 4);
    48         if (($encoding = array_search($sync, self::$syncwords)) !== false) {
    49 
    50             $info['dts']['raw']['magic'] = $sync;
     54        if (($encoding = array_search($sync, self::$syncwords)) !== false) {
     55
     56            $info['dts']['raw']['magic'] = $sync;
    5157            $this->readBinDataOffset = 32;
    5258
    53         } elseif ($this->isDependencyFor('matroska')) {
     59        } elseif ($this->isDependencyFor('matroska')) {
    5460
    5561            // Matroska contains DTS without syncword encoded as raw big-endian format
    … …  
    5763            $this->readBinDataOffset = 0;
    5864
    59         } else {
     65        } else {
    6066
    6167            unset($info['fileformat']);
    … …  
    140146    }
    141147
     148    /**
     149     * @param string $bin
     150     * @param int $length
     151     *
     152     * @return float|int
     153     */
    142154    private function readBinData($bin, $length) {
    143155        $data = substr($bin, $this->readBinDataOffset, $length);
    … …  
    147159    }
    148160
     161    /**
     162     * @param int $index
     163     *
     164     * @return int|string|false
     165     */
    149166    public static function bitrateLookup($index) {
    150167        static $lookup = array(
    … …  
    185202    }
    186203
     204    /**
     205     * @param int $index
     206     *
     207     * @return int|string|false
     208     */
    187209    public static function sampleRateLookup($index) {
    188210        static $lookup = array(
    … …  
    207229    }
    208230
     231    /**
     232     * @param int $index
     233     *
     234     * @return int|false
     235     */
    209236    public static function bitPerSampleLookup($index) {
    210237        static $lookup = array(
    … …  
    217244    }
    218245
     246    /**
     247     * @param int $index
     248     *
     249     * @return int|false
     250     */
    219251    public static function numChannelsLookup($index) {
    220252        switch ($index) {
    … …  
    255287    }
    256288
     289    /**
     290     * @param int $index
     291     *
     292     * @return string
     293     */
    257294    public static function channelArrangementLookup($index) {
    258295        static $lookup = array(
    … …  
    277314    }
    278315
     316    /**
     317     * @param int $index
     318     * @param int $version
     319     *
     320     * @return int|false
     321     */
    279322    public static function dialogNormalization($index, $version) {
    280323        switch ($version) {

  • trunk/src/wp-includes/ID3/module.audio.flac.php

    r32979 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    2525    const syncword = 'fLaC';
    2626
     27    /**
     28     * @return bool
     29     */
    2730    public function Analyze() {
    2831        $info = &$this->getid3->info;
    … …  
    4245    }
    4346
     47    /**
     48     * @return bool
     49     */
    4450    public function parseMETAdata() {
    4551        $info = &$this->getid3->info;
    … …  
    4753            $BlockOffset   = $this->ftell();
    4854            $BlockHeader   = $this->fread(4);
    49             $LBFBT         = getid3_lib::BigEndian2Int(substr($BlockHeader, 0, 1));
     55            $LBFBT         = getid3_lib::BigEndian2Int(substr($BlockHeader, 0, 1));  // LBFBT = LastBlockFlag + BlockType
    5056            $LastBlockFlag = (bool) ($LBFBT & 0x80);
    5157            $BlockType     =        ($LBFBT & 0x7F);
    … …  
    5460
    5561            if (($BlockOffset + 4 + $BlockLength) > $info['avdataend']) {
    56                 $this->error('METADATA_BLOCK_HEADER.BLOCK_TYPE ('.$BlockTypeText.') at offset '.$BlockOffset.' extends beyond end of file');
     62                $this->warning('METADATA_BLOCK_HEADER.BLOCK_TYPE ('.$BlockTypeText.') at offset '.$BlockOffset.' extends beyond end of file');
    5763                break;
    5864            }
    5965            if ($BlockLength < 1) {
     66                if ($BlockTypeText != 'reserved') {
     67                    // probably supposed to be zero-length
     68                    $this->warning('METADATA_BLOCK_HEADER.BLOCK_LENGTH ('.$BlockTypeText.') at offset '.$BlockOffset.' is zero bytes');
     69                    continue;
     70                }
    6071                $this->error('METADATA_BLOCK_HEADER.BLOCK_LENGTH ('.$BlockLength.') at offset '.$BlockOffset.' is invalid');
    6172                break;
    … …  
    168179
    169180            if ($info['flac']['STREAMINFO']['audio_signature'] === str_repeat("\x00", 16)) {
    170                 $this->warning('FLAC STREAMINFO.audio_signature is null (known issue with libOggFLAC)');
     181                $this->warning('FLAC STREAMINFO.audio_signature is null (known issue with libOggFLAC)');
    171182            }
    172183            else {
    … …  
    195206    }
    196207
    197     private function parseSTREAMINFO($BlockData) {
    198         $info = &$this->getid3->info;
    199 
    200         $info['flac']['STREAMINFO'] = array();
    201         $streaminfo = &$info['flac']['STREAMINFO'];
    202 
     208
     209    /**
     210     * @param string $BlockData
     211     *
     212     * @return array
     213     */
     214    public static function parseSTREAMINFOdata($BlockData) {
     215        $streaminfo = array();
    203216        $streaminfo['min_block_size']  = getid3_lib::BigEndian2Int(substr($BlockData, 0, 2));
    204217        $streaminfo['max_block_size']  = getid3_lib::BigEndian2Int(substr($BlockData, 2, 2));
    … …  
    212225        $streaminfo['samples_stream']  = getid3_lib::Bin2Dec(substr($SRCSBSS, 28, 36));
    213226
    214         $streaminfo['audio_signature'] = substr($BlockData, 18, 16);
    215 
    216         if (!empty($streaminfo['sample_rate'])) {
     227        $streaminfo['audio_signature'] =                           substr($BlockData, 18, 16);
     228
     229        return $streaminfo;
     230    }
     231
     232    /**
     233     * @param string $BlockData
     234     *
     235     * @return bool
     236     */
     237    private function parseSTREAMINFO($BlockData) {
     238        $info = &$this->getid3->info;
     239
     240        $info['flac']['STREAMINFO'] = self::parseSTREAMINFOdata($BlockData);
     241
     242        if (!empty($info['flac']['STREAMINFO']['sample_rate'])) {
    217243
    218244            $info['audio']['bitrate_mode']    = 'vbr';
    219             $info['audio']['sample_rate']     = $streaminfo['sample_rate'];
    220             $info['audio']['channels']        = $streaminfo['channels'];
    221             $info['audio']['bits_per_sample'] = $streaminfo['bits_per_sample'];
    222             $info['playtime_seconds']         = $streaminfo['samples_stream'] / $streaminfo['sample_rate'];
     245            $info['audio']['sample_rate']     = $info['flac']['STREAMINFO']['sample_rate'];
     246            $info['audio']['channels']        = $info['flac']['STREAMINFO']['channels'];
     247            $info['audio']['bits_per_sample'] = $info['flac']['STREAMINFO']['bits_per_sample'];
     248            $info['playtime_seconds']         = $info['flac']['STREAMINFO']['samples_stream'] / $info['flac']['STREAMINFO']['sample_rate'];
    223249            if ($info['playtime_seconds'] > 0) {
    224250                if (!$this->isDependencyFor('matroska')) {
    … …  
    237263    }
    238264
     265    /**
     266     * @param string $BlockData
     267     *
     268     * @return bool
     269     */
    239270    private function parseAPPLICATION($BlockData) {
    240271        $info = &$this->getid3->info;
    … …  
    247278    }
    248279
     280    /**
     281     * @param string $BlockData
     282     *
     283     * @return bool
     284     */
    249285    private function parseSEEKTABLE($BlockData) {
    250286        $info = &$this->getid3->info;
    … …  
    276312    }
    277313
     314    /**
     315     * @param string $BlockData
     316     *
     317     * @return bool
     318     */
    278319    private function parseVORBIS_COMMENT($BlockData) {
    279320        $info = &$this->getid3->info;
    … …  
    295336    }
    296337
     338    /**
     339     * @param string $BlockData
     340     *
     341     * @return bool
     342     */
    297343    private function parseCUESHEET($BlockData) {
    298344        $info = &$this->getid3->info;
    … …  
    347393
    348394    /**
    349     * Parse METADATA_BLOCK_PICTURE flac structure and extract attachment
    350     * External usage: audio.ogg
    351     */
     395     * Parse METADATA_BLOCK_PICTURE flac structure and extract attachment
     396     * External usage: audio.ogg
     397     *
     398     * @return bool
     399     */
    352400    public function parsePICTURE() {
    353401        $info = &$this->getid3->info;
    … …  
    381429    }
    382430
     431    /**
     432     * @param int $blocktype
     433     *
     434     * @return string
     435     */
    383436    public static function metaBlockTypeLookup($blocktype) {
    384437        static $lookup = array(
    … …  
    394447    }
    395448
     449    /**
     450     * @param int $applicationid
     451     *
     452     * @return string
     453     */
    396454    public static function applicationIDLookup($applicationid) {
    397455        // http://flac.sourceforge.net/id.html
    … …  
    424482    }
    425483
     484    /**
     485     * @param int $type_id
     486     *
     487     * @return string
     488     */
    426489    public static function pictureTypeLookup($type_id) {
    427490        static $lookup = array (

  • trunk/src/wp-includes/ID3/module.audio.mp3.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    2525class getid3_mp3 extends getid3_handler
    2626{
    27 
    28     public $allow_bruteforce = false; // forces getID3() to scan the file byte-by-byte and log all the valid audio frame headers - extremely slow, unrecommended, but may provide data from otherwise-unusuable files
    29 
     27    /**
     28     * Forces getID3() to scan the file byte-by-byte and log all the valid audio frame headers - extremely slow,
     29     * unrecommended, but may provide data from otherwise-unusable files.
     30     *
     31     * @var bool
     32     */
     33    public $allow_bruteforce = false;
     34
     35    /**
     36     * @return bool
     37     */
    3038    public function Analyze() {
    3139        $info = &$this->getid3->info;
    … …  
    3644            if ($this->allow_bruteforce) {
    3745                $this->error('Rescanning file in BruteForce mode');
    38                 $this->getOnlyMPEGaudioInfoBruteForce($this->getid3->fp, $info);
     46                $this->getOnlyMPEGaudioInfoBruteForce();
    3947            }
    4048        }
    … …  
    153161        // Calculate playtime
    154162        if (!isset($info['playtime_seconds']) && isset($info['audio']['bitrate']) && ($info['audio']['bitrate'] > 0)) {
    155             $info['playtime_seconds'] = ($info['avdataend'] - $info['avdataoffset']) * 8 / $info['audio']['bitrate'];
     163            // https://github.com/JamesHeinrich/getID3/issues/161
     164            // VBR header frame contains ~0.026s of silent audio data, but is not actually part of the original encoding and should be ignored
     165            $xingVBRheaderFrameLength = ((isset($info['mpeg']['audio']['VBR_frames']) && isset($info['mpeg']['audio']['framelength'])) ? $info['mpeg']['audio']['framelength'] : 0);
     166
     167            $info['playtime_seconds'] = ($info['avdataend'] - $info['avdataoffset'] - $xingVBRheaderFrameLength) * 8 / $info['audio']['bitrate'];
    156168        }
    157169
    … …  
    161173    }
    162174
    163 
     175    /**
     176     * @return string
     177     */
    164178    public function GuessEncoderOptions() {
    165179        // shortcuts
    166180        $info = &$this->getid3->info;
     181        $thisfile_mpeg_audio = array();
     182        $thisfile_mpeg_audio_lame = array();
    167183        if (!empty($info['mpeg']['audio'])) {
    168184            $thisfile_mpeg_audio = &$info['mpeg']['audio'];
    … …  
    179195            $encoder_options = 'VBR q'.$thisfile_mpeg_audio['VBR_quality'];
    180196
    181         } elseif (!empty($thisfile_mpeg_audio_lame['preset_used']) && (!in_array($thisfile_mpeg_audio_lame['preset_used_id'], $NamedPresetBitrates))) {
     197        } elseif (!empty($thisfile_mpeg_audio_lame['preset_used']) && isset($thisfile_mpeg_audio_lame['preset_used_id']) && (!in_array($thisfile_mpeg_audio_lame['preset_used_id'], $NamedPresetBitrates))) {
    182198
    183199            $encoder_options = $thisfile_mpeg_audio_lame['preset_used'];
    … …  
    405421    }
    406422
    407 
     423    /**
     424     * @param int   $offset
     425     * @param array $info
     426     * @param bool  $recursivesearch
     427     * @param bool  $ScanAsCBR
     428     * @param bool  $FastMPEGheaderScan
     429     *
     430     * @return bool
     431     */
    408432    public function decodeMPEGaudioHeader($offset, &$info, $recursivesearch=true, $ScanAsCBR=false, $FastMPEGheaderScan=false) {
    409433        static $MPEGaudioVersionLookup;
    … …  
    459483        $thisfile_mpeg_audio = &$info['mpeg']['audio'];
    460484
    461 
    462485        if ($MPEGaudioHeaderValidCache[$head4_key]) {
    463486            $thisfile_mpeg_audio['raw'] = $MPEGheaderRawArray;
    … …  
    563586            $thisfile_mpeg_audio['bitrate_mode'] = 'vbr';
    564587            $thisfile_mpeg_audio['VBR_method']   = 'Fraunhofer';
    565             $info['audio']['codec']                = 'Fraunhofer';
     588            $info['audio']['codec']              = 'Fraunhofer';
    566589
    567590            $SideInfoData = substr($headerstring, 4 + 2, 32);
    … …  
    656679                    } elseif (!empty($info['filesize'])) {
    657680                        $used_filesize  = $info['filesize'];
    658                         $used_filesize -= intval(@$info['id3v2']['headerlength']);
     681                        $used_filesize -= (isset($info['id3v2']['headerlength']) ? intval($info['id3v2']['headerlength']) : 0);
    659682                        $used_filesize -= (isset($info['id3v1']) ? 128 : 0);
    660683                        $used_filesize -= (isset($info['tag_offset_end']) ? $info['tag_offset_end'] - $info['tag_offset_start'] : 0);
    … …  
    679702                    $LAMEtocData = substr($headerstring, $VBRidOffset + 16, 100);
    680703                    for ($i = 0; $i < 100; $i++) {
    681                         $thisfile_mpeg_audio['toc'][$i] = ord($LAMEtocData{$i});
     704                        $thisfile_mpeg_audio['toc'][$i] = ord($LAMEtocData[$i]);
    682705                    }
    683706                }
    … …  
    10841107    }
    10851108
     1109    /**
     1110     * @param int $offset
     1111     * @param int $nextframetestoffset
     1112     * @param bool $ScanAsCBR
     1113     *
     1114     * @return bool
     1115     */
    10861116    public function RecursiveFrameScanning(&$offset, &$nextframetestoffset, $ScanAsCBR) {
    10871117        $info = &$this->getid3->info;
    … …  
    11301160    }
    11311161
     1162    /**
     1163     * @param int  $offset
     1164     * @param bool $deepscan
     1165     *
     1166     * @return int|false
     1167     */
    11321168    public function FreeFormatFrameLength($offset, $deepscan=false) {
    11331169        $info = &$this->getid3->info;
    … …  
    11381174        $SyncPattern1 = substr($MPEGaudioData, 0, 4);
    11391175        // may be different pattern due to padding
    1140         $SyncPattern2 = $SyncPattern1{0}.$SyncPattern1{1}.chr(ord($SyncPattern1{2}) | 0x02).$SyncPattern1{3};
     1176        $SyncPattern2 = $SyncPattern1[0].$SyncPattern1[1].chr(ord($SyncPattern1[2]) | 0x02).$SyncPattern1[3];
    11411177        if ($SyncPattern2 === $SyncPattern1) {
    1142             $SyncPattern2 = $SyncPattern1{0}.$SyncPattern1{1}.chr(ord($SyncPattern1{2}) & 0xFD).$SyncPattern1{3};
     1178            $SyncPattern2 = $SyncPattern1[0].$SyncPattern1[1].chr(ord($SyncPattern1[2]) & 0xFD).$SyncPattern1[3];
    11431179        }
    11441180
    … …  
    12071243    }
    12081244
     1245    /**
     1246     * @return bool
     1247     */
    12091248    public function getOnlyMPEGaudioInfoBruteForce() {
    12101249        $MPEGaudioHeaderDecodeCache   = array();
    … …  
    12421281                break;
    12431282            }
    1244             if ($head4{0} != "\xFF") {
     1283            if ($head4[0] != "\xFF") {
    12451284                for ($i = 1; $i < 4; $i++) {
    1246                     if ($head4{$i} == "\xFF") {
     1285                    if ($head4[$i] == "\xFF") {
    12471286                        $this->fseek($i - 4, SEEK_CUR);
    12481287                        continue 2;
    … …  
    12761315                    $this->fseek($MPEGaudioHeaderLengthCache[$head4] - 4, SEEK_CUR);
    12771316                    $next4 = $this->fread(4);
    1278                     if ($next4{0} == "\xFF") {
     1317                    if ($next4[0] == "\xFF") {
    12791318                        if (!isset($MPEGaudioHeaderDecodeCache[$next4])) {
    12801319                            $MPEGaudioHeaderDecodeCache[$next4] = self::MPEGaudioHeaderDecode($next4);
    … …  
    13541393    }
    13551394
    1356 
     1395    /**
     1396     * @param int  $avdataoffset
     1397     * @param bool $BitrateHistogram
     1398     *
     1399     * @return bool
     1400     */
    13571401    public function getOnlyMPEGaudioInfo($avdataoffset, $BitrateHistogram=false) {
    13581402        // looks for synch, decodes MPEG audio header
    … …  
    13641408        static $MPEGaudioBitrateLookup;
    13651409        if (empty($MPEGaudioVersionLookup)) {
    1366            $MPEGaudioVersionLookup = self::MPEGaudioVersionArray();
    1367            $MPEGaudioLayerLookup   = self::MPEGaudioLayerArray();
    1368            $MPEGaudioBitrateLookup = self::MPEGaudioBitrateArray();
    1369 
     1410            $MPEGaudioVersionLookup = self::MPEGaudioVersionArray();
     1411            $MPEGaudioLayerLookup   = self::MPEGaudioLayerArray();
     1412            $MPEGaudioBitrateLookup = self::MPEGaudioBitrateArray();
    13701413        }
    13711414
    … …  
    14171460            }
    14181461
    1419             if (($header{$SynchSeekOffset} == "\xFF") && ($header{($SynchSeekOffset + 1)} > "\xE0")) { // synch detected
     1462            if (($header[$SynchSeekOffset] == "\xFF") && ($header[($SynchSeekOffset + 1)] > "\xE0")) { // synch detected
     1463                $FirstFrameAVDataOffset = null;
    14201464                if (!isset($FirstFrameThisfileInfo) && !isset($info['mpeg']['audio'])) {
    14211465                    $FirstFrameThisfileInfo = $info;
    … …  
    14411485                            break;
    14421486                    }
    1443                     if (isset($FirstFrameThisfileInfo['mpeg']['audio']['bitrate_mode']) && ($FirstFrameThisfileInfo['mpeg']['audio']['bitrate_mode'] == 'vbr')) {
     1487                    if (isset($FirstFrameThisfileInfo) && isset($FirstFrameThisfileInfo['mpeg']['audio']['bitrate_mode']) && ($FirstFrameThisfileInfo['mpeg']['audio']['bitrate_mode'] == 'vbr')) {
    14441488                        if (!(abs($info['audio']['bitrate'] - $FirstFrameThisfileInfo['audio']['bitrate']) <= 1)) {
    14451489                            // If there is garbage data between a valid VBR header frame and a sequence
    … …  
    15111555                                $buffer_4k = $this->fread(4096);
    15121556                                for ($j = 0; $j < (strlen($buffer_4k) - 4); $j++) {
    1513                                     if (($buffer_4k{$j} == "\xFF") && ($buffer_4k{($j + 1)} > "\xE0")) { // synch detected
     1557                                    if (($buffer_4k[$j] == "\xFF") && ($buffer_4k[($j + 1)] > "\xE0")) { // synch detected
    15141558                                        if ($this->decodeMPEGaudioHeader($scan_start_offset[$current_segment] + $j, $dummy, false, false, $FastMode)) {
    15151559                                            $calculated_next_offset = $scan_start_offset[$current_segment] + $j + $dummy['mpeg']['audio']['framelength'];
    … …  
    15231567                            }
    15241568                            $synchstartoffset = $scan_start_offset[$current_segment];
    1525                             while ($this->decodeMPEGaudioHeader($synchstartoffset, $dummy, false, false, $FastMode)) {
     1569                            while (($synchstartoffset < $info['avdataend']) && $this->decodeMPEGaudioHeader($synchstartoffset, $dummy, false, false, $FastMode)) {
    15261570                                $FastMode = true;
    15271571                                $thisframebitrate = $MPEGaudioBitrateLookup[$MPEGaudioVersionLookup[$dummy['mpeg']['audio']['raw']['version']]][$MPEGaudioLayerLookup[$dummy['mpeg']['audio']['raw']['layer']]][$dummy['mpeg']['audio']['raw']['bitrate']];
    … …  
    16341678    }
    16351679
    1636 
     1680    /**
     1681     * @return array
     1682     */
    16371683    public static function MPEGaudioVersionArray() {
    16381684        static $MPEGaudioVersion = array('2.5', false, '2', '1');
    … …  
    16401686    }
    16411687
     1688    /**
     1689     * @return array
     1690     */
    16421691    public static function MPEGaudioLayerArray() {
    16431692        static $MPEGaudioLayer = array(false, 3, 2, 1);
    … …  
    16451694    }
    16461695
     1696    /**
     1697     * @return array
     1698     */
    16471699    public static function MPEGaudioBitrateArray() {
    16481700        static $MPEGaudioBitrate;
    … …  
    16641716    }
    16651717
     1718    /**
     1719     * @return array
     1720     */
    16661721    public static function MPEGaudioFrequencyArray() {
    16671722        static $MPEGaudioFrequency;
    … …  
    16761731    }
    16771732
     1733    /**
     1734     * @return array
     1735     */
    16781736    public static function MPEGaudioChannelModeArray() {
    16791737        static $MPEGaudioChannelMode = array('stereo', 'joint stereo', 'dual channel', 'mono');
    … …  
    16811739    }
    16821740
     1741    /**
     1742     * @return array
     1743     */
    16831744    public static function MPEGaudioModeExtensionArray() {
    16841745        static $MPEGaudioModeExtension;
    … …  
    16931754    }
    16941755
     1756    /**
     1757     * @return array
     1758     */
    16951759    public static function MPEGaudioEmphasisArray() {
    16961760        static $MPEGaudioEmphasis = array('none', '50/15ms', false, 'CCIT J.17');
    … …  
    16981762    }
    16991763
     1764    /**
     1765     * @param string $head4
     1766     * @param bool   $allowBitrate15
     1767     *
     1768     * @return bool
     1769     */
    17001770    public static function MPEGaudioHeaderBytesValid($head4, $allowBitrate15=false) {
    17011771        return self::MPEGaudioHeaderValid(self::MPEGaudioHeaderDecode($head4), false, $allowBitrate15);
    17021772    }
    17031773
     1774    /**
     1775     * @param array $rawarray
     1776     * @param bool  $echoerrors
     1777     * @param bool  $allowBitrate15
     1778     *
     1779     * @return bool
     1780     */
    17041781    public static function MPEGaudioHeaderValid($rawarray, $echoerrors=false, $allowBitrate15=false) {
    17051782        if (($rawarray['synch'] & 0x0FFE) != 0x0FFE) {
    … …  
    17741851    }
    17751852
     1853    /**
     1854     * @param string $Header4Bytes
     1855     *
     1856     * @return array|false
     1857     */
    17761858    public static function MPEGaudioHeaderDecode($Header4Bytes) {
    17771859        // AAAA AAAA  AAAB BCCD  EEEE FFGH  IIJJ KLMM
    … …  
    17951877
    17961878        $MPEGrawHeader['synch']         = (getid3_lib::BigEndian2Int(substr($Header4Bytes, 0, 2)) & 0xFFE0) >> 4;
    1797         $MPEGrawHeader['version']       = (ord($Header4Bytes{1}) & 0x18) >> 3; //    BB
    1798         $MPEGrawHeader['layer']         = (ord($Header4Bytes{1}) & 0x06) >> 1; //      CC
    1799         $MPEGrawHeader['protection']    = (ord($Header4Bytes{1}) & 0x01);      //        D
    1800         $MPEGrawHeader['bitrate']       = (ord($Header4Bytes{2}) & 0xF0) >> 4; // EEEE
    1801         $MPEGrawHeader['sample_rate']   = (ord($Header4Bytes{2}) & 0x0C) >> 2; //     FF
    1802         $MPEGrawHeader['padding']       = (ord($Header4Bytes{2}) & 0x02) >> 1; //       G
    1803         $MPEGrawHeader['private']       = (ord($Header4Bytes{2}) & 0x01);      //        H
    1804         $MPEGrawHeader['channelmode']   = (ord($Header4Bytes{3}) & 0xC0) >> 6; // II
    1805         $MPEGrawHeader['modeextension'] = (ord($Header4Bytes{3}) & 0x30) >> 4; //   JJ
    1806         $MPEGrawHeader['copyright']     = (ord($Header4Bytes{3}) & 0x08) >> 3; //     K
    1807         $MPEGrawHeader['original']      = (ord($Header4Bytes{3}) & 0x04) >> 2; //      L
    1808         $MPEGrawHeader['emphasis']      = (ord($Header4Bytes{3}) & 0x03);      //       MM
     1879        $MPEGrawHeader['version']       = (ord($Header4Bytes[1]) & 0x18) >> 3; //    BB
     1880        $MPEGrawHeader['layer']         = (ord($Header4Bytes[1]) & 0x06) >> 1; //      CC
     1881        $MPEGrawHeader['protection']    = (ord($Header4Bytes[1]) & 0x01);      //        D
     1882        $MPEGrawHeader['bitrate']       = (ord($Header4Bytes[2]) & 0xF0) >> 4; // EEEE
     1883        $MPEGrawHeader['sample_rate']   = (ord($Header4Bytes[2]) & 0x0C) >> 2; //     FF
     1884        $MPEGrawHeader['padding']       = (ord($Header4Bytes[2]) & 0x02) >> 1; //       G
     1885        $MPEGrawHeader['private']       = (ord($Header4Bytes[2]) & 0x01);      //        H
     1886        $MPEGrawHeader['channelmode']   = (ord($Header4Bytes[3]) & 0xC0) >> 6; // II
     1887        $MPEGrawHeader['modeextension'] = (ord($Header4Bytes[3]) & 0x30) >> 4; //   JJ
     1888        $MPEGrawHeader['copyright']     = (ord($Header4Bytes[3]) & 0x08) >> 3; //     K
     1889        $MPEGrawHeader['original']      = (ord($Header4Bytes[3]) & 0x04) >> 2; //      L
     1890        $MPEGrawHeader['emphasis']      = (ord($Header4Bytes[3]) & 0x03);      //       MM
    18091891
    18101892        return $MPEGrawHeader;
    18111893    }
    18121894
     1895    /**
     1896     * @param int|string $bitrate
     1897     * @param string     $version
     1898     * @param string     $layer
     1899     * @param bool       $padding
     1900     * @param int        $samplerate
     1901     *
     1902     * @return int|false
     1903     */
    18131904    public static function MPEGaudioFrameLength(&$bitrate, &$version, &$layer, $padding, &$samplerate) {
    18141905        static $AudioFrameLengthCache = array();
    … …  
    18721963    }
    18731964
     1965    /**
     1966     * @param float|int $bit_rate
     1967     *
     1968     * @return int|float|string
     1969     */
    18741970    public static function ClosestStandardMP3Bitrate($bit_rate) {
    18751971        static $standard_bit_rates = array (320000, 256000, 224000, 192000, 160000, 128000, 112000, 96000, 80000, 64000, 56000, 48000, 40000, 32000, 24000, 16000, 8000);
    … …  
    18921988    }
    18931989
     1990    /**
     1991     * @param string $version
     1992     * @param string $channelmode
     1993     *
     1994     * @return int
     1995     */
    18941996    public static function XingVBRidOffset($version, $channelmode) {
    18951997        static $XingVBRidOffsetCache = array();
    1896         if (empty($XingVBRidOffset)) {
    1897             $XingVBRidOffset = array (
     1998        if (empty($XingVBRidOffsetCache)) {
     1999            $XingVBRidOffsetCache = array (
    18982000                '1'   => array ('mono'          => 0x15, // 4 + 17 = 21
    18992001                                'stereo'        => 0x24, // 4 + 32 = 36
    … …  
    19152017            );
    19162018        }
    1917         return $XingVBRidOffset[$version][$channelmode];
    1918     }
    1919 
     2019        return $XingVBRidOffsetCache[$version][$channelmode];
     2020    }
     2021
     2022    /**
     2023     * @param int $VBRmethodID
     2024     *
     2025     * @return string
     2026     */
    19202027    public static function LAMEvbrMethodLookup($VBRmethodID) {
    19212028        static $LAMEvbrMethodLookup = array(
    … …  
    19342041    }
    19352042
     2043    /**
     2044     * @param int $StereoModeID
     2045     *
     2046     * @return string
     2047     */
    19362048    public static function LAMEmiscStereoModeLookup($StereoModeID) {
    19372049        static $LAMEmiscStereoModeLookup = array(
    … …  
    19482060    }
    19492061
     2062    /**
     2063     * @param int $SourceSampleFrequencyID
     2064     *
     2065     * @return string
     2066     */
    19502067    public static function LAMEmiscSourceSampleFrequencyLookup($SourceSampleFrequencyID) {
    19512068        static $LAMEmiscSourceSampleFrequencyLookup = array(
    … …  
    19582075    }
    19592076
     2077    /**
     2078     * @param int $SurroundInfoID
     2079     *
     2080     * @return string
     2081     */
    19602082    public static function LAMEsurroundInfoLookup($SurroundInfoID) {
    19612083        static $LAMEsurroundInfoLookup = array(
    … …  
    19682090    }
    19692091
     2092    /**
     2093     * @param array $LAMEtag
     2094     *
     2095     * @return string
     2096     */
    19702097    public static function LAMEpresetUsedLookup($LAMEtag) {
    19712098

  • trunk/src/wp-includes/ID3/module.audio.ogg.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    1919class getid3_ogg extends getid3_handler
    2020{
    21     // http://xiph.org/vorbis/doc/Vorbis_I_spec.html
     21    /**
     22     * @link http://xiph.org/vorbis/doc/Vorbis_I_spec.html
     23     *
     24     * @return bool
     25     */
    2226    public function Analyze() {
    2327        $info = &$this->getid3->info;
    … …  
    6670        } elseif (substr($filedata, 0, 8) == 'OpusHead') {
    6771
    68             if( $this->ParseOpusPageHeader($filedata, $filedataoffset, $oggpageinfo) == false ) {
     72            if ($this->ParseOpusPageHeader($filedata, $filedataoffset, $oggpageinfo) === false) {
    6973                return false;
    7074            }
    … …  
    180184                $info['video']['pixel_aspect_ratio'] = (float) $info['ogg']['pageheader']['theora']['pixel_aspect_numerator'] / $info['ogg']['pageheader']['theora']['pixel_aspect_denominator'];
    181185            }
    182 $this->warning('Ogg Theora (v3) not fully supported in this version of getID3 ['.$this->getid3->version().'] -- bitrate, playtime and all audio data are currently unavailable');
     186            $this->warning('Ogg Theora (v3) not fully supported in this version of getID3 ['.$this->getid3->version().'] -- bitrate, playtime and all audio data are currently unavailable');
    183187
    184188
    … …  
    260264            //return false;
    261265
     266        } elseif (substr($filedata, 0, 5) == "\x7F".'FLAC') {
     267            // https://xiph.org/flac/ogg_mapping.html
     268
     269            $info['audio']['dataformat']   = 'flac';
     270            $info['audio']['bitrate_mode'] = 'vbr';
     271            $info['audio']['lossless']     = true;
     272
     273            $info['ogg']['flac']['header']['version_major']  =                         ord(substr($filedata,  5, 1));
     274            $info['ogg']['flac']['header']['version_minor']  =                         ord(substr($filedata,  6, 1));
     275            $info['ogg']['flac']['header']['header_packets'] =   getid3_lib::BigEndian2Int(substr($filedata,  7, 2)) + 1; // "A two-byte, big-endian binary number signifying the number of header (non-audio) packets, not including this one. This number may be zero (0x0000) to signify 'unknown' but be aware that some decoders may not be able to handle such streams."
     276            $info['ogg']['flac']['header']['magic']          =                             substr($filedata,  9, 4);
     277            if ($info['ogg']['flac']['header']['magic'] != 'fLaC') {
     278                $this->error('Ogg-FLAC expecting "fLaC", found "'.$info['ogg']['flac']['header']['magic'].'" ('.trim(getid3_lib::PrintHexBytes($info['ogg']['flac']['header']['magic'])).')');
     279                return false;
     280            }
     281            $info['ogg']['flac']['header']['STREAMINFO_bytes'] = getid3_lib::BigEndian2Int(substr($filedata, 13, 4));
     282            $info['flac']['STREAMINFO'] = getid3_flac::parseSTREAMINFOdata(substr($filedata, 17, 34));
     283            if (!empty($info['flac']['STREAMINFO']['sample_rate'])) {
     284                $info['audio']['bitrate_mode']    = 'vbr';
     285                $info['audio']['sample_rate']     = $info['flac']['STREAMINFO']['sample_rate'];
     286                $info['audio']['channels']        = $info['flac']['STREAMINFO']['channels'];
     287                $info['audio']['bits_per_sample'] = $info['flac']['STREAMINFO']['bits_per_sample'];
     288                $info['playtime_seconds']         = $info['flac']['STREAMINFO']['samples_stream'] / $info['flac']['STREAMINFO']['sample_rate'];
     289            }
     290
    262291        } else {
    263292
    264             $this->error('Expecting either "Speex   ", "OpusHead" or "vorbis" identifier strings, found "'.substr($filedata, 0, 8).'"');
     293            $this->error('Expecting one of "vorbis", "Speex", "OpusHead", "vorbis", "fishhead", "theora", "fLaC" identifier strings, found "'.substr($filedata, 0, 8).'"');
    265294            unset($info['ogg']);
    266295            unset($info['mime_type']);
    … …  
    379408    }
    380409
     410    /**
     411     * @param string $filedata
     412     * @param int    $filedataoffset
     413     * @param array  $oggpageinfo
     414     *
     415     * @return bool
     416     */
    381417    public function ParseVorbisPageHeader(&$filedata, &$filedataoffset, &$oggpageinfo) {
    382418        $info = &$this->getid3->info;
    … …  
    427463    }
    428464
    429     // http://tools.ietf.org/html/draft-ietf-codec-oggopus-03
     465    /**
     466     * @link http://tools.ietf.org/html/draft-ietf-codec-oggopus-03
     467     *
     468     * @param string $filedata
     469     * @param int    $filedataoffset
     470     * @param array  $oggpageinfo
     471     *
     472     * @return bool
     473     */
    430474    public function ParseOpusPageHeader(&$filedata, &$filedataoffset, &$oggpageinfo) {
    431475        $info = &$this->getid3->info;
    … …  
    459503        $filedataoffset += 2;
    460504
    461         $info['ogg']['pageheader']['opus']['sample_rate'] = getid3_lib::LittleEndian2Int(substr($filedata, $filedataoffset,  4));
     505        $info['ogg']['pageheader']['opus']['input_sample_rate'] = getid3_lib::LittleEndian2Int(substr($filedata, $filedataoffset,  4));
    462506        $filedataoffset += 4;
    463507
    … …  
    468512        //$filedataoffset += 1;
    469513
    470         $info['opus']['opus_version']      = $info['ogg']['pageheader']['opus']['version'];
    471         $info['opus']['sample_rate']       = $info['ogg']['pageheader']['opus']['sample_rate'];
    472         $info['opus']['out_channel_count'] = $info['ogg']['pageheader']['opus']['out_channel_count'];
    473 
    474         $info['audio']['channels']      = $info['opus']['out_channel_count'];
    475         $info['audio']['sample_rate']   = $info['opus']['sample_rate'];
     514        $info['opus']['opus_version']       = $info['ogg']['pageheader']['opus']['version'];
     515        $info['opus']['sample_rate_input']  = $info['ogg']['pageheader']['opus']['input_sample_rate'];
     516        $info['opus']['out_channel_count']  = $info['ogg']['pageheader']['opus']['out_channel_count'];
     517
     518        $info['audio']['channels']          = $info['opus']['out_channel_count'];
     519        $info['audio']['sample_rate_input'] = $info['opus']['sample_rate_input'];
     520        $info['audio']['sample_rate']       = 48000; // "All Opus audio is coded at 48 kHz, and should also be decoded at 48 kHz for playback (unless the target hardware does not support this sampling rate). However, this field may be used to resample the audio back to the original sampling rate, for example, when saving the output to a file." -- https://mf4.xiph.org/jenkins/view/opus/job/opusfile-unix/ws/doc/html/structOpusHead.html
    476521        return true;
    477522    }
    478523
    479 
     524    /**
     525     * @return array|false
     526     */
    480527    public function ParseOggPageHeader() {
    481528        // http://xiph.org/ogg/vorbis/doc/framing.html
    … …  
    490537            }
    491538            if ((($filedataoffset + 28) > strlen($filedata)) || (strlen($filedata) < 28)) {
    492                 if ($this->feof() || (($filedata .= $this->fread($this->getid3->fread_buffer_size())) === false)) {
     539                if ($this->feof() || (($filedata .= $this->fread($this->getid3->fread_buffer_size())) === '')) {
    493540                    // get some more data, unless eof, in which case fail
    494541                    return false;
    … …  
    529576    }
    530577
    531     // http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810005
     578    /**
     579     * @link http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810005
     580     *
     581     * @return bool
     582     */
    532583    public function ParseVorbisComments() {
    533584        $info = &$this->getid3->info;
    534585
    535586        $OriginalOffset = $this->ftell();
     587        $commentdata = null;
    536588        $commentdataoffset = 0;
    537589        $VorbisCommentPage = 1;
     590        $CommentStartOffset = 0;
    538591
    539592        switch ($info['audio']['dataformat']) {
    … …  
    766819    }
    767820
     821    /**
     822     * @param int $mode
     823     *
     824     * @return string|null
     825     */
    768826    public static function SpeexBandModeLookup($mode) {
    769827        static $SpeexBandModeLookup = array();
    … …  
    776834    }
    777835
    778 
     836    /**
     837     * @param array $OggInfoArray
     838     * @param int   $SegmentNumber
     839     *
     840     * @return int
     841     */
    779842    public static function OggPageSegmentLength($OggInfoArray, $SegmentNumber=1) {
     843        $segmentlength = 0;
    780844        for ($i = 0; $i < $SegmentNumber; $i++) {
    781845            $segmentlength = 0;
    … …  
    790854    }
    791855
    792 
     856    /**
     857     * @param int $nominal_bitrate
     858     *
     859     * @return float
     860     */
    793861    public static function get_quality_from_nominal_bitrate($nominal_bitrate) {
    794862
    … …  
    814882    }
    815883
     884    /**
     885     * @param int $colorspace_id
     886     *
     887     * @return string|null
     888     */
    816889    public static function TheoraColorSpace($colorspace_id) {
    817890        // http://www.theora.org/doc/Theora.pdf (table 6.3)
    … …  
    826899    }
    827900
     901    /**
     902     * @param int $pixelformat_id
     903     *
     904     * @return string|null
     905     */
    828906    public static function TheoraPixelFormat($pixelformat_id) {
    829907        // http://www.theora.org/doc/Theora.pdf (table 6.4)

  • trunk/src/wp-includes/ID3/module.tag.apetag.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    1717class getid3_apetag extends getid3_handler
    1818{
    19     public $inline_attachments = true; // true: return full data for all attachments; false: return no data for all attachments; integer: return data for attachments <= than this; string: save as file to this directory
     19    /**
     20     * true: return full data for all attachments;
     21     * false: return no data for all attachments;
     22     * integer: return data for attachments <= than this;
     23     * string: save as file to this directory.
     24     *
     25     * @var int|bool|string
     26     */
     27    public $inline_attachments = true;
     28
    2029    public $overrideendoffset  = 0;
    2130
     31    /**
     32     * @return bool
     33     */
    2234    public function Analyze() {
    2335        $info = &$this->getid3->info;
    … …  
    151163                // http://wiki.hydrogenaud.io/index.php?title=ReplayGain#MP3Gain
    152164                case 'replaygain_track_gain':
    153                     if (preg_match('#^[\\-\\+][0-9\\.,]{8}$#', $thisfile_ape_items_current['data'][0])) {
    154                         $thisfile_replaygain['track']['adjustment'] = (float) str_replace(',', '.', $thisfile_ape_items_current['data'][0]); // float casting will see "0,95" as zero!
     165                    if (preg_match('#^([\\-\\+][0-9\\.,]{8})( dB)?$#', $thisfile_ape_items_current['data'][0], $matches)) {
     166                        $thisfile_replaygain['track']['adjustment'] = (float) str_replace(',', '.', $matches[1]); // float casting will see "0,95" as zero!
    155167                        $thisfile_replaygain['track']['originator'] = 'unspecified';
    156168                    } else {
    … …  
    160172
    161173                case 'replaygain_track_peak':
    162                     if (preg_match('#^[0-9\\.,]{8}$#', $thisfile_ape_items_current['data'][0])) {
    163                         $thisfile_replaygain['track']['peak']       = (float) str_replace(',', '.', $thisfile_ape_items_current['data'][0]); // float casting will see "0,95" as zero!
     174                    if (preg_match('#^([0-9\\.,]{8})$#', $thisfile_ape_items_current['data'][0], $matches)) {
     175                        $thisfile_replaygain['track']['peak']       = (float) str_replace(',', '.', $matches[1]); // float casting will see "0,95" as zero!
    164176                        $thisfile_replaygain['track']['originator'] = 'unspecified';
    165177                        if ($thisfile_replaygain['track']['peak'] <= 0) {
    … …  
    172184
    173185                case 'replaygain_album_gain':
    174                     if (preg_match('#^[\\-\\+][0-9\\.,]{8}$#', $thisfile_ape_items_current['data'][0])) {
    175                         $thisfile_replaygain['album']['adjustment'] = (float) str_replace(',', '.', $thisfile_ape_items_current['data'][0]); // float casting will see "0,95" as zero!
     186                    if (preg_match('#^([\\-\\+][0-9\\.,]{8})( dB)?$#', $thisfile_ape_items_current['data'][0], $matches)) {
     187                        $thisfile_replaygain['album']['adjustment'] = (float) str_replace(',', '.', $matches[1]); // float casting will see "0,95" as zero!
    176188                        $thisfile_replaygain['album']['originator'] = 'unspecified';
    177189                    } else {
    … …  
    181193
    182194                case 'replaygain_album_peak':
    183                     if (preg_match('#^[0-9\\.,]{8}$#', $thisfile_ape_items_current['data'][0])) {
    184                         $thisfile_replaygain['album']['peak']       = (float) str_replace(',', '.', $thisfile_ape_items_current['data'][0]); // float casting will see "0,95" as zero!
     195                    if (preg_match('#^([0-9\\.,]{8})$#', $thisfile_ape_items_current['data'][0], $matches)) {
     196                        $thisfile_replaygain['album']['peak']       = (float) str_replace(',', '.', $matches[1]); // float casting will see "0,95" as zero!
    185197                        $thisfile_replaygain['album']['originator'] = 'unspecified';
    186198                        if ($thisfile_replaygain['album']['peak'] <= 0) {
    … …  
    226238                    if (is_array($thisfile_ape_items_current['data'])) {
    227239                        foreach ($thisfile_ape_items_current['data'] as $comment) {
    228                             $thisfile_ape['comments']['track'][] = $comment;
     240                            $thisfile_ape['comments']['track_number'][] = $comment;
    229241                        }
    230242                    }
    … …  
    336348    }
    337349
     350    /**
     351     * @param string $APEheaderFooterData
     352     *
     353     * @return array|false
     354     */
    338355    public function parseAPEheaderFooter($APEheaderFooterData) {
    339356        // http://www.uni-jena.de/~pfk/mpp/sv8/apeheader.html
    … …  
    360377    }
    361378
     379    /**
     380     * @param int $rawflagint
     381     *
     382     * @return array
     383     */
    362384    public function parseAPEtagFlags($rawflagint) {
    363385        // "Note: APE Tags 1.0 do not use any of the APE Tag flags.
    … …  
    375397    }
    376398
     399    /**
     400     * @param int $contenttypeid
     401     *
     402     * @return string
     403     */
    377404    public function APEcontentTypeFlagLookup($contenttypeid) {
    378405        static $APEcontentTypeFlagLookup = array(
    … …  
    385412    }
    386413
     414    /**
     415     * @param string $itemkey
     416     *
     417     * @return bool
     418     */
    387419    public function APEtagItemIsUTF8Lookup($itemkey) {
    388420        static $APEtagItemIsUTF8Lookup = array(

  • trunk/src/wp-includes/ID3/module.tag.id3v1.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010//                                                             //
    … …  
    1818class getid3_id3v1 extends getid3_handler
    1919{
    20 
     20    /**
     21     * @return bool
     22     */
    2123    public function Analyze() {
    2224        $info = &$this->getid3->info;
    … …  
    4446            // If second-last byte of comment field is null and last byte of comment field is non-null
    4547            // then this is ID3v1.1 and the comment field is 28 bytes long and the 30th byte is the track number
    46             if (($id3v1tag{125} === "\x00") && ($id3v1tag{126} !== "\x00")) {
    47                 $ParsedID3v1['track']  = ord(substr($ParsedID3v1['comment'], 29,  1));
    48                 $ParsedID3v1['comment'] =     substr($ParsedID3v1['comment'],  0, 28);
     48            if (($id3v1tag[125] === "\x00") && ($id3v1tag[126] !== "\x00")) {
     49                $ParsedID3v1['track_number'] = ord(substr($ParsedID3v1['comment'], 29,  1));
     50                $ParsedID3v1['comment']      =     substr($ParsedID3v1['comment'],  0, 28);
    4951            }
    5052            $ParsedID3v1['comment'] = $this->cutfield($ParsedID3v1['comment']);
    … …  
    6769            foreach ($ParsedID3v1['comments'] as $tag_key => $valuearray) {
    6870                foreach ($valuearray as $key => $value) {
    69                     if (preg_match('#^[\\x00-\\x40\\xA8\\B8\\x80-\\xFF]+$#', $value)) {
     71                    if (preg_match('#^[\\x00-\\x40\\xA8\\xB8\\x80-\\xFF]+$#', $value)) {
    7072                        foreach (array('Windows-1251', 'KOI8-R') as $id3v1_bad_encoding) {
    7173                            if (function_exists('mb_convert_encoding') && @mb_convert_encoding($value, $id3v1_bad_encoding, $id3v1_bad_encoding) === $value) {
    … …  
    9092                                            (isset($ParsedID3v1['genre']) ? $this->LookupGenreID($ParsedID3v1['genre']) : false),
    9193                                            $ParsedID3v1['comment'],
    92                                             (!empty($ParsedID3v1['track']) ? $ParsedID3v1['track'] : ''));
     94                                            (!empty($ParsedID3v1['track_number']) ? $ParsedID3v1['track_number'] : ''));
    9395            $ParsedID3v1['padding_valid'] = true;
    9496            if ($id3v1tag !== $GoodFormatID3v1tag) {
    … …  
    125127    }
    126128
     129    /**
     130     * @param string $str
     131     *
     132     * @return string
     133     */
    127134    public static function cutfield($str) {
    128135        return trim(substr($str, 0, strcspn($str, "\x00")));
    129136    }
    130137
     138    /**
     139     * @param bool $allowSCMPXextended
     140     *
     141     * @return string[]
     142     */
    131143    public static function ArrayOfGenres($allowSCMPXextended=false) {
    132144        static $GenreLookup = array(
    … …  
    313325    }
    314326
     327    /**
     328     * @param string $genreid
     329     * @param bool   $allowSCMPXextended
     330     *
     331     * @return string|false
     332     */
    315333    public static function LookupGenreName($genreid, $allowSCMPXextended=true) {
    316334        switch ($genreid) {
    … …  
    329347    }
    330348
     349    /**
     350     * @param string $genre
     351     * @param bool   $allowSCMPXextended
     352     *
     353     * @return string|false
     354     */
    331355    public static function LookupGenreID($genre, $allowSCMPXextended=false) {
    332356        $GenreLookup = self::ArrayOfGenres($allowSCMPXextended);
    … …  
    340364    }
    341365
     366    /**
     367     * @param string $OriginalGenre
     368     *
     369     * @return string|false
     370     */
    342371    public static function StandardiseID3v1GenreName($OriginalGenre) {
    343372        if (($GenreID = self::LookupGenreID($OriginalGenre)) !== false) {
    … …  
    347376    }
    348377
     378    /**
     379     * @param string     $title
     380     * @param string     $artist
     381     * @param string     $album
     382     * @param string     $year
     383     * @param int        $genreid
     384     * @param string     $comment
     385     * @param int|string $track
     386     *
     387     * @return string
     388     */
    349389    public static function GenerateID3v1Tag($title, $artist, $album, $year, $genreid, $comment, $track='') {
    350390        $ID3v1Tag  = 'TAG';

  • trunk/src/wp-includes/ID3/module.tag.id3v2.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010///                                                            //
    … …  
    2121    public $StartingOffset = 0;
    2222
     23    /**
     24     * @return bool
     25     */
    2326    public function Analyze() {
    2427        $info = &$this->getid3->info;
    … …  
    5760        if (substr($header, 0, 3) == 'ID3'  &&  strlen($header) == 10) {
    5861
    59             $thisfile_id3v2['majorversion'] = ord($header{3});
    60             $thisfile_id3v2['minorversion'] = ord($header{4});
     62            $thisfile_id3v2['majorversion'] = ord($header[3]);
     63            $thisfile_id3v2['minorversion'] = ord($header[4]);
    6164
    6265            // shortcut
    … …  
    7780        }
    7881
    79         $id3_flags = ord($header{5});
     82        $id3_flags = ord($header[5]);
    8083        switch ($id3v2_majorversion) {
    8184            case 2:
    … …  
    258261                    $thisfile_id3v2['padding']['valid']  = true;
    259262                    for ($i = 0; $i < $thisfile_id3v2['padding']['length']; $i++) {
    260                         if ($framedata{$i} != "\x00") {
     263                        if ($framedata[$i] != "\x00") {
    261264                            $thisfile_id3v2['padding']['valid'] = false;
    262265                            $thisfile_id3v2['padding']['errorpos'] = $thisfile_id3v2['padding']['start'] + $i;
    … …  
    267270                    break; // skip rest of ID3v2 header
    268271                }
     272                $frame_header = null;
     273                $frame_name   = null;
     274                $frame_size   = null;
     275                $frame_flags  = null;
    269276                if ($id3v2_majorversion == 2) {
    270277                    // Frame ID  $xx xx xx (three characters)
    … …  
    320327                    $len = strlen($framedata);
    321328                    for ($i = 0; $i < $len; $i++) {
    322                         if ($framedata{$i} != "\x00") {
     329                        if ($framedata[$i] != "\x00") {
    323330                            $thisfile_id3v2['padding']['valid'] = false;
    324331                            $thisfile_id3v2['padding']['errorpos'] = $thisfile_id3v2['padding']['start'] + $i;
    … …  
    428435            if (substr($footer, 0, 3) == '3DI') {
    429436                $thisfile_id3v2['footer'] = true;
    430                 $thisfile_id3v2['majorversion_footer'] = ord($footer{3});
    431                 $thisfile_id3v2['minorversion_footer'] = ord($footer{4});
     437                $thisfile_id3v2['majorversion_footer'] = ord($footer[3]);
     438                $thisfile_id3v2['minorversion_footer'] = ord($footer[4]);
    432439            }
    433440            if ($thisfile_id3v2['majorversion_footer'] <= 4) {
    434                 $id3_flags = ord(substr($footer{5}));
     441                $id3_flags = ord($footer[5]);
    435442                $thisfile_id3v2_flags['unsynch_footer']  = (bool) ($id3_flags & 0x80);
    436443                $thisfile_id3v2_flags['extfoot_footer']  = (bool) ($id3_flags & 0x40);
    … …  
    453460        }
    454461
    455         if (isset($thisfile_id3v2['comments']['track'])) {
    456             foreach ($thisfile_id3v2['comments']['track'] as $key => $value) {
     462        if (isset($thisfile_id3v2['comments']['track_number'])) {
     463            foreach ($thisfile_id3v2['comments']['track_number'] as $key => $value) {
    457464                if (strstr($value, '/')) {
    458                     list($thisfile_id3v2['comments']['tracknum'][$key], $thisfile_id3v2['comments']['totaltracks'][$key]) = explode('/', $thisfile_id3v2['comments']['track'][$key]);
     465                    list($thisfile_id3v2['comments']['track_number'][$key], $thisfile_id3v2['comments']['totaltracks'][$key]) = explode('/', $thisfile_id3v2['comments']['track_number'][$key]);
    459466                }
    460467            }
    … …  
    499506    }
    500507
    501 
     508    /**
     509     * @param string $genrestring
     510     *
     511     * @return array
     512     */
    502513    public function ParseID3v2GenreString($genrestring) {
    503514        // Parse genres into arrays of genreName and genreID
    … …  
    531542            $element = trim($element);
    532543            if ($element) {
    533                 if (preg_match('#^[0-9]{1,3}#', $element)) {
     544                if (preg_match('#^[0-9]{1,3}$#', $element)) {
    534545                    $clean_genres[] = getid3_id3v1::LookupGenreName($element);
    535546                } else {
    … …  
    541552    }
    542553
    543 
     554    /**
     555     * @param array $parsedFrame
     556     *
     557     * @return bool
     558     */
    544559    public function ParseID3v2Frame(&$parsedFrame) {
    545560
    … …  
    658673                $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    659674            }
    660             $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    661             if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    662                 // if description only contains a BOM or terminator then make it blank
    663                 $frame_description = '';
    664             }
     675            $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     676            $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
    665677            $parsedFrame['encodingid']  = $frame_textencoding;
    666678            $parsedFrame['encoding']    = $this->TextEncodingNameLookup($frame_textencoding);
    667679
    668             $parsedFrame['description'] = trim(getid3_lib::iconv_fallback($parsedFrame['encoding'], $info['id3v2']['encoding'], $frame_description));
     680            $parsedFrame['description'] = trim(getid3_lib::iconv_fallback($parsedFrame['encoding'], $info['id3v2']['encoding'], $parsedFrame['description']));
    669681            $parsedFrame['data'] = substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator));
     682            $parsedFrame['data'] = $this->RemoveStringTerminator($parsedFrame['data'], $frame_textencoding_terminator);
    670683            if (!empty($parsedFrame['framenameshort']) && !empty($parsedFrame['data'])) {
    671684                $commentkey = ($parsedFrame['description'] ? $parsedFrame['description'] : (isset($info['id3v2']['comments'][$parsedFrame['framenameshort']]) ? count($info['id3v2']['comments'][$parsedFrame['framenameshort']]) : 0));
    … …  
    679692
    680693
    681         } elseif ($parsedFrame['frame_name']{0} == 'T') { // 4.2. T??[?] Text information frame
     694        } elseif ($parsedFrame['frame_name'][0] == 'T') { // 4.2. T??[?] Text information frame
    682695            //   There may only be one text information frame of its kind in an tag.
    683696            // <Header for 'Text information frame', ID: 'T000' - 'TZZZ',
    … …  
    693706
    694707            $parsedFrame['data'] = (string) substr($parsedFrame['data'], $frame_offset);
     708            $parsedFrame['data'] = $this->RemoveStringTerminator($parsedFrame['data'], $this->TextEncodingTerminatorLookup($frame_textencoding));
    695709
    696710            $parsedFrame['encodingid'] = $frame_textencoding;
    697711            $parsedFrame['encoding']   = $this->TextEncodingNameLookup($frame_textencoding);
    698 
    699712            if (!empty($parsedFrame['framenameshort']) && !empty($parsedFrame['data'])) {
    700713                // ID3v2.3 specs say that TPE1 (and others) can contain multiple artist values separated with /
    … …  
    752765                $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    753766            }
    754             $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    755             if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    756                 // if description only contains a BOM or terminator then make it blank
    757                 $frame_description = '';
    758             }
    759             $parsedFrame['data'] = substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator));
    760 
    761             $frame_terminatorpos = strpos($parsedFrame['data'], $frame_textencoding_terminator);
    762             if (ord(substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator), 1)) === 0) {
    763                 $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    764             }
    765             if ($frame_terminatorpos) {
    766                 // there are null bytes after the data - this is not according to spec
    767                 // only use data up to first null byte
    768                 $frame_urldata = (string) substr($parsedFrame['data'], 0, $frame_terminatorpos);
    769             } else {
    770                 // no null bytes following data, just use all data
    771                 $frame_urldata = (string) $parsedFrame['data'];
    772             }
    773 
    774767            $parsedFrame['encodingid']  = $frame_textencoding;
    775768            $parsedFrame['encoding']    = $this->TextEncodingNameLookup($frame_textencoding);
    776 
    777             $parsedFrame['url']         = $frame_urldata;
    778             $parsedFrame['description'] = $frame_description;
     769            $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);           // according to the frame text encoding
     770            $parsedFrame['url']         = substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator)); // always ISO-8859-1
     771            $parsedFrame['description'] = $this->RemoveStringTerminator($parsedFrame['description'], $frame_textencoding_terminator);
     772            $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
     773
    779774            if (!empty($parsedFrame['framenameshort']) && $parsedFrame['url']) {
    780                 $info['id3v2']['comments'][$parsedFrame['framenameshort']][] = getid3_lib::iconv_fallback($parsedFrame['encoding'], $info['id3v2']['encoding'], $parsedFrame['url']);
     775                $info['id3v2']['comments'][$parsedFrame['framenameshort']][] = getid3_lib::iconv_fallback('ISO-8859-1', $info['id3v2']['encoding'], $parsedFrame['url']);
    781776            }
    782777            unset($parsedFrame['data']);
    783778
    784779
    785         } elseif ($parsedFrame['frame_name']{0} == 'W') { // 4.3. W??? URL link frames
     780        } elseif ($parsedFrame['frame_name'][0] == 'W') { // 4.3. W??? URL link frames
    786781            //   There may only be one URL link frame of its kind in a tag,
    787782            //   except when stated otherwise in the frame description
    … …  
    790785            // URL              <text string>
    791786
    792             $parsedFrame['url'] = trim($parsedFrame['data']);
     787            $parsedFrame['url'] = trim($parsedFrame['data']); // always ISO-8859-1
    793788            if (!empty($parsedFrame['framenameshort']) && $parsedFrame['url']) {
    794                 $info['id3v2']['comments'][$parsedFrame['framenameshort']][] = $parsedFrame['url'];
     789                $info['id3v2']['comments'][$parsedFrame['framenameshort']][] = getid3_lib::iconv_fallback('ISO-8859-1', $info['id3v2']['encoding'], $parsedFrame['url']);
    795790            }
    796791            unset($parsedFrame['data']);
    … …  
    814809            $parsedFrame['data_raw']   = (string) substr($parsedFrame['data'], $frame_offset);
    815810
    816             // http://www.getid3.org/phpBB3/viewtopic.php?t=1369
     811            // https://www.getid3.org/phpBB3/viewtopic.php?t=1369
    817812            // "this tag typically contains null terminated strings, which are associated in pairs"
    818813            // "there are users that use the tag incorrectly"
    … …  
    934929            $parsedFrame['bitsformsdeviation']      = getid3_lib::BigEndian2Int(substr($parsedFrame['data'], 9, 1));
    935930            $parsedFrame['data'] = substr($parsedFrame['data'], 10);
     931            $deviationbitstream = '';
    936932            while ($frame_offset < strlen($parsedFrame['data'])) {
    937933                $deviationbitstream .= getid3_lib::BigEndian2Bin(substr($parsedFrame['data'], $frame_offset++, 1));
    … …  
    995991                $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    996992            }
    997             $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    998             if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    999                 // if description only contains a BOM or terminator then make it blank
    1000                 $frame_description = '';
    1001             }
     993            $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     994            $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
    1002995            $parsedFrame['data'] = substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator));
     996            $parsedFrame['data'] = $this->RemoveStringTerminator($parsedFrame['data'], $frame_textencoding_terminator);
    1003997
    1004998            $parsedFrame['encodingid']   = $frame_textencoding;
    … …  
    10071001            $parsedFrame['language']     = $frame_language;
    10081002            $parsedFrame['languagename'] = $this->LanguageLookup($frame_language, false);
    1009             $parsedFrame['description']  = $frame_description;
    10101003            if (!empty($parsedFrame['framenameshort']) && !empty($parsedFrame['data'])) {
    10111004                $info['id3v2']['comments'][$parsedFrame['framenameshort']][] = getid3_lib::iconv_fallback($parsedFrame['encoding'], $info['id3v2']['encoding'], $parsedFrame['data']);
    … …  
    10621055
    10631056                    $frame_remainingdata = substr($frame_remainingdata, $frame_terminatorpos + strlen($frame_textencoding_terminator));
    1064                     if (($timestampindex == 0) && (ord($frame_remainingdata{0}) != 0)) {
     1057                    if (($timestampindex == 0) && (ord($frame_remainingdata[0]) != 0)) {
    10651058                        // timestamp probably omitted for first data item
    10661059                    } else {
    … …  
    11031096                    $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    11041097                }
    1105                 $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    1106                 if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    1107                     // if description only contains a BOM or terminator then make it blank
    1108                     $frame_description = '';
    1109                 }
     1098                $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     1099                $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
    11101100                $frame_text = (string) substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator));
     1101                $frame_text = $this->RemoveStringTerminator($frame_text, $frame_textencoding_terminator);
    11111102
    11121103                $parsedFrame['encodingid']   = $frame_textencoding;
    … …  
    11151106                $parsedFrame['language']     = $frame_language;
    11161107                $parsedFrame['languagename'] = $this->LanguageLookup($frame_language, false);
    1117                 $parsedFrame['description']  = $frame_description;
    11181108                $parsedFrame['data']         = $frame_text;
    11191109                if (!empty($parsedFrame['framenameshort']) && !empty($parsedFrame['data'])) {
    … …  
    14081398                    $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    14091399                }
    1410                 $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    1411                 if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    1412                     // if description only contains a BOM or terminator then make it blank
    1413                     $frame_description = '';
     1400                $parsedFrame['description']   = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     1401                $parsedFrame['description']   = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
     1402                $parsedFrame['encodingid']    = $frame_textencoding;
     1403                $parsedFrame['encoding']      = $this->TextEncodingNameLookup($frame_textencoding);
     1404
     1405                if ($id3v2_majorversion == 2) {
     1406                    $parsedFrame['imagetype'] = isset($frame_imagetype) ? $frame_imagetype : null;
     1407                } else {
     1408                    $parsedFrame['mime']      = isset($frame_mimetype) ? $frame_mimetype : null;
    14141409                }
    1415                 $parsedFrame['encodingid']       = $frame_textencoding;
    1416                 $parsedFrame['encoding']         = $this->TextEncodingNameLookup($frame_textencoding);
    1417 
    1418                 if ($id3v2_majorversion == 2) {
    1419                     $parsedFrame['imagetype']    = $frame_imagetype;
    1420                 } else {
    1421                     $parsedFrame['mime']         = $frame_mimetype;
    1422                 }
    1423                 $parsedFrame['picturetypeid']    = $frame_picturetype;
    1424                 $parsedFrame['picturetype']      = $this->APICPictureTypeLookup($frame_picturetype);
    1425                 $parsedFrame['description']      = $frame_description;
    1426                 $parsedFrame['data']             = substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator));
    1427                 $parsedFrame['datalength']       = strlen($parsedFrame['data']);
    1428 
    1429                 $parsedFrame['image_mime'] = '';
     1410                $parsedFrame['picturetypeid'] = $frame_picturetype;
     1411                $parsedFrame['picturetype']   = $this->APICPictureTypeLookup($frame_picturetype);
     1412                $parsedFrame['data']          = substr($parsedFrame['data'], $frame_terminatorpos + strlen($frame_textencoding_terminator));
     1413                $parsedFrame['datalength']    = strlen($parsedFrame['data']);
     1414
     1415                $parsedFrame['image_mime']    = '';
    14301416                $imageinfo = array();
    14311417                if ($imagechunkcheck = getid3_lib::GetDataImageSize($parsedFrame['data'], $imageinfo)) {
    14321418                    if (($imagechunkcheck[2] >= 1) && ($imagechunkcheck[2] <= 3)) {
    1433                         $parsedFrame['image_mime']       = 'image/'.getid3_lib::ImageTypesLookup($imagechunkcheck[2]);
     1419                        $parsedFrame['image_mime']       = image_type_to_mime_type($imagechunkcheck[2]);
    14341420                        if ($imagechunkcheck[0]) {
    14351421                            $parsedFrame['image_width']  = $imagechunkcheck[0];
    … …  
    14471433                        break;
    14481434                    }
     1435                    $dir = '';
    14491436                    if ($this->getid3->option_save_attachments === true) {
    14501437                        // great
    … …  
    15341521                $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    15351522            }
    1536             $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    1537             if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    1538                 // if description only contains a BOM or terminator then make it blank
    1539                 $frame_description = '';
    1540             }
     1523            $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     1524            $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
    15411525            $frame_offset = $frame_terminatorpos + strlen($frame_textencoding_terminator);
    15421526
    … …  
    15471531            $parsedFrame['mime']        = $frame_mimetype;
    15481532            $parsedFrame['filename']    = $frame_filename;
    1549             $parsedFrame['description'] = $frame_description;
    15501533            unset($parsedFrame['data']);
    15511534
    … …  
    16171600
    16181601            $frame_terminatorpos = strpos($parsedFrame['data'], "\x00", $frame_offset);
    1619             $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    1620             if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    1621                 // if description only contains a BOM or terminator then make it blank
    1622                 $frame_description = '';
    1623             }
     1602            $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     1603            $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
    16241604            $frame_offset = $frame_terminatorpos + strlen("\x00");
    16251605
    16261606            $parsedFrame['ownerid']     = $frame_ownerid;
    16271607            $parsedFrame['data']        = (string) substr($parsedFrame['data'], $frame_offset);
    1628             $parsedFrame['description'] = $frame_description;
    16291608            unset($parsedFrame['data']);
    16301609
    … …  
    17221701            $parsedFrame['encoding']     = $this->TextEncodingNameLookup($frame_textencoding);
    17231702
    1724             $parsedFrame['data']         = (string) substr($parsedFrame['data'], $frame_offset);
     1703            $parsedFrame['data'] = (string) substr($parsedFrame['data'], $frame_offset);
     1704            $parsedFrame['data'] = $this->RemoveStringTerminator($parsedFrame['data'], $this->TextEncodingTerminatorLookup($frame_textencoding));
    17251705            if (!empty($parsedFrame['framenameshort']) && !empty($parsedFrame['data'])) {
    17261706                $info['id3v2']['comments'][$parsedFrame['framenameshort']][] = getid3_lib::iconv_fallback($parsedFrame['encoding'], $info['id3v2']['encoding'], $parsedFrame['data']);
    … …  
    17601740
    17611741            $parsedFrame['seller'] = (string) substr($parsedFrame['data'], $frame_offset);
     1742            $parsedFrame['seller'] = $this->RemoveStringTerminator($parsedFrame['seller'], $this->TextEncodingTerminatorLookup($frame_textencoding));
    17621743            unset($parsedFrame['data']);
    17631744
    … …  
    18181799                $frame_terminatorpos++; // strpos() fooled because 2nd byte of Unicode chars are often 0x00
    18191800            }
    1820             $frame_description = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
    1821             if (in_array($frame_description, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
    1822                 // if description only contains a BOM or terminator then make it blank
    1823                 $frame_description = '';
    1824             }
     1801            $parsedFrame['description'] = substr($parsedFrame['data'], $frame_offset, $frame_terminatorpos - $frame_offset);
     1802            $parsedFrame['description'] = $this->MakeUTF16emptyStringEmpty($parsedFrame['description']);
    18251803            $frame_offset = $frame_terminatorpos + strlen($frame_textencoding_terminator);
    18261804
    … …  
    18391817            $parsedFrame['receivedas']        = $this->COMRReceivedAsLookup($frame_receivedasid);
    18401818            $parsedFrame['sellername']        = $frame_sellername;
    1841             $parsedFrame['description']       = $frame_description;
    18421819            $parsedFrame['mime']              = $frame_mimetype;
    18431820            $parsedFrame['logo']              = $frame_sellerlogo;
    … …  
    20031980            // Start time      $xx xx xx xx
    20041981            // End time        $xx xx xx xx
    2005             // Start offset    $xx xx xx xx
    2006             // End offset      $xx xx xx xx
    2007             // <Optional embedded sub-frames>
     1982            // Start offset    $xx xx xx xx
     1983            // End offset      $xx xx xx xx
     1984            // <Optional embedded sub-frames>
    20081985
    20091986            $frame_offset = 0;
    … …  
    20382015                    if ($subframe['size'] > (strlen($parsedFrame['data']) - $frame_offset)) {
    20392016                        $this->warning('CHAP subframe "'.$subframe['name'].'" at frame offset '.$frame_offset.' claims to be "'.$subframe['size'].'" bytes, which is more than the available data ('.(strlen($parsedFrame['data']) - $frame_offset).' bytes)');
     2017                        break;
     2018                    }
     2019                    $subframe_rawdata = substr($parsedFrame['data'], $frame_offset, $subframe['size']);
     2020                    $frame_offset += $subframe['size'];
     2021
     2022                    $subframe['encodingid'] = ord(substr($subframe_rawdata, 0, 1));
     2023                    $subframe['text']       =     substr($subframe_rawdata, 1);
     2024                    $subframe['encoding']   = $this->TextEncodingNameLookup($subframe['encodingid']);
     2025                    $encoding_converted_text = trim(getid3_lib::iconv_fallback($subframe['encoding'], $info['encoding'], $subframe['text']));
     2026                    switch (substr($encoding_converted_text, 0, 2)) {
     2027                        case "\xFF\xFE":
     2028                        case "\xFE\xFF":
     2029                            switch (strtoupper($info['id3v2']['encoding'])) {
     2030                                case 'ISO-8859-1':
     2031                                case 'UTF-8':
     2032                                    $encoding_converted_text = substr($encoding_converted_text, 2);
     2033                                    // remove unwanted byte-order-marks
     2034                                    break;
     2035                                default:
     2036                                    // ignore
     2037                                    break;
     2038                            }
     2039                            break;
     2040                        default:
     2041                            // do not remove BOM
     2042                            break;
     2043                    }
     2044
     2045                    switch ($subframe['name']) {
     2046                        case 'TIT2':
     2047                            $parsedFrame['chapter_name']        = $encoding_converted_text;
     2048                            $parsedFrame['subframes'][] = $subframe;
     2049                            break;
     2050                        case 'TIT3':
     2051                            $parsedFrame['chapter_description'] = $encoding_converted_text;
     2052                            $parsedFrame['subframes'][] = $subframe;
     2053                            break;
     2054                        case 'WXXX':
     2055                            list($subframe['chapter_url_description'], $subframe['chapter_url']) = explode("\x00", $encoding_converted_text, 2);
     2056                            $parsedFrame['chapter_url'][$subframe['chapter_url_description']] = $subframe['chapter_url'];
     2057                            $parsedFrame['subframes'][] = $subframe;
     2058                            break;
     2059                        case 'APIC':
     2060                            if (preg_match('#^([^\\x00]+)*\\x00(.)([^\\x00]+)*\\x00(.+)$#s', $subframe['text'], $matches)) {
     2061                                list($dummy, $subframe_apic_mime, $subframe_apic_picturetype, $subframe_apic_description, $subframe_apic_picturedata) = $matches;
     2062                                $subframe['image_mime']   = trim(getid3_lib::iconv_fallback($subframe['encoding'], $info['encoding'], $subframe_apic_mime));
     2063                                $subframe['picture_type'] = $this->APICPictureTypeLookup($subframe_apic_picturetype);
     2064                                $subframe['description']  = trim(getid3_lib::iconv_fallback($subframe['encoding'], $info['encoding'], $subframe_apic_description));
     2065                                if (strlen($this->TextEncodingTerminatorLookup($subframe['encoding'])) == 2) {
     2066                                    // the null terminator between "description" and "picture data" could be either 1 byte (ISO-8859-1, UTF-8) or two bytes (UTF-16)
     2067                                    // the above regex assumes one byte, if it's actually two then strip the second one here
     2068                                    $subframe_apic_picturedata = substr($subframe_apic_picturedata, 1);
     2069                                }
     2070                                $subframe['data'] = $subframe_apic_picturedata;
     2071                                unset($dummy, $subframe_apic_mime, $subframe_apic_picturetype, $subframe_apic_description, $subframe_apic_picturedata);
     2072                                unset($subframe['text'], $parsedFrame['text']);
     2073                                $parsedFrame['subframes'][] = $subframe;
     2074                                $parsedFrame['picture_present'] = true;
     2075                            } else {
     2076                                $this->warning('ID3v2.CHAP subframe #'.(count($parsedFrame['subframes']) + 1).' "'.$subframe['name'].'" not in expected format');
     2077                            }
     2078                            break;
     2079                        default:
     2080                            $this->warning('ID3v2.CHAP subframe "'.$subframe['name'].'" not handled (supported: TIT2, TIT3, WXXX, APIC)');
     2081                            break;
     2082                    }
     2083                }
     2084                unset($subframe_rawdata, $subframe, $encoding_converted_text);
     2085                unset($parsedFrame['data']); // debatable whether this this be here, without it the returned structure may contain a large amount of duplicate data if chapters contain APIC
     2086            }
     2087
     2088            $id3v2_chapter_entry = array();
     2089            foreach (array('id', 'time_begin', 'time_end', 'offset_begin', 'offset_end', 'chapter_name', 'chapter_description', 'chapter_url', 'picture_present') as $id3v2_chapter_key) {
     2090                if (isset($parsedFrame[$id3v2_chapter_key])) {
     2091                    $id3v2_chapter_entry[$id3v2_chapter_key] = $parsedFrame[$id3v2_chapter_key];
     2092                }
     2093            }
     2094            if (!isset($info['id3v2']['chapters'])) {
     2095                $info['id3v2']['chapters'] = array();
     2096            }
     2097            $info['id3v2']['chapters'][] = $id3v2_chapter_entry;
     2098            unset($id3v2_chapter_entry, $id3v2_chapter_key);
     2099
     2100
     2101        } elseif (($id3v2_majorversion >= 3) && ($parsedFrame['frame_name'] == 'CTOC')) { // CTOC Chapters Table Of Contents frame (ID3v2.3+ only)
     2102            // http://id3.org/id3v2-chapters-1.0
     2103            // <ID3v2.3 or ID3v2.4 frame header, ID: "CTOC">           (10 bytes)
     2104            // Element ID      <text string> $00
     2105            // CTOC flags        %xx
     2106            // Entry count       $xx
     2107            // Child Element ID  <string>$00   /* zero or more child CHAP or CTOC entries */
     2108            // <Optional embedded sub-frames>
     2109
     2110            $frame_offset = 0;
     2111            @list($parsedFrame['element_id']) = explode("\x00", $parsedFrame['data'], 2);
     2112            $frame_offset += strlen($parsedFrame['element_id']."\x00");
     2113            $ctoc_flags_raw = ord(substr($parsedFrame['data'], $frame_offset, 1));
     2114            $frame_offset += 1;
     2115            $parsedFrame['entry_count'] = ord(substr($parsedFrame['data'], $frame_offset, 1));
     2116            $frame_offset += 1;
     2117
     2118            $terminator_position = null;
     2119            for ($i = 0; $i < $parsedFrame['entry_count']; $i++) {
     2120                $terminator_position = strpos($parsedFrame['data'], "\x00", $frame_offset);
     2121                $parsedFrame['child_element_ids'][$i] = substr($parsedFrame['data'], $frame_offset, $terminator_position - $frame_offset);
     2122                $frame_offset = $terminator_position + 1;
     2123            }
     2124
     2125            $parsedFrame['ctoc_flags']['ordered']   = (bool) ($ctoc_flags_raw & 0x01);
     2126            $parsedFrame['ctoc_flags']['top_level'] = (bool) ($ctoc_flags_raw & 0x03);
     2127
     2128            unset($ctoc_flags_raw, $terminator_position);
     2129
     2130            if ($frame_offset < strlen($parsedFrame['data'])) {
     2131                $parsedFrame['subframes'] = array();
     2132                while ($frame_offset < strlen($parsedFrame['data'])) {
     2133                    // <Optional embedded sub-frames>
     2134                    $subframe = array();
     2135                    $subframe['name']      =                           substr($parsedFrame['data'], $frame_offset, 4);
     2136                    $frame_offset += 4;
     2137                    $subframe['size']      = getid3_lib::BigEndian2Int(substr($parsedFrame['data'], $frame_offset, 4));
     2138                    $frame_offset += 4;
     2139                    $subframe['flags_raw'] = getid3_lib::BigEndian2Int(substr($parsedFrame['data'], $frame_offset, 2));
     2140                    $frame_offset += 2;
     2141                    if ($subframe['size'] > (strlen($parsedFrame['data']) - $frame_offset)) {
     2142                        $this->warning('CTOS subframe "'.$subframe['name'].'" at frame offset '.$frame_offset.' claims to be "'.$subframe['size'].'" bytes, which is more than the available data ('.(strlen($parsedFrame['data']) - $frame_offset).' bytes)');
    20402143                        break;
    20412144                    }
    … …  
    20682171                    if (($subframe['name'] == 'TIT2') || ($subframe['name'] == 'TIT3')) {
    20692172                        if ($subframe['name'] == 'TIT2') {
    2070                             $parsedFrame['chapter_name']        = $encoding_converted_text;
    2071                         } elseif ($subframe['name'] == 'TIT3') {
    2072                             $parsedFrame['chapter_description'] = $encoding_converted_text;
    2073                         }
    2074                         $parsedFrame['subframes'][] = $subframe;
    2075                     } else {
    2076                         $this->warning('ID3v2.CHAP subframe "'.$subframe['name'].'" not handled (only TIT2 and TIT3)');
    2077                     }
    2078                 }
    2079                 unset($subframe_rawdata, $subframe, $encoding_converted_text);
    2080             }
    2081 
    2082             $id3v2_chapter_entry = array();
    2083             foreach (array('id', 'time_begin', 'time_end', 'offset_begin', 'offset_end', 'chapter_name', 'chapter_description') as $id3v2_chapter_key) {
    2084                 if (isset($parsedFrame[$id3v2_chapter_key])) {
    2085                     $id3v2_chapter_entry[$id3v2_chapter_key] = $parsedFrame[$id3v2_chapter_key];
    2086                 }
    2087             }
    2088             if (!isset($info['id3v2']['chapters'])) {
    2089                 $info['id3v2']['chapters'] = array();
    2090             }
    2091             $info['id3v2']['chapters'][] = $id3v2_chapter_entry;
    2092             unset($id3v2_chapter_entry, $id3v2_chapter_key);
    2093 
    2094 
    2095         } elseif (($id3v2_majorversion >= 3) && ($parsedFrame['frame_name'] == 'CTOC')) { // CTOC Chapters Table Of Contents frame (ID3v2.3+ only)
    2096             // http://id3.org/id3v2-chapters-1.0
    2097             // <ID3v2.3 or ID3v2.4 frame header, ID: "CTOC">           (10 bytes)
    2098             // Element ID      <text string> $00
    2099             // CTOC flags        %xx
    2100             // Entry count       $xx
    2101             // Child Element ID  <string>$00   /* zero or more child CHAP or CTOC entries */
    2102             // <Optional embedded sub-frames>
    2103 
    2104             $frame_offset = 0;
    2105             @list($parsedFrame['element_id']) = explode("\x00", $parsedFrame['data'], 2);
    2106             $frame_offset += strlen($parsedFrame['element_id']."\x00");
    2107             $ctoc_flags_raw = ord(substr($parsedFrame['data'], $frame_offset, 1));
    2108             $frame_offset += 1;
    2109             $parsedFrame['entry_count'] = ord(substr($parsedFrame['data'], $frame_offset, 1));
    2110             $frame_offset += 1;
    2111 
    2112             $terminator_position = null;
    2113             for ($i = 0; $i < $parsedFrame['entry_count']; $i++) {
    2114                 $terminator_position = strpos($parsedFrame['data'], "\x00", $frame_offset);
    2115                 $parsedFrame['child_element_ids'][$i] = substr($parsedFrame['data'], $frame_offset, $terminator_position - $frame_offset);
    2116                 $frame_offset = $terminator_position + 1;
    2117             }
    2118 
    2119             $parsedFrame['ctoc_flags']['ordered']   = (bool) ($ctoc_flags_raw & 0x01);
    2120             $parsedFrame['ctoc_flags']['top_level'] = (bool) ($ctoc_flags_raw & 0x03);
    2121 
    2122             unset($ctoc_flags_raw, $terminator_position);
    2123 
    2124             if ($frame_offset < strlen($parsedFrame['data'])) {
    2125                 $parsedFrame['subframes'] = array();
    2126                 while ($frame_offset < strlen($parsedFrame['data'])) {
    2127                     // <Optional embedded sub-frames>
    2128                     $subframe = array();
    2129                     $subframe['name']      =                           substr($parsedFrame['data'], $frame_offset, 4);
    2130                     $frame_offset += 4;
    2131                     $subframe['size']      = getid3_lib::BigEndian2Int(substr($parsedFrame['data'], $frame_offset, 4));
    2132                     $frame_offset += 4;
    2133                     $subframe['flags_raw'] = getid3_lib::BigEndian2Int(substr($parsedFrame['data'], $frame_offset, 2));
    2134                     $frame_offset += 2;
    2135                     if ($subframe['size'] > (strlen($parsedFrame['data']) - $frame_offset)) {
    2136                         $this->warning('CTOS subframe "'.$subframe['name'].'" at frame offset '.$frame_offset.' claims to be "'.$subframe['size'].'" bytes, which is more than the available data ('.(strlen($parsedFrame['data']) - $frame_offset).' bytes)');
    2137                         break;
    2138                     }
    2139                     $subframe_rawdata = substr($parsedFrame['data'], $frame_offset, $subframe['size']);
    2140                     $frame_offset += $subframe['size'];
    2141 
    2142                     $subframe['encodingid'] = ord(substr($subframe_rawdata, 0, 1));
    2143                     $subframe['text']       =     substr($subframe_rawdata, 1);
    2144                     $subframe['encoding']   = $this->TextEncodingNameLookup($subframe['encodingid']);
    2145                     $encoding_converted_text = trim(getid3_lib::iconv_fallback($subframe['encoding'], $info['encoding'], $subframe['text']));;
    2146                     switch (substr($encoding_converted_text, 0, 2)) {
    2147                         case "\xFF\xFE":
    2148                         case "\xFE\xFF":
    2149                             switch (strtoupper($info['id3v2']['encoding'])) {
    2150                                 case 'ISO-8859-1':
    2151                                 case 'UTF-8':
    2152                                     $encoding_converted_text = substr($encoding_converted_text, 2);
    2153                                     // remove unwanted byte-order-marks
    2154                                     break;
    2155                                 default:
    2156                                     // ignore
    2157                                     break;
    2158                             }
    2159                             break;
    2160                         default:
    2161                             // do not remove BOM
    2162                             break;
    2163                     }
    2164 
    2165                     if (($subframe['name'] == 'TIT2') || ($subframe['name'] == 'TIT3')) {
    2166                         if ($subframe['name'] == 'TIT2') {
    21672173                            $parsedFrame['toc_name']        = $encoding_converted_text;
    21682174                        } elseif ($subframe['name'] == 'TIT3') {
    … …  
    21822188    }
    21832189
    2184 
     2190    /**
     2191     * @param string $data
     2192     *
     2193     * @return string
     2194     */
    21852195    public function DeUnsynchronise($data) {
    21862196        return str_replace("\xFF\x00", "\xFF", $data);
    21872197    }
    21882198
     2199    /**
     2200     * @param int $index
     2201     *
     2202     * @return string
     2203     */
    21892204    public function LookupExtendedHeaderRestrictionsTagSizeLimits($index) {
    21902205        static $LookupExtendedHeaderRestrictionsTagSizeLimits = array(
    … …  
    21972212    }
    21982213
     2214    /**
     2215     * @param int $index
     2216     *
     2217     * @return string
     2218     */
    21992219    public function LookupExtendedHeaderRestrictionsTextEncodings($index) {
    22002220        static $LookupExtendedHeaderRestrictionsTextEncodings = array(
    … …  
    22052225    }
    22062226
     2227    /**
     2228     * @param int $index
     2229     *
     2230     * @return string
     2231     */
    22072232    public function LookupExtendedHeaderRestrictionsTextFieldSize($index) {
    22082233        static $LookupExtendedHeaderRestrictionsTextFieldSize = array(
    … …  
    22152240    }
    22162241
     2242    /**
     2243     * @param int $index
     2244     *
     2245     * @return string
     2246     */
    22172247    public function LookupExtendedHeaderRestrictionsImageEncoding($index) {
    22182248        static $LookupExtendedHeaderRestrictionsImageEncoding = array(
    … …  
    22232253    }
    22242254
     2255    /**
     2256     * @param int $index
     2257     *
     2258     * @return string
     2259     */
    22252260    public function LookupExtendedHeaderRestrictionsImageSizeSize($index) {
    22262261        static $LookupExtendedHeaderRestrictionsImageSizeSize = array(
    … …  
    22332268    }
    22342269
     2270    /**
     2271     * @param string $currencyid
     2272     *
     2273     * @return string
     2274     */
    22352275    public function LookupCurrencyUnits($currencyid) {
    22362276
    … …  
    24292469    }
    24302470
    2431 
     2471    /**
     2472     * @param string $currencyid
     2473     *
     2474     * @return string
     2475     */
    24322476    public function LookupCurrencyCountry($currencyid) {
    24332477
    … …  
    26252669    }
    26262670
    2627 
    2628 
     2671    /**
     2672     * @param string $languagecode
     2673     * @param bool   $casesensitive
     2674     *
     2675     * @return string
     2676     */
    26292677    public static function LanguageLookup($languagecode, $casesensitive=false) {
    26302678
    … …  
    30823130    }
    30833131
    3084 
     3132    /**
     3133     * @param int $index
     3134     *
     3135     * @return string
     3136     */
    30853137    public static function ETCOEventLookup($index) {
    30863138        if (($index >= 0x17) && ($index <= 0xDF)) {
    … …  
    31263178    }
    31273179
     3180    /**
     3181     * @param int $index
     3182     *
     3183     * @return string
     3184     */
    31283185    public static function SYTLContentTypeLookup($index) {
    31293186        static $SYTLContentTypeLookup = array(
    … …  
    31423199    }
    31433200
     3201    /**
     3202     * @param int   $index
     3203     * @param bool $returnarray
     3204     *
     3205     * @return array|string
     3206     */
    31443207    public static function APICPictureTypeLookup($index, $returnarray=false) {
    31453208        static $APICPictureTypeLookup = array(
    … …  
    31723235    }
    31733236
     3237    /**
     3238     * @param int $index
     3239     *
     3240     * @return string
     3241     */
    31743242    public static function COMRReceivedAsLookup($index) {
    31753243        static $COMRReceivedAsLookup = array(
    … …  
    31883256    }
    31893257
     3258    /**
     3259     * @param int $index
     3260     *
     3261     * @return string
     3262     */
    31903263    public static function RVA2ChannelTypeLookup($index) {
    31913264        static $RVA2ChannelTypeLookup = array(
    … …  
    32043277    }
    32053278
     3279    /**
     3280     * @param string $framename
     3281     *
     3282     * @return string
     3283     */
    32063284    public static function FrameNameLongLookup($framename) {
    32073285
    … …  
    33553433            UFI Unique file identifier
    33563434            UFID    Unique file identifier
    3357             ULT Unsychronised lyric/text transcription
     3435            ULT Unsynchronised lyric/text transcription
    33583436            USER    Terms of use
    33593437            USLT    Unsynchronised lyric/text transcription
    … …  
    33873465    }
    33883466
    3389 
     3467    /**
     3468     * @param string $framename
     3469     *
     3470     * @return string
     3471     */
    33903472    public static function FrameNameShortLookup($framename) {
    33913473
    … …  
    35393621            UFI unique_file_identifier
    35403622            UFID    unique_file_identifier
    3541             ULT unsychronised_lyric
     3623            ULT unsynchronised_lyric
    35423624            USER    terms_of_use
    35433625            USLT    unsynchronised_lyric
    … …  
    35673649    }
    35683650
     3651    /**
     3652     * @param string $encoding
     3653     *
     3654     * @return string
     3655     */
    35693656    public static function TextEncodingTerminatorLookup($encoding) {
    35703657        // http://www.id3.org/id3v2.4.0-structure.txt
    … …  
    35803667    }
    35813668
     3669    /**
     3670     * @param int $encoding
     3671     *
     3672     * @return string
     3673     */
    35823674    public static function TextEncodingNameLookup($encoding) {
    35833675        // http://www.id3.org/id3v2.4.0-structure.txt
    … …  
    35933685    }
    35943686
     3687    /**
     3688     * @param string $string
     3689     * @param string $terminator
     3690     *
     3691     * @return string
     3692     */
     3693    public static function RemoveStringTerminator($string, $terminator) {
     3694        // Null terminator at end of comment string is somewhat ambiguous in the specification, may or may not be implemented by various taggers. Remove terminator only if present.
     3695        // https://github.com/JamesHeinrich/getID3/issues/121
     3696        // https://community.mp3tag.de/t/x-trailing-nulls-in-id3v2-comments/19227
     3697        if (substr($string, -strlen($terminator), strlen($terminator)) === $terminator) {
     3698            $string = substr($string, 0, -strlen($terminator));
     3699        }
     3700        return $string;
     3701    }
     3702
     3703    /**
     3704     * @param string $string
     3705     *
     3706     * @return string
     3707     */
     3708    public static function MakeUTF16emptyStringEmpty($string) {
     3709        if (in_array($string, array("\x00", "\x00\x00", "\xFF\xFE", "\xFE\xFF"))) {
     3710            // if string only contains a BOM or terminator then make it actually an empty string
     3711            $string = '';
     3712        }
     3713        return $string;
     3714    }
     3715
     3716    /**
     3717     * @param string $framename
     3718     * @param int    $id3v2majorversion
     3719     *
     3720     * @return bool|int
     3721     */
    35953722    public static function IsValidID3v2FrameName($framename, $id3v2majorversion) {
    35963723        switch ($id3v2majorversion) {
    … …  
    36073734    }
    36083735
     3736    /**
     3737     * @param string $numberstring
     3738     * @param bool   $allowdecimal
     3739     * @param bool   $allownegative
     3740     *
     3741     * @return bool
     3742     */
    36093743    public static function IsANumber($numberstring, $allowdecimal=false, $allownegative=false) {
    36103744        for ($i = 0; $i < strlen($numberstring); $i++) {
    3611             if ((chr($numberstring{$i}) < chr('0')) || (chr($numberstring{$i}) > chr('9'))) {
    3612                 if (($numberstring{$i} == '.') && $allowdecimal) {
     3745            if ((chr($numberstring[$i]) < chr('0')) || (chr($numberstring[$i]) > chr('9'))) {
     3746                if (($numberstring[$i] == '.') && $allowdecimal) {
    36133747                    // allowed
    3614                 } elseif (($numberstring{$i} == '-') && $allownegative && ($i == 0)) {
     3748                } elseif (($numberstring[$i] == '-') && $allownegative && ($i == 0)) {
    36153749                    // allowed
    36163750                } else {
    … …  
    36223756    }
    36233757
     3758    /**
     3759     * @param string $datestamp
     3760     *
     3761     * @return bool
     3762     */
    36243763    public static function IsValidDateStampString($datestamp) {
    36253764        if (strlen($datestamp) != 8) {
    … …  
    36503789    }
    36513790
     3791    /**
     3792     * @param int $majorversion
     3793     *
     3794     * @return int
     3795     */
    36523796    public static function ID3v2HeaderLength($majorversion) {
    36533797        return (($majorversion == 2) ? 6 : 10);
    36543798    }
    36553799
     3800    /**
     3801     * @param string $frame_name
     3802     *
     3803     * @return string|false
     3804     */
    36563805    public static function ID3v22iTunesBrokenFrameName($frame_name) {
    36573806        // iTunes (multiple versions) has been known to write ID3v2.3 style frames
    … …  
    37403889
    37413890}
     3891

  • trunk/src/wp-includes/ID3/module.tag.lyrics3.php

    r41196 r46112  
    11<?php
     2
    23/////////////////////////////////////////////////////////////////
    34/// getID3() by James Heinrich <info@getid3.org>               //
    4 //  available at http://getid3.sourceforge.net                 //
    5 //            or http://www.getid3.org                         //
    6 //          also https://github.com/JamesHeinrich/getID3       //
    7 /////////////////////////////////////////////////////////////////
    8 // See readme.txt for more details                             //
     5//  available at https://github.com/JamesHeinrich/getID3       //
     6//            or https://www.getid3.org                        //
     7//            or http://getid3.sourceforge.net                 //
     8//  see readme.txt for more details                            //
    99/////////////////////////////////////////////////////////////////
    1010///                                                            //
    … …  
    1818class getid3_lyrics3 extends getid3_handler
    1919{
    20 
     20    /**
     21     * @return bool
     22     */
    2123    public function Analyze() {
    2224        $info = &$this->getid3->info;
    … …  
    6264            // Lyrics3v2, no ID3v1, no APE
    6365
    64             $lyrics3size    = strrev(substr(strrev($lyrics3_id3v1), 9, 6)) + 6 + strlen('LYRICS200'); // LSZ = lyrics + 'LYRICSBEGIN'; add 6-byte size field; add 'LYRICS200'
     66            $lyrics3size    = (int) strrev(substr(strrev($lyrics3_id3v1), 9, 6)) + 6 + strlen('LYRICS200'); // LSZ = lyrics + 'LYRICSBEGIN'; add 6-byte size field; add 'LYRICS200'
    6567            $lyrics3offset  = $info['filesize'] - $lyrics3size;
    6668            $lyrics3version = 2;
    … …  
    9799        }
    98100
    99         if (isset($lyrics3offset)) {
     101        if (isset($lyrics3offset) && isset($lyrics3version) && isset($lyrics3size)) {
    100102            $info['avdataend'] = $lyrics3offset;
    101103            $this->getLyrics3Data($lyrics3offset, $lyrics3version, $lyrics3size);
    … …  
    127129    }
    128130
     131    /**
     132     * @param int $endoffset
     133     * @param int $version
     134     * @param int $length
     135     *
     136     * @return bool
     137     */
    129138    public function getLyrics3Data($endoffset, $version, $length) {
    130139        // http://www.volweb.cz/str/tags.htm
    … …  
    142151        }
    143152        $rawdata = $this->fread($length);
     153
     154        $ParsedLyrics3 = array();
    144155
    145156        $ParsedLyrics3['raw']['lyrics3version'] = $version;
    … …  
    251262    }
    252263
     264    /**
     265     * @param string $rawtimestamp
     266     *
     267     * @return int|false
     268     */
    253269    public function Lyrics3Timestamp2Seconds($rawtimestamp) {
    254270        if (preg_match('#^\\[([0-9]{2}):([0-9]{2})\\]$#', $rawtimestamp, $regs)) {
    … …  
    258274    }
    259275
     276    /**
     277     * @param array $Lyrics3data
     278     *
     279     * @return bool
     280     */
    260281    public function Lyrics3LyricsTimestampParse(&$Lyrics3data) {
    261282        $lyricsarray = explode("\r\n", $Lyrics3data['raw']['LYR']);
     283        $notimestamplyricsarray = array();
    262284        foreach ($lyricsarray as $key => $lyricline) {
    263285            $regs = array();
    … …  
    288310    }
    289311
     312    /**
     313     * @param string $char
     314     *
     315     * @return bool|null
     316     */
    290317    public function IntString2Bool($char) {
    291318        if ($char == '1') {

  • trunk/src/wp-includes/ID3/readme.txt

    r29734 r46112  
    22/// getID3() by James Heinrich <info@getid3.org>               //
    33//  available at http://getid3.sourceforge.net                 //
    4 //            or http://www.getid3.org                         //
     4//            or https://www.getid3.org                        //
    55//          also https://github.com/JamesHeinrich/getID3       //
    66/////////////////////////////////////////////////////////////////
    … …  
    1919GNU LGPL: https://gnu.org/licenses/lgpl.html                 (v3)
    2020
    21 Mozilla MPL: http://www.mozilla.org/MPL/2.0/                 (v2)
    22 
    23 getID3 Commercial License: http://getid3.org/#gCL (payment required)
     21Mozilla MPL: https://www.mozilla.org/MPL/2.0/                (v2)
     22
     23getID3 Commercial License: https://www.getid3.org/#gCL (payment required)
    2424
    2525*****************************************************************
    … …  
    2929
    3030
    31        +---------------------------------------------+
    32        | If you want to donate, there is a link on   |
    33        | http://www.getid3.org for PayPal donations. |
    34        +---------------------------------------------+
     31       +----------------------------------------------+
     32       | If you want to donate, there is a link on    |
     33       | https://www.getid3.org for PayPal donations. |
     34       +----------------------------------------------+
    3535
    3636
    … …  
    7878  * MP3/MP2/MP1
    7979  * MPC / Musepack
    80   * Ogg (Vorbis, OggFLAC, Speex)
     80  * Ogg (Vorbis, OggFLAC, Speex, Opus)
    8181  * AAC / MP4
    8282  * AC3
    … …  
    146146===========================================================================
    147147
    148 * PHP 4.2.0 up to 5.2.x for getID3() 1.7.x (and earlier)
    149 * PHP 5.0.5 (or higher) for getID3() 1.8.x (and up)
    150 * PHP 5.0.5 (or higher) for getID3() 2.0.x (and up)
     148* PHP 4.2.0 up to 5.2.x for getID3() 1.7.x  (and earlier)
     149* PHP 5.0.5 (or higher) for getID3() 1.8.x  (and up)
     150* PHP 5.3.0 (or higher) for getID3() 1.9.17 (and up)
     151* PHP 5.3.0 (or higher) for getID3() 2.0.x  (and up)
    151152* at least 4MB memory for PHP. 8MB or more is highly recommended.
    152153  12MB is required with all modules loaded.
    … …  
    178179$remotefilename = 'http://www.example.com/filename.mp3';
    179180if ($fp_remote = fopen($remotefilename, 'rb')) {
    180     $localtempfilename = tempnam('/tmp', 'getID3');
    181     if ($fp_local = fopen($localtempfilename, 'wb')) {
    182         while ($buffer = fread($fp_remote, 8192)) {
    183             fwrite($fp_local, $buffer);
    184         }
    185         fclose($fp_local);
     181    $localtempfilename = tempnam('/tmp', 'getID3');
     182    if ($fp_local = fopen($localtempfilename, 'wb')) {
     183        while ($buffer = fread($fp_remote, 32768)) {
     184            fwrite($fp_local, $buffer);
     185        }
     186        fclose($fp_local);
     187
     188        $remote_headers = array_change_key_case(get_headers($remotefilename, 1), CASE_LOWER);
     189        $remote_filesize = (isset($remote_headers['content-length']) ? (is_array($remote_headers['content-length']) ? $remote_headers['content-length'][count($remote_headers['content-length']) - 1] : $remote_headers['content-length']) : null);
    186190
    187191        // Initialize getID3 engine
    188192        $getID3 = new getID3;
    189193
    190         $ThisFileInfo = $getID3->analyze($filename);
    191 
    192         // Delete temporary file
    193         unlink($localtempfilename);
    194     }
    195     fclose($fp_remote);
     194        $ThisFileInfo = $getID3->analyze($localtempfilename, $remote_filesize, basename($remotefilename));
     195
     196        // Delete temporary file
     197        unlink($localtempfilename);
     198    }
     199    fclose($fp_remote);
    196200}
    197201
     202Note: since v1.9.9-20150212 it is possible a second and third parameter
     203to $getID3->analyze(), for original filesize and original filename
     204respectively. This permits you to download only a portion of a large remote
     205file but get accurate playtime estimates, assuming the format only requires
     206the beginning of the file for correct format analysis.
    198207
    199208See /demos/demo.write.php for how to write tags.
    … …  
    293302Future Plans
    294303===========================================================================
    295 http://www.getid3.org/phpBB3/viewforum.php?f=7
     304https://www.getid3.org/phpBB3/viewforum.php?f=7
    296305
    297306* Better support for MP4 container format
    … …  
    335344  (thanks rockcohenØmassive-interactive*nl)
    336345* Support for TTF (thanks infoØbutterflyx*com)
    337 * Support for DSS (http://www.getid3.org/phpBB3/viewtopic.php?t=171)
     346* Support for DSS (https://www.getid3.org/phpBB3/viewtopic.php?t=171)
    338347* Support for SMAF (http://smaf-yamaha.com/what/demo.html)
    339   http://www.getid3.org/phpBB3/viewtopic.php?t=182
    340 * Support for AMR (http://www.getid3.org/phpBB3/viewtopic.php?t=195)
    341 * Support for 3gpp (http://www.getid3.org/phpBB3/viewtopic.php?t=195)
     348  https://www.getid3.org/phpBB3/viewtopic.php?t=182
     349* Support for AMR (https://www.getid3.org/phpBB3/viewtopic.php?t=195)
     350* Support for 3gpp (https://www.getid3.org/phpBB3/viewtopic.php?t=195)
    342351* Support for ID4 (http://www.wackysoft.cjb.net grizlyY2KØhotmail*com)
    343352* Parse XML data returned in Ogg comments
    … …  
    375384Known Bugs/Issues in getID3() that may be fixed eventually
    376385===========================================================================
    377 http://www.getid3.org/phpBB3/viewtopic.php?t=25
     386https://www.getid3.org/phpBB3/viewtopic.php?t=25
    378387
    379388* Cannot determine bitrate for MPEG video with VBR video data
    … …  
    401410Known Bugs/Issues in getID3() that cannot be fixed
    402411--------------------------------------------------
    403 http://www.getid3.org/phpBB3/viewtopic.php?t=25
     412https://www.getid3.org/phpBB3/viewtopic.php?t=25
    404413
    405414* 32-bit PHP installations only:
    … …  
    431440Known Bugs/Issues in other programs
    432441-----------------------------------
    433 http://www.getid3.org/phpBB3/viewtopic.php?t=25
    434 
     442https://www.getid3.org/phpBB3/viewtopic.php?t=25
     443
     444* MusicBrainz Picard (at least up to v1.3.2) writes multiple
     445  ID3v2.3 genres in non-standard forward-slash separated text
     446  rather than parenthesis-numeric+refinement style per the ID3v2.3
     447  specs. Tags written in ID3v2.4 mode are written correctly.
     448  (detected and worked around by getID3())
     449* PZ TagEditor v4.53.408 has been known to insert ID3v2.3 frames
     450  into an existing ID3v2.2 tag which, of course, breaks things
    435451* Windows Media Player (up to v11) and iTunes (up to v10+) do
    436452    not correctly handle ID3v2.3 tags with UTF-16BE+BOM
    … …  
    452468* Oggenc 0.9-rc3 flags the encoded file as ABR whether it's
    453469    actually ABR or VBR.
     470* iTunes (versions "v7.0.0.70" is known-guilty, probably
     471    other versions are too) writes ID3v2.3 comment tags using an
     472    ID3v2.2 frame name (3-bytes) null-padded to 4 bytes which is
     473    not valid for ID3v2.3+
     474    (detected by getID3() since 1.9.12-201603221746)
    454475* iTunes (versions "X v2.0.3", "v3.0.1" are known-guilty, probably
    455476    other versions are too) writes ID3v2.3 comment tags using a
    … …  
    603624* http://wyday.com/cuesharp/specification.php
    604625* http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/Nikon.html
     626* http://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header
     627* http://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
Note: See TracChangeset for help on using the changeset viewer.