Ticket #23673: 23673.diff

wp-admin/includes/image.php

@@ -116 +116 @@
                 if ( $image_meta )
                         $metadata['image_meta'] = $image_meta;
 
+        } elseif ( preg_match( '#^video/#', get_post_mime_type( $attachment ) ) ) {
+                $metadata = wp_read_video_metadata( $file );
+        } elseif ( preg_match( '#^audio/#', get_post_mime_type( $attachment ) ) ) {
+                $metadata = wp_read_audio_metadata( $file );
         }
 
         return apply_filters( 'wp_generate_attachment_metadata', $metadata, $attachment_id );

new file wp-includes/ID3/class-getid3.php

@@ +1 @@
+<?php
+/////////////////////////////////////////////////////////////////
+/// getID3() by James Heinrich <info@getid3.org>               //
+//  available at http://getid3.sourceforge.net                 //
+//            or http://www.getid3.org                         //
+/////////////////////////////////////////////////////////////////
+//                                                             //
+// Please see readme.txt for more information                  //
+//                                                            ///
+/////////////////////////////////////////////////////////////////
+
+// define a constant rather than looking up every time it is needed
+if (!defined('GETID3_OS_ISWINDOWS')) {
+        define('GETID3_OS_ISWINDOWS', (stripos(PHP_OS, 'WIN') === 0));
+}
+// Get base path of getID3() - ONCE
+if (!defined('GETID3_INCLUDEPATH')) {
+        define('GETID3_INCLUDEPATH', dirname(__FILE__).DIRECTORY_SEPARATOR);
+}
+
+// attempt to define temp dir as something flexible but reliable
+$temp_dir = ini_get('upload_tmp_dir');
+if ($temp_dir && (!is_dir($temp_dir) || !is_readable($temp_dir))) {
+        $temp_dir = '';
+}
+if (!$temp_dir && function_exists('sys_get_temp_dir')) {
+        // PHP v5.2.1+
+        // sys_get_temp_dir() may give inaccessible temp dir, e.g. with open_basedir on virtual hosts
+        $temp_dir = sys_get_temp_dir();
+}
+$temp_dir = realpath($temp_dir);
+$open_basedir = ini_get('open_basedir');
+if ($open_basedir) {
+        // e.g. "/var/www/vhosts/getid3.org/httpdocs/:/tmp/"
+        $temp_dir     = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $temp_dir);
+        $open_basedir = str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $open_basedir);
+        if (substr($temp_dir, -1, 1) != DIRECTORY_SEPARATOR) {
+                $temp_dir .= DIRECTORY_SEPARATOR;
+        }
+        $found_valid_tempdir = false;
+        $open_basedirs = explode(PATH_SEPARATOR, $open_basedir);
+        foreach ($open_basedirs as $basedir) {
+                if (substr($basedir, -1, 1) != DIRECTORY_SEPARATOR) {
+                        $basedir .= DIRECTORY_SEPARATOR;
+                }
+                if (preg_match('#^'.preg_quote($basedir).'#', $temp_dir)) {
+                        $found_valid_tempdir = true;
+                        break;
+                }
+        }
+        if (!$found_valid_tempdir) {
+                $temp_dir = '';
+        }
+        unset($open_basedirs, $found_valid_tempdir, $basedir);
+}
+if (!$temp_dir) {
+        $temp_dir = '*'; // invalid directory name should force tempnam() to use system default temp dir
+}
+// $temp_dir = '/something/else/';  // feel free to override temp dir here if it works better for your system
+define('GETID3_TEMP_DIR', $temp_dir);
+unset($open_basedir, $temp_dir);
+
+// End: Defines
+
+
+class getID3
+{
+        // public: Settings
+        public $encoding        = 'UTF-8';        // CASE SENSITIVE! - i.e. (must be supported by iconv()). Examples:  ISO-8859-1  UTF-8  UTF-16  UTF-16BE
+        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'
+
+        // public: Optional tag checks - disable for speed.
+        public $option_tag_id3v1         = true;  // Read and process ID3v1 tags
+        public $option_tag_id3v2         = true;  // Read and process ID3v2 tags
+        public $option_tag_lyrics3       = true;  // Read and process Lyrics3 tags
+        public $option_tag_apetag        = true;  // Read and process APE tags
+        public $option_tags_process      = true;  // Copy tags to root key 'tags' and encode to $this->encoding
+        public $option_tags_html         = true;  // Copy tags to root key 'tags_html' properly translated from various encodings to HTML entities
+
+        // public: Optional tag/comment calucations
+        public $option_extra_info        = true;  // Calculate additional info such as bitrate, channelmode etc
+
+        // public: Optional handling of embedded attachments (e.g. images)
+        public $option_save_attachments  = true; // defaults to true (ATTACHMENTS_INLINE) for backward compatibility
+
+        // public: Optional calculations
+        public $option_md5_data          = false; // Get MD5 sum of data part - slow
+        public $option_md5_data_source   = false; // Use MD5 of source file if availble - only FLAC and OptimFROG
+        public $option_sha1_data         = false; // Get SHA1 sum of data part - slow
+        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)
+
+        // public: Read buffer size in bytes
+        public $option_fread_buffer_size = 32768;
+
+        // Public variables
+        public $filename;                         // Filename of file being analysed.
+        public $fp;                               // Filepointer to file being analysed.
+        public $info;                             // Result array.
+        public $tempdir = GETID3_TEMP_DIR;
+
+        // Protected variables
+        protected $startup_error   = '';
+        protected $startup_warning = '';
+        protected $memory_limit    = 0;
+
+        const VERSION           = '1.9.5-20130220';
+        const FREAD_BUFFER_SIZE = 32768;
+
+        const ATTACHMENTS_NONE   = false;
+        const ATTACHMENTS_INLINE = true;
+
+        // public: constructor
+        public function __construct() {
+
+                // Check for PHP version
+                $required_php_version = '5.0.5';
+                if (version_compare(PHP_VERSION, $required_php_version, '<')) {
+                        $this->startup_error .= 'getID3() requires PHP v'.$required_php_version.' or higher - you are running v'.PHP_VERSION;
+                        return false;
+                }
+
+                // Check memory
+                $this->memory_limit = ini_get('memory_limit');
+                if (preg_match('#([0-9]+)M#i', $this->memory_limit, $matches)) {
+                        // could be stored as "16M" rather than 16777216 for example
+                        $this->memory_limit = $matches[1] * 1048576;
+                } elseif (preg_match('#([0-9]+)G#i', $this->memory_limit, $matches)) { // The 'G' modifier is available since PHP 5.1.0
+                        // could be stored as "2G" rather than 2147483648 for example
+                        $this->memory_limit = $matches[1] * 1073741824;
+                }
+                if ($this->memory_limit <= 0) {
+                        // memory limits probably disabled
+                } elseif ($this->memory_limit <= 4194304) {
+                        $this->startup_error .= 'PHP has less than 4MB available memory and will very likely run out. Increase memory_limit in php.ini';
+                } elseif ($this->memory_limit <= 12582912) {
+                        $this->startup_warning .= 'PHP has less than 12MB available memory and might run out if all modules are loaded. Increase memory_limit in php.ini';
+                }
+
+                // Check safe_mode off
+                if (preg_match('#(1|ON)#i', ini_get('safe_mode'))) {
+                        $this->warning('WARNING: Safe mode is on, shorten support disabled, md5data/sha1data for ogg vorbis disabled, ogg vorbos/flac tag writing disabled.');
+                }
+
+                if (intval(ini_get('mbstring.func_overload')) > 0) {
+                        $this->warning('WARNING: php.ini contains "mbstring.func_overload = '.ini_get('mbstring.func_overload').'", this may break things.');
+                }
+
+                // Check for magic_quotes_runtime
+                if (function_exists('get_magic_quotes_runtime')) {
+                        if (get_magic_quotes_runtime()) {
+                                return $this->startup_error('magic_quotes_runtime must be disabled before running getID3(). Surround getid3 block by set_magic_quotes_runtime(0) and set_magic_quotes_runtime(1).');
+                        }
+                }
+
+                // Check for magic_quotes_gpc
+                if (function_exists('magic_quotes_gpc')) {
+                        if (get_magic_quotes_gpc()) {
+                                return $this->startup_error('magic_quotes_gpc must be disabled before running getID3(). Surround getid3 block by set_magic_quotes_gpc(0) and set_magic_quotes_gpc(1).');
+                        }
+                }
+
+                // Load support library
+                if (!include_once(GETID3_INCLUDEPATH.'getid3.lib.php')) {
+                        $this->startup_error .= 'getid3.lib.php is missing or corrupt';
+                }
+
+                if ($this->option_max_2gb_check === null) {
+                        $this->option_max_2gb_check = (PHP_INT_MAX <= 2147483647);
+                }
+
+
+                // Needed for Windows only:
+                // Define locations of helper applications for Shorten, VorbisComment, MetaFLAC
+                //   as well as other helper functions such as head, tail, md5sum, etc
+                // This path cannot contain spaces, but the below code will attempt to get the
+                //   8.3-equivalent path automatically
+                // IMPORTANT: This path must include the trailing slash
+                if (GETID3_OS_ISWINDOWS && !defined('GETID3_HELPERAPPSDIR')) {
+
+                        $helperappsdir = GETID3_INCLUDEPATH.'..'.DIRECTORY_SEPARATOR.'helperapps'; // must not have any space in this path
+
+                        if (!is_dir($helperappsdir)) {
+                                $this->startup_warning .= '"'.$helperappsdir.'" cannot be defined as GETID3_HELPERAPPSDIR because it does not exist';
+                        } elseif (strpos(realpath($helperappsdir), ' ') !== false) {
+                                $DirPieces = explode(DIRECTORY_SEPARATOR, realpath($helperappsdir));
+                                $path_so_far = array();
+                                foreach ($DirPieces as $key => $value) {
+                                        if (strpos($value, ' ') !== false) {
+                                                if (!empty($path_so_far)) {
+                                                        $commandline = 'dir /x '.escapeshellarg(implode(DIRECTORY_SEPARATOR, $path_so_far));
+                                                        $dir_listing = `$commandline`;
+                                                        $lines = explode("\n", $dir_listing);
+                                                        foreach ($lines as $line) {
+                                                                $line = trim($line);
+                                                                if (preg_match('#^([0-9/]{10}) +([0-9:]{4,5}( [AP]M)?) +(<DIR>|[0-9,]+) +([^ ]{0,11}) +(.+)$#', $line, $matches)) {
+                                                                        list($dummy, $date, $time, $ampm, $filesize, $shortname, $filename) = $matches;
+                                                                        if ((strtoupper($filesize) == '<DIR>') && (strtolower($filename) == strtolower($value))) {
+                                                                                $value = $shortname;
+                                                                        }
+                                                                }
+                                                        }
+                                                } else {
+                                                        $this->startup_warning .= 'GETID3_HELPERAPPSDIR must not have any spaces in it - use 8dot3 naming convention if neccesary. You can run "dir /x" from the commandline to see the correct 8.3-style names.';
+                                                }
+                                        }
+                                        $path_so_far[] = $value;
+                                }
+                                $helperappsdir = implode(DIRECTORY_SEPARATOR, $path_so_far);
+                        }
+                        define('GETID3_HELPERAPPSDIR', $helperappsdir.DIRECTORY_SEPARATOR);
+                }
+
+                return true;
+        }
+
+        public function version() {
+                return self::VERSION;
+        }
+
+        public function fread_buffer_size() {
+                return $this->option_fread_buffer_size;
+        }
+
+        // public: setOption
+        public function setOption($optArray) {
+                if (!is_array($optArray) || empty($optArray)) {
+                        return false;
+                }
+                foreach ($optArray as $opt => $val) {
+                        if (isset($this->$opt) === false) {
+                                continue;
+                        }
+                        $this->$opt = $val;
+                }
+                return true;
+        }
+
+        public function openfile($filename) {
+                try {
+                        if (!empty($this->startup_error)) {
+                                throw new getid3_exception($this->startup_error);
+                        }
+                        if (!empty($this->startup_warning)) {
+                                $this->warning($this->startup_warning);
+                        }
+
+                        // init result array and set parameters
+                        $this->filename = $filename;
+                        $this->info = array();
+                        $this->info['GETID3_VERSION']   = $this->version();
+                        $this->info['php_memory_limit'] = $this->memory_limit;
+
+                        // remote files not supported
+                        if (preg_match('/^(ht|f)tp:\/\//', $filename)) {
+                                throw new getid3_exception('Remote files are not supported - please copy the file locally first');
+                        }
+
+                        $filename = str_replace('/', DIRECTORY_SEPARATOR, $filename);
+                        $filename = preg_replace('#(.+)'.preg_quote(DIRECTORY_SEPARATOR).'{2,}#U', '\1'.DIRECTORY_SEPARATOR, $filename);
+
+                        // open local file
+                        if (is_readable($filename) && is_file($filename) && ($this->fp = fopen($filename, 'rb'))) {
+                                // great
+                        } else {
+                                throw new getid3_exception('Could not open "'.$filename.'" (does not exist, or is not a file)');
+                        }
+
+                        $this->info['filesize'] = filesize($filename);
+                        // set redundant parameters - might be needed in some include file
+                        $this->info['filename']     = basename($filename);
+                        $this->info['filepath']     = str_replace('\\', '/', realpath(dirname($filename)));
+                        $this->info['filenamepath'] = $this->info['filepath'].'/'.$this->info['filename'];
+
+
+                        // option_max_2gb_check
+                        if ($this->option_max_2gb_check) {
+                                // PHP (32-bit all, and 64-bit Windows) doesn't support integers larger than 2^31 (~2GB)
+                                // filesize() simply returns (filesize % (pow(2, 32)), no matter the actual filesize
+                                // ftell() returns 0 if seeking to the end is beyond the range of unsigned integer
+                                $fseek = fseek($this->fp, 0, SEEK_END);
+                                if (($fseek < 0) || (($this->info['filesize'] != 0) && (ftell($this->fp) == 0)) ||
+                                        ($this->info['filesize'] < 0) ||
+                                        (ftell($this->fp) < 0)) {
+                                                $real_filesize = getid3_lib::getFileSizeSyscall($this->info['filenamepath']);
+
+                                                if ($real_filesize === false) {
+                                                        unset($this->info['filesize']);
+                                                        fclose($this->fp);
+                                                        throw new getid3_exception('Unable to determine actual filesize. File is most likely larger than '.round(PHP_INT_MAX / 1073741824).'GB and is not supported by PHP.');
+                                                } elseif (getid3_lib::intValueSupported($real_filesize)) {
+                                                        unset($this->info['filesize']);
+                                                        fclose($this->fp);
+                                                        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');
+                                                }
+                                                $this->info['filesize'] = $real_filesize;
+                                                $this->error('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.');
+                                }
+                        }
+
+                        // set more parameters
+                        $this->info['avdataoffset']        = 0;
+                        $this->info['avdataend']           = $this->info['filesize'];
+                        $this->info['fileformat']          = '';                // filled in later
+                        $this->info['audio']['dataformat'] = '';                // filled in later, unset if not used
+                        $this->info['video']['dataformat'] = '';                // filled in later, unset if not used
+                        $this->info['tags']                = array();           // filled in later, unset if not used
+                        $this->info['error']               = array();           // filled in later, unset if not used
+                        $this->info['warning']             = array();           // filled in later, unset if not used
+                        $this->info['comments']            = array();           // filled in later, unset if not used
+                        $this->info['encoding']            = $this->encoding;   // required by id3v2 and iso modules - can be unset at the end if desired
+
+                        return true;
+
+                } catch (Exception $e) {
+                        $this->error($e->getMessage());
+                }
+                return false;
+        }
+
+        // public: analyze file
+        public function analyze($filename) {
+                try {
+                        if (!$this->openfile($filename)) {
+                                return $this->info;
+                        }
+
+                        // Handle tags
+                        foreach (array('id3v2'=>'id3v2', 'id3v1'=>'id3v1', 'apetag'=>'ape', 'lyrics3'=>'lyrics3') as $tag_name => $tag_key) {
+                                $option_tag = 'option_tag_'.$tag_name;
+                                if ($this->$option_tag) {
+                                        $this->include_module('tag.'.$tag_name);
+                                        try {
+                                                $tag_class = 'getid3_'.$tag_name;
+                                                $tag = new $tag_class($this);
+                                                $tag->Analyze();
+                                        }
+                                        catch (getid3_exception $e) {
+                                                throw $e;
+                                        }
+                                }
+                        }
+                        if (isset($this->info['id3v2']['tag_offset_start'])) {
+                                $this->info['avdataoffset'] = max($this->info['avdataoffset'], $this->info['id3v2']['tag_offset_end']);
+                        }
+                        foreach (array('id3v1'=>'id3v1', 'apetag'=>'ape', 'lyrics3'=>'lyrics3') as $tag_name => $tag_key) {
+                                if (isset($this->info[$tag_key]['tag_offset_start'])) {
+                                        $this->info['avdataend'] = min($this->info['avdataend'], $this->info[$tag_key]['tag_offset_start']);
+                                }
+                        }
+
+                        // ID3v2 detection (NOT parsing), even if ($this->option_tag_id3v2 == false) done to make fileformat easier
+                        if (!$this->option_tag_id3v2) {
+                                fseek($this->fp, 0, SEEK_SET);
+                                $header = fread($this->fp, 10);
+                                if ((substr($header, 0, 3) == 'ID3') && (strlen($header) == 10)) {
+                                        $this->info['id3v2']['header']        = true;
+                                        $this->info['id3v2']['majorversion']  = ord($header{3});
+                                        $this->info['id3v2']['minorversion']  = ord($header{4});
+                                        $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
+                                }
+                        }
+
+                        // read 32 kb file data
+                        fseek($this->fp, $this->info['avdataoffset'], SEEK_SET);
+                        $formattest = fread($this->fp, 32774);
+
+                        // determine format
+                        $determined_format = $this->GetFileFormat($formattest, $filename);
+
+                        // unable to determine file format
+                        if (!$determined_format) {
+                                fclose($this->fp);
+                                return $this->error('unable to determine file format');
+                        }
+
+                        // check for illegal ID3 tags
+                        if (isset($determined_format['fail_id3']) && (in_array('id3v1', $this->info['tags']) || in_array('id3v2', $this->info['tags']))) {
+                                if ($determined_format['fail_id3'] === 'ERROR') {
+                                        fclose($this->fp);
+                                        return $this->error('ID3 tags not allowed on this file type.');
+                                } elseif ($determined_format['fail_id3'] === 'WARNING') {
+                                        $this->warning('ID3 tags not allowed on this file type.');
+                                }
+                        }
+
+                        // check for illegal APE tags
+                        if (isset($determined_format['fail_ape']) && in_array('ape', $this->info['tags'])) {
+                                if ($determined_format['fail_ape'] === 'ERROR') {
+                                        fclose($this->fp);
+                                        return $this->error('APE tags not allowed on this file type.');
+                                } elseif ($determined_format['fail_ape'] === 'WARNING') {
+                                        $this->warning('APE tags not allowed on this file type.');
+                                }
+                        }
+
+                        // set mime type
+                        $this->info['mime_type'] = $determined_format['mime_type'];
+
+                        // supported format signature pattern detected, but module deleted
+                        if (!file_exists(GETID3_INCLUDEPATH.$determined_format['include'])) {
+                                fclose($this->fp);
+                                return $this->error('Format not supported, module "'.$determined_format['include'].'" was removed.');
+                        }
+
+                        // module requires iconv support
+                        // Check encoding/iconv support
+                        if (!empty($determined_format['iconv_req']) && !function_exists('iconv') && !in_array($this->encoding, array('ISO-8859-1', 'UTF-8', 'UTF-16LE', 'UTF-16BE', 'UTF-16'))) {
+                                $errormessage = 'iconv() support is required for this module ('.$determined_format['include'].') for encodings other than ISO-8859-1, UTF-8, UTF-16LE, UTF16-BE, UTF-16. ';
+                                if (GETID3_OS_ISWINDOWS) {
+                                        $errormessage .= 'PHP does not have iconv() support. Please enable php_iconv.dll in php.ini, and copy iconv.dll from c:/php/dlls to c:/windows/system32';
+                                } else {
+                                        $errormessage .= 'PHP is not compiled with iconv() support. Please recompile with the --with-iconv switch';
+                                }
+                                return $this->error($errormessage);
+                        }
+
+                        // include module
+                        include_once(GETID3_INCLUDEPATH.$determined_format['include']);
+
+                        // instantiate module class
+                        $class_name = 'getid3_'.$determined_format['module'];
+                        if (!class_exists($class_name)) {
+                                return $this->error('Format not supported, module "'.$determined_format['include'].'" is corrupt.');
+                        }
+                        $class = new $class_name($this);
+                        $class->Analyze();
+                        unset($class);
+
+                        // close file
+                        fclose($this->fp);
+
+                        // process all tags - copy to 'tags' and convert charsets
+                        if ($this->option_tags_process) {
+                                $this->HandleAllTags();
+                        }
+
+                        // perform more calculations
+                        if ($this->option_extra_info) {
+                                $this->ChannelsBitratePlaytimeCalculations();
+                                $this->CalculateCompressionRatioVideo();
+                                $this->CalculateCompressionRatioAudio();
+                                $this->CalculateReplayGain();
+                                $this->ProcessAudioStreams();
+                        }
+
+                        // get the MD5 sum of the audio/video portion of the file - without ID3/APE/Lyrics3/etc header/footer tags
+                        if ($this->option_md5_data) {
+                                // do not calc md5_data if md5_data_source is present - set by flac only - future MPC/SV8 too
+                                if (!$this->option_md5_data_source || empty($this->info['md5_data_source'])) {
+                                        $this->getHashdata('md5');
+                                }
+                        }
+
+                        // get the SHA1 sum of the audio/video portion of the file - without ID3/APE/Lyrics3/etc header/footer tags
+                        if ($this->option_sha1_data) {
+                                $this->getHashdata('sha1');
+                        }
+
+                        // remove undesired keys
+                        $this->CleanUp();
+
+                } catch (Exception $e) {
+                        $this->error('Caught exception: '.$e->getMessage());
+                }
+
+                // return info array
+                return $this->info;
+        }
+
+
+        // private: error handling
+        public function error($message) {
+                $this->CleanUp();
+                if (!isset($this->info['error'])) {
+                        $this->info['error'] = array();
+                }
+                $this->info['error'][] = $message;
+                return $this->info;
+        }
+
+
+        // private: warning handling
+        public function warning($message) {
+                $this->info['warning'][] = $message;
+                return true;
+        }
+
+
+        // private: CleanUp
+        private function CleanUp() {
+
+                // remove possible empty keys
+                $AVpossibleEmptyKeys = array('dataformat', 'bits_per_sample', 'encoder_options', 'streams', 'bitrate');
+                foreach ($AVpossibleEmptyKeys as $dummy => $key) {
+                        if (empty($this->info['audio'][$key]) && isset($this->info['audio'][$key])) {
+                                unset($this->info['audio'][$key]);
+                        }
+                        if (empty($this->info['video'][$key]) && isset($this->info['video'][$key])) {
+                                unset($this->info['video'][$key]);
+                        }
+                }
+
+                // remove empty root keys
+                if (!empty($this->info)) {
+                        foreach ($this->info as $key => $value) {
+                                if (empty($this->info[$key]) && ($this->info[$key] !== 0) && ($this->info[$key] !== '0')) {
+                                        unset($this->info[$key]);
+                                }
+                        }
+                }
+
+                // remove meaningless entries from unknown-format files
+                if (empty($this->info['fileformat'])) {
+                        if (isset($this->info['avdataoffset'])) {
+                                unset($this->info['avdataoffset']);
+                        }
+                        if (isset($this->info['avdataend'])) {
+                                unset($this->info['avdataend']);
+                        }
+                }
+
+                // remove possible duplicated identical entries
+                if (!empty($this->info['error'])) {
+                        $this->info['error'] = array_values(array_unique($this->info['error']));
+                }
+                if (!empty($this->info['warning'])) {
+                        $this->info['warning'] = array_values(array_unique($this->info['warning']));
+                }
+
+                // remove "global variable" type keys
+                unset($this->info['php_memory_limit']);
+
+                return true;
+        }
+
+
+        // return array containing information about all supported formats
+        public function GetFileFormatArray() {
+                static $format_info = array();
+                if (empty($format_info)) {
+                        $format_info = array(
+
+                                // Audio formats
+
+                                // AC-3   - audio      - Dolby AC-3 / Dolby Digital
+                                'ac3'  => array(
+                                                        'pattern'   => '^\x0B\x77',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'ac3',
+                                                        'mime_type' => 'audio/ac3',
+                                                ),
+
+                                // AAC  - audio       - Advanced Audio Coding (AAC) - ADIF format
+                                'adif' => array(
+                                                        'pattern'   => '^ADIF',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'aac',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_ape'  => 'WARNING',
+                                                ),
+
+/*
+                                // AA   - audio       - Audible Audiobook
+                                'aa'   => array(
+                                                        'pattern'   => '^.{4}\x57\x90\x75\x36',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'aa',
+                                                        'mime_type' => 'audio/audible',
+                                                ),
+*/
+                                // AAC  - audio       - Advanced Audio Coding (AAC) - ADTS format (very similar to MP3)
+                                'adts' => array(
+                                                        'pattern'   => '^\xFF[\xF0-\xF1\xF8-\xF9]',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'aac',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_ape'  => 'WARNING',
+                                                ),
+
+
+                                // AU   - audio       - NeXT/Sun AUdio (AU)
+                                'au'   => array(
+                                                        'pattern'   => '^\.snd',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'au',
+                                                        'mime_type' => 'audio/basic',
+                                                ),
+
+                                // AVR  - audio       - Audio Visual Research
+                                'avr'  => array(
+                                                        'pattern'   => '^2BIT',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'avr',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // BONK - audio       - Bonk v0.9+
+                                'bonk' => array(
+                                                        'pattern'   => '^\x00(BONK|INFO|META| ID3)',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'bonk',
+                                                        'mime_type' => 'audio/xmms-bonk',
+                                                ),
+
+                                // DSS  - audio       - Digital Speech Standard
+                                'dss'  => array(
+                                                        'pattern'   => '^[\x02-\x03]ds[s2]',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'dss',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // DTS  - audio       - Dolby Theatre System
+                                'dts'  => array(
+                                                        'pattern'   => '^\x7F\xFE\x80\x01',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'dts',
+                                                        'mime_type' => 'audio/dts',
+                                                ),
+
+                                // FLAC - audio       - Free Lossless Audio Codec
+                                'flac' => array(
+                                                        'pattern'   => '^fLaC',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'flac',
+                                                        'mime_type' => 'audio/x-flac',
+                                                ),
+
+                                // LA   - audio       - Lossless Audio (LA)
+                                'la'   => array(
+                                                        'pattern'   => '^LA0[2-4]',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'la',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // LPAC - audio       - Lossless Predictive Audio Compression (LPAC)
+                                'lpac' => array(
+                                                        'pattern'   => '^LPAC',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'lpac',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // MIDI - audio       - MIDI (Musical Instrument Digital Interface)
+                                'midi' => array(
+                                                        'pattern'   => '^MThd',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'midi',
+                                                        'mime_type' => 'audio/midi',
+                                                ),
+
+                                // MAC  - audio       - Monkey's Audio Compressor
+                                'mac'  => array(
+                                                        'pattern'   => '^MAC ',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'monkey',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+// has been known to produce false matches in random files (e.g. JPEGs), leave out until more precise matching available
+//                              // MOD  - audio       - MODule (assorted sub-formats)
+//                              'mod'  => array(
+//                                                      'pattern'   => '^.{1080}(M\\.K\\.|M!K!|FLT4|FLT8|[5-9]CHN|[1-3][0-9]CH)',
+//                                                      'group'     => 'audio',
+//                                                      'module'    => 'mod',
+//                                                      'option'    => 'mod',
+//                                                      'mime_type' => 'audio/mod',
+//                                              ),
+
+                                // MOD  - audio       - MODule (Impulse Tracker)
+                                'it'   => array(
+                                                        'pattern'   => '^IMPM',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'mod',
+                                                        //'option'    => 'it',
+                                                        'mime_type' => 'audio/it',
+                                                ),
+
+                                // MOD  - audio       - MODule (eXtended Module, various sub-formats)
+                                'xm'   => array(
+                                                        'pattern'   => '^Extended Module',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'mod',
+                                                        //'option'    => 'xm',
+                                                        'mime_type' => 'audio/xm',
+                                                ),
+
+                                // MOD  - audio       - MODule (ScreamTracker)
+                                's3m'  => array(
+                                                        'pattern'   => '^.{44}SCRM',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'mod',
+                                                        //'option'    => 's3m',
+                                                        'mime_type' => 'audio/s3m',
+                                                ),
+
+                                // MPC  - audio       - Musepack / MPEGplus
+                                'mpc'  => array(
+                                                        'pattern'   => '^(MPCK|MP\+|[\x00\x01\x10\x11\x40\x41\x50\x51\x80\x81\x90\x91\xC0\xC1\xD0\xD1][\x20-37][\x00\x20\x40\x60\x80\xA0\xC0\xE0])',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'mpc',
+                                                        'mime_type' => 'audio/x-musepack',
+                                                ),
+
+                                // MP3  - audio       - MPEG-audio Layer 3 (very similar to AAC-ADTS)
+                                'mp3'  => array(
+                                                        'pattern'   => '^\xFF[\xE2-\xE7\xF2-\xF7\xFA-\xFF][\x00-\x0B\x10-\x1B\x20-\x2B\x30-\x3B\x40-\x4B\x50-\x5B\x60-\x6B\x70-\x7B\x80-\x8B\x90-\x9B\xA0-\xAB\xB0-\xBB\xC0-\xCB\xD0-\xDB\xE0-\xEB\xF0-\xFB]',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'mp3',
+                                                        'mime_type' => 'audio/mpeg',
+                                                ),
+
+                                // OFR  - audio       - OptimFROG
+                                'ofr'  => array(
+                                                        'pattern'   => '^(\*RIFF|OFR)',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'optimfrog',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // RKAU - audio       - RKive AUdio compressor
+                                'rkau' => array(
+                                                        'pattern'   => '^RKA',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'rkau',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // SHN  - audio       - Shorten
+                                'shn'  => array(
+                                                        'pattern'   => '^ajkg',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'shorten',
+                                                        'mime_type' => 'audio/xmms-shn',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // TTA  - audio       - TTA Lossless Audio Compressor (http://tta.corecodec.org)
+                                'tta'  => array(
+                                                        'pattern'   => '^TTA',  // could also be '^TTA(\x01|\x02|\x03|2|1)'
+                                                        'group'     => 'audio',
+                                                        'module'    => 'tta',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // VOC  - audio       - Creative Voice (VOC)
+                                'voc'  => array(
+                                                        'pattern'   => '^Creative Voice File',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'voc',
+                                                        'mime_type' => 'audio/voc',
+                                                ),
+
+                                // VQF  - audio       - transform-domain weighted interleave Vector Quantization Format (VQF)
+                                'vqf'  => array(
+                                                        'pattern'   => '^TWIN',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'vqf',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // WV  - audio        - WavPack (v4.0+)
+                                'wv'   => array(
+                                                        'pattern'   => '^wvpk',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'wavpack',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+
+                                // Audio-Video formats
+
+                                // ASF  - audio/video - Advanced Streaming Format, Windows Media Video, Windows Media Audio
+                                'asf'  => array(
+                                                        'pattern'   => '^\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'asf',
+                                                        'mime_type' => 'video/x-ms-asf',
+                                                        'iconv_req' => false,
+                                                ),
+
+                                // BINK - audio/video - Bink / Smacker
+                                'bink' => array(
+                                                        'pattern'   => '^(BIK|SMK)',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'bink',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // FLV  - audio/video - FLash Video
+                                'flv' => array(
+                                                        'pattern'   => '^FLV\x01',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'flv',
+                                                        'mime_type' => 'video/x-flv',
+                                                ),
+
+                                // MKAV - audio/video - Mastroka
+                                'matroska' => array(
+                                                        'pattern'   => '^\x1A\x45\xDF\xA3',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'matroska',
+                                                        'mime_type' => 'video/x-matroska', // may also be audio/x-matroska
+                                                ),
+
+                                // MPEG - audio/video - MPEG (Moving Pictures Experts Group)
+                                'mpeg' => array(
+                                                        'pattern'   => '^\x00\x00\x01(\xBA|\xB3)',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'mpeg',
+                                                        'mime_type' => 'video/mpeg',
+                                                ),
+
+                                // NSV  - audio/video - Nullsoft Streaming Video (NSV)
+                                'nsv'  => array(
+                                                        'pattern'   => '^NSV[sf]',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'nsv',
+                                                        'mime_type' => 'application/octet-stream',
+                                                ),
+
+                                // Ogg  - audio/video - Ogg (Ogg-Vorbis, Ogg-FLAC, Speex, Ogg-Theora(*), Ogg-Tarkin(*))
+                                'ogg'  => array(
+                                                        'pattern'   => '^OggS',
+                                                        'group'     => 'audio',
+                                                        'module'    => 'ogg',
+                                                        'mime_type' => 'application/ogg',
+                                                        'fail_id3'  => 'WARNING',
+                                                        'fail_ape'  => 'WARNING',
+                                                ),
+
+                                // QT   - audio/video - Quicktime
+                                'quicktime' => array(
+                                                        'pattern'   => '^.{4}(cmov|free|ftyp|mdat|moov|pnot|skip|wide)',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'quicktime',
+                                                        'mime_type' => 'video/quicktime',
+                                                ),
+
+                                // RIFF - audio/video - Resource Interchange File Format (RIFF) / WAV / AVI / CD-audio / SDSS = renamed variant used by SmartSound QuickTracks (www.smartsound.com) / FORM = Audio Interchange File Format (AIFF)
+                                'riff' => array(
+                                                        'pattern'   => '^(RIFF|SDSS|FORM)',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'riff',
+                                                        'mime_type' => 'audio/x-wave',
+                                                        'fail_ape'  => 'WARNING',
+                                                ),
+
+                                // Real - audio/video - RealAudio, RealVideo
+                                'real' => array(
+                                                        'pattern'   => '^(\\.RMF|\\.ra)',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'real',
+                                                        'mime_type' => 'audio/x-realaudio',
+                                                ),
+
+                                // SWF - audio/video - ShockWave Flash
+                                'swf' => array(
+                                                        'pattern'   => '^(F|C)WS',
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'swf',
+                                                        'mime_type' => 'application/x-shockwave-flash',
+                                                ),
+
+                                // TS - audio/video - MPEG-2 Transport Stream
+                                'ts' => array(
+                                                        'pattern'   => '^(\x47.{187}){10,}', // packets are 188 bytes long and start with 0x47 "G".  Check for at least 10 packets matching this pattern
+                                                        'group'     => 'audio-video',
+                                                        'module'    => 'ts',
+                                                        'mime_type' => 'video/MP2T',
+                                                ),
+
+
+                                // Still-Image formats
+
+                                // BMP  - still image - Bitmap (Windows, OS/2; uncompressed, RLE8, RLE4)
+                                'bmp'  => array(
+                                                        'pattern'   => '^BM',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'bmp',
+                                                        'mime_type' => 'image/bmp',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // GIF  - still image - Graphics Interchange Format
+                                'gif'  => array(
+                                                        'pattern'   => '^GIF',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'gif',
+                                                        'mime_type' => 'image/gif',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // JPEG - still image - Joint Photographic Experts Group (JPEG)
+                                'jpg'  => array(
+                                                        'pattern'   => '^\xFF\xD8\xFF',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'jpg',
+                                                        'mime_type' => 'image/jpeg',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // PCD  - still image - Kodak Photo CD
+                                'pcd'  => array(
+                                                        'pattern'   => '^.{2048}PCD_IPI\x00',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'pcd',
+                                                        'mime_type' => 'image/x-photo-cd',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+
+                                // PNG  - still image - Portable Network Graphics (PNG)
+                                'png'  => array(
+                                                        'pattern'   => '^\x89\x50\x4E\x47\x0D\x0A\x1A\x0A',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'png',
+                                                        'mime_type' => 'image/png',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+
+                                // SVG  - still image - Scalable Vector Graphics (SVG)
+                                'svg'  => array(
+                                                        'pattern'   => '(<!DOCTYPE svg PUBLIC |xmlns="http:\/\/www\.w3\.org\/2000\/svg")',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'svg',
+                                                        'mime_type' => 'image/svg+xml',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+
+                                // TIFF - still image - Tagged Information File Format (TIFF)
+                                'tiff' => array(
+                                                        'pattern'   => '^(II\x2A\x00|MM\x00\x2A)',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'tiff',
+                                                        'mime_type' => 'image/tiff',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+
+                                // EFAX - still image - eFax (TIFF derivative)
+                                'efax'  => array(
+                                                        'pattern'   => '^\xDC\xFE',
+                                                        'group'     => 'graphic',
+                                                        'module'    => 'efax',
+                                                        'mime_type' => 'image/efax',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+
+                                // Data formats
+
+                                // ISO  - data        - International Standards Organization (ISO) CD-ROM Image
+                                'iso'  => array(
+                                                        'pattern'   => '^.{32769}CD001',
+                                                        'group'     => 'misc',
+                                                        'module'    => 'iso',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                        'iconv_req' => false,
+                                                ),
+
+                                // RAR  - data        - RAR compressed data
+                                'rar'  => array(
+                                                        'pattern'   => '^Rar\!',
+                                                        'group'     => 'archive',
+                                                        'module'    => 'rar',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // SZIP - audio/data  - SZIP compressed data
+                                'szip' => array(
+                                                        'pattern'   => '^SZ\x0A\x04',
+                                                        'group'     => 'archive',
+                                                        'module'    => 'szip',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // TAR  - data        - TAR compressed data
+                                'tar'  => array(
+                                                        'pattern'   => '^.{100}[0-9\x20]{7}\x00[0-9\x20]{7}\x00[0-9\x20]{7}\x00[0-9\x20\x00]{12}[0-9\x20\x00]{12}',
+                                                        'group'     => 'archive',
+                                                        'module'    => 'tar',
+                                                        'mime_type' => 'application/x-tar',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // GZIP  - data        - GZIP compressed data
+                                'gz'  => array(
+                                                        'pattern'   => '^\x1F\x8B\x08',
+                                                        'group'     => 'archive',
+                                                        'module'    => 'gzip',
+                                                        'mime_type' => 'application/x-gzip',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // ZIP  - data         - ZIP compressed data
+                                'zip'  => array(
+                                                        'pattern'   => '^PK\x03\x04',
+                                                        'group'     => 'archive',
+                                                        'module'    => 'zip',
+                                                        'mime_type' => 'application/zip',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+
+                                // Misc other formats
+
+                                // PAR2 - data        - Parity Volume Set Specification 2.0
+                                'par2' => array (
+                                                        'pattern'   => '^PAR2\x00PKT',
+                                                        'group'     => 'misc',
+                                                        'module'    => 'par2',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // PDF  - data        - Portable Document Format
+                                'pdf'  => array(
+                                                        'pattern'   => '^\x25PDF',
+                                                        'group'     => 'misc',
+                                                        'module'    => 'pdf',
+                                                        'mime_type' => 'application/pdf',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                // MSOFFICE  - data   - ZIP compressed data
+                                'msoffice' => array(
+                                                        'pattern'   => '^\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1', // D0CF11E == DOCFILE == Microsoft Office Document
+                                                        'group'     => 'misc',
+                                                        'module'    => 'msoffice',
+                                                        'mime_type' => 'application/octet-stream',
+                                                        'fail_id3'  => 'ERROR',
+                                                        'fail_ape'  => 'ERROR',
+                                                ),
+
+                                 // CUE  - data       - CUEsheet (index to single-file disc images)
+                                 'cue' => array(
+                                                        'pattern'   => '', // empty pattern means cannot be automatically detected, will fall through all other formats and match based on filename and very basic file contents
+                                                        'group'     => 'misc',
+                                                        'module'    => 'cue',
+                                                        'mime_type' => 'application/octet-stream',
+                                                   ),
+
+                        );
+                }
+
+                return $format_info;
+        }
+
+
+
+        public function GetFileFormat(&$filedata, $filename='') {
+                // this function will determine the format of a file based on usually
+                // the first 2-4 bytes of the file (8 bytes for PNG, 16 bytes for JPG,
+                // and in the case of ISO CD image, 6 bytes offset 32kb from the start
+                // of the file).
+
+                // Identify file format - loop through $format_info and detect with reg expr
+                foreach ($this->GetFileFormatArray() as $format_name => $info) {
+                        // The /s switch on preg_match() forces preg_match() NOT to treat
+                        // newline (0x0A) characters as special chars but do a binary match
+                        if (!empty($info['pattern']) && preg_match('#'.$info['pattern'].'#s', $filedata)) {
+                                $info['include'] = 'module.'.$info['group'].'.'.$info['module'].'.php';
+                                return $info;
+                        }
+                }
+
+
+                if (preg_match('#\.mp[123a]$#i', $filename)) {
+                        // Too many mp3 encoders on the market put gabage in front of mpeg files
+                        // use assume format on these if format detection failed
+                        $GetFileFormatArray = $this->GetFileFormatArray();
+                        $info = $GetFileFormatArray['mp3'];
+                        $info['include'] = 'module.'.$info['group'].'.'.$info['module'].'.php';
+                        return $info;
+                } elseif (preg_match('/\.cue$/i', $filename) && preg_match('#FILE "[^"]+" (BINARY|MOTOROLA|AIFF|WAVE|MP3)#', $filedata)) {
+                        // there's not really a useful consistent "magic" at the beginning of .cue files to identify them
+                        // so until I think of something better, just go by filename if all other format checks fail
+                        // and verify there's at least one instance of "TRACK xx AUDIO" in the file
+                        $GetFileFormatArray = $this->GetFileFormatArray();
+                        $info = $GetFileFormatArray['cue'];
+                        $info['include']   = 'module.'.$info['group'].'.'.$info['module'].'.php';
+                        return $info;
+                }
+
+                return false;
+        }
+
+
+        // converts array to $encoding charset from $this->encoding
+        public function CharConvert(&$array, $encoding) {
+
+                // identical encoding - end here
+                if ($encoding == $this->encoding) {
+                        return;
+                }
+
+                // loop thru array
+                foreach ($array as $key => $value) {
+
+                        // go recursive
+                        if (is_array($value)) {
+                                $this->CharConvert($array[$key], $encoding);
+                        }
+
+                        // convert string
+                        elseif (is_string($value)) {
+                                $array[$key] = trim(getid3_lib::iconv_fallback($encoding, $this->encoding, $value));
+                        }
+                }
+        }
+
+
+        public function HandleAllTags() {
+
+                // key name => array (tag name, character encoding)
+                static $tags;
+                if (empty($tags)) {
+                        $tags = array(
+                                'asf'       => array('asf'           , 'UTF-16LE'),
+                                'midi'      => array('midi'          , 'ISO-8859-1'),
+                                'nsv'       => array('nsv'           , 'ISO-8859-1'),
+                                'ogg'       => array('vorbiscomment' , 'UTF-8'),
+                                'png'       => array('png'           , 'UTF-8'),
+                                'tiff'      => array('tiff'          , 'ISO-8859-1'),
+                                'quicktime' => array('quicktime'     , 'UTF-8'),
+                                'real'      => array('real'          , 'ISO-8859-1'),
+                                'vqf'       => array('vqf'           , 'ISO-8859-1'),
+                                'zip'       => array('zip'           , 'ISO-8859-1'),
+                                'riff'      => array('riff'          , 'ISO-8859-1'),
+                                'lyrics3'   => array('lyrics3'       , 'ISO-8859-1'),
+                                'id3v1'     => array('id3v1'         , $this->encoding_id3v1),
+                                'id3v2'     => array('id3v2'         , 'UTF-8'), // not according to the specs (every frame can have a different encoding), but getID3() force-converts all encodings to UTF-8
+                                'ape'       => array('ape'           , 'UTF-8'),
+                                'cue'       => array('cue'           , 'ISO-8859-1'),
+                                'matroska'  => array('matroska'      , 'UTF-8'),
+                                'flac'      => array('vorbiscomment' , 'UTF-8'),
+                                'divxtag'   => array('divx'          , 'ISO-8859-1'),
+                        );
+                }
+
+                // loop through comments array
+                foreach ($tags as $comment_name => $tagname_encoding_array) {
+                        list($tag_name, $encoding) = $tagname_encoding_array;
+
+                        // fill in default encoding type if not already present
+                        if (isset($this->info[$comment_name]) && !isset($this->info[$comment_name]['encoding'])) {
+                                $this->info[$comment_name]['encoding'] = $encoding;
+                        }
+
+                        // copy comments if key name set
+                        if (!empty($this->info[$comment_name]['comments'])) {
+                                foreach ($this->info[$comment_name]['comments'] as $tag_key => $valuearray) {
+                                        foreach ($valuearray as $key => $value) {
+                                                if (is_string($value)) {
+                                                        $value = trim($value, " \r\n\t"); // do not trim nulls from $value!! Unicode characters will get mangled if trailing nulls are removed!
+                                                }
+                                                if ($value) {
+                                                        $this->info['tags'][trim($tag_name)][trim($tag_key)][] = $value;
+                                                }
+                                        }
+                                        if ($tag_key == 'picture') {
+                                                unset($this->info[$comment_name]['comments'][$tag_key]);
+                                        }
+                                }
+
+                                if (!isset($this->info['tags'][$tag_name])) {
+                                        // comments are set but contain nothing but empty strings, so skip
+                                        continue;
+                                }
+
+                                if ($this->option_tags_html) {
+                                        foreach ($this->info['tags'][$tag_name] as $tag_key => $valuearray) {
+                                                foreach ($valuearray as $key => $value) {
+                                                        if (is_string($value)) {
+                                                                //$this->info['tags_html'][$tag_name][$tag_key][$key] = getid3_lib::MultiByteCharString2HTML($value, $encoding);
+                                                                $this->info['tags_html'][$tag_name][$tag_key][$key] = str_replace('&#0;', '', trim(getid3_lib::MultiByteCharString2HTML($value, $encoding)));
+                                                        } else {
+                                                                $this->info['tags_html'][$tag_name][$tag_key][$key] = $value;
+                                                        }
+                                                }
+                                        }
+                                }
+
+                                $this->CharConvert($this->info['tags'][$tag_name], $encoding);           // only copy gets converted!
+                        }
+
+                }
+
+                // 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
+                if (!empty($this->info['tags'])) {
+                        $unset_keys = array('tags', 'tags_html');
+                        foreach ($this->info['tags'] as $tagtype => $tagarray) {
+                                foreach ($tagarray as $tagname => $tagdata) {
+                                        if ($tagname == 'picture') {
+                                                foreach ($tagdata as $key => $tagarray) {
+                                                        $this->info['comments']['picture'][] = $tagarray;
+                                                        if (isset($tagarray['data']) && isset($tagarray['image_mime'])) {
+                                                                if (isset($this->info['tags'][$tagtype][$tagname][$key])) {
+                                                                        unset($this->info['tags'][$tagtype][$tagname][$key]);
+                                                                }
+                                                                if (isset($this->info['tags_html'][$tagtype][$tagname][$key])) {
+                                                                        unset($this->info['tags_html'][$tagtype][$tagname][$key]);
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                }
+                                foreach ($unset_keys as $unset_key) {
+                                        // remove possible empty keys from (e.g. [tags][id3v2][picture])
+                                        if (empty($this->info[$unset_key][$tagtype]['picture'])) {
+                                                unset($this->info[$unset_key][$tagtype]['picture']);
+                                        }
+                                        if (empty($this->info[$unset_key][$tagtype])) {
+                                                unset($this->info[$unset_key][$tagtype]);
+                                        }
+                                        if (empty($this->info[$unset_key])) {
+                                                unset($this->info[$unset_key]);
+                                        }
+                                }
+                                // remove duplicate copy of picture data from (e.g. [id3v2][comments][picture])
+                                if (isset($this->info[$tagtype]['comments']['picture'])) {
+                                        unset($this->info[$tagtype]['comments']['picture']);
+                                }
+                                if (empty($this->info[$tagtype]['comments'])) {
+                                        unset($this->info[$tagtype]['comments']);
+                                }
+                                if (empty($this->info[$tagtype])) {
+                                        unset($this->info[$tagtype]);
+                                }
+                        }
+                }
+                return true;
+        }
+
+
+        public function getHashdata($algorithm) {
+                switch ($algorithm) {
+                        case 'md5':
+                        case 'sha1':
+                                break;
+
+                        default:
+                                return $this->error('bad algorithm "'.$algorithm.'" in getHashdata()');
+                                break;
+                }
+
+                if (!empty($this->info['fileformat']) && !empty($this->info['dataformat']) && ($this->info['fileformat'] == 'ogg') && ($this->info['audio']['dataformat'] == 'vorbis')) {
+
+                        // We cannot get an identical md5_data value for Ogg files where the comments
+                        // span more than 1 Ogg page (compared to the same audio data with smaller
+                        // comments) using the normal getID3() method of MD5'ing the data between the
+                        // end of the comments and the end of the file (minus any trailing tags),
+                        // because the page sequence numbers of the pages that the audio data is on
+                        // do not match. Under normal circumstances, where comments are smaller than
+                        // the nominal 4-8kB page size, then this is not a problem, but if there are
+                        // very large comments, the only way around it is to strip off the comment
+                        // tags with vorbiscomment and MD5 that file.
+                        // This procedure must be applied to ALL Ogg files, not just the ones with
+                        // comments larger than 1 page, because the below method simply MD5's the
+                        // whole file with the comments stripped, not just the portion after the
+                        // comments block (which is the standard getID3() method.
+
+                        // The above-mentioned problem of comments spanning multiple pages and changing
+                        // page sequence numbers likely happens for OggSpeex and OggFLAC as well, but
+                        // currently vorbiscomment only works on OggVorbis files.
+
+                        if (preg_match('#(1|ON)#i', ini_get('safe_mode'))) {
+
+                                $this->warning('Failed making system call to vorbiscomment.exe - '.$algorithm.'_data is incorrect - error returned: PHP running in Safe Mode (backtick operator not available)');
+                                $this->info[$algorithm.'_data'] = false;
+
+                        } else {
+
+                                // Prevent user from aborting script
+                                $old_abort = ignore_user_abort(true);
+
+                                // Create empty file
+                                $empty = tempnam(GETID3_TEMP_DIR, 'getID3');
+                                touch($empty);
+
+                                // Use vorbiscomment to make temp file without comments
+                                $temp = tempnam(GETID3_TEMP_DIR, 'getID3');
+                                $file = $this->info['filenamepath'];
+
+                                if (GETID3_OS_ISWINDOWS) {
+
+                                        if (file_exists(GETID3_HELPERAPPSDIR.'vorbiscomment.exe')) {
+
+                                                $commandline = '"'.GETID3_HELPERAPPSDIR.'vorbiscomment.exe" -w -c "'.$empty.'" "'.$file.'" "'.$temp.'"';
+                                                $VorbisCommentError = `$commandline`;
+
+                                        } else {
+
+                                                $VorbisCommentError = 'vorbiscomment.exe not found in '.GETID3_HELPERAPPSDIR;
+
+                                        }
+
+                                } else {
+
+                                        $commandline = 'vorbiscomment -w -c "'.$empty.'" "'.$file.'" "'.$temp.'" 2>&1';
+                                        $commandline = 'vorbiscomment -w -c '.escapeshellarg($empty).' '.escapeshellarg($file).' '.escapeshellarg($temp).' 2>&1';
+                                        $VorbisCommentError = `$commandline`;
+
+                                }
+
+                                if (!empty($VorbisCommentError)) {
+
+                                        $this->info['warning'][]         = 'Failed making system call to vorbiscomment(.exe) - '.$algorithm.'_data will be incorrect. If vorbiscomment is unavailable, please download from http://www.vorbis.com/download.psp and put in the getID3() directory. Error returned: '.$VorbisCommentError;
+                                        $this->info[$algorithm.'_data']  = false;
+
+                                } else {
+
+                                        // Get hash of newly created file
+                                        switch ($algorithm) {
+                                                case 'md5':
+                                                        $this->info[$algorithm.'_data'] = md5_file($temp);
+                                                        break;
+
+                                                case 'sha1':
+                                                        $this->info[$algorithm.'_data'] = sha1_file($temp);
+                                                        break;
+                                        }
+                                }
+
+                                // Clean up
+                                unlink($empty);
+                                unlink($temp);
+
+                                // Reset abort setting
+                                ignore_user_abort($old_abort);
+
+                        }
+
+                } else {
+
+                        if (!empty($this->info['avdataoffset']) || (isset($this->info['avdataend']) && ($this->info['avdataend'] < $this->info['filesize']))) {
+
+                                // get hash from part of file
+                                $this->info[$algorithm.'_data'] = getid3_lib::hash_data($this->info['filenamepath'], $this->info['avdataoffset'], $this->info['avdataend'], $algorithm);
+
+                        } else {
+
+                                // get hash from whole file
+                                switch ($algorithm) {
+                                        case 'md5':
+                                                $this->info[$algorithm.'_data'] = md5_file($this->info['filenamepath']);
+                                                break;
+
+                                        case 'sha1':
+                                                $this->info[$algorithm.'_data'] = sha1_file($this->info['filenamepath']);
+                                                break;
+                                }
+                        }
+
+                }
+                return true;
+        }
+
+
+        public function ChannelsBitratePlaytimeCalculations() {
+
+                // set channelmode on audio
+                if (!empty($this->info['audio']['channelmode']) || !isset($this->info['audio']['channels'])) {
+                        // ignore
+                } elseif ($this->info['audio']['channels'] == 1) {
+                        $this->info['audio']['channelmode'] = 'mono';
+                } elseif ($this->info['audio']['channels'] == 2) {
+                        $this->info['audio']['channelmode'] = 'stereo';
+                }
+
+                // Calculate combined bitrate - audio + video
+                $CombinedBitrate  = 0;
+                $CombinedBitrate += (isset($this->info['audio']['bitrate']) ? $this->info['audio']['bitrate'] : 0);
+                $CombinedBitrate += (isset($this->info['video']['bitrate']) ? $this->info['video']['bitrate'] : 0);
+                if (($CombinedBitrate > 0) && empty($this->info['bitrate'])) {
+                        $this->info['bitrate'] = $CombinedBitrate;
+                }
+                //if ((isset($this->info['video']) && !isset($this->info['video']['bitrate'])) || (isset($this->info['audio']) && !isset($this->info['audio']['bitrate']))) {
+                //      // for example, VBR MPEG video files cannot determine video bitrate:
+                //      // should not set overall bitrate and playtime from audio bitrate only
+                //      unset($this->info['bitrate']);
+                //}
+
+                // video bitrate undetermined, but calculable
+                if (isset($this->info['video']['dataformat']) && $this->info['video']['dataformat'] && (!isset($this->info['video']['bitrate']) || ($this->info['video']['bitrate'] == 0))) {
+                        // if video bitrate not set
+                        if (isset($this->info['audio']['bitrate']) && ($this->info['audio']['bitrate'] > 0) && ($this->info['audio']['bitrate'] == $this->info['bitrate'])) {
+                                // AND if audio bitrate is set to same as overall bitrate
+                                if (isset($this->info['playtime_seconds']) && ($this->info['playtime_seconds'] > 0)) {
+                                        // AND if playtime is set
+                                        if (isset($this->info['avdataend']) && isset($this->info['avdataoffset'])) {
+                                                // AND if AV data offset start/end is known
+                                                // THEN we can calculate the video bitrate
+                                                $this->info['bitrate'] = round((($this->info['avdataend'] - $this->info['avdataoffset']) * 8) / $this->info['playtime_seconds']);
+                                                $this->info['video']['bitrate'] = $this->info['bitrate'] - $this->info['audio']['bitrate'];
+                                        }
+                                }
+                        }
+                }
+
+                if ((!isset($this->info['playtime_seconds']) || ($this->info['playtime_seconds'] <= 0)) && !empty($this->info['bitrate'])) {
+                        $this->info['playtime_seconds'] = (($this->info['avdataend'] - $this->info['avdataoffset']) * 8) / $this->info['bitrate'];
+                }
+
+                if (!isset($this->info['bitrate']) && !empty($this->info['playtime_seconds'])) {
+                        $this->info['bitrate'] = (($this->info['avdataend'] - $this->info['avdataoffset']) * 8) / $this->info['playtime_seconds'];
+                }
+                if (isset($this->info['bitrate']) && empty($this->info['audio']['bitrate']) && empty($this->info['video']['bitrate'])) {
+                        if (isset($this->info['audio']['dataformat']) && empty($this->info['video']['resolution_x'])) {
+                                // audio only
+                                $this->info['audio']['bitrate'] = $this->info['bitrate'];
+                        } elseif (isset($this->info['video']['resolution_x']) && empty($this->info['audio']['dataformat'])) {
+                                // video only
+                                $this->info['video']['bitrate'] = $this->info['bitrate'];
+                        }
+                }
+
+                // Set playtime string
+                if (!empty($this->info['playtime_seconds']) && empty($this->info['playtime_string'])) {
+                        $this->info['playtime_string'] = getid3_lib::PlaytimeString($this->info['playtime_seconds']);
+                }
+        }
+
+
+        public function CalculateCompressionRatioVideo() {
+                if (empty($this->info['video'])) {
+                        return false;
+                }
+                if (empty($this->info['video']['resolution_x']) || empty($this->info['video']['resolution_y'])) {
+                        return false;
+                }
+                if (empty($this->info['video']['bits_per_sample'])) {
+                        return false;
+                }
+
+                switch ($this->info['video']['dataformat']) {
+                        case 'bmp':
+                        case 'gif':
+                        case 'jpeg':
+                        case 'jpg':
+                        case 'png':
+                        case 'tiff':
+                                $FrameRate = 1;
+                                $PlaytimeSeconds = 1;
+                                $BitrateCompressed = $this->info['filesize'] * 8;
+                                break;
+
+                        default:
+                                if (!empty($this->info['video']['frame_rate'])) {
+                                        $FrameRate = $this->info['video']['frame_rate'];
+                                } else {
+                                        return false;
+                                }
+                                if (!empty($this->info['playtime_seconds'])) {
+                                        $PlaytimeSeconds = $this->info['playtime_seconds'];
+                                } else {
+                                        return false;
+                                }
+                                if (!empty($this->info['video']['bitrate'])) {
+                                        $BitrateCompressed = $this->info['video']['bitrate'];
+                                } else {
+                                        return false;
+                                }
+                                break;
+                }
+                $BitrateUncompressed = $this->info['video']['resolution_x'] * $this->info['video']['resolution_y'] * $this->info['video']['bits_per_sample'] * $FrameRate;
+
+                $this->info['video']['compression_ratio'] = $BitrateCompressed / $BitrateUncompressed;
+                return true;
+        }
+
+
+        public function CalculateCompressionRatioAudio() {
+                if (empty($this->info['audio']['bitrate']) || empty($this->info['audio']['channels']) || empty($this->info['audio']['sample_rate']) || !is_numeric($this->info['audio']['sample_rate'])) {
+                        return false;
+                }
+                $this->info['audio']['compression_ratio'] = $this->info['audio']['bitrate'] / ($this->info['audio']['channels'] * $this->info['audio']['sample_rate'] * (!empty($this->info['audio']['bits_per_sample']) ? $this->info['audio']['bits_per_sample'] : 16));
+
+                if (!empty($this->info['audio']['streams'])) {
+                        foreach ($this->info['audio']['streams'] as $streamnumber => $streamdata) {
+                                if (!empty($streamdata['bitrate']) && !empty($streamdata['channels']) && !empty($streamdata['sample_rate'])) {
+                                        $this->info['audio']['streams'][$streamnumber]['compression_ratio'] = $streamdata['bitrate'] / ($streamdata['channels'] * $streamdata['sample_rate'] * (!empty($streamdata['bits_per_sample']) ? $streamdata['bits_per_sample'] : 16));
+                                }
+                        }
+                }
+                return true;
+        }
+
+
+        public function CalculateReplayGain() {
+                if (isset($this->info['replay_gain'])) {
+                        if (!isset($this->info['replay_gain']['reference_volume'])) {
+                                $this->info['replay_gain']['reference_volume'] = (double) 89.0;
+                        }
+                        if (isset($this->info['replay_gain']['track']['adjustment'])) {
+                                $this->info['replay_gain']['track']['volume'] = $this->info['replay_gain']['reference_volume'] - $this->info['replay_gain']['track']['adjustment'];
+                        }
+                        if (isset($this->info['replay_gain']['album']['adjustment'])) {
+                                $this->info['replay_gain']['album']['volume'] = $this->info['replay_gain']['reference_volume'] - $this->info['replay_gain']['album']['adjustment'];
+                        }
+
+                        if (isset($this->info['replay_gain']['track']['peak'])) {
+                                $this->info['replay_gain']['track']['max_noclip_gain'] = 0 - getid3_lib::RGADamplitude2dB($this->info['replay_gain']['track']['peak']);
+                        }
+                        if (isset($this->info['replay_gain']['album']['peak'])) {
+                                $this->info['replay_gain']['album']['max_noclip_gain'] = 0 - getid3_lib::RGADamplitude2dB($this->info['replay_gain']['album']['peak']);
+                        }
+                }
+                return true;
+        }
+
+        public function ProcessAudioStreams() {
+                if (!empty($this->info['audio']['bitrate']) || !empty($this->info['audio']['channels']) || !empty($this->info['audio']['sample_rate'])) {
+                        if (!isset($this->info['audio']['streams'])) {
+                                foreach ($this->info['audio'] as $key => $value) {
+                                        if ($key != 'streams') {
+                                                $this->info['audio']['streams'][0][$key] = $value;
+                                        }
+                                }
+                        }
+                }
+                return true;
+        }
+
+        public function getid3_tempnam() {
+                return tempnam($this->tempdir, 'gI3');
+        }
+
+        public function include_module($name) {
+                //if (!file_exists($this->include_path.'module.'.$name.'.php')) {
+                if (!file_exists(GETID3_INCLUDEPATH.'module.'.$name.'.php')) {
+                        throw new getid3_exception('Required module.'.$name.'.php is missing.');
+                }
+                include_once(GETID3_INCLUDEPATH.'module.'.$name.'.php');
+                return true;
+        }
+
+}
+
+
+abstract class getid3_handler
+{
+        protected $getid3;                       // pointer
+
+        protected $data_string_flag     = false; // analyzing filepointer or string
+        protected $data_string          = '';    // string to analyze
+        protected $data_string_position = 0;     // seek position in string
+        protected $data_string_length   = 0;     // string length
+
+        private $dependency_to = null;
+
+
+        public function __construct(getID3 $getid3, $call_module=null) {
+                $this->getid3 = $getid3;
+
+                if ($call_module) {
+                        $this->dependency_to = str_replace('getid3_', '', $call_module);
+                }
+        }
+
+
+        // Analyze from file pointer
+        abstract public function Analyze();
+
+
+        // Analyze from string instead
+        public function AnalyzeString($string) {
+                // Enter string mode
+            $this->setStringMode($string);
+
+                // Save info
+                $saved_avdataoffset = $this->getid3->info['avdataoffset'];
+                $saved_avdataend    = $this->getid3->info['avdataend'];
+                $saved_filesize     = (isset($this->getid3->info['filesize']) ? $this->getid3->info['filesize'] : null); // may be not set if called as dependency without openfile() call
+
+                // Reset some info
+                $this->getid3->info['avdataoffset'] = 0;
+                $this->getid3->info['avdataend']    = $this->getid3->info['filesize'] = $this->data_string_length;
+
+                // Analyze
+                $this->Analyze();
+
+                // Restore some info
+                $this->getid3->info['avdataoffset'] = $saved_avdataoffset;
+                $this->getid3->info['avdataend']    = $saved_avdataend;
+                $this->getid3->info['filesize']     = $saved_filesize;
+
+                // Exit string mode
+                $this->data_string_flag = false;
+        }
+
+        public function setStringMode($string) {
+                $this->data_string_flag   = true;
+                $this->data_string        = $string;
+                $this->data_string_length = strlen($string);
+        }
+
+        protected function ftell() {
+                if ($this->data_string_flag) {
+                        return $this->data_string_position;
+                }
+                return ftell($this->getid3->fp);
+        }
+
+        protected function fread($bytes) {
+                if ($this->data_string_flag) {
+                        $this->data_string_position += $bytes;
+                        return substr($this->data_string, $this->data_string_position - $bytes, $bytes);
+                }
+            $pos = $this->ftell() + $bytes;
+            if (!getid3_lib::intValueSupported($pos)) {
+                        throw new getid3_exception('cannot fread('.$bytes.' from '.$this->ftell().') because beyond PHP filesystem limit', 10);
+            }
+                return fread($this->getid3->fp, $bytes);
+        }
+
+        protected function fseek($bytes, $whence=SEEK_SET) {
+                if ($this->data_string_flag) {
+                        switch ($whence) {
+                                case SEEK_SET:
+                                        $this->data_string_position = $bytes;
+                                        break;
+
+                                case SEEK_CUR:
+                                        $this->data_string_position += $bytes;
+                                        break;
+
+                                case SEEK_END:
+                                        $this->data_string_position = $this->data_string_length + $bytes;
+                                        break;
+                        }
+                        return 0;
+            } else {
+                $pos = $bytes;
+                if ($whence == SEEK_CUR) {
+                                $pos = $this->ftell() + $bytes;
+                } elseif ($whence == SEEK_END) {
+                                $pos = $this->info['filesize'] + $bytes;
+                }
+                if (!getid3_lib::intValueSupported($pos)) {
+                                throw new getid3_exception('cannot fseek('.$pos.') because beyond PHP filesystem limit', 10);
+                        }
+                }
+                return fseek($this->getid3->fp, $bytes, $whence);
+        }
+
+        protected function feof() {
+                if ($this->data_string_flag) {
+                        return $this->data_string_position >= $this->data_string_length;
+                }
+                return feof($this->getid3->fp);
+        }
+
+        final protected function isDependencyFor($module) {
+                return $this->dependency_to == $module;
+        }
+
+        protected function error($text)
+        {
+                $this->getid3->info['error'][] = $text;
+
+                return false;
+        }
+
+        protected function warning($text)
+        {
+                return $this->getid3->warning($text);
+        }
+
+        protected function notice($text)
+        {
+                // does nothing for now
+        }
+
+        public function saveAttachment($name, $offset, $length, $image_mime=null) {
+                try {
+
+                        // do not extract at all
+                        if ($this->getid3->option_save_attachments === getID3::ATTACHMENTS_NONE) {
+
+                                $attachment = null; // do not set any
+
+                        // extract to return array
+                        } elseif ($this->getid3->option_save_attachments === getID3::ATTACHMENTS_INLINE) {
+
+                                $this->fseek($offset);
+                                $attachment = $this->fread($length); // get whole data in one pass, till it is anyway stored in memory
+                                if ($attachment === false || strlen($attachment) != $length) {
+                                        throw new Exception('failed to read attachment data');
+                                }
+
+                        // assume directory path is given
+                        } else {
+
+                                // set up destination path
+                                $dir = rtrim(str_replace(array('/', '\\'), DIRECTORY_SEPARATOR, $this->getid3->option_save_attachments), DIRECTORY_SEPARATOR);
+                                if (!is_dir($dir) || !is_writable($dir)) { // check supplied directory
+                                        throw new Exception('supplied path ('.$dir.') does not exist, or is not writable');
+                                }
+                                $dest = $dir.DIRECTORY_SEPARATOR.$name.($image_mime ? '.'.getid3_lib::ImageExtFromMime($image_mime) : '');
+
+                                // create dest file
+                                if (($fp_dest = fopen($dest, 'wb')) == false) {
+                                        throw new Exception('failed to create file '.$dest);
+                                }
+
+                                // copy data
+                                $this->fseek($offset);
+                                $buffersize = ($this->data_string_flag ? $length : $this->getid3->fread_buffer_size());
+                                $bytesleft = $length;
+                                while ($bytesleft > 0) {
+                                        if (($buffer = $this->fread(min($buffersize, $bytesleft))) === false || ($byteswritten = fwrite($fp_dest, $buffer)) === false || ($byteswritten === 0)) {
+                                                throw new Exception($buffer === false ? 'not enough data to read' : 'failed to write to destination file, may be not enough disk space');
+                                        }
+                                        $bytesleft -= $byteswritten;
+                                }
+
+                                fclose($fp_dest);
+                                $attachment = $dest;
+
+                        }
+
+                } catch (Exception $e) {
+
+                        // close and remove dest file if created
+                        if (isset($fp_dest) && is_resource($fp_dest)) {
+                                fclose($fp_dest);
+                                unlink($dest);
+                        }
+
+                        // do not set any is case of error
+                        $attachment = null;
+                        $this->warning('Failed to extract attachment '.$name.': '.$e->getMessage());
+
+                }
+
+                // seek to the end of attachment
+                $this->fseek($offset + $length);
+
+                return $attachment;
+        }
+}
+
+class getid3_exception extends Exception {
+        public $message;
+}
+ No newline at end of file

new file wp-includes/ID3/getid3.lib.php

@@ +1 @@
+<?php
+/////////////////////////////////////////////////////////////////
+/// getID3() by James Heinrich <info@getid3.org>               //
+//  available at http://getid3.sourceforge.net                 //
+//            or http://www.getid3.org                         //
+/////////////////////////////////////////////////////////////////
+//                                                             //
+// getid3.lib.php - part of getID3()                           //
+// See readme.txt for more details                             //
+//                                                            ///
+/////////////////////////////////////////////////////////////////
+
+
+class getid3_lib
+{
+
+        public static function PrintHexBytes($string, $hex=true, $spaces=true, $htmlencoding='UTF-8') {
+                $returnstring = '';
+                for ($i = 0; $i < strlen($string); $i++) {
+                        if ($hex) {
+                                $returnstring .= str_pad(dechex(ord($string{$i})), 2, '0', STR_PAD_LEFT);
+                        } else {
+                                $returnstring .= ' '.(preg_match("#[\x20-\x7E]#", $string{$i}) ? $string{$i} : '¤');
+                        }
+                        if ($spaces) {
+                                $returnstring .= ' ';
+                        }
+                }
+                if (!empty($htmlencoding)) {
+                        if ($htmlencoding === true) {
+                                $htmlencoding = 'UTF-8'; // prior to getID3 v1.9.0 the function's 4th parameter was boolean
+                        }
+                        $returnstring = htmlentities($returnstring, ENT_QUOTES, $htmlencoding);
+                }
+                return $returnstring;
+        }
+
+        public static function trunc($floatnumber) {
+                // truncates a floating-point number at the decimal point
+                // returns int (if possible, otherwise float)
+                if ($floatnumber >= 1) {
+                        $truncatednumber = floor($floatnumber);
+                } elseif ($floatnumber <= -1) {
+                        $truncatednumber = ceil($floatnumber);
+                } else {
+                        $truncatednumber = 0;
+                }
+                if (self::intValueSupported($truncatednumber)) {
+                        $truncatednumber = (int) $truncatednumber;
+                }
+                return $truncatednumber;
+        }
+
+
+        public static function safe_inc(&$variable, $increment=1) {
+                if (isset($variable)) {
+                        $variable += $increment;
+                } else {
+                        $variable = $increment;
+                }
+                return true;
+        }
+
+        public static function CastAsInt($floatnum) {
+                // convert to float if not already
+                $floatnum = (float) $floatnum;
+
+                // convert a float to type int, only if possible
+                if (self::trunc($floatnum) == $floatnum) {
+                        // it's not floating point
+                        if (self::intValueSupported($floatnum)) {
+                                // it's within int range
+                                $floatnum = (int) $floatnum;
+                        }
+                }
+                return $floatnum;
+        }
+
+        public static function intValueSupported($num) {
+                // check if integers are 64-bit
+                static $hasINT64 = null;
+                if ($hasINT64 === null) { // 10x faster than is_null()
+                        $hasINT64 = is_int(pow(2, 31)); // 32-bit int are limited to (2^31)-1
+                        if (!$hasINT64 && !defined('PHP_INT_MIN')) {
+                                define('PHP_INT_MIN', ~PHP_INT_MAX);
+                        }
+                }
+                // if integers are 64-bit - no other check required
+                if ($hasINT64 || (($num <= PHP_INT_MAX) && ($num >= PHP_INT_MIN))) {
+                        return true;
+                }
+                return false;
+        }
+
+        public static function DecimalizeFraction($fraction) {
+                list($numerator, $denominator) = explode('/', $fraction);
+                return $numerator / ($denominator ? $denominator : 1);
+        }
+
+
+        public static function DecimalBinary2Float($binarynumerator) {
+                $numerator   = self::Bin2Dec($binarynumerator);
+                $denominator = self::Bin2Dec('1'.str_repeat('0', strlen($binarynumerator)));
+                return ($numerator / $denominator);
+        }
+
+
+        public static function NormalizeBinaryPoint($binarypointnumber, $maxbits=52) {
+                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
+                if (strpos($binarypointnumber, '.') === false) {
+                        $binarypointnumber = '0.'.$binarypointnumber;
+                } elseif ($binarypointnumber{0} == '.') {
+                        $binarypointnumber = '0'.$binarypointnumber;
+                }
+                $exponent = 0;
+                while (($binarypointnumber{0} != '1') || (substr($binarypointnumber, 1, 1) != '.')) {
+                        if (substr($binarypointnumber, 1, 1) == '.') {
+                                $exponent--;
+                                $binarypointnumber = substr($binarypointnumber, 2, 1).'.'.substr($binarypointnumber, 3);
+                        } else {
+                                $pointpos = strpos($binarypointnumber, '.');
+                                $exponent += ($pointpos - 1);
+                                $binarypointnumber = str_replace('.', '', $binarypointnumber);
+                                $binarypointnumber = $binarypointnumber{0}.'.'.substr($binarypointnumber, 1);
+                        }
+                }
+                $binarypointnumber = str_pad(substr($binarypointnumber, 0, $maxbits + 2), $maxbits + 2, '0', STR_PAD_RIGHT);
+                return array('normalized'=>$binarypointnumber, 'exponent'=>(int) $exponent);
+        }
+
+
+        public static function Float2BinaryDecimal($floatvalue) {
+                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/binary.html
+                $maxbits = 128; // to how many bits of precision should the calculations be taken?
+                $intpart   = self::trunc($floatvalue);
+                $floatpart = abs($floatvalue - $intpart);
+                $pointbitstring = '';
+                while (($floatpart != 0) && (strlen($pointbitstring) < $maxbits)) {
+                        $floatpart *= 2;
+                        $pointbitstring .= (string) self::trunc($floatpart);
+                        $floatpart -= self::trunc($floatpart);
+                }
+                $binarypointnumber = decbin($intpart).'.'.$pointbitstring;
+                return $binarypointnumber;
+        }
+
+
+        public static function Float2String($floatvalue, $bits) {
+                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee-expl.html
+                switch ($bits) {
+                        case 32:
+                                $exponentbits = 8;
+                                $fractionbits = 23;
+                                break;
+
+                        case 64:
+                                $exponentbits = 11;
+                                $fractionbits = 52;
+                                break;
+
+                        default:
+                                return false;
+                                break;
+                }
+                if ($floatvalue >= 0) {
+                        $signbit = '0';
+                } else {
+                        $signbit = '1';
+                }
+                $normalizedbinary  = self::NormalizeBinaryPoint(self::Float2BinaryDecimal($floatvalue), $fractionbits);
+                $biasedexponent    = pow(2, $exponentbits - 1) - 1 + $normalizedbinary['exponent']; // (127 or 1023) +/- exponent
+                $exponentbitstring = str_pad(decbin($biasedexponent), $exponentbits, '0', STR_PAD_LEFT);
+                $fractionbitstring = str_pad(substr($normalizedbinary['normalized'], 2), $fractionbits, '0', STR_PAD_RIGHT);
+
+                return self::BigEndian2String(self::Bin2Dec($signbit.$exponentbitstring.$fractionbitstring), $bits % 8, false);
+        }
+
+
+        public static function LittleEndian2Float($byteword) {
+                return self::BigEndian2Float(strrev($byteword));
+        }
+
+
+        public static function BigEndian2Float($byteword) {
+                // ANSI/IEEE Standard 754-1985, Standard for Binary Floating Point Arithmetic
+                // http://www.psc.edu/general/software/packages/ieee/ieee.html
+                // http://www.scri.fsu.edu/~jac/MAD3401/Backgrnd/ieee.html
+
+                $bitword = self::BigEndian2Bin($byteword);
+                if (!$bitword) {
+                        return 0;
+                }
+                $signbit = $bitword{0};
+
+                switch (strlen($byteword) * 8) {
+                        case 32:
+                                $exponentbits = 8;
+                                $fractionbits = 23;
+                                break;
+
+                        case 64:
+                                $exponentbits = 11;
+                                $fractionbits = 52;
+                                break;
+
+                        case 80:
+                                // 80-bit Apple SANE format
+                                // http://www.mactech.com/articles/mactech/Vol.06/06.01/SANENormalized/
+                                $exponentstring = substr($bitword, 1, 15);
+                                $isnormalized = intval($bitword{16});
+                                $fractionstring = substr($bitword, 17, 63);
+                                $exponent = pow(2, self::Bin2Dec($exponentstring) - 16383);
+                                $fraction = $isnormalized + self::DecimalBinary2Float($fractionstring);
+                                $floatvalue = $exponent * $fraction;
+                                if ($signbit == '1') {
+                                        $floatvalue *= -1;
+                                }
+                                return $floatvalue;
+                                break;
+
+                        default:
+                                return false;
+                                break;
+                }
+                $exponentstring = substr($bitword, 1, $exponentbits);
+                $fractionstring = substr($bitword, $exponentbits + 1, $fractionbits);
+                $exponent = self::Bin2Dec($exponentstring);
+                $fraction = self::Bin2Dec($fractionstring);
+
+                if (($exponent == (pow(2, $exponentbits) - 1)) && ($fraction != 0)) {
+                        // Not a Number
+                        $floatvalue = false;
+                } elseif (($exponent == (pow(2, $exponentbits) - 1)) && ($fraction == 0)) {
+                        if ($signbit == '1') {
+                                $floatvalue = '-infinity';
+                        } else {
+                                $floatvalue = '+infinity';
+                        }
+                } elseif (($exponent == 0) && ($fraction == 0)) {
+                        if ($signbit == '1') {
+                                $floatvalue = -0;
+                        } else {
+                                $floatvalue = 0;
+                        }
+                        $floatvalue = ($signbit ? 0 : -0);
+                } elseif (($exponent == 0) && ($fraction != 0)) {
+                        // These are 'unnormalized' values
+                        $floatvalue = pow(2, (-1 * (pow(2, $exponentbits - 1) - 2))) * self::DecimalBinary2Float($fractionstring);
+                        if ($signbit == '1') {
+                                $floatvalue *= -1;
+                        }
+                } elseif ($exponent != 0) {
+                        $floatvalue = pow(2, ($exponent - (pow(2, $exponentbits - 1) - 1))) * (1 + self::DecimalBinary2Float($fractionstring));
+                        if ($signbit == '1') {
+                                $floatvalue *= -1;
+                        }
+                }
+                return (float) $floatvalue;
+        }
+
+
+        public static function BigEndian2Int($byteword, $synchsafe=false, $signed=false) {
+                $intvalue = 0;
+                $bytewordlen = strlen($byteword);
+                if ($bytewordlen == 0) {
+                        return false;
+                }
+                for ($i = 0; $i < $bytewordlen; $i++) {
+                        if ($synchsafe) { // disregard MSB, effectively 7-bit bytes
+                                //$intvalue = $intvalue | (ord($byteword{$i}) & 0x7F) << (($bytewordlen - 1 - $i) * 7); // faster, but runs into problems past 2^31 on 32-bit systems
+                                $intvalue += (ord($byteword{$i}) & 0x7F) * pow(2, ($bytewordlen - 1 - $i) * 7);
+                        } else {
+                                $intvalue += ord($byteword{$i}) * pow(256, ($bytewordlen - 1 - $i));
+                        }
+                }
+                if ($signed && !$synchsafe) {
+                        // synchsafe ints are not allowed to be signed
+                        if ($bytewordlen <= PHP_INT_SIZE) {
+                                $signMaskBit = 0x80 << (8 * ($bytewordlen - 1));
+                                if ($intvalue & $signMaskBit) {
+                                        $intvalue = 0 - ($intvalue & ($signMaskBit - 1));
+                                }
+                        } else {
+                                throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits ('.strlen($byteword).') in self::BigEndian2Int()');
+                                break;
+                        }
+                }
+                return self::CastAsInt($intvalue);
+        }
+
+
+        public static function LittleEndian2Int($byteword, $signed=false) {
+                return self::BigEndian2Int(strrev($byteword), false, $signed);
+        }
+
+
+        public static function BigEndian2Bin($byteword) {
+                $binvalue = '';
+                $bytewordlen = strlen($byteword);
+                for ($i = 0; $i < $bytewordlen; $i++) {
+                        $binvalue .= str_pad(decbin(ord($byteword{$i})), 8, '0', STR_PAD_LEFT);
+                }
+                return $binvalue;
+        }
+
+
+        public static function BigEndian2String($number, $minbytes=1, $synchsafe=false, $signed=false) {
+                if ($number < 0) {
+                        throw new Exception('ERROR: self::BigEndian2String() does not support negative numbers');
+                }
+                $maskbyte = (($synchsafe || $signed) ? 0x7F : 0xFF);
+                $intstring = '';
+                if ($signed) {
+                        if ($minbytes > PHP_INT_SIZE) {
+                                throw new Exception('ERROR: Cannot have signed integers larger than '.(8 * PHP_INT_SIZE).'-bits in self::BigEndian2String()');
+                        }
+                        $number = $number & (0x80 << (8 * ($minbytes - 1)));
+                }
+                while ($number != 0) {
+                        $quotient = ($number / ($maskbyte + 1));
+                        $intstring = chr(ceil(($quotient - floor($quotient)) * $maskbyte)).$intstring;
+                        $number = floor($quotient);
+                }
+                return str_pad($intstring, $minbytes, "\x00", STR_PAD_LEFT);
+        }
+
+
+        public static function Dec2Bin($number) {
+                while ($number >= 256) {
+                        $bytes[] = (($number / 256) - (floor($number / 256))) * 256;
+                        $number = floor($number / 256);
+                }
+                $bytes[] = $number;
+                $binstring = '';
+                for ($i = 0; $i < count($bytes); $i++) {
+                        $binstring = (($i == count($bytes) - 1) ? decbin($bytes[$i]) : str_pad(decbin($bytes[$i]), 8, '0', STR_PAD_LEFT)).$binstring;
+                }
+                return $binstring;
+        }
+
+
+        public static function Bin2Dec($binstring, $signed=false) {
+                $signmult = 1;
+                if ($signed) {
+                        if ($binstring{0} == '1') {
+                                $signmult = -1;
+                        }
+                        $binstring = substr($binstring, 1);
+                }
+                $decvalue = 0;
+                for ($i = 0; $i < strlen($binstring); $i++) {
+                        $decvalue += ((int) substr($binstring, strlen($binstring) - $i - 1, 1)) * pow(2, $i);
+                }
+                return self::CastAsInt($decvalue * $signmult);
+        }
+
+
+        public static function Bin2String($binstring) {
+                // return 'hi' for input of '0110100001101001'
+                $string = '';
+                $binstringreversed = strrev($binstring);
+                for ($i = 0; $i < strlen($binstringreversed); $i += 8) {
+                        $string = chr(self::Bin2Dec(strrev(substr($binstringreversed, $i, 8)))).$string;
+                }
+                return $string;
+        }
+
+
+        public static function LittleEndian2String($number, $minbytes=1, $synchsafe=false) {
+                $intstring = '';
+                while ($number > 0) {
+                        if ($synchsafe) {
+                                $intstring = $intstring.chr($number & 127);
+                                $number >>= 7;
+                        } else {
+                                $intstring = $intstring.chr($number & 255);
+                                $number >>= 8;
+                        }
+                }
+                return str_pad($intstring, $minbytes, "\x00", STR_PAD_RIGHT);
+        }
+
+
+        public static function array_merge_clobber($array1, $array2) {
+                // written by kcØhireability*com
+                // taken from http://www.php.net/manual/en/function.array-merge-recursive.php
+                if (!is_array($array1) || !is_array($array2)) {
+                        return false;
+                }
+                $newarray = $array1;
+                foreach ($array2 as $key => $val) {
+                        if (is_array($val) && isset($newarray[$key]) && is_array($newarray[$key])) {
+                                $newarray[$key] = self::array_merge_clobber($newarray[$key], $val);
+                        } else {
+                                $newarray[$key] = $val;
+                        }
+                }
+                return $newarray;
+        }
+
+
+        public static function array_merge_noclobber($array1, $array2) {
+                if (!is_array($array1) || !is_array($array2)) {
+                        return false;
+                }
+                $newarray = $array1;
+                foreach ($array2 as $key => $val) {
+                        if (is_array($val) && isset($newarray[$key]) && is_array($newarray[$key])) {
+                                $newarray[$key] = self::array_merge_noclobber($newarray[$key], $val);
+                        } elseif (!isset($newarray[$key])) {
+                                $newarray[$key] = $val;
+                        }
+                }
+                return $newarray;
+        }
+
+
+        public static function ksort_recursive(&$theArray) {
+                ksort($theArray);
+                foreach ($theArray as $key => $value) {
+                        if (is_array($value)) {
+                                self::ksort_recursive($theArray[$key]);
+                        }
+                }
+                return true;
+        }
+
+        public static function fileextension($filename, $numextensions=1) {
+                if (strstr($filename, '.')) {
+                        $reversedfilename = strrev($filename);
+                        $offset = 0;
+                        for ($i = 0; $i < $numextensions; $i++) {
+                                $offset = strpos($reversedfilename, '.', $offset + 1);
+                                if ($offset === false) {
+                                        return '';
+                                }
+                        }
+                        return strrev(substr($reversedfilename, 0, $offset));
+                }
+                return '';
+        }
+
+
+        public static function PlaytimeString($seconds) {
+                $sign = (($seconds < 0) ? '-' : '');
+                $seconds = round(abs($seconds));
+                $H = (int) floor( $seconds                            / 3600);
+                $M = (int) floor(($seconds - (3600 * $H)            ) /   60);
+                $S = (int) round( $seconds - (3600 * $H) - (60 * $M)        );
+                return $sign.($H ? $H.':' : '').($H ? str_pad($M, 2, '0', STR_PAD_LEFT) : intval($M)).':'.str_pad($S, 2, 0, STR_PAD_LEFT);
+        }
+
+
+        public static function DateMac2Unix($macdate) {
+                // Macintosh timestamp: seconds since 00:00h January 1, 1904
+                // UNIX timestamp:      seconds since 00:00h January 1, 1970
+                return self::CastAsInt($macdate - 2082844800);
+        }
+
+
+        public static function FixedPoint8_8($rawdata) {
+                return self::BigEndian2Int(substr($rawdata, 0, 1)) + (float) (self::BigEndian2Int(substr($rawdata, 1, 1)) / pow(2, 8));
+        }
+
+
+        public static function FixedPoint16_16($rawdata) {
+                return self::BigEndian2Int(substr($rawdata, 0, 2)) + (float) (self::BigEndian2Int(substr($rawdata, 2, 2)) / pow(2, 16));
+        }
+
+
+        public static function FixedPoint2_30($rawdata) {
+                $binarystring = self::BigEndian2Bin($rawdata);
+                return self::Bin2Dec(substr($binarystring, 0, 2)) + (float) (self::Bin2Dec(substr($binarystring, 2, 30)) / pow(2, 30));
+        }
+
+
+        public static function CreateDeepArray($ArrayPath, $Separator, $Value) {
+                // assigns $Value to a nested array path:
+                //   $foo = self::CreateDeepArray('/path/to/my', '/', 'file.txt')
+                // is the same as:
+                //   $foo = array('path'=>array('to'=>'array('my'=>array('file.txt'))));
+                // or
+                //   $foo['path']['to']['my'] = 'file.txt';
+                $ArrayPath = ltrim($ArrayPath, $Separator);
+                if (($pos = strpos($ArrayPath, $Separator)) !== false) {
+                        $ReturnedArray[substr($ArrayPath, 0, $pos)] = self::CreateDeepArray(substr($ArrayPath, $pos + 1), $Separator, $Value);
+                } else {
+                        $ReturnedArray[$ArrayPath] = $Value;
+                }
+                return $ReturnedArray;
+        }
+
+        public static function array_max($arraydata, $returnkey=false) {
+                $maxvalue = false;
+                $maxkey = false;
+                foreach ($arraydata as $key => $value) {
+                        if (!is_array($value)) {
+                                if ($value > $maxvalue) {
+                                        $maxvalue = $value;
+                                        $maxkey = $key;
+                                }
+                        }
+                }
+                return ($returnkey ? $maxkey : $maxvalue);
+        }
+
+        public static function array_min($arraydata, $returnkey=false) {
+                $minvalue = false;
+                $minkey = false;
+                foreach ($arraydata as $key => $value) {
+                        if (!is_array($value)) {
+                                if ($value > $minvalue) {
+                                        $minvalue = $value;
+                                        $minkey = $key;
+                                }
+                        }
+                }
+                return ($returnkey ? $minkey : $minvalue);
+        }
+
+        public static function XML2array($XMLstring) {
+                if (function_exists('simplexml_load_string')) {
+                        if (function_exists('get_object_vars')) {
+                                $XMLobject = simplexml_load_string($XMLstring);
+                                return self::SimpleXMLelement2array($XMLobject);
+                        }
+                }
+                return false;
+        }
+
+        public static function SimpleXMLelement2array($XMLobject) {
+                if (!is_object($XMLobject) && !is_array($XMLobject)) {
+                        return $XMLobject;
+                }
+                $XMLarray = (is_object($XMLobject) ? get_object_vars($XMLobject) : $XMLobject);
+                foreach ($XMLarray as $key => $value) {
+                        $XMLarray[$key] = self::SimpleXMLelement2array($value);
+                }
+                return $XMLarray;
+        }
+
+
+        // Allan Hansen <ahØartemis*dk>
+        // self::md5_data() - returns md5sum for a file from startuing position to absolute end position
+        public static function hash_data($file, $offset, $end, $algorithm) {
+                static $tempdir = '';
+                if (!self::intValueSupported($end)) {
+                        return false;
+                }
+                switch ($algorithm) {
+                        case 'md5':
+                                $hash_function = 'md5_file';
+                                $unix_call     = 'md5sum';
+                                $windows_call  = 'md5sum.exe';
+                                $hash_length   = 32;
+                                break;
+
+                        case 'sha1':
+                                $hash_function = 'sha1_file';
+                                $unix_call     = 'sha1sum';
+                                $windows_call  = 'sha1sum.exe';
+                                $hash_length   = 40;
+                                break;
+
+                        default:
+                                throw new Exception('Invalid algorithm ('.$algorithm.') in self::hash_data()');
+                                break;
+                }
+                $size = $end - $offset;
+                while (true) {
+                        if (GETID3_OS_ISWINDOWS) {
+
+                                // It seems that sha1sum.exe for Windows only works on physical files, does not accept piped data
+                                // Fall back to create-temp-file method:
+                                if ($algorithm == 'sha1') {
+                                        break;
+                                }
+
+                                $RequiredFiles = array('cygwin1.dll', 'head.exe', 'tail.exe', $windows_call);
+                                foreach ($RequiredFiles as $required_file) {
+                                        if (!is_readable(GETID3_HELPERAPPSDIR.$required_file)) {
+                                                // helper apps not available - fall back to old method
+                                                break 2;
+                                        }
+                                }
+                                $commandline  = GETID3_HELPERAPPSDIR.'head.exe -c '.$end.' '.escapeshellarg(str_replace('/', DIRECTORY_SEPARATOR, $file)).' | ';
+                                $commandline .= GETID3_HELPERAPPSDIR.'tail.exe -c '.$size.' | ';
+                                $commandline .= GETID3_HELPERAPPSDIR.$windows_call;
+
+                        } else {
+
+                                $commandline  = 'head -c'.$end.' '.escapeshellarg($file).' | ';
+                                $commandline .= 'tail -c'.$size.' | ';
+                                $commandline .= $unix_call;
+
+                        }
+                        if (preg_match('#(1|ON)#i', ini_get('safe_mode'))) {
+                                //throw new Exception('PHP running in Safe Mode - backtick operator not available, using slower non-system-call '.$algorithm.' algorithm');
+                                break;
+                        }
+                        return substr(`$commandline`, 0, $hash_length);
+                }
+
+                if (empty($tempdir)) {
+                        // yes this is ugly, feel free to suggest a better way
+                        require_once(dirname(__FILE__).'/getid3.php');
+                        $getid3_temp = new getID3();
+                        $tempdir = $getid3_temp->tempdir;
+                        unset($getid3_temp);
+                }
+                // try to create a temporary file in the system temp directory - invalid dirname should force to system temp dir
+                if (($data_filename = tempnam($tempdir, 'gI3')) === false) {
+                        // can't find anywhere to create a temp file, just fail
+                        return false;
+                }
+
+                // Init
+                $result = false;
+
+                // copy parts of file
+                try {
+                        self::CopyFileParts($file, $data_filename, $offset, $end - $offset);
+                        $result = $hash_function($data_filename);
+                } catch (Exception $e) {
+                        throw new Exception('self::CopyFileParts() failed in getid_lib::hash_data(): '.$e->getMessage());
+                }
+                unlink($data_filename);
+                return $result;
+        }
+
+        public static function CopyFileParts($filename_source, $filename_dest, $offset, $length) {
+                if (!self::intValueSupported($offset + $length)) {
+                        throw new Exception('cannot copy file portion, it extends beyond the '.round(PHP_INT_MAX / 1073741824).'GB limit');
+                }
+                if (is_readable($filename_source) && is_file($filename_source) && ($fp_src = fopen($filename_source, 'rb'))) {
+                        if (($fp_dest = fopen($filename_dest, 'wb'))) {
+                                if (fseek($fp_src, $offset, SEEK_SET) == 0) {
+                                        $byteslefttowrite = $length;
+                                        while (($byteslefttowrite > 0) && ($buffer = fread($fp_src, min($byteslefttowrite, getID3::FREAD_BUFFER_SIZE)))) {
+                                                $byteswritten = fwrite($fp_dest, $buffer, $byteslefttowrite);
+                                                $byteslefttowrite -= $byteswritten;
+                                        }
+                                        return true;
+                                } else {
+                                        throw new Exception('failed to seek to offset '.$offset.' in '.$filename_source);
+                                }
+                                fclose($fp_dest);
+                        } else {
+                                throw new Exception('failed to create file for writing '.$filename_dest);
+                        }
+                        fclose($fp_src);
+                } else {
+                        throw new Exception('failed to open file for reading '.$filename_source);
+                }
+                return false;
+        }
+
+        public static function iconv_fallback_int_utf8($charval) {
+                if ($charval < 128) {
+                        // 0bbbbbbb
+                        $newcharstring = chr($charval);
+                } elseif ($charval < 2048) {
+                        // 110bbbbb 10bbbbbb
+                        $newcharstring  = chr(($charval >>   6) | 0xC0);
+                        $newcharstring .= chr(($charval & 0x3F) | 0x80);
+                } elseif ($charval < 65536) {
+                        // 1110bbbb 10bbbbbb 10bbbbbb
+                        $newcharstring  = chr(($charval >>  12) | 0xE0);
+                        $newcharstring .= chr(($charval >>   6) | 0xC0);
+                        $newcharstring .= chr(($charval & 0x3F) | 0x80);
+                } else {
+                        // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
+                        $newcharstring  = chr(($charval >>  18) | 0xF0);
+                        $newcharstring .= chr(($charval >>  12) | 0xC0);
+                        $newcharstring .= chr(($charval >>   6) | 0xC0);
+                        $newcharstring .= chr(($charval & 0x3F) | 0x80);
+                }
+                return $newcharstring;
+        }
+
+        // ISO-8859-1 => UTF-8
+        public static function iconv_fallback_iso88591_utf8($string, $bom=false) {
+                if (function_exists('utf8_encode')) {
+                        return utf8_encode($string);
+                }
+                // utf8_encode() unavailable, use getID3()'s iconv_fallback() conversions (possibly PHP is compiled without XML support)
+                $newcharstring = '';
+                if ($bom) {
+                        $newcharstring .= "\xEF\xBB\xBF";
+                }
+                for ($i = 0; $i < strlen($string); $i++) {
+                        $charval = ord($string{$i});
+                        $newcharstring .= self::iconv_fallback_int_utf8($charval);
+                }
+                return $newcharstring;
+        }
+
+        // ISO-8859-1 => UTF-16BE
+        public static function iconv_fallback_iso88591_utf16be($string, $bom=false) {
+                $newcharstring = '';
+                if ($bom) {
+                        $newcharstring .= "\xFE\xFF";
+                }
+                for ($i = 0; $i < strlen($string); $i++) {
+                        $newcharstring .= "\x00".$string{$i};
+                }
+                return $newcharstring;
+        }
+
+        // ISO-8859-1 => UTF-16LE
+        public static function iconv_fallback_iso88591_utf16le($string, $bom=false) {
+                $newcharstring = '';
+                if ($bom) {
+                        $newcharstring .= "\xFF\xFE";
+                }
+                for ($i = 0; $i < strlen($string); $i++) {
+                        $newcharstring .= $string{$i}."\x00";
+                }
+                return $newcharstring;
+        }
+
+        // ISO-8859-1 => UTF-16LE (BOM)
+        public static function iconv_fallback_iso88591_utf16($string) {
+                return self::iconv_fallback_iso88591_utf16le($string, true);
+        }
+
+        // UTF-8 => ISO-8859-1
+        public static function iconv_fallback_utf8_iso88591($string) {
+                if (function_exists('utf8_decode')) {
+                        return utf8_decode($string);
+                }
+                // utf8_decode() unavailable, use getID3()'s iconv_fallback() conversions (possibly PHP is compiled without XML support)
+                $newcharstring = '';
+                $offset = 0;
+                $stringlength = strlen($string);
+                while ($offset < $stringlength) {
+                        if ((ord($string{$offset}) | 0x07) == 0xF7) {
+                                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x07) << 18) &
+                                                   ((ord($string{($offset + 1)}) & 0x3F) << 12) &
+                                                   ((ord($string{($offset + 2)}) & 0x3F) <<  6) &
+                                                        (ord($string{($offset + 3)}) & 0x3F);
+                                $offset += 4;
+                        } elseif ((ord($string{$offset}) | 0x0F) == 0xEF) {
+                                // 1110bbbb 10bbbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x0F) << 12) &
+                                                   ((ord($string{($offset + 1)}) & 0x3F) <<  6) &
+                                                        (ord($string{($offset + 2)}) & 0x3F);
+                                $offset += 3;
+                        } elseif ((ord($string{$offset}) | 0x1F) == 0xDF) {
+                                // 110bbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x1F) <<  6) &
+                                                        (ord($string{($offset + 1)}) & 0x3F);
+                                $offset += 2;
+                        } elseif ((ord($string{$offset}) | 0x7F) == 0x7F) {
+                                // 0bbbbbbb
+                                $charval = ord($string{$offset});
+                                $offset += 1;
+                        } else {
+                                // error? throw some kind of warning here?
+                                $charval = false;
+                                $offset += 1;
+                        }
+                        if ($charval !== false) {
+                                $newcharstring .= (($charval < 256) ? chr($charval) : '?');
+                        }
+                }
+                return $newcharstring;
+        }
+
+        // UTF-8 => UTF-16BE
+        public static function iconv_fallback_utf8_utf16be($string, $bom=false) {
+                $newcharstring = '';
+                if ($bom) {
+                        $newcharstring .= "\xFE\xFF";
+                }
+                $offset = 0;
+                $stringlength = strlen($string);
+                while ($offset < $stringlength) {
+                        if ((ord($string{$offset}) | 0x07) == 0xF7) {
+                                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x07) << 18) &
+                                                   ((ord($string{($offset + 1)}) & 0x3F) << 12) &
+                                                   ((ord($string{($offset + 2)}) & 0x3F) <<  6) &
+                                                        (ord($string{($offset + 3)}) & 0x3F);
+                                $offset += 4;
+                        } elseif ((ord($string{$offset}) | 0x0F) == 0xEF) {
+                                // 1110bbbb 10bbbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x0F) << 12) &
+                                                   ((ord($string{($offset + 1)}) & 0x3F) <<  6) &
+                                                        (ord($string{($offset + 2)}) & 0x3F);
+                                $offset += 3;
+                        } elseif ((ord($string{$offset}) | 0x1F) == 0xDF) {
+                                // 110bbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x1F) <<  6) &
+                                                        (ord($string{($offset + 1)}) & 0x3F);
+                                $offset += 2;
+                        } elseif ((ord($string{$offset}) | 0x7F) == 0x7F) {
+                                // 0bbbbbbb
+                                $charval = ord($string{$offset});
+                                $offset += 1;
+                        } else {
+                                // error? throw some kind of warning here?
+                                $charval = false;
+                                $offset += 1;
+                        }
+                        if ($charval !== false) {
+                                $newcharstring .= (($charval < 65536) ? self::BigEndian2String($charval, 2) : "\x00".'?');
+                        }
+                }
+                return $newcharstring;
+        }
+
+        // UTF-8 => UTF-16LE
+        public static function iconv_fallback_utf8_utf16le($string, $bom=false) {
+                $newcharstring = '';
+                if ($bom) {
+                        $newcharstring .= "\xFF\xFE";
+                }
+                $offset = 0;
+                $stringlength = strlen($string);
+                while ($offset < $stringlength) {
+                        if ((ord($string{$offset}) | 0x07) == 0xF7) {
+                                // 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x07) << 18) &
+                                                   ((ord($string{($offset + 1)}) & 0x3F) << 12) &
+                                                   ((ord($string{($offset + 2)}) & 0x3F) <<  6) &
+                                                        (ord($string{($offset + 3)}) & 0x3F);
+                                $offset += 4;
+                        } elseif ((ord($string{$offset}) | 0x0F) == 0xEF) {
+                                // 1110bbbb 10bbbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x0F) << 12) &
+                                                   ((ord($string{($offset + 1)}) & 0x3F) <<  6) &
+                                                        (ord($string{($offset + 2)}) & 0x3F);
+                                $offset += 3;
+                        } elseif ((ord($string{$offset}) | 0x1F) == 0xDF) {
+                                // 110bbbbb 10bbbbbb
+                                $charval = ((ord($string{($offset + 0)}) & 0x1F) <<  6) &
+                                                        (ord($string{($offset + 1)}) & 0x3F);
+                                $offset += 2;
+                        } elseif ((ord($string{$offset}) | 0x7F) == 0x7F) {
+                                // 0bbbbbbb
+                                $charval = ord($string{$offset});
+                                $offset += 1;
+                        } else {
+                                // error? maybe throw some warning here?
+                                $charval = false;
+                                $offset += 1;
+                        }
+                        if ($charval !== false) {
+                                $newcharstring .= (($charval < 65536) ? self::LittleEndian2String($charval, 2) : '?'."\x00");
+                        }
+                }
+                return $newcharstring;
+        }
+
+        // UTF-8 => UTF-16LE (BOM)
+        public static function iconv_fallback_utf8_utf16($string) {
+                return self::iconv_fallback_utf8_utf16le($string, true);
+        }
+
+        // UTF-16BE => UTF-8
+        public static function iconv_fallback_utf16be_utf8($string) {
+                if (substr($string, 0, 2) == "\xFE\xFF") {
+                        // strip BOM
+                        $string = substr($string, 2);
+                }
+                $newcharstring = '';
+                for ($i = 0; $i < strlen($string); $i += 2) {
+                        $charval = self::BigEndian2Int(substr($string, $i, 2));
+                        $newcharstring .= self::iconv_fallback_int_utf8($charval);
+                }
+                return $newcharstring;
+        }
+
+        // UTF-16LE => UTF-8
+        public static function iconv_fallback_utf16le_utf8($string) {
+                if (substr($string, 0, 2) == "\xFF\xFE") {
+                        // strip BOM
+                        $string = substr($string, 2);
+                }
+                $newcharstring = '';
+                for ($i = 0; $i < strlen($string); $i += 2) {
+                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
+                        $newcharstring .= self::iconv_fallback_int_utf8($charval);
+                }
+                return $newcharstring;
+        }
+
+        // UTF-16BE => ISO-8859-1
+        public static function iconv_fallback_utf16be_iso88591($string) {
+                if (substr($string, 0, 2) == "\xFE\xFF") {
+                        // strip BOM
+                        $string = substr($string, 2);
+                }
+                $newcharstring = '';
+                for ($i = 0; $i < strlen($string); $i += 2) {
+                        $charval = self::BigEndian2Int(substr($string, $i, 2));
+                        $newcharstring .= (($charval < 256) ? chr($charval) : '?');
+                }
+                return $newcharstring;
+        }
+
+        // UTF-16LE => ISO-8859-1
+        public static function iconv_fallback_utf16le_iso88591($string) {
+                if (substr($string, 0, 2) == "\xFF\xFE") {
+                        // strip BOM
+                        $string = substr($string, 2);
+                }
+                $newcharstring = '';
+                for ($i = 0; $i < strlen($string); $i += 2) {
+                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
+                        $newcharstring .= (($charval < 256) ? chr($charval) : '?');
+                }
+                return $newcharstring;
+        }
+
+        // UTF-16 (BOM) => ISO-8859-1
+        public static function iconv_fallback_utf16_iso88591($string) {
+                $bom = substr($string, 0, 2);
+                if ($bom == "\xFE\xFF") {
+                        return self::iconv_fallback_utf16be_iso88591(substr($string, 2));
+                } elseif ($bom == "\xFF\xFE") {
+                        return self::iconv_fallback_utf16le_iso88591(substr($string, 2));
+                }
+                return $string;
+        }
+
+        // UTF-16 (BOM) => UTF-8
+        public static function iconv_fallback_utf16_utf8($string) {
+                $bom = substr($string, 0, 2);
+                if ($bom == "\xFE\xFF") {
+                        return self::iconv_fallback_utf16be_utf8(substr($string, 2));
+                } elseif ($bom == "\xFF\xFE") {
+                        return self::iconv_fallback_utf16le_utf8(substr($string, 2));
+                }
+                return $string;
+        }
+
+        public static function iconv_fallback($in_charset, $out_charset, $string) {
+
+                if ($in_charset == $out_charset) {
+                        return $string;
+                }
+
+                // iconv() availble
+                if (function_exists('iconv')) {
+                        if ($converted_string = @iconv($in_charset, $out_charset.'//TRANSLIT', $string)) {
+                                switch ($out_charset) {
+                                        case 'ISO-8859-1':
+                                                $converted_string = rtrim($converted_string, "\x00");
+                                                break;
+                                }
+                                return $converted_string;
+                        }
+
+                        // iconv() may sometimes fail with "illegal character in input string" error message
+                        // and return an empty string, but returning the unconverted string is more useful
+                        return $string;
+                }
+
+
+                // iconv() not available
+                static $ConversionFunctionList = array();
+                if (empty($ConversionFunctionList)) {
+                        $ConversionFunctionList['ISO-8859-1']['UTF-8']    = 'iconv_fallback_iso88591_utf8';
+                        $ConversionFunctionList['ISO-8859-1']['UTF-16']   = 'iconv_fallback_iso88591_utf16';
+                        $ConversionFunctionList['ISO-8859-1']['UTF-16BE'] = 'iconv_fallback_iso88591_utf16be';
+                        $ConversionFunctionList['ISO-8859-1']['UTF-16LE'] = 'iconv_fallback_iso88591_utf16le';
+                        $ConversionFunctionList['UTF-8']['ISO-8859-1']    = 'iconv_fallback_utf8_iso88591';
+                        $ConversionFunctionList['UTF-8']['UTF-16']        = 'iconv_fallback_utf8_utf16';
+                        $ConversionFunctionList['UTF-8']['UTF-16BE']      = 'iconv_fallback_utf8_utf16be';
+                        $ConversionFunctionList['UTF-8']['UTF-16LE']      = 'iconv_fallback_utf8_utf16le';
+                        $ConversionFunctionList['UTF-16']['ISO-8859-1']   = 'iconv_fallback_utf16_iso88591';
+                        $ConversionFunctionList['UTF-16']['UTF-8']        = 'iconv_fallback_utf16_utf8';
+                        $ConversionFunctionList['UTF-16LE']['ISO-8859-1'] = 'iconv_fallback_utf16le_iso88591';
+                        $ConversionFunctionList['UTF-16LE']['UTF-8']      = 'iconv_fallback_utf16le_utf8';
+                        $ConversionFunctionList['UTF-16BE']['ISO-8859-1'] = 'iconv_fallback_utf16be_iso88591';
+                        $ConversionFunctionList['UTF-16BE']['UTF-8']      = 'iconv_fallback_utf16be_utf8';
+                }
+                if (isset($ConversionFunctionList[strtoupper($in_charset)][strtoupper($out_charset)])) {
+                        $ConversionFunction = $ConversionFunctionList[strtoupper($in_charset)][strtoupper($out_charset)];
+                        return self::$ConversionFunction($string);
+                }
+                throw new Exception('PHP does not have iconv() support - cannot convert from '.$in_charset.' to '.$out_charset);
+        }
+
+
+        public static function MultiByteCharString2HTML($string, $charset='ISO-8859-1') {
+                $string = (string) $string; // in case trying to pass a numeric (float, int) string, would otherwise return an empty string
+                $HTMLstring = '';
+
+                switch ($charset) {
+                        case '1251':
+                        case '1252':
+                        case '866':
+                        case '932':
+                        case '936':
+                        case '950':
+                        case 'BIG5':
+                        case 'BIG5-HKSCS':
+                        case 'cp1251':
+                        case 'cp1252':
+                        case 'cp866':
+                        case 'EUC-JP':
+                        case 'EUCJP':
+                        case 'GB2312':
+                        case 'ibm866':
+                        case 'ISO-8859-1':
+                        case 'ISO-8859-15':
+                        case 'ISO8859-1':
+                        case 'ISO8859-15':
+                        case 'KOI8-R':
+                        case 'koi8-ru':
+                        case 'koi8r':
+                        case 'Shift_JIS':
+                        case 'SJIS':
+                        case 'win-1251':
+                        case 'Windows-1251':
+                        case 'Windows-1252':
+                                $HTMLstring = htmlentities($string, ENT_COMPAT, $charset);
+                                break;
+
+                        case 'UTF-8':
+                                $strlen = strlen($string);
+                                for ($i = 0; $i < $strlen; $i++) {
+                                        $char_ord_val = ord($string{$i});
+                                        $charval = 0;
+                                        if ($char_ord_val < 0x80) {
+                                                $charval = $char_ord_val;
+                                        } elseif ((($char_ord_val & 0xF0) >> 4) == 0x0F  &&  $i+3 < $strlen) {
+                                                $charval  = (($char_ord_val & 0x07) << 18);
+                                                $charval += ((ord($string{++$i}) & 0x3F) << 12);
+                                                $charval += ((ord($string{++$i}) & 0x3F) << 6);
+                                                $charval +=  (ord($string{++$i}) & 0x3F);
+                                        } elseif ((($char_ord_val & 0xE0) >> 5) == 0x07  &&  $i+2 < $strlen) {
+                                                $charval  = (($char_ord_val & 0x0F) << 12);
+                                                $charval += ((ord($string{++$i}) & 0x3F) << 6);
+                                                $charval +=  (ord($string{++$i}) & 0x3F);
+                                        } elseif ((($char_ord_val & 0xC0) >> 6) == 0x03  &&  $i+1 < $strlen) {
+                                                $charval  = (($char_ord_val & 0x1F) << 6);
+                                                $charval += (ord($string{++$i}) & 0x3F);
+                                        }
+                                        if (($charval >= 32) && ($charval <= 127)) {
+                                                $HTMLstring .= htmlentities(chr($charval));
+                                        } else {
+                                                $HTMLstring .= '&#'.$charval.';';
+                                        }
+                                }
+                                break;
+
+                        case 'UTF-16LE':
+                                for ($i = 0; $i < strlen($string); $i += 2) {
+                                        $charval = self::LittleEndian2Int(substr($string, $i, 2));
+                                        if (($charval >= 32) && ($charval <= 127)) {
+                                                $HTMLstring .= chr($charval);
+                                        } else {
+                                                $HTMLstring .= '&#'.$charval.';';
+                                        }
+                                }
+                                break;
+
+                        case 'UTF-16BE':
+                                for ($i = 0; $i < strlen($string); $i += 2) {
+                                        $charval = self::BigEndian2Int(substr($string, $i, 2));
+                                        if (($charval >= 32) && ($charval <= 127)) {
+                                                $HTMLstring .= chr($charval);
+                                        } else {
+                                                $HTMLstring .= '&#'.$charval.';';
+                                        }
+                                }
+                                break;
+
+                        default:
+                                $HTMLstring = 'ERROR: Character set "'.$charset.'" not supported in MultiByteCharString2HTML()';
+                                break;
+                }
+                return $HTMLstring;
+        }
+
+
+
+        public static function RGADnameLookup($namecode) {
+                static $RGADname = array();
+                if (empty($RGADname)) {
+                        $RGADname[0] = 'not set';
+                        $RGADname[1] = 'Track Gain Adjustment';
+                        $RGADname[2] = 'Album Gain Adjustment';
+                }
+
+                return (isset($RGADname[$namecode]) ? $RGADname[$namecode] : '');
+        }
+
+
+        public static function RGADoriginatorLookup($originatorcode) {
+                static $RGADoriginator = array();
+                if (empty($RGADoriginator)) {
+                        $RGADoriginator[0] = 'unspecified';
+                        $RGADoriginator[1] = 'pre-set by artist/producer/mastering engineer';
+                        $RGADoriginator[2] = 'set by user';
+                        $RGADoriginator[3] = 'determined automatically';
+                }
+
+                return (isset($RGADoriginator[$originatorcode]) ? $RGADoriginator[$originatorcode] : '');
+        }
+
+
+        public static function RGADadjustmentLookup($rawadjustment, $signbit) {
+                $adjustment = $rawadjustment / 10;
+                if ($signbit == 1) {
+                        $adjustment *= -1;
+                }
+                return (float) $adjustment;
+        }
+
+
+        public static function RGADgainString($namecode, $originatorcode, $replaygain) {
+                if ($replaygain < 0) {
+                        $signbit = '1';
+                } else {
+                        $signbit = '0';
+                }
+                $storedreplaygain = intval(round($replaygain * 10));
+                $gainstring  = str_pad(decbin($namecode), 3, '0', STR_PAD_LEFT);
+                $gainstring .= str_pad(decbin($originatorcode), 3, '0', STR_PAD_LEFT);
+                $gainstring .= $signbit;
+                $gainstring .= str_pad(decbin($storedreplaygain), 9, '0', STR_PAD_LEFT);
+
+                return $gainstring;
+        }
+
+        public static function RGADamplitude2dB($amplitude) {
+                return 20 * log10($amplitude);
+        }
+
+
+        public static function GetDataImageSize($imgData, &$imageinfo=array()) {
+                static $tempdir = '';
+                if (empty($tempdir)) {
+                        // yes this is ugly, feel free to suggest a better way
+                        require_once(dirname(__FILE__).'/class-getid3.php');
+                        $getid3_temp = new getID3();
+                        $tempdir = $getid3_temp->tempdir;
+                        unset($getid3_temp);
+                }
+                $GetDataImageSize = false;
+                if ($tempfilename = tempnam($tempdir, 'gI3')) {
+                        if (is_writable($tempfilename) && is_file($tempfilename) && ($tmp = fopen($tempfilename, 'wb'))) {
+                                fwrite($tmp, $imgData);
+                                fclose($tmp);
+                                $GetDataImageSize = @getimagesize($tempfilename, $imageinfo);
+                        }
+                        unlink($tempfilename);
+                }
+                return $GetDataImageSize;
+        }
+
+        public static function ImageExtFromMime($mime_type) {
+                // temporary way, works OK for now, but should be reworked in the future
+                return str_replace(array('image/', 'x-', 'jpeg'), array('', '', 'jpg'), $mime_type);
+        }
+
+        public static function ImageTypesLookup($imagetypeid) {
+                static $ImageTypesLookup = array();
+                if (empty($ImageTypesLookup)) {
+                        $ImageTypesLookup[1]  = 'gif';
+                        $ImageTypesLookup[2]  = 'jpeg';
+                        $ImageTypesLookup[3]  = 'png';
+                        $ImageTypesLookup[4]  = 'swf';
+                        $ImageTypesLookup[5]  = 'psd';
+                        $ImageTypesLookup[6]  = 'bmp';
+                        $ImageTypesLookup[7]  = 'tiff (little-endian)';
+                        $ImageTypesLookup[8]  = 'tiff (big-endian)';
+                        $ImageTypesLookup[9]  = 'jpc';
+                        $ImageTypesLookup[10] = 'jp2';
+                        $ImageTypesLookup[11] = 'jpx';
+                        $ImageTypesLookup[12] = 'jb2';
+                        $ImageTypesLookup[13] = 'swc';
+                        $ImageTypesLookup[14] = 'iff';
+                }
+                return (isset($ImageTypesLookup[$imagetypeid]) ? $ImageTypesLookup[$imagetypeid] : '');
+        }
+
+        public static function CopyTagsToComments(&$ThisFileInfo) {
+
+                // Copy all entries from ['tags'] into common ['comments']
+                if (!empty($ThisFileInfo['tags'])) {
+                        foreach ($ThisFileInfo['tags'] as $tagtype => $tagarray) {
+                                foreach ($tagarray as $tagname => $tagdata) {
+                                        foreach ($tagdata as $key => $value) {
+                                                if (!empty($value)) {
+                                                        if (empty($ThisFileInfo['comments'][$tagname])) {
+
+                                                                // fall through and append value
+
+                                                        } elseif ($tagtype == 'id3v1') {
+
+                                                                $newvaluelength = strlen(trim($value));
+                                                                foreach ($ThisFileInfo['comments'][$tagname] as $existingkey => $existingvalue) {
+                                                                        $oldvaluelength = strlen(trim($existingvalue));
+                                                                        if (($newvaluelength <= $oldvaluelength) && (substr($existingvalue, 0, $newvaluelength) == trim($value))) {
+                                                                                // new value is identical but shorter-than (or equal-length to) one already in comments - skip
+                                                                                break 2;
+                                                                        }
+                                                                }
+
+                                                        } elseif (!is_array($value)) {
+
+                                                                $newvaluelength = strlen(trim($value));
+                                                                foreach ($ThisFileInfo['comments'][$tagname] as $existingkey => $existingvalue) {
+                                                                        $oldvaluelength = strlen(trim($existingvalue));
+                                                                        if (($newvaluelength > $oldvaluelength) && (substr(trim($value), 0, strlen($existingvalue)) == $existingvalue)) {
+                                                                                $ThisFileInfo['comments'][$tagname][$existingkey] = trim($value);
+                                                                                break 2;
+                                                                        }
+                                                                }
+
+                                                        }
+                                                        if (is_array($value) || empty($ThisFileInfo['comments'][$tagname]) || !in_array(trim($value), $ThisFileInfo['comments'][$tagname])) {
+                                                                $value = (is_string($value) ? trim($value) : $value);
+                                                                $ThisFileInfo['comments'][$tagname][] = $value;
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+
+                        // Copy to ['comments_html']
+                        foreach ($ThisFileInfo['comments'] as $field => $values) {
+                                if ($field == 'picture') {
+                                        // 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
+                                        continue;
+                                }
+                                foreach ($values as $index => $value) {
+                                        if (is_array($value)) {
+                                                $ThisFileInfo['comments_html'][$field][$index] = $value;
+                                        } else {
+                                                $ThisFileInfo['comments_html'][$field][$index] = str_replace('&#0;', '', self::MultiByteCharString2HTML($value, $ThisFileInfo['encoding']));
+                                        }
+                                }
+                        }
+                }
+                return true;
+        }
+
+
+        public static function EmbeddedLookup($key, $begin, $end, $file, $name) {
+
+                // Cached
+                static $cache;
+                if (isset($cache[$file][$name])) {
+                        return (isset($cache[$file][$name][$key]) ? $cache[$file][$name][$key] : '');
+                }
+
+                // Init
+                $keylength  = strlen($key);
+                $line_count = $end - $begin - 7;
+
+                // Open php file
+                $fp = fopen($file, 'r');
+
+                // Discard $begin lines
+                for ($i = 0; $i < ($begin + 3); $i++) {
+                        fgets($fp, 1024);
+                }
+
+                // Loop thru line
+                while (0 < $line_count--) {
+
+                        // Read line
+                        $line = ltrim(fgets($fp, 1024), "\t ");
+
+                        // METHOD A: only cache the matching key - less memory but slower on next lookup of not-previously-looked-up key
+                        //$keycheck = substr($line, 0, $keylength);
+                        //if ($key == $keycheck)  {
+                        //      $cache[$file][$name][$keycheck] = substr($line, $keylength + 1);
+                        //      break;
+                        //}
+
+                        // METHOD B: cache all keys in this lookup - more memory but faster on next lookup of not-previously-looked-up key
+                        //$cache[$file][$name][substr($line, 0, $keylength)] = trim(substr($line, $keylength + 1));
+                        $explodedLine = explode("\t", $line, 2);
+                        $ThisKey   = (isset($explodedLine[0]) ? $explodedLine[0] : '');
+                        $ThisValue = (isset($explodedLine[1]) ? $explodedLine[1] : '');
+                        $cache[$file][$name][$ThisKey] = trim($ThisValue);
+                }
+
+                // Close and return
+                fclose($fp);
+                return (isset($cache[$file][$name][$key]) ? $cache[$file][$name][$key] : '');
+        }
+
+        public static function IncludeDependency($filename, $sourcefile, $DieOnFailure=false) {
+                global $GETID3_ERRORARRAY;
+
+                if (file_exists($filename)) {
+                        if (include_once($filename)) {
+                                return true;
+                        } else {
+                                $diemessage = basename($sourcefile).' depends on '.$filename.', which has errors';
+                        }
+                } else {
+                        $diemessage = basename($sourcefile).' depends on '.$filename.', which is missing';
+                }
+                if ($DieOnFailure) {
+                        throw new Exception($diemessage);
+                } else {
+                        $GETID3_ERRORARRAY[] = $diemessage;
+                }
+                return false;
+        }
+
+        public static function trimNullByte($string) {
+                return trim($string, "\x00");
+        }
+
+        public static function getFileSizeSyscall($path) {
+                $filesize = false;
+
+                if (GETID3_OS_ISWINDOWS) {
+                        if (class_exists('COM')) { // From PHP 5.3.15 and 5.4.5, COM and DOTNET is no longer built into the php core.you have to add COM support in php.ini:
+                                $filesystem = new COM('Scripting.FileSystemObject');
+                                $file = $filesystem->GetFile($path);
+                                $filesize = $file->Size();
+                                unset($filesystem, $file);
+                        } else {
+                                $commandline = 'for %I in ('.escapeshellarg($path).') do @echo %~zI';
+                        }
+                } else {
+                        $commandline = 'ls -l '.escapeshellarg($path).' | awk \'{print $5}\'';
+                }
+                if (isset($commandline)) {
+                        $output = trim(`$commandline`);
+                        if (ctype_digit($output)) {
+                                $filesize = (float) $output;
+                        }
+                }
+                return $filesize;
+        }
+}
+ No newline at end of file

new file wp-includes/ID3/module.audio-video.asf.php

@@ +1 @@
+<?php
+/////////////////////////////////////////////////////////////////
+/// getID3() by James Heinrich <info@getid3.org>               //
+//  available at http://getid3.sourceforge.net                 //
+//            or http://www.getid3.org                         //
+/////////////////////////////////////////////////////////////////
+// See readme.txt for more details                             //
+/////////////////////////////////////////////////////////////////
+//                                                             //
+// module.audio-video.asf.php                                  //
+// module for analyzing ASF, WMA and WMV files                 //
+// dependencies: module.audio-video.riff.php                   //
+//                                                            ///
+/////////////////////////////////////////////////////////////////
+
+getid3_lib::IncludeDependency(GETID3_INCLUDEPATH.'module.audio-video.riff.php', __FILE__, true);
+
+class getid3_asf extends getid3_handler
+{
+
+        public function __construct(getID3 $getid3) {
+                parent::__construct($getid3);  // extends getid3_handler::__construct()
+
+                // initialize all GUID constants
+                $GUIDarray = $this->KnownGUIDs();
+                foreach ($GUIDarray as $GUIDname => $hexstringvalue) {
+                        if (!defined($GUIDname)) {
+                                define($GUIDname, $this->GUIDtoBytestring($hexstringvalue));
+                        }
+                }
+        }
+
+        public function Analyze() {
+                $info = &$this->getid3->info;
+
+                // Shortcuts
+                $thisfile_audio = &$info['audio'];
+                $thisfile_video = &$info['video'];
+                $info['asf']  = array();
+                $thisfile_asf = &$info['asf'];
+                $thisfile_asf['comments'] = array();
+                $thisfile_asf_comments    = &$thisfile_asf['comments'];
+                $thisfile_asf['header_object'] = array();
+                $thisfile_asf_headerobject     = &$thisfile_asf['header_object'];
+
+
+                // ASF structure:
+                // * Header Object [required]
+                //   * File Properties Object [required]   (global file attributes)
+                //   * Stream Properties Object [required] (defines media stream & characteristics)
+                //   * Header Extension Object [required]  (additional functionality)
+                //   * Content Description Object          (bibliographic information)
+                //   * Script Command Object               (commands for during playback)
+                //   * Marker Object                       (named jumped points within the file)
+                // * Data Object [required]
+                //   * Data Packets
+                // * Index Object
+
+                // Header Object: (mandatory, one only)
+                // Field Name                   Field Type   Size (bits)
+                // Object ID                    GUID         128             // GUID for header object - GETID3_ASF_Header_Object
+                // Object Size                  QWORD        64              // size of header object, including 30 bytes of Header Object header
+                // Number of Header Objects     DWORD        32              // number of objects in header object
+                // Reserved1                    BYTE         8               // hardcoded: 0x01
+                // Reserved2                    BYTE         8               // hardcoded: 0x02
+
+                $info['fileformat'] = 'asf';
+
+                fseek($this->getid3->fp, $info['avdataoffset'], SEEK_SET);
+                $HeaderObjectData = fread($this->getid3->fp, 30);
+
+                $thisfile_asf_headerobject['objectid']      = substr($HeaderObjectData, 0, 16);
+                $thisfile_asf_headerobject['objectid_guid'] = $this->BytestringToGUID($thisfile_asf_headerobject['objectid']);
+                if ($thisfile_asf_headerobject['objectid'] != GETID3_ASF_Header_Object) {
+                        $info['warning'][] = 'ASF header GUID {'.$this->BytestringToGUID($thisfile_asf_headerobject['objectid']).'} does not match expected "GETID3_ASF_Header_Object" GUID {'.$this->BytestringToGUID(GETID3_ASF_Header_Object).'}';
+                        unset($info['fileformat']);
+                        unset($info['asf']);
+                        return false;
+                        break;
+                }
+                $thisfile_asf_headerobject['objectsize']    = getid3_lib::LittleEndian2Int(substr($HeaderObjectData, 16, 8));
+                $thisfile_asf_headerobject['headerobjects'] = getid3_lib::LittleEndian2Int(substr($HeaderObjectData, 24, 4));
+                $thisfile_asf_headerobject['reserved1']     = getid3_lib::LittleEndian2Int(substr($HeaderObjectData, 28, 1));
+                $thisfile_asf_headerobject['reserved2']     = getid3_lib::LittleEndian2Int(substr($HeaderObjectData, 29, 1));
+
+                $NextObjectOffset = ftell($this->getid3->fp);
+                $ASFHeaderData = fread($this->getid3->fp, $thisfile_asf_headerobject['objectsize'] - 30);
+                $offset = 0;
+
+                for ($HeaderObjectsCounter = 0; $HeaderObjectsCounter < $thisfile_asf_headerobject['headerobjects']; $HeaderObjectsCounter++) {
+                        $NextObjectGUID = substr($ASFHeaderData, $offset, 16);
+                        $offset += 16;
+                        $NextObjectGUIDtext = $this->BytestringToGUID($NextObjectGUID);
+                        $NextObjectSize = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                        $offset += 8;
+                        switch ($NextObjectGUID) {
+
+                                case GETID3_ASF_File_Properties_Object:
+                                        // File Properties Object: (mandatory, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for file properties object - GETID3_ASF_File_Properties_Object
+                                        // Object Size                  QWORD        64              // size of file properties object, including 104 bytes of File Properties Object header
+                                        // File ID                      GUID         128             // unique ID - identical to File ID in Data Object
+                                        // File Size                    QWORD        64              // entire file in bytes. Invalid if Broadcast Flag == 1
+                                        // Creation Date                QWORD        64              // date & time of file creation. Maybe invalid if Broadcast Flag == 1
+                                        // Data Packets Count           QWORD        64              // number of data packets in Data Object. Invalid if Broadcast Flag == 1
+                                        // Play Duration                QWORD        64              // playtime, in 100-nanosecond units. Invalid if Broadcast Flag == 1
+                                        // Send Duration                QWORD        64              // time needed to send file, in 100-nanosecond units. Players can ignore this value. Invalid if Broadcast Flag == 1
+                                        // Preroll                      QWORD        64              // time to buffer data before starting to play file, in 1-millisecond units. If <> 0, PlayDuration and PresentationTime have been offset by this amount
+                                        // Flags                        DWORD        32              //
+                                        // * Broadcast Flag             bits         1  (0x01)       // file is currently being written, some header values are invalid
+                                        // * Seekable Flag              bits         1  (0x02)       // is file seekable
+                                        // * Reserved                   bits         30 (0xFFFFFFFC) // reserved - set to zero
+                                        // Minimum Data Packet Size     DWORD        32              // in bytes. should be same as Maximum Data Packet Size. Invalid if Broadcast Flag == 1
+                                        // Maximum Data Packet Size     DWORD        32              // in bytes. should be same as Minimum Data Packet Size. Invalid if Broadcast Flag == 1
+                                        // Maximum Bitrate              DWORD        32              // maximum instantaneous bitrate in bits per second for entire file, including all data streams and ASF overhead
+
+                                        // shortcut
+                                        $thisfile_asf['file_properties_object'] = array();
+                                        $thisfile_asf_filepropertiesobject      = &$thisfile_asf['file_properties_object'];
+
+                                        $thisfile_asf_filepropertiesobject['offset']             = $NextObjectOffset + $offset;
+                                        $thisfile_asf_filepropertiesobject['objectid']           = $NextObjectGUID;
+                                        $thisfile_asf_filepropertiesobject['objectid_guid']      = $NextObjectGUIDtext;
+                                        $thisfile_asf_filepropertiesobject['objectsize']         = $NextObjectSize;
+                                        $thisfile_asf_filepropertiesobject['fileid']             = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $thisfile_asf_filepropertiesobject['fileid_guid']        = $this->BytestringToGUID($thisfile_asf_filepropertiesobject['fileid']);
+                                        $thisfile_asf_filepropertiesobject['filesize']           = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $offset += 8;
+                                        $thisfile_asf_filepropertiesobject['creation_date']      = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $thisfile_asf_filepropertiesobject['creation_date_unix'] = $this->FILETIMEtoUNIXtime($thisfile_asf_filepropertiesobject['creation_date']);
+                                        $offset += 8;
+                                        $thisfile_asf_filepropertiesobject['data_packets']       = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $offset += 8;
+                                        $thisfile_asf_filepropertiesobject['play_duration']      = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $offset += 8;
+                                        $thisfile_asf_filepropertiesobject['send_duration']      = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $offset += 8;
+                                        $thisfile_asf_filepropertiesobject['preroll']            = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $offset += 8;
+                                        $thisfile_asf_filepropertiesobject['flags_raw']          = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $thisfile_asf_filepropertiesobject['flags']['broadcast'] = (bool) ($thisfile_asf_filepropertiesobject['flags_raw'] & 0x0001);
+                                        $thisfile_asf_filepropertiesobject['flags']['seekable']  = (bool) ($thisfile_asf_filepropertiesobject['flags_raw'] & 0x0002);
+
+                                        $thisfile_asf_filepropertiesobject['min_packet_size']    = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $thisfile_asf_filepropertiesobject['max_packet_size']    = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $thisfile_asf_filepropertiesobject['max_bitrate']        = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+
+                                        if ($thisfile_asf_filepropertiesobject['flags']['broadcast']) {
+
+                                                // broadcast flag is set, some values invalid
+                                                unset($thisfile_asf_filepropertiesobject['filesize']);
+                                                unset($thisfile_asf_filepropertiesobject['data_packets']);
+                                                unset($thisfile_asf_filepropertiesobject['play_duration']);
+                                                unset($thisfile_asf_filepropertiesobject['send_duration']);
+                                                unset($thisfile_asf_filepropertiesobject['min_packet_size']);
+                                                unset($thisfile_asf_filepropertiesobject['max_packet_size']);
+
+                                        } else {
+
+                                                // broadcast flag NOT set, perform calculations
+                                                $info['playtime_seconds'] = ($thisfile_asf_filepropertiesobject['play_duration'] / 10000000) - ($thisfile_asf_filepropertiesobject['preroll'] / 1000);
+
+                                                //$info['bitrate'] = $thisfile_asf_filepropertiesobject['max_bitrate'];
+                                                $info['bitrate'] = ((isset($thisfile_asf_filepropertiesobject['filesize']) ? $thisfile_asf_filepropertiesobject['filesize'] : $info['filesize']) * 8) / $info['playtime_seconds'];
+                                        }
+                                        break;
+
+                                case GETID3_ASF_Stream_Properties_Object:
+                                        // Stream Properties Object: (mandatory, one per media stream)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for stream properties object - GETID3_ASF_Stream_Properties_Object
+                                        // Object Size                  QWORD        64              // size of stream properties object, including 78 bytes of Stream Properties Object header
+                                        // Stream Type                  GUID         128             // GETID3_ASF_Audio_Media, GETID3_ASF_Video_Media or GETID3_ASF_Command_Media
+                                        // Error Correction Type        GUID         128             // GETID3_ASF_Audio_Spread for audio-only streams, GETID3_ASF_No_Error_Correction for other stream types
+                                        // Time Offset                  QWORD        64              // 100-nanosecond units. typically zero. added to all timestamps of samples in the stream
+                                        // Type-Specific Data Length    DWORD        32              // number of bytes for Type-Specific Data field
+                                        // Error Correction Data Length DWORD        32              // number of bytes for Error Correction Data field
+                                        // Flags                        WORD         16              //
+                                        // * Stream Number              bits         7 (0x007F)      // number of this stream.  1 <= valid <= 127
+                                        // * Reserved                   bits         8 (0x7F80)      // reserved - set to zero
+                                        // * Encrypted Content Flag     bits         1 (0x8000)      // stream contents encrypted if set
+                                        // Reserved                     DWORD        32              // reserved - set to zero
+                                        // Type-Specific Data           BYTESTREAM   variable        // type-specific format data, depending on value of Stream Type
+                                        // Error Correction Data        BYTESTREAM   variable        // error-correction-specific format data, depending on value of Error Correct Type
+
+                                        // There is one GETID3_ASF_Stream_Properties_Object for each stream (audio, video) but the
+                                        // stream number isn't known until halfway through decoding the structure, hence it
+                                        // it is decoded to a temporary variable and then stuck in the appropriate index later
+
+                                        $StreamPropertiesObjectData['offset']             = $NextObjectOffset + $offset;
+                                        $StreamPropertiesObjectData['objectid']           = $NextObjectGUID;
+                                        $StreamPropertiesObjectData['objectid_guid']      = $NextObjectGUIDtext;
+                                        $StreamPropertiesObjectData['objectsize']         = $NextObjectSize;
+                                        $StreamPropertiesObjectData['stream_type']        = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $StreamPropertiesObjectData['stream_type_guid']   = $this->BytestringToGUID($StreamPropertiesObjectData['stream_type']);
+                                        $StreamPropertiesObjectData['error_correct_type'] = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $StreamPropertiesObjectData['error_correct_guid'] = $this->BytestringToGUID($StreamPropertiesObjectData['error_correct_type']);
+                                        $StreamPropertiesObjectData['time_offset']        = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                        $offset += 8;
+                                        $StreamPropertiesObjectData['type_data_length']   = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $StreamPropertiesObjectData['error_data_length']  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $StreamPropertiesObjectData['flags_raw']          = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $StreamPropertiesObjectStreamNumber               = $StreamPropertiesObjectData['flags_raw'] & 0x007F;
+                                        $StreamPropertiesObjectData['flags']['encrypted'] = (bool) ($StreamPropertiesObjectData['flags_raw'] & 0x8000);
+
+                                        $offset += 4; // reserved - DWORD
+                                        $StreamPropertiesObjectData['type_specific_data'] = substr($ASFHeaderData, $offset, $StreamPropertiesObjectData['type_data_length']);
+                                        $offset += $StreamPropertiesObjectData['type_data_length'];
+                                        $StreamPropertiesObjectData['error_correct_data'] = substr($ASFHeaderData, $offset, $StreamPropertiesObjectData['error_data_length']);
+                                        $offset += $StreamPropertiesObjectData['error_data_length'];
+
+                                        switch ($StreamPropertiesObjectData['stream_type']) {
+
+                                                case GETID3_ASF_Audio_Media:
+                                                        $thisfile_audio['dataformat']   = (!empty($thisfile_audio['dataformat'])   ? $thisfile_audio['dataformat']   : 'asf');
+                                                        $thisfile_audio['bitrate_mode'] = (!empty($thisfile_audio['bitrate_mode']) ? $thisfile_audio['bitrate_mode'] : 'cbr');
+
+                                                        $audiodata = getid3_riff::parseWAVEFORMATex(substr($StreamPropertiesObjectData['type_specific_data'], 0, 16));
+                                                        unset($audiodata['raw']);
+                                                        $thisfile_audio = getid3_lib::array_merge_noclobber($audiodata, $thisfile_audio);
+                                                        break;
+
+                                                case GETID3_ASF_Video_Media:
+                                                        $thisfile_video['dataformat']   = (!empty($thisfile_video['dataformat'])   ? $thisfile_video['dataformat']   : 'asf');
+                                                        $thisfile_video['bitrate_mode'] = (!empty($thisfile_video['bitrate_mode']) ? $thisfile_video['bitrate_mode'] : 'cbr');
+                                                        break;
+
+                                                case GETID3_ASF_Command_Media:
+                                                default:
+                                                        // do nothing
+                                                        break;
+
+                                        }
+
+                                        $thisfile_asf['stream_properties_object'][$StreamPropertiesObjectStreamNumber] = $StreamPropertiesObjectData;
+                                        unset($StreamPropertiesObjectData); // clear for next stream, if any
+                                        break;
+
+                                case GETID3_ASF_Header_Extension_Object:
+                                        // Header Extension Object: (mandatory, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Header Extension object - GETID3_ASF_Header_Extension_Object
+                                        // Object Size                  QWORD        64              // size of Header Extension object, including 46 bytes of Header Extension Object header
+                                        // Reserved Field 1             GUID         128             // hardcoded: GETID3_ASF_Reserved_1
+                                        // Reserved Field 2             WORD         16              // hardcoded: 0x00000006
+                                        // Header Extension Data Size   DWORD        32              // in bytes. valid: 0, or > 24. equals object size minus 46
+                                        // Header Extension Data        BYTESTREAM   variable        // array of zero or more extended header objects
+
+                                        // shortcut
+                                        $thisfile_asf['header_extension_object'] = array();
+                                        $thisfile_asf_headerextensionobject      = &$thisfile_asf['header_extension_object'];
+
+                                        $thisfile_asf_headerextensionobject['offset']              = $NextObjectOffset + $offset;
+                                        $thisfile_asf_headerextensionobject['objectid']            = $NextObjectGUID;
+                                        $thisfile_asf_headerextensionobject['objectid_guid']       = $NextObjectGUIDtext;
+                                        $thisfile_asf_headerextensionobject['objectsize']          = $NextObjectSize;
+                                        $thisfile_asf_headerextensionobject['reserved_1']          = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $thisfile_asf_headerextensionobject['reserved_1_guid']     = $this->BytestringToGUID($thisfile_asf_headerextensionobject['reserved_1']);
+                                        if ($thisfile_asf_headerextensionobject['reserved_1'] != GETID3_ASF_Reserved_1) {
+                                                $info['warning'][] = 'header_extension_object.reserved_1 GUID ('.$this->BytestringToGUID($thisfile_asf_headerextensionobject['reserved_1']).') does not match expected "GETID3_ASF_Reserved_1" GUID ('.$this->BytestringToGUID(GETID3_ASF_Reserved_1).')';
+                                                //return false;
+                                                break;
+                                        }
+                                        $thisfile_asf_headerextensionobject['reserved_2']          = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        if ($thisfile_asf_headerextensionobject['reserved_2'] != 6) {
+                                                $info['warning'][] = 'header_extension_object.reserved_2 ('.getid3_lib::PrintHexBytes($thisfile_asf_headerextensionobject['reserved_2']).') does not match expected value of "6"';
+                                                //return false;
+                                                break;
+                                        }
+                                        $thisfile_asf_headerextensionobject['extension_data_size'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $thisfile_asf_headerextensionobject['extension_data']      =                              substr($ASFHeaderData, $offset, $thisfile_asf_headerextensionobject['extension_data_size']);
+                                        $unhandled_sections = 0;
+                                        $thisfile_asf_headerextensionobject['extension_data_parsed'] = $this->ASF_HeaderExtensionObjectDataParse($thisfile_asf_headerextensionobject['extension_data'], $unhandled_sections);
+                                        if ($unhandled_sections === 0) {
+                                                unset($thisfile_asf_headerextensionobject['extension_data']);
+                                        }
+                                        $offset += $thisfile_asf_headerextensionobject['extension_data_size'];
+                                        break;
+
+                                case GETID3_ASF_Codec_List_Object:
+                                        // Codec List Object: (optional, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Codec List object - GETID3_ASF_Codec_List_Object
+                                        // Object Size                  QWORD        64              // size of Codec List object, including 44 bytes of Codec List Object header
+                                        // Reserved                     GUID         128             // hardcoded: 86D15241-311D-11D0-A3A4-00A0C90348F6
+                                        // Codec Entries Count          DWORD        32              // number of entries in Codec Entries array
+                                        // Codec Entries                array of:    variable        //
+                                        // * Type                       WORD         16              // 0x0001 = Video Codec, 0x0002 = Audio Codec, 0xFFFF = Unknown Codec
+                                        // * Codec Name Length          WORD         16              // number of Unicode characters stored in the Codec Name field
+                                        // * Codec Name                 WCHAR        variable        // array of Unicode characters - name of codec used to create the content
+                                        // * Codec Description Length   WORD         16              // number of Unicode characters stored in the Codec Description field
+                                        // * Codec Description          WCHAR        variable        // array of Unicode characters - description of format used to create the content
+                                        // * Codec Information Length   WORD         16              // number of Unicode characters stored in the Codec Information field
+                                        // * Codec Information          BYTESTREAM   variable        // opaque array of information bytes about the codec used to create the content
+
+                                        // shortcut
+                                        $thisfile_asf['codec_list_object'] = array();
+                                        $thisfile_asf_codeclistobject      = &$thisfile_asf['codec_list_object'];
+
+                                        $thisfile_asf_codeclistobject['offset']                    = $NextObjectOffset + $offset;
+                                        $thisfile_asf_codeclistobject['objectid']                  = $NextObjectGUID;
+                                        $thisfile_asf_codeclistobject['objectid_guid']             = $NextObjectGUIDtext;
+                                        $thisfile_asf_codeclistobject['objectsize']                = $NextObjectSize;
+                                        $thisfile_asf_codeclistobject['reserved']                  = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $thisfile_asf_codeclistobject['reserved_guid']             = $this->BytestringToGUID($thisfile_asf_codeclistobject['reserved']);
+                                        if ($thisfile_asf_codeclistobject['reserved'] != $this->GUIDtoBytestring('86D15241-311D-11D0-A3A4-00A0C90348F6')) {
+                                                $info['warning'][] = 'codec_list_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_codeclistobject['reserved']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {86D15241-311D-11D0-A3A4-00A0C90348F6}';
+                                                //return false;
+                                                break;
+                                        }
+                                        $thisfile_asf_codeclistobject['codec_entries_count'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        for ($CodecEntryCounter = 0; $CodecEntryCounter < $thisfile_asf_codeclistobject['codec_entries_count']; $CodecEntryCounter++) {
+                                                // shortcut
+                                                $thisfile_asf_codeclistobject['codec_entries'][$CodecEntryCounter] = array();
+                                                $thisfile_asf_codeclistobject_codecentries_current = &$thisfile_asf_codeclistobject['codec_entries'][$CodecEntryCounter];
+
+                                                $thisfile_asf_codeclistobject_codecentries_current['type_raw'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                                $thisfile_asf_codeclistobject_codecentries_current['type'] = $this->ASFCodecListObjectTypeLookup($thisfile_asf_codeclistobject_codecentries_current['type_raw']);
+
+                                                $CodecNameLength = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2)) * 2; // 2 bytes per character
+                                                $offset += 2;
+                                                $thisfile_asf_codeclistobject_codecentries_current['name'] = substr($ASFHeaderData, $offset, $CodecNameLength);
+                                                $offset += $CodecNameLength;
+
+                                                $CodecDescriptionLength = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2)) * 2; // 2 bytes per character
+                                                $offset += 2;
+                                                $thisfile_asf_codeclistobject_codecentries_current['description'] = substr($ASFHeaderData, $offset, $CodecDescriptionLength);
+                                                $offset += $CodecDescriptionLength;
+
+                                                $CodecInformationLength = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                                $thisfile_asf_codeclistobject_codecentries_current['information'] = substr($ASFHeaderData, $offset, $CodecInformationLength);
+                                                $offset += $CodecInformationLength;
+
+                                                if ($thisfile_asf_codeclistobject_codecentries_current['type_raw'] == 2) { // audio codec
+
+                                                        if (strpos($thisfile_asf_codeclistobject_codecentries_current['description'], ',') === false) {
+                                                                $info['warning'][] = '[asf][codec_list_object][codec_entries]['.$CodecEntryCounter.'][description] expected to contain comma-seperated list of parameters: "'.$thisfile_asf_codeclistobject_codecentries_current['description'].'"';
+                                                        } else {
+
+                                                                list($AudioCodecBitrate, $AudioCodecFrequency, $AudioCodecChannels) = explode(',', $this->TrimConvert($thisfile_asf_codeclistobject_codecentries_current['description']));
+                                                                $thisfile_audio['codec'] = $this->TrimConvert($thisfile_asf_codeclistobject_codecentries_current['name']);
+
+                                                                if (!isset($thisfile_audio['bitrate']) && strstr($AudioCodecBitrate, 'kbps')) {
+                                                                        $thisfile_audio['bitrate'] = (int) (trim(str_replace('kbps', '', $AudioCodecBitrate)) * 1000);
+                                                                }
+                                                                //if (!isset($thisfile_video['bitrate']) && isset($thisfile_audio['bitrate']) && isset($thisfile_asf['file_properties_object']['max_bitrate']) && ($thisfile_asf_codeclistobject['codec_entries_count'] > 1)) {
+                                                                if (empty($thisfile_video['bitrate']) && !empty($thisfile_audio['bitrate']) && !empty($info['bitrate'])) {
+                                                                        //$thisfile_video['bitrate'] = $thisfile_asf['file_properties_object']['max_bitrate'] - $thisfile_audio['bitrate'];
+                                                                        $thisfile_video['bitrate'] = $info['bitrate'] - $thisfile_audio['bitrate'];
+                                                                }
+
+                                                                $AudioCodecFrequency = (int) trim(str_replace('kHz', '', $AudioCodecFrequency));
+                                                                switch ($AudioCodecFrequency) {
+                                                                        case 8:
+                                                                        case 8000:
+                                                                                $thisfile_audio['sample_rate'] = 8000;
+                                                                                break;
+
+                                                                        case 11:
+                                                                        case 11025:
+                                                                                $thisfile_audio['sample_rate'] = 11025;
+                                                                                break;
+
+                                                                        case 12:
+                                                                        case 12000:
+                                                                                $thisfile_audio['sample_rate'] = 12000;
+                                                                                break;
+
+                                                                        case 16:
+                                                                        case 16000:
+                                                                                $thisfile_audio['sample_rate'] = 16000;
+                                                                                break;
+
+                                                                        case 22:
+                                                                        case 22050:
+                                                                                $thisfile_audio['sample_rate'] = 22050;
+                                                                                break;
+
+                                                                        case 24:
+                                                                        case 24000:
+                                                                                $thisfile_audio['sample_rate'] = 24000;
+                                                                                break;
+
+                                                                        case 32:
+                                                                        case 32000:
+                                                                                $thisfile_audio['sample_rate'] = 32000;
+                                                                                break;
+
+                                                                        case 44:
+                                                                        case 441000:
+                                                                                $thisfile_audio['sample_rate'] = 44100;
+                                                                                break;
+
+                                                                        case 48:
+                                                                        case 48000:
+                                                                                $thisfile_audio['sample_rate'] = 48000;
+                                                                                break;
+
+                                                                        default:
+                                                                                $info['warning'][] = 'unknown frequency: "'.$AudioCodecFrequency.'" ('.$this->TrimConvert($thisfile_asf_codeclistobject_codecentries_current['description']).')';
+                                                                                break;
+                                                                }
+
+                                                                if (!isset($thisfile_audio['channels'])) {
+                                                                        if (strstr($AudioCodecChannels, 'stereo')) {
+                                                                                $thisfile_audio['channels'] = 2;
+                                                                        } elseif (strstr($AudioCodecChannels, 'mono')) {
+                                                                                $thisfile_audio['channels'] = 1;
+                                                                        }
+                                                                }
+
+                                                        }
+                                                }
+                                        }
+                                        break;
+
+                                case GETID3_ASF_Script_Command_Object:
+                                        // Script Command Object: (optional, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Script Command object - GETID3_ASF_Script_Command_Object
+                                        // Object Size                  QWORD        64              // size of Script Command object, including 44 bytes of Script Command Object header
+                                        // Reserved                     GUID         128             // hardcoded: 4B1ACBE3-100B-11D0-A39B-00A0C90348F6
+                                        // Commands Count               WORD         16              // number of Commands structures in the Script Commands Objects
+                                        // Command Types Count          WORD         16              // number of Command Types structures in the Script Commands Objects
+                                        // Command Types                array of:    variable        //
+                                        // * Command Type Name Length   WORD         16              // number of Unicode characters for Command Type Name
+                                        // * Command Type Name          WCHAR        variable        // array of Unicode characters - name of a type of command
+                                        // Commands                     array of:    variable        //
+                                        // * Presentation Time          DWORD        32              // presentation time of that command, in milliseconds
+                                        // * Type Index                 WORD         16              // type of this command, as a zero-based index into the array of Command Types of this object
+                                        // * Command Name Length        WORD         16              // number of Unicode characters for Command Name
+                                        // * Command Name               WCHAR        variable        // array of Unicode characters - name of this command
+
+                                        // shortcut
+                                        $thisfile_asf['script_command_object'] = array();
+                                        $thisfile_asf_scriptcommandobject      = &$thisfile_asf['script_command_object'];
+
+                                        $thisfile_asf_scriptcommandobject['offset']               = $NextObjectOffset + $offset;
+                                        $thisfile_asf_scriptcommandobject['objectid']             = $NextObjectGUID;
+                                        $thisfile_asf_scriptcommandobject['objectid_guid']        = $NextObjectGUIDtext;
+                                        $thisfile_asf_scriptcommandobject['objectsize']           = $NextObjectSize;
+                                        $thisfile_asf_scriptcommandobject['reserved']             = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $thisfile_asf_scriptcommandobject['reserved_guid']        = $this->BytestringToGUID($thisfile_asf_scriptcommandobject['reserved']);
+                                        if ($thisfile_asf_scriptcommandobject['reserved'] != $this->GUIDtoBytestring('4B1ACBE3-100B-11D0-A39B-00A0C90348F6')) {
+                                                $info['warning'][] = 'script_command_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_scriptcommandobject['reserved']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {4B1ACBE3-100B-11D0-A39B-00A0C90348F6}';
+                                                //return false;
+                                                break;
+                                        }
+                                        $thisfile_asf_scriptcommandobject['commands_count']       = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_scriptcommandobject['command_types_count']  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        for ($CommandTypesCounter = 0; $CommandTypesCounter < $thisfile_asf_scriptcommandobject['command_types_count']; $CommandTypesCounter++) {
+                                                $CommandTypeNameLength = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2)) * 2; // 2 bytes per character
+                                                $offset += 2;
+                                                $thisfile_asf_scriptcommandobject['command_types'][$CommandTypesCounter]['name'] = substr($ASFHeaderData, $offset, $CommandTypeNameLength);
+                                                $offset += $CommandTypeNameLength;
+                                        }
+                                        for ($CommandsCounter = 0; $CommandsCounter < $thisfile_asf_scriptcommandobject['commands_count']; $CommandsCounter++) {
+                                                $thisfile_asf_scriptcommandobject['commands'][$CommandsCounter]['presentation_time']  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                                $offset += 4;
+                                                $thisfile_asf_scriptcommandobject['commands'][$CommandsCounter]['type_index']         = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+
+                                                $CommandTypeNameLength = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2)) * 2; // 2 bytes per character
+                                                $offset += 2;
+                                                $thisfile_asf_scriptcommandobject['commands'][$CommandsCounter]['name'] = substr($ASFHeaderData, $offset, $CommandTypeNameLength);
+                                                $offset += $CommandTypeNameLength;
+                                        }
+                                        break;
+
+                                case GETID3_ASF_Marker_Object:
+                                        // Marker Object: (optional, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Marker object - GETID3_ASF_Marker_Object
+                                        // Object Size                  QWORD        64              // size of Marker object, including 48 bytes of Marker Object header
+                                        // Reserved                     GUID         128             // hardcoded: 4CFEDB20-75F6-11CF-9C0F-00A0C90349CB
+                                        // Markers Count                DWORD        32              // number of Marker structures in Marker Object
+                                        // Reserved                     WORD         16              // hardcoded: 0x0000
+                                        // Name Length                  WORD         16              // number of bytes in the Name field
+                                        // Name                         WCHAR        variable        // name of the Marker Object
+                                        // Markers                      array of:    variable        //
+                                        // * Offset                     QWORD        64              // byte offset into Data Object
+                                        // * Presentation Time          QWORD        64              // in 100-nanosecond units
+                                        // * Entry Length               WORD         16              // length in bytes of (Send Time + Flags + Marker Description Length + Marker Description + Padding)
+                                        // * Send Time                  DWORD        32              // in milliseconds
+                                        // * Flags                      DWORD        32              // hardcoded: 0x00000000
+                                        // * Marker Description Length  DWORD        32              // number of bytes in Marker Description field
+                                        // * Marker Description         WCHAR        variable        // array of Unicode characters - description of marker entry
+                                        // * Padding                    BYTESTREAM   variable        // optional padding bytes
+
+                                        // shortcut
+                                        $thisfile_asf['marker_object'] = array();
+                                        $thisfile_asf_markerobject     = &$thisfile_asf['marker_object'];
+
+                                        $thisfile_asf_markerobject['offset']               = $NextObjectOffset + $offset;
+                                        $thisfile_asf_markerobject['objectid']             = $NextObjectGUID;
+                                        $thisfile_asf_markerobject['objectid_guid']        = $NextObjectGUIDtext;
+                                        $thisfile_asf_markerobject['objectsize']           = $NextObjectSize;
+                                        $thisfile_asf_markerobject['reserved']             = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $thisfile_asf_markerobject['reserved_guid']        = $this->BytestringToGUID($thisfile_asf_markerobject['reserved']);
+                                        if ($thisfile_asf_markerobject['reserved'] != $this->GUIDtoBytestring('4CFEDB20-75F6-11CF-9C0F-00A0C90349CB')) {
+                                                $info['warning'][] = 'marker_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_markerobject['reserved_1']).'} does not match expected "GETID3_ASF_Reserved_1" GUID {4CFEDB20-75F6-11CF-9C0F-00A0C90349CB}';
+                                                break;
+                                        }
+                                        $thisfile_asf_markerobject['markers_count'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        $thisfile_asf_markerobject['reserved_2'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        if ($thisfile_asf_markerobject['reserved_2'] != 0) {
+                                                $info['warning'][] = 'marker_object.reserved_2 ('.getid3_lib::PrintHexBytes($thisfile_asf_markerobject['reserved_2']).') does not match expected value of "0"';
+                                                break;
+                                        }
+                                        $thisfile_asf_markerobject['name_length'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_markerobject['name'] = substr($ASFHeaderData, $offset, $thisfile_asf_markerobject['name_length']);
+                                        $offset += $thisfile_asf_markerobject['name_length'];
+                                        for ($MarkersCounter = 0; $MarkersCounter < $thisfile_asf_markerobject['markers_count']; $MarkersCounter++) {
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['offset']  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                                $offset += 8;
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['presentation_time']         = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 8));
+                                                $offset += 8;
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['entry_length']              = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['send_time']                 = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                                $offset += 4;
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['flags']                     = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                                $offset += 4;
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['marker_description_length'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                                $offset += 4;
+                                                $thisfile_asf_markerobject['markers'][$MarkersCounter]['marker_description']        = substr($ASFHeaderData, $offset, $thisfile_asf_markerobject['markers'][$MarkersCounter]['marker_description_length']);
+                                                $offset += $thisfile_asf_markerobject['markers'][$MarkersCounter]['marker_description_length'];
+                                                $PaddingLength = $thisfile_asf_markerobject['markers'][$MarkersCounter]['entry_length'] - 4 -  4 - 4 - $thisfile_asf_markerobject['markers'][$MarkersCounter]['marker_description_length'];
+                                                if ($PaddingLength > 0) {
+                                                        $thisfile_asf_markerobject['markers'][$MarkersCounter]['padding']               = substr($ASFHeaderData, $offset, $PaddingLength);
+                                                        $offset += $PaddingLength;
+                                                }
+                                        }
+                                        break;
+
+                                case GETID3_ASF_Bitrate_Mutual_Exclusion_Object:
+                                        // Bitrate Mutual Exclusion Object: (optional)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Bitrate Mutual Exclusion object - GETID3_ASF_Bitrate_Mutual_Exclusion_Object
+                                        // Object Size                  QWORD        64              // size of Bitrate Mutual Exclusion object, including 42 bytes of Bitrate Mutual Exclusion Object header
+                                        // Exlusion Type                GUID         128             // nature of mutual exclusion relationship. one of: (GETID3_ASF_Mutex_Bitrate, GETID3_ASF_Mutex_Unknown)
+                                        // Stream Numbers Count         WORD         16              // number of video streams
+                                        // Stream Numbers               WORD         variable        // array of mutually exclusive video stream numbers. 1 <= valid <= 127
+
+                                        // shortcut
+                                        $thisfile_asf['bitrate_mutual_exclusion_object'] = array();
+                                        $thisfile_asf_bitratemutualexclusionobject       = &$thisfile_asf['bitrate_mutual_exclusion_object'];
+
+                                        $thisfile_asf_bitratemutualexclusionobject['offset']               = $NextObjectOffset + $offset;
+                                        $thisfile_asf_bitratemutualexclusionobject['objectid']             = $NextObjectGUID;
+                                        $thisfile_asf_bitratemutualexclusionobject['objectid_guid']        = $NextObjectGUIDtext;
+                                        $thisfile_asf_bitratemutualexclusionobject['objectsize']           = $NextObjectSize;
+                                        $thisfile_asf_bitratemutualexclusionobject['reserved']             = substr($ASFHeaderData, $offset, 16);
+                                        $thisfile_asf_bitratemutualexclusionobject['reserved_guid']        = $this->BytestringToGUID($thisfile_asf_bitratemutualexclusionobject['reserved']);
+                                        $offset += 16;
+                                        if (($thisfile_asf_bitratemutualexclusionobject['reserved'] != GETID3_ASF_Mutex_Bitrate) && ($thisfile_asf_bitratemutualexclusionobject['reserved'] != GETID3_ASF_Mutex_Unknown)) {
+                                                $info['warning'][] = 'bitrate_mutual_exclusion_object.reserved GUID {'.$this->BytestringToGUID($thisfile_asf_bitratemutualexclusionobject['reserved']).'} does not match expected "GETID3_ASF_Mutex_Bitrate" GUID {'.$this->BytestringToGUID(GETID3_ASF_Mutex_Bitrate).'} or  "GETID3_ASF_Mutex_Unknown" GUID {'.$this->BytestringToGUID(GETID3_ASF_Mutex_Unknown).'}';
+                                                //return false;
+                                                break;
+                                        }
+                                        $thisfile_asf_bitratemutualexclusionobject['stream_numbers_count'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        for ($StreamNumberCounter = 0; $StreamNumberCounter < $thisfile_asf_bitratemutualexclusionobject['stream_numbers_count']; $StreamNumberCounter++) {
+                                                $thisfile_asf_bitratemutualexclusionobject['stream_numbers'][$StreamNumberCounter] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                        }
+                                        break;
+
+                                case GETID3_ASF_Error_Correction_Object:
+                                        // Error Correction Object: (optional, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Error Correction object - GETID3_ASF_Error_Correction_Object
+                                        // Object Size                  QWORD        64              // size of Error Correction object, including 44 bytes of Error Correction Object header
+                                        // Error Correction Type        GUID         128             // type of error correction. one of: (GETID3_ASF_No_Error_Correction, GETID3_ASF_Audio_Spread)
+                                        // Error Correction Data Length DWORD        32              // number of bytes in Error Correction Data field
+                                        // Error Correction Data        BYTESTREAM   variable        // structure depends on value of Error Correction Type field
+
+                                        // shortcut
+                                        $thisfile_asf['error_correction_object'] = array();
+                                        $thisfile_asf_errorcorrectionobject      = &$thisfile_asf['error_correction_object'];
+
+                                        $thisfile_asf_errorcorrectionobject['offset']                = $NextObjectOffset + $offset;
+                                        $thisfile_asf_errorcorrectionobject['objectid']              = $NextObjectGUID;
+                                        $thisfile_asf_errorcorrectionobject['objectid_guid']         = $NextObjectGUIDtext;
+                                        $thisfile_asf_errorcorrectionobject['objectsize']            = $NextObjectSize;
+                                        $thisfile_asf_errorcorrectionobject['error_correction_type'] = substr($ASFHeaderData, $offset, 16);
+                                        $offset += 16;
+                                        $thisfile_asf_errorcorrectionobject['error_correction_guid'] = $this->BytestringToGUID($thisfile_asf_errorcorrectionobject['error_correction_type']);
+                                        $thisfile_asf_errorcorrectionobject['error_correction_data_length'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 4));
+                                        $offset += 4;
+                                        switch ($thisfile_asf_errorcorrectionobject['error_correction_type']) {
+                                                case GETID3_ASF_No_Error_Correction:
+                                                        // should be no data, but just in case there is, skip to the end of the field
+                                                        $offset += $thisfile_asf_errorcorrectionobject['error_correction_data_length'];
+                                                        break;
+
+                                                case GETID3_ASF_Audio_Spread:
+                                                        // Field Name                   Field Type   Size (bits)
+                                                        // Span                         BYTE         8               // number of packets over which audio will be spread.
+                                                        // Virtual Packet Length        WORD         16              // size of largest audio payload found in audio stream
+                                                        // Virtual Chunk Length         WORD         16              // size of largest audio payload found in audio stream
+                                                        // Silence Data Length          WORD         16              // number of bytes in Silence Data field
+                                                        // Silence Data                 BYTESTREAM   variable        // hardcoded: 0x00 * (Silence Data Length) bytes
+
+                                                        $thisfile_asf_errorcorrectionobject['span']                  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 1));
+                                                        $offset += 1;
+                                                        $thisfile_asf_errorcorrectionobject['virtual_packet_length'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                        $offset += 2;
+                                                        $thisfile_asf_errorcorrectionobject['virtual_chunk_length']  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                        $offset += 2;
+                                                        $thisfile_asf_errorcorrectionobject['silence_data_length']   = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                        $offset += 2;
+                                                        $thisfile_asf_errorcorrectionobject['silence_data']          = substr($ASFHeaderData, $offset, $thisfile_asf_errorcorrectionobject['silence_data_length']);
+                                                        $offset += $thisfile_asf_errorcorrectionobject['silence_data_length'];
+                                                        break;
+
+                                                default:
+                                                        $info['warning'][] = 'error_correction_object.error_correction_type GUID {'.$this->BytestringToGUID($thisfile_asf_errorcorrectionobject['reserved']).'} does not match expected "GETID3_ASF_No_Error_Correction" GUID {'.$this->BytestringToGUID(GETID3_ASF_No_Error_Correction).'} or  "GETID3_ASF_Audio_Spread" GUID {'.$this->BytestringToGUID(GETID3_ASF_Audio_Spread).'}';
+                                                        //return false;
+                                                        break;
+                                        }
+
+                                        break;
+
+                                case GETID3_ASF_Content_Description_Object:
+                                        // Content Description Object: (optional, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Content Description object - GETID3_ASF_Content_Description_Object
+                                        // Object Size                  QWORD        64              // size of Content Description object, including 34 bytes of Content Description Object header
+                                        // Title Length                 WORD         16              // number of bytes in Title field
+                                        // Author Length                WORD         16              // number of bytes in Author field
+                                        // Copyright Length             WORD         16              // number of bytes in Copyright field
+                                        // Description Length           WORD         16              // number of bytes in Description field
+                                        // Rating Length                WORD         16              // number of bytes in Rating field
+                                        // Title                        WCHAR        16              // array of Unicode characters - Title
+                                        // Author                       WCHAR        16              // array of Unicode characters - Author
+                                        // Copyright                    WCHAR        16              // array of Unicode characters - Copyright
+                                        // Description                  WCHAR        16              // array of Unicode characters - Description
+                                        // Rating                       WCHAR        16              // array of Unicode characters - Rating
+
+                                        // shortcut
+                                        $thisfile_asf['content_description_object'] = array();
+                                        $thisfile_asf_contentdescriptionobject      = &$thisfile_asf['content_description_object'];
+
+                                        $thisfile_asf_contentdescriptionobject['offset']                = $NextObjectOffset + $offset;
+                                        $thisfile_asf_contentdescriptionobject['objectid']              = $NextObjectGUID;
+                                        $thisfile_asf_contentdescriptionobject['objectid_guid']         = $NextObjectGUIDtext;
+                                        $thisfile_asf_contentdescriptionobject['objectsize']            = $NextObjectSize;
+                                        $thisfile_asf_contentdescriptionobject['title_length']          = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_contentdescriptionobject['author_length']         = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_contentdescriptionobject['copyright_length']      = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_contentdescriptionobject['description_length']    = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_contentdescriptionobject['rating_length']         = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        $thisfile_asf_contentdescriptionobject['title']                 = substr($ASFHeaderData, $offset, $thisfile_asf_contentdescriptionobject['title_length']);
+                                        $offset += $thisfile_asf_contentdescriptionobject['title_length'];
+                                        $thisfile_asf_contentdescriptionobject['author']                = substr($ASFHeaderData, $offset, $thisfile_asf_contentdescriptionobject['author_length']);
+                                        $offset += $thisfile_asf_contentdescriptionobject['author_length'];
+                                        $thisfile_asf_contentdescriptionobject['copyright']             = substr($ASFHeaderData, $offset, $thisfile_asf_contentdescriptionobject['copyright_length']);
+                                        $offset += $thisfile_asf_contentdescriptionobject['copyright_length'];
+                                        $thisfile_asf_contentdescriptionobject['description']           = substr($ASFHeaderData, $offset, $thisfile_asf_contentdescriptionobject['description_length']);
+                                        $offset += $thisfile_asf_contentdescriptionobject['description_length'];
+                                        $thisfile_asf_contentdescriptionobject['rating']                = substr($ASFHeaderData, $offset, $thisfile_asf_contentdescriptionobject['rating_length']);
+                                        $offset += $thisfile_asf_contentdescriptionobject['rating_length'];
+
+                                        $ASFcommentKeysToCopy = array('title'=>'title', 'author'=>'artist', 'copyright'=>'copyright', 'description'=>'comment', 'rating'=>'rating');
+                                        foreach ($ASFcommentKeysToCopy as $keytocopyfrom => $keytocopyto) {
+                                                if (!empty($thisfile_asf_contentdescriptionobject[$keytocopyfrom])) {
+                                                        $thisfile_asf_comments[$keytocopyto][] = $this->TrimTerm($thisfile_asf_contentdescriptionobject[$keytocopyfrom]);
+                                                }
+                                        }
+                                        break;
+
+                                case GETID3_ASF_Extended_Content_Description_Object:
+                                        // Extended Content Description Object: (optional, one only)
+                                        // Field Name                   Field Type   Size (bits)
+                                        // Object ID                    GUID         128             // GUID for Extended Content Description object - GETID3_ASF_Extended_Content_Description_Object
+                                        // Object Size                  QWORD        64              // size of ExtendedContent Description object, including 26 bytes of Extended Content Description Object header
+                                        // Content Descriptors Count    WORD         16              // number of entries in Content Descriptors list
+                                        // Content Descriptors          array of:    variable        //
+                                        // * Descriptor Name Length     WORD         16              // size in bytes of Descriptor Name field
+                                        // * Descriptor Name            WCHAR        variable        // array of Unicode characters - Descriptor Name
+                                        // * Descriptor Value Data Type WORD         16              // Lookup array:
+                                                                                                                                                                        // 0x0000 = Unicode String (variable length)
+                                                                                                                                                                        // 0x0001 = BYTE array     (variable length)
+                                                                                                                                                                        // 0x0002 = BOOL           (DWORD, 32 bits)
+                                                                                                                                                                        // 0x0003 = DWORD          (DWORD, 32 bits)
+                                                                                                                                                                        // 0x0004 = QWORD          (QWORD, 64 bits)
+                                                                                                                                                                        // 0x0005 = WORD           (WORD,  16 bits)
+                                        // * Descriptor Value Length    WORD         16              // number of bytes stored in Descriptor Value field
+                                        // * Descriptor Value           variable     variable        // value for Content Descriptor
+
+                                        // shortcut
+                                        $thisfile_asf['extended_content_description_object'] = array();
+                                        $thisfile_asf_extendedcontentdescriptionobject       = &$thisfile_asf['extended_content_description_object'];
+
+                                        $thisfile_asf_extendedcontentdescriptionobject['offset']                    = $NextObjectOffset + $offset;
+                                        $thisfile_asf_extendedcontentdescriptionobject['objectid']                  = $NextObjectGUID;
+                                        $thisfile_asf_extendedcontentdescriptionobject['objectid_guid']             = $NextObjectGUIDtext;
+                                        $thisfile_asf_extendedcontentdescriptionobject['objectsize']                = $NextObjectSize;
+                                        $thisfile_asf_extendedcontentdescriptionobject['content_descriptors_count'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                        $offset += 2;
+                                        for ($ExtendedContentDescriptorsCounter = 0; $ExtendedContentDescriptorsCounter < $thisfile_asf_extendedcontentdescriptionobject['content_descriptors_count']; $ExtendedContentDescriptorsCounter++) {
+                                                // shortcut
+                                                $thisfile_asf_extendedcontentdescriptionobject['content_descriptors'][$ExtendedContentDescriptorsCounter] = array();
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current                 = &$thisfile_asf_extendedcontentdescriptionobject['content_descriptors'][$ExtendedContentDescriptorsCounter];
+
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['base_offset']  = $offset + 30;
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['name_length']  = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['name']         = substr($ASFHeaderData, $offset, $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['name_length']);
+                                                $offset += $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['name_length'];
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_type']   = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_length'] = getid3_lib::LittleEndian2Int(substr($ASFHeaderData, $offset, 2));
+                                                $offset += 2;
+                                                $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value']        = substr($ASFHeaderData, $offset, $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_length']);
+                                                $offset += $thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_length'];
+                                                switch ($thisfile_asf_extendedcontentdescriptionobject_contentdescriptor_current['value_type']) {
+                                                        case 0x0000: // Unicode string
+