<h2>File Contents: /home/planet5/public_html/bansibaba.com/wp-includes/ID3/module.audio.mp3.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/bansibaba.com/wp-includes/ID3/module.audio.mp3.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

/////////////////////////////////////////////////////////////////
/// getID3() by James Heinrich &lt;info@getid3.org&gt;               //
//  available at https://github.com/JamesHeinrich/getID3       //
//            or https://www.getid3.org                        //
//            or http://getid3.sourceforge.net                 //
//  see readme.txt for more details                            //
/////////////////////////////////////////////////////////////////
//                                                             //
// module.audio.mp3.php                                        //
// module for analyzing MP3 files                              //
// dependencies: NONE                                          //
//                                                            ///
/////////////////////////////////////////////////////////////////

if (!defined(&#039;GETID3_INCLUDEPATH&#039;)) { // prevent path-exposing attacks that access modules directly on public webservers
	exit;
}


class getid3_mp3 extends getid3_handler
{
	/**
	 * Forces getID3() to scan the file byte-by-byte and log all the valid audio frame headers - extremely slow,
	 * unrecommended, but may provide data from otherwise-unusable files.
	 *
	 * @var bool
	 */
	public $allow_bruteforce = false;

	/**
	 * number of frames to scan to determine if MPEG-audio sequence is valid
	 * Lower this number to 5-20 for faster scanning
	 * Increase this number to 50+ for most accurate detection of valid VBR/CBR mpeg-audio streams
	 *
	 * @var int
	 */
	public $mp3_valid_check_frames = 50;

	/**
	 * @return bool
	 */
	public function Analyze() {
		$info = &amp;$this-&gt;getid3-&gt;info;

		$initialOffset = $info[&#039;avdataoffset&#039;];

		if (!$this-&gt;getOnlyMPEGaudioInfo($info[&#039;avdataoffset&#039;])) {
			if ($this-&gt;allow_bruteforce) {
				$this-&gt;error(&#039;Rescanning file in BruteForce mode&#039;);
				$this-&gt;getOnlyMPEGaudioInfoBruteForce();
			}
		}


		if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;])) {
			$info[&#039;audio&#039;][&#039;bitrate_mode&#039;] = strtolower($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;]);
		}

		$CurrentDataLAMEversionString = null;
		if (((isset($info[&#039;id3v2&#039;][&#039;headerlength&#039;]) &amp;&amp; ($info[&#039;avdataoffset&#039;] &gt; $info[&#039;id3v2&#039;][&#039;headerlength&#039;])) || (!isset($info[&#039;id3v2&#039;]) &amp;&amp; ($info[&#039;avdataoffset&#039;] &gt; 0) &amp;&amp; ($info[&#039;avdataoffset&#039;] != $initialOffset)))) {

			$synchoffsetwarning = &#039;Unknown data before synch &#039;;
			if (isset($info[&#039;id3v2&#039;][&#039;headerlength&#039;])) {
				$synchoffsetwarning .= &#039;(ID3v2 header ends at &#039;.$info[&#039;id3v2&#039;][&#039;headerlength&#039;].&#039;, then &#039;.($info[&#039;avdataoffset&#039;] - $info[&#039;id3v2&#039;][&#039;headerlength&#039;]).&#039; bytes garbage, &#039;;
			} elseif ($initialOffset &gt; 0) {
				$synchoffsetwarning .= &#039;(should be at &#039;.$initialOffset.&#039;, &#039;;
			} else {
				$synchoffsetwarning .= &#039;(should be at beginning of file, &#039;;
			}
			$synchoffsetwarning .= &#039;synch detected at &#039;.$info[&#039;avdataoffset&#039;].&#039;)&#039;;
			if (isset($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]) &amp;&amp; ($info[&#039;audio&#039;][&#039;bitrate_mode&#039;] == &#039;cbr&#039;)) {

				if (!empty($info[&#039;id3v2&#039;][&#039;headerlength&#039;]) &amp;&amp; (($info[&#039;avdataoffset&#039;] - $info[&#039;id3v2&#039;][&#039;headerlength&#039;]) == $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;])) {

					$synchoffsetwarning .= &#039;. This is a known problem with some versions of LAME (3.90-3.92) DLL in CBR mode.&#039;;
					$info[&#039;audio&#039;][&#039;codec&#039;] = &#039;LAME&#039;;
					$CurrentDataLAMEversionString = &#039;LAME3.&#039;;

				} elseif (empty($info[&#039;id3v2&#039;][&#039;headerlength&#039;]) &amp;&amp; ($info[&#039;avdataoffset&#039;] == $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;])) {

					$synchoffsetwarning .= &#039;. This is a known problem with some versions of LAME (3.90 - 3.92) DLL in CBR mode.&#039;;
					$info[&#039;audio&#039;][&#039;codec&#039;] = &#039;LAME&#039;;
					$CurrentDataLAMEversionString = &#039;LAME3.&#039;;

				}

			}
			$this-&gt;warning($synchoffsetwarning);

		}

		if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;])) {
			$info[&#039;audio&#039;][&#039;codec&#039;] = &#039;LAME&#039;;
			if (!empty($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;long_version&#039;])) {
				$info[&#039;audio&#039;][&#039;encoder&#039;] = rtrim($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;long_version&#039;], &quot;\x00&quot;);
			} elseif (!empty($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;short_version&#039;])) {
				$info[&#039;audio&#039;][&#039;encoder&#039;] = rtrim($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;short_version&#039;], &quot;\x00&quot;);
			}
		}

		$CurrentDataLAMEversionString = (!empty($CurrentDataLAMEversionString) ? $CurrentDataLAMEversionString : (isset($info[&#039;audio&#039;][&#039;encoder&#039;]) ? $info[&#039;audio&#039;][&#039;encoder&#039;] : &#039;&#039;));
		if (!empty($CurrentDataLAMEversionString) &amp;&amp; (substr($CurrentDataLAMEversionString, 0, 6) == &#039;LAME3.&#039;) &amp;&amp; !preg_match(&#039;[0-9\)]&#039;, substr($CurrentDataLAMEversionString, -1))) {
			// a version number of LAME that does not end with a number like &quot;LAME3.92&quot;
			// or with a closing parenthesis like &quot;LAME3.88 (alpha)&quot;
			// or a version of LAME with the LAMEtag-not-filled-in-DLL-mode bug (3.90-3.92)

			// not sure what the actual last frame length will be, but will be less than or equal to 1441
			$PossiblyLongerLAMEversion_FrameLength = 1441;

			// Not sure what version of LAME this is - look in padding of last frame for longer version string
			$PossibleLAMEversionStringOffset = $info[&#039;avdataend&#039;] - $PossiblyLongerLAMEversion_FrameLength;
			$this-&gt;fseek($PossibleLAMEversionStringOffset);
			$PossiblyLongerLAMEversion_Data = $this-&gt;fread($PossiblyLongerLAMEversion_FrameLength);
			switch (substr($CurrentDataLAMEversionString, -1)) {
				case &#039;a&#039;:
				case &#039;b&#039;:
					// &quot;LAME3.94a&quot; will have a longer version string of &quot;LAME3.94 (alpha)&quot; for example
					// need to trim off &quot;a&quot; to match longer string
					$CurrentDataLAMEversionString = substr($CurrentDataLAMEversionString, 0, -1);
					break;
			}
			if (($PossiblyLongerLAMEversion_String = strstr($PossiblyLongerLAMEversion_Data, $CurrentDataLAMEversionString)) !== false) {
				if (substr($PossiblyLongerLAMEversion_String, 0, strlen($CurrentDataLAMEversionString)) == $CurrentDataLAMEversionString) {
					$PossiblyLongerLAMEversion_NewString = substr($PossiblyLongerLAMEversion_String, 0, strspn($PossiblyLongerLAMEversion_String, &#039;LAME0123456789., (abcdefghijklmnopqrstuvwxyzJFSOND)&#039;)); //&quot;LAME3.90.3&quot;  &quot;LAME3.87 (beta 1, Sep 27 2000)&quot; &quot;LAME3.88 (beta)&quot;
					if (empty($info[&#039;audio&#039;][&#039;encoder&#039;]) || (strlen($PossiblyLongerLAMEversion_NewString) &gt; strlen($info[&#039;audio&#039;][&#039;encoder&#039;]))) {
						if (!empty($info[&#039;audio&#039;][&#039;encoder&#039;]) &amp;&amp; !empty($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;short_version&#039;]) &amp;&amp; ($info[&#039;audio&#039;][&#039;encoder&#039;] == $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;short_version&#039;])) {
							if (preg_match(&#039;#^LAME[0-9\\.]+#&#039;, $PossiblyLongerLAMEversion_NewString, $matches)) {
								// &quot;LAME3.100&quot; -&gt; &quot;LAME3.100.1&quot;, but avoid including &quot;(alpha)&quot; and similar
								$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;LAME&#039;][&#039;short_version&#039;] = $matches[0];
							}
						}
						$info[&#039;audio&#039;][&#039;encoder&#039;] = $PossiblyLongerLAMEversion_NewString;
					}
				}
			}
		}
		if (!empty($info[&#039;audio&#039;][&#039;encoder&#039;])) {
			$info[&#039;audio&#039;][&#039;encoder&#039;] = rtrim($info[&#039;audio&#039;][&#039;encoder&#039;], &quot;\x00 &quot;);
		}

		switch (isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;]) ? $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;] : &#039;&#039;) {
			case 1:
			case 2:
				$info[&#039;audio&#039;][&#039;dataformat&#039;] = &#039;mp&#039;.$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;];
				break;
		}
		if (isset($info[&#039;fileformat&#039;]) &amp;&amp; ($info[&#039;fileformat&#039;] == &#039;mp3&#039;)) {
			switch ($info[&#039;audio&#039;][&#039;dataformat&#039;]) {
				case &#039;mp1&#039;:
				case &#039;mp2&#039;:
				case &#039;mp3&#039;:
					$info[&#039;fileformat&#039;] = $info[&#039;audio&#039;][&#039;dataformat&#039;];
					break;

				default:
					$this-&gt;warning(&#039;Expecting [audio][dataformat] to be mp1/mp2/mp3 when fileformat == mp3, [audio][dataformat] actually &quot;&#039;.$info[&#039;audio&#039;][&#039;dataformat&#039;].&#039;&quot;&#039;);
					break;
			}
		}

		if (empty($info[&#039;fileformat&#039;])) {
			unset($info[&#039;fileformat&#039;]);
			unset($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]);
			unset($info[&#039;avdataoffset&#039;]);
			unset($info[&#039;avdataend&#039;]);
			return false;
		}

		$info[&#039;mime_type&#039;]         = &#039;audio/mpeg&#039;;
		$info[&#039;audio&#039;][&#039;lossless&#039;] = false;

		// Calculate playtime
		if (!isset($info[&#039;playtime_seconds&#039;]) &amp;&amp; isset($info[&#039;audio&#039;][&#039;bitrate&#039;]) &amp;&amp; ($info[&#039;audio&#039;][&#039;bitrate&#039;] &gt; 0)) {
			// https://github.com/JamesHeinrich/getID3/issues/161
			// VBR header frame contains ~0.026s of silent audio data, but is not actually part of the original encoding and should be ignored
			$xingVBRheaderFrameLength = ((isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;VBR_frames&#039;]) &amp;&amp; isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;])) ? $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;] : 0);

			$info[&#039;playtime_seconds&#039;] = ($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;] - $xingVBRheaderFrameLength) * 8 / $info[&#039;audio&#039;][&#039;bitrate&#039;];
		}

		$info[&#039;audio&#039;][&#039;encoder_options&#039;] = $this-&gt;GuessEncoderOptions();

		return true;
	}

	/**
	 * @return string
	 */
	public function GuessEncoderOptions() {
		// shortcuts
		$info = &amp;$this-&gt;getid3-&gt;info;
		$thisfile_mpeg_audio = array();
		$thisfile_mpeg_audio_lame = array();
		if (!empty($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
			$thisfile_mpeg_audio = &amp;$info[&#039;mpeg&#039;][&#039;audio&#039;];
			if (!empty($thisfile_mpeg_audio[&#039;LAME&#039;])) {
				$thisfile_mpeg_audio_lame = &amp;$thisfile_mpeg_audio[&#039;LAME&#039;];
			}
		}

		$encoder_options = &#039;&#039;;
		static $NamedPresetBitrates = array(16, 24, 40, 56, 112, 128, 160, 192, 256);

		if (isset($thisfile_mpeg_audio[&#039;VBR_method&#039;]) &amp;&amp; ($thisfile_mpeg_audio[&#039;VBR_method&#039;] == &#039;Fraunhofer&#039;) &amp;&amp; !empty($thisfile_mpeg_audio[&#039;VBR_quality&#039;])) {

			$encoder_options = &#039;VBR q&#039;.$thisfile_mpeg_audio[&#039;VBR_quality&#039;];

		} elseif (!empty($thisfile_mpeg_audio_lame[&#039;preset_used&#039;]) &amp;&amp; isset($thisfile_mpeg_audio_lame[&#039;preset_used_id&#039;]) &amp;&amp; (!in_array($thisfile_mpeg_audio_lame[&#039;preset_used_id&#039;], $NamedPresetBitrates))) {

			$encoder_options = $thisfile_mpeg_audio_lame[&#039;preset_used&#039;];

		} elseif (!empty($thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;])) {

			static $KnownEncoderValues = array();
			if (empty($KnownEncoderValues)) {

				//$KnownEncoderValues[abrbitrate_minbitrate][vbr_quality][raw_vbr_method][raw_noise_shaping][raw_stereo_mode][ath_type][lowpass_frequency] = &#039;preset name&#039;;
				$KnownEncoderValues[0xFF][58][1][1][3][2][20500] = &#039;--alt-preset insane&#039;;        // 3.90,   3.90.1, 3.92
				$KnownEncoderValues[0xFF][58][1][1][3][2][20600] = &#039;--alt-preset insane&#039;;        // 3.90.2, 3.90.3, 3.91
				$KnownEncoderValues[0xFF][57][1][1][3][4][20500] = &#039;--alt-preset insane&#039;;        // 3.94,   3.95
				$KnownEncoderValues[&#039;**&#039;][78][3][2][3][2][19500] = &#039;--alt-preset extreme&#039;;       // 3.90,   3.90.1, 3.92
				$KnownEncoderValues[&#039;**&#039;][78][3][2][3][2][19600] = &#039;--alt-preset extreme&#039;;       // 3.90.2, 3.91
				$KnownEncoderValues[&#039;**&#039;][78][3][1][3][2][19600] = &#039;--alt-preset extreme&#039;;       // 3.90.3
				$KnownEncoderValues[&#039;**&#039;][78][4][2][3][2][19500] = &#039;--alt-preset fast extreme&#039;;  // 3.90,   3.90.1, 3.92
				$KnownEncoderValues[&#039;**&#039;][78][4][2][3][2][19600] = &#039;--alt-preset fast extreme&#039;;  // 3.90.2, 3.90.3, 3.91
				$KnownEncoderValues[&#039;**&#039;][78][3][2][3][4][19000] = &#039;--alt-preset standard&#039;;      // 3.90,   3.90.1, 3.90.2, 3.91, 3.92
				$KnownEncoderValues[&#039;**&#039;][78][3][1][3][4][19000] = &#039;--alt-preset standard&#039;;      // 3.90.3
				$KnownEncoderValues[&#039;**&#039;][78][4][2][3][4][19000] = &#039;--alt-preset fast standard&#039;; // 3.90,   3.90.1, 3.90.2, 3.91, 3.92
				$KnownEncoderValues[&#039;**&#039;][78][4][1][3][4][19000] = &#039;--alt-preset fast standard&#039;; // 3.90.3
				$KnownEncoderValues[&#039;**&#039;][88][4][1][3][3][19500] = &#039;--r3mix&#039;;                    // 3.90,   3.90.1, 3.92
				$KnownEncoderValues[&#039;**&#039;][88][4][1][3][3][19600] = &#039;--r3mix&#039;;                    // 3.90.2, 3.90.3, 3.91
				$KnownEncoderValues[&#039;**&#039;][67][4][1][3][4][18000] = &#039;--r3mix&#039;;                    // 3.94,   3.95
				$KnownEncoderValues[&#039;**&#039;][68][3][2][3][4][18000] = &#039;--alt-preset medium&#039;;        // 3.90.3
				$KnownEncoderValues[&#039;**&#039;][68][4][2][3][4][18000] = &#039;--alt-preset fast medium&#039;;   // 3.90.3

				$KnownEncoderValues[0xFF][99][1][1][1][2][0]     = &#039;--preset studio&#039;;            // 3.90,   3.90.1, 3.90.2, 3.91, 3.92
				$KnownEncoderValues[0xFF][58][2][1][3][2][20600] = &#039;--preset studio&#039;;            // 3.90.3, 3.93.1
				$KnownEncoderValues[0xFF][58][2][1][3][2][20500] = &#039;--preset studio&#039;;            // 3.93
				$KnownEncoderValues[0xFF][57][2][1][3][4][20500] = &#039;--preset studio&#039;;            // 3.94,   3.95
				$KnownEncoderValues[0xC0][88][1][1][1][2][0]     = &#039;--preset cd&#039;;                // 3.90,   3.90.1, 3.90.2,   3.91, 3.92
				$KnownEncoderValues[0xC0][58][2][2][3][2][19600] = &#039;--preset cd&#039;;                // 3.90.3, 3.93.1
				$KnownEncoderValues[0xC0][58][2][2][3][2][19500] = &#039;--preset cd&#039;;                // 3.93
				$KnownEncoderValues[0xC0][57][2][1][3][4][19500] = &#039;--preset cd&#039;;                // 3.94,   3.95
				$KnownEncoderValues[0xA0][78][1][1][3][2][18000] = &#039;--preset hifi&#039;;              // 3.90,   3.90.1, 3.90.2,   3.91, 3.92
				$KnownEncoderValues[0xA0][58][2][2][3][2][18000] = &#039;--preset hifi&#039;;              // 3.90.3, 3.93,   3.93.1
				$KnownEncoderValues[0xA0][57][2][1][3][4][18000] = &#039;--preset hifi&#039;;              // 3.94,   3.95
				$KnownEncoderValues[0x80][67][1][1][3][2][18000] = &#039;--preset tape&#039;;              // 3.90,   3.90.1, 3.90.2,   3.91, 3.92
				$KnownEncoderValues[0x80][67][1][1][3][2][15000] = &#039;--preset radio&#039;;             // 3.90,   3.90.1, 3.90.2,   3.91, 3.92
				$KnownEncoderValues[0x70][67][1][1][3][2][15000] = &#039;--preset fm&#039;;                // 3.90,   3.90.1, 3.90.2,   3.91, 3.92
				$KnownEncoderValues[0x70][58][2][2][3][2][16000] = &#039;--preset tape/radio/fm&#039;;     // 3.90.3, 3.93,   3.93.1
				$KnownEncoderValues[0x70][57][2][1][3][4][16000] = &#039;--preset tape/radio/fm&#039;;     // 3.94,   3.95
				$KnownEncoderValues[0x38][58][2][2][0][2][10000] = &#039;--preset voice&#039;;             // 3.90.3, 3.93,   3.93.1
				$KnownEncoderValues[0x38][57][2][1][0][4][15000] = &#039;--preset voice&#039;;             // 3.94,   3.95
				$KnownEncoderValues[0x38][57][2][1][0][4][16000] = &#039;--preset voice&#039;;             // 3.94a14
				$KnownEncoderValues[0x28][65][1][1][0][2][7500]  = &#039;--preset mw-us&#039;;             // 3.90,   3.90.1, 3.92
				$KnownEncoderValues[0x28][65][1][1][0][2][7600]  = &#039;--preset mw-us&#039;;             // 3.90.2, 3.91
				$KnownEncoderValues[0x28][58][2][2][0][2][7000]  = &#039;--preset mw-us&#039;;             // 3.90.3, 3.93,   3.93.1
				$KnownEncoderValues[0x28][57][2][1][0][4][10500] = &#039;--preset mw-us&#039;;             // 3.94,   3.95
				$KnownEncoderValues[0x28][57][2][1][0][4][11200] = &#039;--preset mw-us&#039;;             // 3.94a14
				$KnownEncoderValues[0x28][57][2][1][0][4][8800]  = &#039;--preset mw-us&#039;;             // 3.94a15
				$KnownEncoderValues[0x18][58][2][2][0][2][4000]  = &#039;--preset phon+/lw/mw-eu/sw&#039;; // 3.90.3, 3.93.1
				$KnownEncoderValues[0x18][58][2][2][0][2][3900]  = &#039;--preset phon+/lw/mw-eu/sw&#039;; // 3.93
				$KnownEncoderValues[0x18][57][2][1][0][4][5900]  = &#039;--preset phon+/lw/mw-eu/sw&#039;; // 3.94,   3.95
				$KnownEncoderValues[0x18][57][2][1][0][4][6200]  = &#039;--preset phon+/lw/mw-eu/sw&#039;; // 3.94a14
				$KnownEncoderValues[0x18][57][2][1][0][4][3200]  = &#039;--preset phon+/lw/mw-eu/sw&#039;; // 3.94a15
				$KnownEncoderValues[0x10][58][2][2][0][2][3800]  = &#039;--preset phone&#039;;             // 3.90.3, 3.93.1
				$KnownEncoderValues[0x10][58][2][2][0][2][3700]  = &#039;--preset phone&#039;;             // 3.93
				$KnownEncoderValues[0x10][57][2][1][0][4][5600]  = &#039;--preset phone&#039;;             // 3.94,   3.95
			}

			if (isset($KnownEncoderValues[$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;abrbitrate_minbitrate&#039;]][$thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;vbr_method&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;noise_shaping&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;stereo_mode&#039;]][$thisfile_mpeg_audio_lame[&#039;ath_type&#039;]][$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;]])) {

				$encoder_options = $KnownEncoderValues[$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;abrbitrate_minbitrate&#039;]][$thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;vbr_method&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;noise_shaping&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;stereo_mode&#039;]][$thisfile_mpeg_audio_lame[&#039;ath_type&#039;]][$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;]];

			} elseif (isset($KnownEncoderValues[&#039;**&#039;][$thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;vbr_method&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;noise_shaping&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;stereo_mode&#039;]][$thisfile_mpeg_audio_lame[&#039;ath_type&#039;]][$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;]])) {

				$encoder_options = $KnownEncoderValues[&#039;**&#039;][$thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;vbr_method&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;noise_shaping&#039;]][$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;stereo_mode&#039;]][$thisfile_mpeg_audio_lame[&#039;ath_type&#039;]][$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;]];

			} elseif ($info[&#039;audio&#039;][&#039;bitrate_mode&#039;] == &#039;vbr&#039;) {

				// http://gabriel.mp3-tech.org/mp3infotag.html
				// int    Quality = (100 - 10 * gfp-&gt;VBR_q - gfp-&gt;quality)h


				$LAME_V_value = 10 - ceil($thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;] / 10);
				$LAME_q_value = 100 - $thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;] - ($LAME_V_value * 10);
				$encoder_options = &#039;-V&#039;.$LAME_V_value.&#039; -q&#039;.$LAME_q_value;

			} elseif ($info[&#039;audio&#039;][&#039;bitrate_mode&#039;] == &#039;cbr&#039;) {

				$encoder_options = strtoupper($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]).ceil($info[&#039;audio&#039;][&#039;bitrate&#039;] / 1000);

			} else {

				$encoder_options = strtoupper($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]);

			}

		} elseif (!empty($thisfile_mpeg_audio_lame[&#039;bitrate_abr&#039;])) {

			$encoder_options = &#039;ABR&#039;.$thisfile_mpeg_audio_lame[&#039;bitrate_abr&#039;];

		} elseif (!empty($info[&#039;audio&#039;][&#039;bitrate&#039;])) {

			if ($info[&#039;audio&#039;][&#039;bitrate_mode&#039;] == &#039;cbr&#039;) {
				$encoder_options = strtoupper($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]).round($info[&#039;audio&#039;][&#039;bitrate&#039;] / 1000);
			} else {
				$encoder_options = strtoupper($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]);
			}

		}
		if (!empty($thisfile_mpeg_audio_lame[&#039;bitrate_min&#039;])) {
			$encoder_options .= &#039; -b&#039;.$thisfile_mpeg_audio_lame[&#039;bitrate_min&#039;];
		}

		if (isset($thisfile_mpeg_audio[&#039;bitrate&#039;]) &amp;&amp; $thisfile_mpeg_audio[&#039;bitrate&#039;] === &#039;free&#039;) {
			$encoder_options .= &#039; --freeformat&#039;;
		}

		if (!empty($thisfile_mpeg_audio_lame[&#039;encoding_flags&#039;][&#039;nogap_prev&#039;]) || !empty($thisfile_mpeg_audio_lame[&#039;encoding_flags&#039;][&#039;nogap_next&#039;])) {
			$encoder_options .= &#039; --nogap&#039;;
		}

		if (!empty($thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;])) {
			$ExplodedOptions = explode(&#039; &#039;, $encoder_options, 4);
			if ($ExplodedOptions[0] == &#039;--r3mix&#039;) {
				$ExplodedOptions[1] = &#039;r3mix&#039;;
			}
			switch ($ExplodedOptions[0]) {
				case &#039;--preset&#039;:
				case &#039;--alt-preset&#039;:
				case &#039;--r3mix&#039;:
					if ($ExplodedOptions[1] == &#039;fast&#039;) {
						$ExplodedOptions[1] .= &#039; &#039;.$ExplodedOptions[2];
					}
					switch ($ExplodedOptions[1]) {
						case &#039;portable&#039;:
						case &#039;medium&#039;:
						case &#039;standard&#039;:
						case &#039;extreme&#039;:
						case &#039;insane&#039;:
						case &#039;fast portable&#039;:
						case &#039;fast medium&#039;:
						case &#039;fast standard&#039;:
						case &#039;fast extreme&#039;:
						case &#039;fast insane&#039;:
						case &#039;r3mix&#039;:
							static $ExpectedLowpass = array(
									&#039;insane|20500&#039;        =&gt; 20500,
									&#039;insane|20600&#039;        =&gt; 20600,  // 3.90.2, 3.90.3, 3.91
									&#039;medium|18000&#039;        =&gt; 18000,
									&#039;fast medium|18000&#039;   =&gt; 18000,
									&#039;extreme|19500&#039;       =&gt; 19500,  // 3.90,   3.90.1, 3.92, 3.95
									&#039;extreme|19600&#039;       =&gt; 19600,  // 3.90.2, 3.90.3, 3.91, 3.93.1
									&#039;fast extreme|19500&#039;  =&gt; 19500,  // 3.90,   3.90.1, 3.92, 3.95
									&#039;fast extreme|19600&#039;  =&gt; 19600,  // 3.90.2, 3.90.3, 3.91, 3.93.1
									&#039;standard|19000&#039;      =&gt; 19000,
									&#039;fast standard|19000&#039; =&gt; 19000,
									&#039;r3mix|19500&#039;         =&gt; 19500,  // 3.90,   3.90.1, 3.92
									&#039;r3mix|19600&#039;         =&gt; 19600,  // 3.90.2, 3.90.3, 3.91
									&#039;r3mix|18000&#039;         =&gt; 18000,  // 3.94,   3.95
								);
							if (!isset($ExpectedLowpass[$ExplodedOptions[1].&#039;|&#039;.$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;]]) &amp;&amp; ($thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;] &lt; 22050) &amp;&amp; (round($thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;] / 1000) &lt; round($thisfile_mpeg_audio[&#039;sample_rate&#039;] / 2000))) {
								$encoder_options .= &#039; --lowpass &#039;.$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;];
							}
							break;

						default:
							break;
					}
					break;
			}
		}

		if (isset($thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;source_sample_freq&#039;])) {
			if (($thisfile_mpeg_audio[&#039;sample_rate&#039;] == 44100) &amp;&amp; ($thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;source_sample_freq&#039;] != 1)) {
				$encoder_options .= &#039; --resample 44100&#039;;
			} elseif (($thisfile_mpeg_audio[&#039;sample_rate&#039;] == 48000) &amp;&amp; ($thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;source_sample_freq&#039;] != 2)) {
				$encoder_options .= &#039; --resample 48000&#039;;
			} elseif ($thisfile_mpeg_audio[&#039;sample_rate&#039;] &lt; 44100) {
				switch ($thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;source_sample_freq&#039;]) {
					case 0: // &lt;= 32000
						// may or may not be same as source frequency - ignore
						break;
					case 1: // 44100
					case 2: // 48000
					case 3: // 48000+
						$ExplodedOptions = explode(&#039; &#039;, $encoder_options, 4);
						switch ($ExplodedOptions[0]) {
							case &#039;--preset&#039;:
							case &#039;--alt-preset&#039;:
								switch ($ExplodedOptions[1]) {
									case &#039;fast&#039;:
									case &#039;portable&#039;:
									case &#039;medium&#039;:
									case &#039;standard&#039;:
									case &#039;extreme&#039;:
									case &#039;insane&#039;:
										$encoder_options .= &#039; --resample &#039;.$thisfile_mpeg_audio[&#039;sample_rate&#039;];
										break;

									default:
										static $ExpectedResampledRate = array(
												&#039;phon+/lw/mw-eu/sw|16000&#039; =&gt; 16000,
												&#039;mw-us|24000&#039;             =&gt; 24000, // 3.95
												&#039;mw-us|32000&#039;             =&gt; 32000, // 3.93
												&#039;mw-us|16000&#039;             =&gt; 16000, // 3.92
												&#039;phone|16000&#039;             =&gt; 16000,
												&#039;phone|11025&#039;             =&gt; 11025, // 3.94a15
												&#039;radio|32000&#039;             =&gt; 32000, // 3.94a15
												&#039;fm/radio|32000&#039;          =&gt; 32000, // 3.92
												&#039;fm|32000&#039;                =&gt; 32000, // 3.90
												&#039;voice|32000&#039;             =&gt; 32000);
										if (!isset($ExpectedResampledRate[$ExplodedOptions[1].&#039;|&#039;.$thisfile_mpeg_audio[&#039;sample_rate&#039;]])) {
											$encoder_options .= &#039; --resample &#039;.$thisfile_mpeg_audio[&#039;sample_rate&#039;];
										}
										break;
								}
								break;

							case &#039;--r3mix&#039;:
							default:
								$encoder_options .= &#039; --resample &#039;.$thisfile_mpeg_audio[&#039;sample_rate&#039;];
								break;
						}
						break;
				}
			}
		}
		if (empty($encoder_options) &amp;&amp; !empty($info[&#039;audio&#039;][&#039;bitrate&#039;]) &amp;&amp; !empty($info[&#039;audio&#039;][&#039;bitrate_mode&#039;])) {
			//$encoder_options = strtoupper($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]).ceil($info[&#039;audio&#039;][&#039;bitrate&#039;] / 1000);
			$encoder_options = strtoupper($info[&#039;audio&#039;][&#039;bitrate_mode&#039;]);
		}

		return $encoder_options;
	}

	/**
	 * @param int   $offset
	 * @param array $info
	 * @param bool  $recursivesearch
	 * @param bool  $ScanAsCBR
	 * @param bool  $FastMPEGheaderScan
	 *
	 * @return bool
	 */
	public function decodeMPEGaudioHeader($offset, &amp;$info, $recursivesearch=true, $ScanAsCBR=false, $FastMPEGheaderScan=false) {
		static $MPEGaudioVersionLookup;
		static $MPEGaudioLayerLookup;
		static $MPEGaudioBitrateLookup;
		static $MPEGaudioFrequencyLookup;
		static $MPEGaudioChannelModeLookup;
		static $MPEGaudioModeExtensionLookup;
		static $MPEGaudioEmphasisLookup;
		if (empty($MPEGaudioVersionLookup)) {
			$MPEGaudioVersionLookup       = self::MPEGaudioVersionArray();
			$MPEGaudioLayerLookup         = self::MPEGaudioLayerArray();
			$MPEGaudioBitrateLookup       = self::MPEGaudioBitrateArray();
			$MPEGaudioFrequencyLookup     = self::MPEGaudioFrequencyArray();
			$MPEGaudioChannelModeLookup   = self::MPEGaudioChannelModeArray();
			$MPEGaudioModeExtensionLookup = self::MPEGaudioModeExtensionArray();
			$MPEGaudioEmphasisLookup      = self::MPEGaudioEmphasisArray();
		}

		if ($this-&gt;fseek($offset) != 0) {
			$this-&gt;error(&#039;decodeMPEGaudioHeader() failed to seek to next offset at &#039;.$offset);
			return false;
		}
		//$headerstring = $this-&gt;fread(1441); // worst-case max length = 32kHz @ 320kbps layer 3 = 1441 bytes/frame
		$headerstring = $this-&gt;fread(226); // LAME header at offset 36 + 190 bytes of Xing/LAME data

		// MP3 audio frame structure:
		// $aa $aa $aa $aa [$bb $bb] $cc...
		// where $aa..$aa is the four-byte mpeg-audio header (below)
		// $bb $bb is the optional 2-byte CRC
		// and $cc... is the audio data

		$head4 = substr($headerstring, 0, 4);
		$head4_key = getid3_lib::PrintHexBytes($head4, true, false, false);
		static $MPEGaudioHeaderDecodeCache = array();
		if (isset($MPEGaudioHeaderDecodeCache[$head4_key])) {
			$MPEGheaderRawArray = $MPEGaudioHeaderDecodeCache[$head4_key];
		} else {
			$MPEGheaderRawArray = self::MPEGaudioHeaderDecode($head4);
			$MPEGaudioHeaderDecodeCache[$head4_key] = $MPEGheaderRawArray;
		}

		static $MPEGaudioHeaderValidCache = array();
		if (!isset($MPEGaudioHeaderValidCache[$head4_key])) { // Not in cache
			//$MPEGaudioHeaderValidCache[$head4_key] = self::MPEGaudioHeaderValid($MPEGheaderRawArray, false, true);  // allow badly-formatted freeformat (from LAME 3.90 - 3.93.1)
			$MPEGaudioHeaderValidCache[$head4_key] = self::MPEGaudioHeaderValid($MPEGheaderRawArray, false, false);
		}

		// shortcut
		if (!isset($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
			$info[&#039;mpeg&#039;][&#039;audio&#039;] = array();
		}
		$thisfile_mpeg_audio = &amp;$info[&#039;mpeg&#039;][&#039;audio&#039;];

		if ($MPEGaudioHeaderValidCache[$head4_key]) {
			$thisfile_mpeg_audio[&#039;raw&#039;] = $MPEGheaderRawArray;
		} else {
			$this-&gt;warning(&#039;Invalid MPEG audio header (&#039;.getid3_lib::PrintHexBytes($head4).&#039;) at offset &#039;.$offset);
			return false;
		}

		if (!$FastMPEGheaderScan) {
			$thisfile_mpeg_audio[&#039;version&#039;]       = $MPEGaudioVersionLookup[$thisfile_mpeg_audio[&#039;raw&#039;][&#039;version&#039;]];
			$thisfile_mpeg_audio[&#039;layer&#039;]         = $MPEGaudioLayerLookup[$thisfile_mpeg_audio[&#039;raw&#039;][&#039;layer&#039;]];

			$thisfile_mpeg_audio[&#039;channelmode&#039;]   = $MPEGaudioChannelModeLookup[$thisfile_mpeg_audio[&#039;raw&#039;][&#039;channelmode&#039;]];
			$thisfile_mpeg_audio[&#039;channels&#039;]      = (($thisfile_mpeg_audio[&#039;channelmode&#039;] == &#039;mono&#039;) ? 1 : 2);
			$thisfile_mpeg_audio[&#039;sample_rate&#039;]   = $MPEGaudioFrequencyLookup[$thisfile_mpeg_audio[&#039;version&#039;]][$thisfile_mpeg_audio[&#039;raw&#039;][&#039;sample_rate&#039;]];
			$thisfile_mpeg_audio[&#039;protection&#039;]    = !$thisfile_mpeg_audio[&#039;raw&#039;][&#039;protection&#039;];
			$thisfile_mpeg_audio[&#039;private&#039;]       = (bool) $thisfile_mpeg_audio[&#039;raw&#039;][&#039;private&#039;];
			$thisfile_mpeg_audio[&#039;modeextension&#039;] = $MPEGaudioModeExtensionLookup[$thisfile_mpeg_audio[&#039;layer&#039;]][$thisfile_mpeg_audio[&#039;raw&#039;][&#039;modeextension&#039;]];
			$thisfile_mpeg_audio[&#039;copyright&#039;]     = (bool) $thisfile_mpeg_audio[&#039;raw&#039;][&#039;copyright&#039;];
			$thisfile_mpeg_audio[&#039;original&#039;]      = (bool) $thisfile_mpeg_audio[&#039;raw&#039;][&#039;original&#039;];
			$thisfile_mpeg_audio[&#039;emphasis&#039;]      = $MPEGaudioEmphasisLookup[$thisfile_mpeg_audio[&#039;raw&#039;][&#039;emphasis&#039;]];

			$info[&#039;audio&#039;][&#039;channels&#039;]    = $thisfile_mpeg_audio[&#039;channels&#039;];
			$info[&#039;audio&#039;][&#039;sample_rate&#039;] = $thisfile_mpeg_audio[&#039;sample_rate&#039;];

			if ($thisfile_mpeg_audio[&#039;protection&#039;]) {
				$thisfile_mpeg_audio[&#039;crc&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, 4, 2));
			}
		}

		if ($thisfile_mpeg_audio[&#039;raw&#039;][&#039;bitrate&#039;] == 15) {
			// http://www.hydrogenaudio.org/?act=ST&amp;f=16&amp;t=9682&amp;st=0
			$this-&gt;warning(&#039;Invalid bitrate index (15), this is a known bug in free-format MP3s encoded by LAME v3.90 - 3.93.1&#039;);
			$thisfile_mpeg_audio[&#039;raw&#039;][&#039;bitrate&#039;] = 0;
		}
		$thisfile_mpeg_audio[&#039;padding&#039;] = (bool) $thisfile_mpeg_audio[&#039;raw&#039;][&#039;padding&#039;];
		$thisfile_mpeg_audio[&#039;bitrate&#039;] = $MPEGaudioBitrateLookup[$thisfile_mpeg_audio[&#039;version&#039;]][$thisfile_mpeg_audio[&#039;layer&#039;]][$thisfile_mpeg_audio[&#039;raw&#039;][&#039;bitrate&#039;]];

		if (($thisfile_mpeg_audio[&#039;bitrate&#039;] == &#039;free&#039;) &amp;&amp; ($offset == $info[&#039;avdataoffset&#039;])) {
			// only skip multiple frame check if free-format bitstream found at beginning of file
			// otherwise is quite possibly simply corrupted data
			$recursivesearch = false;
		}

		// For Layer 2 there are some combinations of bitrate and mode which are not allowed.
		if (!$FastMPEGheaderScan &amp;&amp; ($thisfile_mpeg_audio[&#039;layer&#039;] == &#039;2&#039;)) {

			$info[&#039;audio&#039;][&#039;dataformat&#039;] = &#039;mp2&#039;;
			switch ($thisfile_mpeg_audio[&#039;channelmode&#039;]) {

				case &#039;mono&#039;:
					if (($thisfile_mpeg_audio[&#039;bitrate&#039;] == &#039;free&#039;) || ($thisfile_mpeg_audio[&#039;bitrate&#039;] &lt;= 192000)) {
						// these are ok
					} else {
						$this-&gt;error($thisfile_mpeg_audio[&#039;bitrate&#039;].&#039;kbps not allowed in Layer 2, &#039;.$thisfile_mpeg_audio[&#039;channelmode&#039;].&#039;.&#039;);
						return false;
					}
					break;

				case &#039;stereo&#039;:
				case &#039;joint stereo&#039;:
				case &#039;dual channel&#039;:
					if (($thisfile_mpeg_audio[&#039;bitrate&#039;] == &#039;free&#039;) || ($thisfile_mpeg_audio[&#039;bitrate&#039;] == 64000) || ($thisfile_mpeg_audio[&#039;bitrate&#039;] &gt;= 96000)) {
						// these are ok
					} else {
						$this-&gt;error(intval(round($thisfile_mpeg_audio[&#039;bitrate&#039;] / 1000)).&#039;kbps not allowed in Layer 2, &#039;.$thisfile_mpeg_audio[&#039;channelmode&#039;].&#039;.&#039;);
						return false;
					}
					break;

			}

		}


		if ($info[&#039;audio&#039;][&#039;sample_rate&#039;] &gt; 0) {
			$thisfile_mpeg_audio[&#039;framelength&#039;] = self::MPEGaudioFrameLength($thisfile_mpeg_audio[&#039;bitrate&#039;], $thisfile_mpeg_audio[&#039;version&#039;], $thisfile_mpeg_audio[&#039;layer&#039;], (int) $thisfile_mpeg_audio[&#039;padding&#039;], $info[&#039;audio&#039;][&#039;sample_rate&#039;]);
		}

		$nextframetestoffset = $offset + 1;
		if ($thisfile_mpeg_audio[&#039;bitrate&#039;] != &#039;free&#039;) {

			$info[&#039;audio&#039;][&#039;bitrate&#039;] = $thisfile_mpeg_audio[&#039;bitrate&#039;];

			if (isset($thisfile_mpeg_audio[&#039;framelength&#039;])) {
				$nextframetestoffset = $offset + $thisfile_mpeg_audio[&#039;framelength&#039;];
			} else {
				$this-&gt;error(&#039;Frame at offset(&#039;.$offset.&#039;) is has an invalid frame length.&#039;);
				return false;
			}

		}

		$ExpectedNumberOfAudioBytes = 0;

		////////////////////////////////////////////////////////////////////////////////////
		// Variable-bitrate headers

		if (substr($headerstring, 4 + 32, 4) == &#039;VBRI&#039;) {
			// Fraunhofer VBR header is hardcoded &#039;VBRI&#039; at offset 0x24 (36)
			// specs taken from http://minnie.tuhs.org/pipermail/mp3encoder/2001-January/001800.html

			$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;vbr&#039;;
			$thisfile_mpeg_audio[&#039;VBR_method&#039;]   = &#039;Fraunhofer&#039;;
			$info[&#039;audio&#039;][&#039;codec&#039;]              = &#039;Fraunhofer&#039;;

			$SideInfoData = substr($headerstring, 4 + 2, 32);

			$FraunhoferVBROffset = 36;

			$thisfile_mpeg_audio[&#039;VBR_encoder_version&#039;]     = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset +  4, 2)); // VbriVersion
			$thisfile_mpeg_audio[&#039;VBR_encoder_delay&#039;]       = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset +  6, 2)); // VbriDelay
			$thisfile_mpeg_audio[&#039;VBR_quality&#039;]             = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset +  8, 2)); // VbriQuality
			$thisfile_mpeg_audio[&#039;VBR_bytes&#039;]               = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset + 10, 4)); // VbriStreamBytes
			$thisfile_mpeg_audio[&#039;VBR_frames&#039;]              = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset + 14, 4)); // VbriStreamFrames
			$thisfile_mpeg_audio[&#039;VBR_seek_offsets&#039;]        = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset + 18, 2)); // VbriTableSize
			$thisfile_mpeg_audio[&#039;VBR_seek_scale&#039;]          = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset + 20, 2)); // VbriTableScale
			$thisfile_mpeg_audio[&#039;VBR_entry_bytes&#039;]         = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset + 22, 2)); // VbriEntryBytes
			$thisfile_mpeg_audio[&#039;VBR_entry_frames&#039;]        = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset + 24, 2)); // VbriEntryFrames

			$ExpectedNumberOfAudioBytes = $thisfile_mpeg_audio[&#039;VBR_bytes&#039;];

			$previousbyteoffset = $offset;
			for ($i = 0; $i &lt; $thisfile_mpeg_audio[&#039;VBR_seek_offsets&#039;]; $i++) {
				$Fraunhofer_OffsetN = getid3_lib::BigEndian2Int(substr($headerstring, $FraunhoferVBROffset, $thisfile_mpeg_audio[&#039;VBR_entry_bytes&#039;]));
				$FraunhoferVBROffset += $thisfile_mpeg_audio[&#039;VBR_entry_bytes&#039;];
				$thisfile_mpeg_audio[&#039;VBR_offsets_relative&#039;][$i] = ($Fraunhofer_OffsetN * $thisfile_mpeg_audio[&#039;VBR_seek_scale&#039;]);
				$thisfile_mpeg_audio[&#039;VBR_offsets_absolute&#039;][$i] = ($Fraunhofer_OffsetN * $thisfile_mpeg_audio[&#039;VBR_seek_scale&#039;]) + $previousbyteoffset;
				$previousbyteoffset += $Fraunhofer_OffsetN;
			}


		} else {

			// Xing VBR header is hardcoded &#039;Xing&#039; at a offset 0x0D (13), 0x15 (21) or 0x24 (36)
			// depending on MPEG layer and number of channels

			$VBRidOffset = self::XingVBRidOffset($thisfile_mpeg_audio[&#039;version&#039;], $thisfile_mpeg_audio[&#039;channelmode&#039;]);
			$SideInfoData = substr($headerstring, 4 + 2, $VBRidOffset - 4);

			if ((substr($headerstring, $VBRidOffset, strlen(&#039;Xing&#039;)) == &#039;Xing&#039;) || (substr($headerstring, $VBRidOffset, strlen(&#039;Info&#039;)) == &#039;Info&#039;)) {
				// &#039;Xing&#039; is traditional Xing VBR frame
				// &#039;Info&#039; is LAME-encoded CBR (This was done to avoid CBR files to be recognized as traditional Xing VBR files by some decoders.)
				// &#039;Info&#039; *can* legally be used to specify a VBR file as well, however.

				// http://www.multiweb.cz/twoinches/MP3inside.htm
				//00..03 = &quot;Xing&quot; or &quot;Info&quot;
				//04..07 = Flags:
				//  0x01  Frames Flag     set if value for number of frames in file is stored
				//  0x02  Bytes Flag      set if value for filesize in bytes is stored
				//  0x04  TOC Flag        set if values for TOC are stored
				//  0x08  VBR Scale Flag  set if values for VBR scale is stored
				//08..11  Frames: Number of frames in file (including the first Xing/Info one)
				//12..15  Bytes:  File length in Bytes
				//16..115  TOC (Table of Contents):
				//  Contains of 100 indexes (one Byte length) for easier lookup in file. Approximately solves problem with moving inside file.
				//  Each Byte has a value according this formula:
				//  (TOC[i] / 256) * fileLenInBytes
				//  So if song lasts eg. 240 sec. and you want to jump to 60. sec. (and file is 5 000 000 Bytes length) you can use:
				//  TOC[(60/240)*100] = TOC[25]
				//  and corresponding Byte in file is then approximately at:
				//  (TOC[25]/256) * 5000000
				//116..119  VBR Scale


				// should be safe to leave this at &#039;vbr&#039; and let it be overriden to &#039;cbr&#039; if a CBR preset/mode is used by LAME
//				if (substr($headerstring, $VBRidOffset, strlen(&#039;Info&#039;)) == &#039;Xing&#039;) {
					$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;vbr&#039;;
					$thisfile_mpeg_audio[&#039;VBR_method&#039;]   = &#039;Xing&#039;;
//				} else {
//					$ScanAsCBR = true;
//					$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;cbr&#039;;
//				}

				$thisfile_mpeg_audio[&#039;xing_flags_raw&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $VBRidOffset + 4, 4));

				$thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;frames&#039;]    = (bool) ($thisfile_mpeg_audio[&#039;xing_flags_raw&#039;] &amp; 0x00000001);
				$thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;bytes&#039;]     = (bool) ($thisfile_mpeg_audio[&#039;xing_flags_raw&#039;] &amp; 0x00000002);
				$thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;toc&#039;]       = (bool) ($thisfile_mpeg_audio[&#039;xing_flags_raw&#039;] &amp; 0x00000004);
				$thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;vbr_scale&#039;] = (bool) ($thisfile_mpeg_audio[&#039;xing_flags_raw&#039;] &amp; 0x00000008);

				if ($thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;frames&#039;]) {
					$thisfile_mpeg_audio[&#039;VBR_frames&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $VBRidOffset +  8, 4));
					//$thisfile_mpeg_audio[&#039;VBR_frames&#039;]--; // don&#039;t count header Xing/Info frame
				}
				if ($thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;bytes&#039;]) {
					$thisfile_mpeg_audio[&#039;VBR_bytes&#039;]  = getid3_lib::BigEndian2Int(substr($headerstring, $VBRidOffset + 12, 4));
				}

				//if (($thisfile_mpeg_audio[&#039;bitrate&#039;] == &#039;free&#039;) &amp;&amp; !empty($thisfile_mpeg_audio[&#039;VBR_frames&#039;]) &amp;&amp; !empty($thisfile_mpeg_audio[&#039;VBR_bytes&#039;])) {
				//if (!empty($thisfile_mpeg_audio[&#039;VBR_frames&#039;]) &amp;&amp; !empty($thisfile_mpeg_audio[&#039;VBR_bytes&#039;])) {
				if (!empty($thisfile_mpeg_audio[&#039;VBR_frames&#039;])) {
					$used_filesize  = 0;
					if (!empty($thisfile_mpeg_audio[&#039;VBR_bytes&#039;])) {
						$used_filesize = $thisfile_mpeg_audio[&#039;VBR_bytes&#039;];
					} elseif (!empty($info[&#039;filesize&#039;])) {
						$used_filesize  = $info[&#039;filesize&#039;];
						$used_filesize -= (isset($info[&#039;id3v2&#039;][&#039;headerlength&#039;]) ? intval($info[&#039;id3v2&#039;][&#039;headerlength&#039;]) : 0);
						$used_filesize -= (isset($info[&#039;id3v1&#039;]) ? 128 : 0);
						$used_filesize -= (isset($info[&#039;tag_offset_end&#039;]) ? $info[&#039;tag_offset_end&#039;] - $info[&#039;tag_offset_start&#039;] : 0);
						$this-&gt;warning(&#039;MP3.Xing header missing VBR_bytes, assuming MPEG audio portion of file is &#039;.number_format($used_filesize).&#039; bytes&#039;);
					}

					$framelengthfloat = $used_filesize / $thisfile_mpeg_audio[&#039;VBR_frames&#039;];

					if ($thisfile_mpeg_audio[&#039;layer&#039;] == &#039;1&#039;) {
						// BitRate = (((FrameLengthInBytes / 4) - Padding) * SampleRate) / 12
						//$info[&#039;audio&#039;][&#039;bitrate&#039;] = ((($framelengthfloat / 4) - intval($thisfile_mpeg_audio[&#039;padding&#039;])) * $thisfile_mpeg_audio[&#039;sample_rate&#039;]) / 12;
						$info[&#039;audio&#039;][&#039;bitrate&#039;] = ($framelengthfloat / 4) * $thisfile_mpeg_audio[&#039;sample_rate&#039;] * (2 / $info[&#039;audio&#039;][&#039;channels&#039;]) / 12;
					} else {
						// Bitrate = ((FrameLengthInBytes - Padding) * SampleRate) / 144
						//$info[&#039;audio&#039;][&#039;bitrate&#039;] = (($framelengthfloat - intval($thisfile_mpeg_audio[&#039;padding&#039;])) * $thisfile_mpeg_audio[&#039;sample_rate&#039;]) / 144;
						$info[&#039;audio&#039;][&#039;bitrate&#039;] = $framelengthfloat * $thisfile_mpeg_audio[&#039;sample_rate&#039;] * (2 / $info[&#039;audio&#039;][&#039;channels&#039;]) / 144;
					}
					$thisfile_mpeg_audio[&#039;framelength&#039;] = floor($framelengthfloat);
				}

				if ($thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;toc&#039;]) {
					$LAMEtocData = substr($headerstring, $VBRidOffset + 16, 100);
					for ($i = 0; $i &lt; 100; $i++) {
						$thisfile_mpeg_audio[&#039;toc&#039;][$i] = ord($LAMEtocData[$i]);
					}
				}
				if ($thisfile_mpeg_audio[&#039;xing_flags&#039;][&#039;vbr_scale&#039;]) {
					$thisfile_mpeg_audio[&#039;VBR_scale&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $VBRidOffset + 116, 4));
				}


				// http://gabriel.mp3-tech.org/mp3infotag.html
				if (substr($headerstring, $VBRidOffset + 120, 4) == &#039;LAME&#039;) {

					// shortcut
					$thisfile_mpeg_audio[&#039;LAME&#039;] = array();
					$thisfile_mpeg_audio_lame    = &amp;$thisfile_mpeg_audio[&#039;LAME&#039;];


					$thisfile_mpeg_audio_lame[&#039;long_version&#039;]  = substr($headerstring, $VBRidOffset + 120, 20);
					$thisfile_mpeg_audio_lame[&#039;short_version&#039;] = substr($thisfile_mpeg_audio_lame[&#039;long_version&#039;], 0, 9);

					//$thisfile_mpeg_audio_lame[&#039;numeric_version&#039;] = str_replace(&#039;LAME&#039;, &#039;&#039;, $thisfile_mpeg_audio_lame[&#039;short_version&#039;]);
					$thisfile_mpeg_audio_lame[&#039;numeric_version&#039;] = &#039;&#039;;
					if (preg_match(&#039;#^LAME([0-9\\.a-z]*)#&#039;, $thisfile_mpeg_audio_lame[&#039;long_version&#039;], $matches)) {
						$thisfile_mpeg_audio_lame[&#039;short_version&#039;]   = $matches[0];
						$thisfile_mpeg_audio_lame[&#039;numeric_version&#039;] = $matches[1];
					}
					if (strlen($thisfile_mpeg_audio_lame[&#039;numeric_version&#039;]) &gt; 0) {
						foreach (explode(&#039;.&#039;, $thisfile_mpeg_audio_lame[&#039;numeric_version&#039;]) as $key =&gt; $number) {
							$thisfile_mpeg_audio_lame[&#039;integer_version&#039;][$key] = intval($number);
						}
						//if ($thisfile_mpeg_audio_lame[&#039;short_version&#039;] &gt;= &#039;LAME3.90&#039;) {
						if ((($thisfile_mpeg_audio_lame[&#039;integer_version&#039;][0] * 1000) + $thisfile_mpeg_audio_lame[&#039;integer_version&#039;][1]) &gt;= 3090) { // cannot use string version compare, may have &quot;LAME3.90&quot; or &quot;LAME3.100&quot; -- see https://github.com/JamesHeinrich/getID3/issues/207

							// extra 11 chars are not part of version string when LAMEtag present
							unset($thisfile_mpeg_audio_lame[&#039;long_version&#039;]);

							// It the LAME tag was only introduced in LAME v3.90
							// https://wiki.hydrogenaud.io/index.php/LAME#VBR_header_and_LAME_tag
							// https://hydrogenaud.io/index.php?topic=9933

							// Offsets of various bytes in http://gabriel.mp3-tech.org/mp3infotag.html
							// are assuming a &#039;Xing&#039; identifier offset of 0x24, which is the case for
							// MPEG-1 non-mono, but not for other combinations
							$LAMEtagOffsetContant = $VBRidOffset - 0x24;

							// shortcuts
							$thisfile_mpeg_audio_lame[&#039;RGAD&#039;]    = array(&#039;track&#039;=&gt;array(), &#039;album&#039;=&gt;array());
							$thisfile_mpeg_audio_lame_RGAD       = &amp;$thisfile_mpeg_audio_lame[&#039;RGAD&#039;];
							$thisfile_mpeg_audio_lame_RGAD_track = &amp;$thisfile_mpeg_audio_lame_RGAD[&#039;track&#039;];
							$thisfile_mpeg_audio_lame_RGAD_album = &amp;$thisfile_mpeg_audio_lame_RGAD[&#039;album&#039;];
							$thisfile_mpeg_audio_lame[&#039;raw&#039;] = array();
							$thisfile_mpeg_audio_lame_raw    = &amp;$thisfile_mpeg_audio_lame[&#039;raw&#039;];

							// byte $9B  VBR Quality
							// This field is there to indicate a quality level, although the scale was not precised in the original Xing specifications.
							// Actually overwrites original Xing bytes
							unset($thisfile_mpeg_audio[&#039;VBR_scale&#039;]);
							$thisfile_mpeg_audio_lame[&#039;vbr_quality&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0x9B, 1));

							// bytes $9C-$A4  Encoder short VersionString
							$thisfile_mpeg_audio_lame[&#039;short_version&#039;] = substr($headerstring, $LAMEtagOffsetContant + 0x9C, 9);

							// byte $A5  Info Tag revision + VBR method
							$LAMEtagRevisionVBRmethod = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xA5, 1));

							$thisfile_mpeg_audio_lame[&#039;tag_revision&#039;]   = ($LAMEtagRevisionVBRmethod &amp; 0xF0) &gt;&gt; 4;
							$thisfile_mpeg_audio_lame_raw[&#039;vbr_method&#039;] =  $LAMEtagRevisionVBRmethod &amp; 0x0F;
							$thisfile_mpeg_audio_lame[&#039;vbr_method&#039;]     = self::LAMEvbrMethodLookup($thisfile_mpeg_audio_lame_raw[&#039;vbr_method&#039;]);
							$thisfile_mpeg_audio[&#039;bitrate_mode&#039;]        = substr($thisfile_mpeg_audio_lame[&#039;vbr_method&#039;], 0, 3); // usually either &#039;cbr&#039; or &#039;vbr&#039;, but truncates &#039;vbr-old / vbr-rh&#039; to &#039;vbr&#039;

							// byte $A6  Lowpass filter value
							$thisfile_mpeg_audio_lame[&#039;lowpass_frequency&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xA6, 1)) * 100;

							// bytes $A7-$AE  Replay Gain
							// https://web.archive.org/web/20021015212753/http://privatewww.essex.ac.uk/~djmrob/replaygain/rg_data_format.html
							// bytes $A7-$AA : 32 bit floating point &quot;Peak signal amplitude&quot;
							if ($thisfile_mpeg_audio_lame[&#039;short_version&#039;] &gt;= &#039;LAME3.94b&#039;) {
								// LAME 3.94a16 and later - 9.23 fixed point
								// ie 0x0059E2EE / (2^23) = 5890798 / 8388608 = 0.7022378444671630859375
								$thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;] = (float) ((getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xA7, 4))) / 8388608);
							} else {
								// LAME 3.94a15 and earlier - 32-bit floating point
								// Actually 3.94a16 will fall in here too and be WRONG, but is hard to detect 3.94a16 vs 3.94a15
								$thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;] = getid3_lib::LittleEndian2Float(substr($headerstring, $LAMEtagOffsetContant + 0xA7, 4));
							}
							if ($thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;] == 0) {
								unset($thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;]);
							} else {
								$thisfile_mpeg_audio_lame_RGAD[&#039;peak_db&#039;] = getid3_lib::RGADamplitude2dB($thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;]);
							}

							$thisfile_mpeg_audio_lame_raw[&#039;RGAD_track&#039;]      =   getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xAB, 2));
							$thisfile_mpeg_audio_lame_raw[&#039;RGAD_album&#039;]      =   getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xAD, 2));


							if ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_track&#039;] != 0) {

								$thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;name&#039;]        = ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_track&#039;] &amp; 0xE000) &gt;&gt; 13;
								$thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;originator&#039;]  = ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_track&#039;] &amp; 0x1C00) &gt;&gt; 10;
								$thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;sign_bit&#039;]    = ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_track&#039;] &amp; 0x0200) &gt;&gt; 9;
								$thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;gain_adjust&#039;] =  $thisfile_mpeg_audio_lame_raw[&#039;RGAD_track&#039;] &amp; 0x01FF;
								$thisfile_mpeg_audio_lame_RGAD_track[&#039;name&#039;]       = getid3_lib::RGADnameLookup($thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;name&#039;]);
								$thisfile_mpeg_audio_lame_RGAD_track[&#039;originator&#039;] = getid3_lib::RGADoriginatorLookup($thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;originator&#039;]);
								$thisfile_mpeg_audio_lame_RGAD_track[&#039;gain_db&#039;]    = getid3_lib::RGADadjustmentLookup($thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;gain_adjust&#039;], $thisfile_mpeg_audio_lame_RGAD_track[&#039;raw&#039;][&#039;sign_bit&#039;]);

								if (!empty($thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;])) {
									$info[&#039;replay_gain&#039;][&#039;track&#039;][&#039;peak&#039;]   = $thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;];
								}
								$info[&#039;replay_gain&#039;][&#039;track&#039;][&#039;originator&#039;] = $thisfile_mpeg_audio_lame_RGAD_track[&#039;originator&#039;];
								$info[&#039;replay_gain&#039;][&#039;track&#039;][&#039;adjustment&#039;] = $thisfile_mpeg_audio_lame_RGAD_track[&#039;gain_db&#039;];
							} else {
								unset($thisfile_mpeg_audio_lame_RGAD[&#039;track&#039;]);
							}
							if ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_album&#039;] != 0) {

								$thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;name&#039;]        = ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_album&#039;] &amp; 0xE000) &gt;&gt; 13;
								$thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;originator&#039;]  = ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_album&#039;] &amp; 0x1C00) &gt;&gt; 10;
								$thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;sign_bit&#039;]    = ($thisfile_mpeg_audio_lame_raw[&#039;RGAD_album&#039;] &amp; 0x0200) &gt;&gt; 9;
								$thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;gain_adjust&#039;] = $thisfile_mpeg_audio_lame_raw[&#039;RGAD_album&#039;] &amp; 0x01FF;
								$thisfile_mpeg_audio_lame_RGAD_album[&#039;name&#039;]       = getid3_lib::RGADnameLookup($thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;name&#039;]);
								$thisfile_mpeg_audio_lame_RGAD_album[&#039;originator&#039;] = getid3_lib::RGADoriginatorLookup($thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;originator&#039;]);
								$thisfile_mpeg_audio_lame_RGAD_album[&#039;gain_db&#039;]    = getid3_lib::RGADadjustmentLookup($thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;gain_adjust&#039;], $thisfile_mpeg_audio_lame_RGAD_album[&#039;raw&#039;][&#039;sign_bit&#039;]);

								if (!empty($thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;])) {
									$info[&#039;replay_gain&#039;][&#039;album&#039;][&#039;peak&#039;]   = $thisfile_mpeg_audio_lame_RGAD[&#039;peak_amplitude&#039;];
								}
								$info[&#039;replay_gain&#039;][&#039;album&#039;][&#039;originator&#039;] = $thisfile_mpeg_audio_lame_RGAD_album[&#039;originator&#039;];
								$info[&#039;replay_gain&#039;][&#039;album&#039;][&#039;adjustment&#039;] = $thisfile_mpeg_audio_lame_RGAD_album[&#039;gain_db&#039;];
							} else {
								unset($thisfile_mpeg_audio_lame_RGAD[&#039;album&#039;]);
							}
							if (empty($thisfile_mpeg_audio_lame_RGAD)) {
								unset($thisfile_mpeg_audio_lame[&#039;RGAD&#039;]);
							}


							// byte $AF  Encoding flags + ATH Type
							$EncodingFlagsATHtype = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xAF, 1));
							$thisfile_mpeg_audio_lame[&#039;encoding_flags&#039;][&#039;nspsytune&#039;]   = (bool) ($EncodingFlagsATHtype &amp; 0x10);
							$thisfile_mpeg_audio_lame[&#039;encoding_flags&#039;][&#039;nssafejoint&#039;] = (bool) ($EncodingFlagsATHtype &amp; 0x20);
							$thisfile_mpeg_audio_lame[&#039;encoding_flags&#039;][&#039;nogap_next&#039;]  = (bool) ($EncodingFlagsATHtype &amp; 0x40);
							$thisfile_mpeg_audio_lame[&#039;encoding_flags&#039;][&#039;nogap_prev&#039;]  = (bool) ($EncodingFlagsATHtype &amp; 0x80);
							$thisfile_mpeg_audio_lame[&#039;ath_type&#039;]                      =         $EncodingFlagsATHtype &amp; 0x0F;

							// byte $B0  if ABR {specified bitrate} else {minimal bitrate}
							$thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;abrbitrate_minbitrate&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xB0, 1));
							if ($thisfile_mpeg_audio_lame_raw[&#039;vbr_method&#039;] == 2) { // Average BitRate (ABR)
								$thisfile_mpeg_audio_lame[&#039;bitrate_abr&#039;] = $thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;abrbitrate_minbitrate&#039;];
							} elseif ($thisfile_mpeg_audio_lame_raw[&#039;vbr_method&#039;] == 1) { // Constant BitRate (CBR)
								// ignore
							} elseif ($thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;abrbitrate_minbitrate&#039;] &gt; 0) { // Variable BitRate (VBR) - minimum bitrate
								$thisfile_mpeg_audio_lame[&#039;bitrate_min&#039;] = $thisfile_mpeg_audio_lame[&#039;raw&#039;][&#039;abrbitrate_minbitrate&#039;];
							}

							// bytes $B1-$B3  Encoder delays
							$EncoderDelays = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xB1, 3));
							$thisfile_mpeg_audio_lame[&#039;encoder_delay&#039;] = ($EncoderDelays &amp; 0xFFF000) &gt;&gt; 12;
							$thisfile_mpeg_audio_lame[&#039;end_padding&#039;]   =  $EncoderDelays &amp; 0x000FFF;

							// byte $B4  Misc
							$MiscByte = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xB4, 1));
							$thisfile_mpeg_audio_lame_raw[&#039;noise_shaping&#039;]       = ($MiscByte &amp; 0x03);
							$thisfile_mpeg_audio_lame_raw[&#039;stereo_mode&#039;]         = ($MiscByte &amp; 0x1C) &gt;&gt; 2;
							$thisfile_mpeg_audio_lame_raw[&#039;not_optimal_quality&#039;] = ($MiscByte &amp; 0x20) &gt;&gt; 5;
							$thisfile_mpeg_audio_lame_raw[&#039;source_sample_freq&#039;]  = ($MiscByte &amp; 0xC0) &gt;&gt; 6;
							$thisfile_mpeg_audio_lame[&#039;noise_shaping&#039;]       = $thisfile_mpeg_audio_lame_raw[&#039;noise_shaping&#039;];
							$thisfile_mpeg_audio_lame[&#039;stereo_mode&#039;]         = self::LAMEmiscStereoModeLookup($thisfile_mpeg_audio_lame_raw[&#039;stereo_mode&#039;]);
							$thisfile_mpeg_audio_lame[&#039;not_optimal_quality&#039;] = (bool) $thisfile_mpeg_audio_lame_raw[&#039;not_optimal_quality&#039;];
							$thisfile_mpeg_audio_lame[&#039;source_sample_freq&#039;]  = self::LAMEmiscSourceSampleFrequencyLookup($thisfile_mpeg_audio_lame_raw[&#039;source_sample_freq&#039;]);

							// byte $B5  MP3 Gain
							$thisfile_mpeg_audio_lame_raw[&#039;mp3_gain&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xB5, 1), false, true);
							$thisfile_mpeg_audio_lame[&#039;mp3_gain_db&#039;]     = (getid3_lib::RGADamplitude2dB(2) / 4) * $thisfile_mpeg_audio_lame_raw[&#039;mp3_gain&#039;];
							$thisfile_mpeg_audio_lame[&#039;mp3_gain_factor&#039;] = pow(2, ($thisfile_mpeg_audio_lame[&#039;mp3_gain_db&#039;] / 6));

							// bytes $B6-$B7  Preset and surround info
							$PresetSurroundBytes = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xB6, 2));
							// Reserved                                                    = ($PresetSurroundBytes &amp; 0xC000);
							$thisfile_mpeg_audio_lame_raw[&#039;surround_info&#039;] = ($PresetSurroundBytes &amp; 0x3800);
							$thisfile_mpeg_audio_lame[&#039;surround_info&#039;]     = self::LAMEsurroundInfoLookup($thisfile_mpeg_audio_lame_raw[&#039;surround_info&#039;]);
							$thisfile_mpeg_audio_lame[&#039;preset_used_id&#039;]    = ($PresetSurroundBytes &amp; 0x07FF);
							$thisfile_mpeg_audio_lame[&#039;preset_used&#039;]       = self::LAMEpresetUsedLookup($thisfile_mpeg_audio_lame);
							if (!empty($thisfile_mpeg_audio_lame[&#039;preset_used_id&#039;]) &amp;&amp; empty($thisfile_mpeg_audio_lame[&#039;preset_used&#039;])) {
								$this-&gt;warning(&#039;Unknown LAME preset used (&#039;.$thisfile_mpeg_audio_lame[&#039;preset_used_id&#039;].&#039;) - please report to info@getid3.org&#039;);
							}
							if (($thisfile_mpeg_audio_lame[&#039;short_version&#039;] == &#039;LAME3.90.&#039;) &amp;&amp; !empty($thisfile_mpeg_audio_lame[&#039;preset_used_id&#039;])) {
								// this may change if 3.90.4 ever comes out
								$thisfile_mpeg_audio_lame[&#039;short_version&#039;] = &#039;LAME3.90.3&#039;;
							}

							// bytes $B8-$BB  MusicLength
							$thisfile_mpeg_audio_lame[&#039;audio_bytes&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xB8, 4));
							$ExpectedNumberOfAudioBytes = (($thisfile_mpeg_audio_lame[&#039;audio_bytes&#039;] &gt; 0) ? $thisfile_mpeg_audio_lame[&#039;audio_bytes&#039;] : $thisfile_mpeg_audio[&#039;VBR_bytes&#039;]);

							// bytes $BC-$BD  MusicCRC
							$thisfile_mpeg_audio_lame[&#039;music_crc&#039;]    = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xBC, 2));

							// bytes $BE-$BF  CRC-16 of Info Tag
							$thisfile_mpeg_audio_lame[&#039;lame_tag_crc&#039;] = getid3_lib::BigEndian2Int(substr($headerstring, $LAMEtagOffsetContant + 0xBE, 2));


							// LAME CBR
							if ($thisfile_mpeg_audio_lame_raw[&#039;vbr_method&#039;] == 1 &amp;&amp; $thisfile_mpeg_audio[&#039;bitrate&#039;] !== &#039;free&#039;) {

								$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;cbr&#039;;
								$thisfile_mpeg_audio[&#039;bitrate&#039;] = self::ClosestStandardMP3Bitrate($thisfile_mpeg_audio[&#039;bitrate&#039;]);
								$info[&#039;audio&#039;][&#039;bitrate&#039;] = $thisfile_mpeg_audio[&#039;bitrate&#039;];
								//if (empty($thisfile_mpeg_audio[&#039;bitrate&#039;]) || (!empty($thisfile_mpeg_audio_lame[&#039;bitrate_min&#039;]) &amp;&amp; ($thisfile_mpeg_audio_lame[&#039;bitrate_min&#039;] != 255))) {
								//	$thisfile_mpeg_audio[&#039;bitrate&#039;] = $thisfile_mpeg_audio_lame[&#039;bitrate_min&#039;];
								//}

							}

						}
					}
				}

			} else {

				// not Fraunhofer or Xing VBR methods, most likely CBR (but could be VBR with no header)
				$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;cbr&#039;;
				if ($recursivesearch) {
					$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;vbr&#039;;
					if ($this-&gt;RecursiveFrameScanning($offset, $nextframetestoffset, true)) {
						$recursivesearch = false;
						$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;cbr&#039;;
					}
					if ($thisfile_mpeg_audio[&#039;bitrate_mode&#039;] == &#039;vbr&#039;) {
						$this-&gt;warning(&#039;VBR file with no VBR header. Bitrate values calculated from actual frame bitrates.&#039;);
					}
				}

			}

		}

		if (($ExpectedNumberOfAudioBytes &gt; 0) &amp;&amp; ($ExpectedNumberOfAudioBytes != ($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]))) {
			if ($ExpectedNumberOfAudioBytes &gt; ($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;])) {
				if ($this-&gt;isDependencyFor(&#039;matroska&#039;) || $this-&gt;isDependencyFor(&#039;riff&#039;)) {
					// ignore, audio data is broken into chunks so will always be data &quot;missing&quot;
				}
				elseif (($ExpectedNumberOfAudioBytes - ($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;])) == 1) {
					$this-&gt;warning(&#039;Last byte of data truncated (this is a known bug in Meracl ID3 Tag Writer before v1.3.5)&#039;);
				}
				else {
					$this-&gt;warning(&#039;Probable truncated file: expecting &#039;.$ExpectedNumberOfAudioBytes.&#039; bytes of audio data, only found &#039;.($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]).&#039; (short by &#039;.($ExpectedNumberOfAudioBytes - ($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;])).&#039; bytes)&#039;);
				}
			} else {
				if ((($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]) - $ExpectedNumberOfAudioBytes) == 1) {
				//	$prenullbytefileoffset = $this-&gt;ftell();
				//	$this-&gt;fseek($info[&#039;avdataend&#039;]);
				//	$PossibleNullByte = $this-&gt;fread(1);
				//	$this-&gt;fseek($prenullbytefileoffset);
				//	if ($PossibleNullByte === &quot;\x00&quot;) {
						$info[&#039;avdataend&#039;]--;
				//		$this-&gt;warning(&#039;Extra null byte at end of MP3 data assumed to be RIFF padding and therefore ignored&#039;);
				//	} else {
				//		$this-&gt;warning(&#039;Too much data in file: expecting &#039;.$ExpectedNumberOfAudioBytes.&#039; bytes of audio data, found &#039;.($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]).&#039; (&#039;.(($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]) - $ExpectedNumberOfAudioBytes).&#039; bytes too many)&#039;);
				//	}
				} else {
					$this-&gt;warning(&#039;Too much data in file: expecting &#039;.$ExpectedNumberOfAudioBytes.&#039; bytes of audio data, found &#039;.($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]).&#039; (&#039;.(($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]) - $ExpectedNumberOfAudioBytes).&#039; bytes too many)&#039;);
				}
			}
		}

		if (($thisfile_mpeg_audio[&#039;bitrate&#039;] == &#039;free&#039;) &amp;&amp; empty($info[&#039;audio&#039;][&#039;bitrate&#039;])) {
			if (($offset == $info[&#039;avdataoffset&#039;]) &amp;&amp; empty($thisfile_mpeg_audio[&#039;VBR_frames&#039;])) {
				$framebytelength = $this-&gt;FreeFormatFrameLength($offset, true);
				if ($framebytelength &gt; 0) {
					$thisfile_mpeg_audio[&#039;framelength&#039;] = $framebytelength;
					if ($thisfile_mpeg_audio[&#039;layer&#039;] == &#039;1&#039;) {
						// BitRate = (((FrameLengthInBytes / 4) - Padding) * SampleRate) / 12
						$info[&#039;audio&#039;][&#039;bitrate&#039;] = ((($framebytelength / 4) - intval($thisfile_mpeg_audio[&#039;padding&#039;])) * $thisfile_mpeg_audio[&#039;sample_rate&#039;]) / 12;
					} else {
						// Bitrate = ((FrameLengthInBytes - Padding) * SampleRate) / 144
						$info[&#039;audio&#039;][&#039;bitrate&#039;] = (($framebytelength - intval($thisfile_mpeg_audio[&#039;padding&#039;])) * $thisfile_mpeg_audio[&#039;sample_rate&#039;]) / 144;
					}
				} else {
					$this-&gt;error(&#039;Error calculating frame length of free-format MP3 without Xing/LAME header&#039;);
				}
			}
		}

		if (isset($thisfile_mpeg_audio[&#039;VBR_frames&#039;]) ? $thisfile_mpeg_audio[&#039;VBR_frames&#039;] : &#039;&#039;) {
			switch ($thisfile_mpeg_audio[&#039;bitrate_mode&#039;]) {
				case &#039;vbr&#039;:
				case &#039;abr&#039;:
					$bytes_per_frame = 1152;
					if (($thisfile_mpeg_audio[&#039;version&#039;] == &#039;1&#039;) &amp;&amp; ($thisfile_mpeg_audio[&#039;layer&#039;] == 1)) {
						$bytes_per_frame = 384;
					} elseif ((($thisfile_mpeg_audio[&#039;version&#039;] == &#039;2&#039;) || ($thisfile_mpeg_audio[&#039;version&#039;] == &#039;2.5&#039;)) &amp;&amp; ($thisfile_mpeg_audio[&#039;layer&#039;] == 3)) {
						$bytes_per_frame = 576;
					}
					$thisfile_mpeg_audio[&#039;VBR_bitrate&#039;] = (isset($thisfile_mpeg_audio[&#039;VBR_bytes&#039;]) ? (($thisfile_mpeg_audio[&#039;VBR_bytes&#039;] / $thisfile_mpeg_audio[&#039;VBR_frames&#039;]) * 8) * ($info[&#039;audio&#039;][&#039;sample_rate&#039;] / $bytes_per_frame) : 0);
					if ($thisfile_mpeg_audio[&#039;VBR_bitrate&#039;] &gt; 0) {
						$info[&#039;audio&#039;][&#039;bitrate&#039;]       = $thisfile_mpeg_audio[&#039;VBR_bitrate&#039;];
						$thisfile_mpeg_audio[&#039;bitrate&#039;] = $thisfile_mpeg_audio[&#039;VBR_bitrate&#039;]; // to avoid confusion
					}
					break;
			}
		}

		// End variable-bitrate headers
		////////////////////////////////////////////////////////////////////////////////////

		if ($recursivesearch) {

			if (!$this-&gt;RecursiveFrameScanning($offset, $nextframetestoffset, $ScanAsCBR)) {
				return false;
			}
			if (!empty($this-&gt;getid3-&gt;info[&#039;mp3_validity_check_bitrates&#039;]) &amp;&amp; !empty($thisfile_mpeg_audio[&#039;bitrate_mode&#039;]) &amp;&amp; ($thisfile_mpeg_audio[&#039;bitrate_mode&#039;] == &#039;vbr&#039;) &amp;&amp; !empty($thisfile_mpeg_audio[&#039;VBR_bitrate&#039;])) {
				// https://github.com/JamesHeinrich/getID3/issues/287
				if (count(array_keys($this-&gt;getid3-&gt;info[&#039;mp3_validity_check_bitrates&#039;])) == 1) {
					list($cbr_bitrate_in_short_scan) = array_keys($this-&gt;getid3-&gt;info[&#039;mp3_validity_check_bitrates&#039;]);
					$deviation_cbr_from_header_bitrate = abs($thisfile_mpeg_audio[&#039;VBR_bitrate&#039;] - $cbr_bitrate_in_short_scan) / $cbr_bitrate_in_short_scan;
					if ($deviation_cbr_from_header_bitrate &lt; 0.01) {
						// VBR header bitrate may differ slightly from true bitrate of frames, perhaps accounting for overhead of VBR header frame itself?
						// If measured CBR bitrate is within 1% of specified bitrate in VBR header then assume that file is truly CBR
						$thisfile_mpeg_audio[&#039;bitrate_mode&#039;] = &#039;cbr&#039;;
						//$this-&gt;warning(&#039;VBR header ignored, assuming CBR &#039;.round($cbr_bitrate_in_short_scan / 1000).&#039;kbps based on scan of &#039;.$this-&gt;mp3_valid_check_frames.&#039; frames&#039;);
					}
				}
			}
			if (isset($this-&gt;getid3-&gt;info[&#039;mp3_validity_check_bitrates&#039;])) {
				unset($this-&gt;getid3-&gt;info[&#039;mp3_validity_check_bitrates&#039;]);
			}

		}


		//if (false) {
		//    // experimental side info parsing section - not returning anything useful yet
		//
		//    $SideInfoBitstream = getid3_lib::BigEndian2Bin($SideInfoData);
		//    $SideInfoOffset = 0;
		//
		//    if ($thisfile_mpeg_audio[&#039;version&#039;] == &#039;1&#039;) {
		//        if ($thisfile_mpeg_audio[&#039;channelmode&#039;] == &#039;mono&#039;) {
		//            // MPEG-1 (mono)
		//            $thisfile_mpeg_audio[&#039;side_info&#039;][&#039;main_data_begin&#039;] = substr($SideInfoBitstream, $SideInfoOffset, 9);
		//            $SideInfoOffset += 9;
		//            $SideInfoOffset += 5;
		//        } else {
		//            // MPEG-1 (stereo, joint-stereo, dual-channel)
		//            $thisfile_mpeg_audio[&#039;side_info&#039;][&#039;main_data_begin&#039;] = substr($SideInfoBitstream, $SideInfoOffset, 9);
		//            $SideInfoOffset += 9;
		//            $SideInfoOffset += 3;
		//        }
		//    } else { // 2 or 2.5
		//        if ($thisfile_mpeg_audio[&#039;channelmode&#039;] == &#039;mono&#039;) {
		//            // MPEG-2, MPEG-2.5 (mono)
		//            $thisfile_mpeg_audio[&#039;side_info&#039;][&#039;main_data_begin&#039;] = substr($SideInfoBitstream, $SideInfoOffset, 8);
		//            $SideInfoOffset += 8;
		//            $SideInfoOffset += 1;
		//        } else {
		//            // MPEG-2, MPEG-2.5 (stereo, joint-stereo, dual-channel)
		//            $thisfile_mpeg_audio[&#039;side_info&#039;][&#039;main_data_begin&#039;] = substr($SideInfoBitstream, $SideInfoOffset, 8);
		//            $SideInfoOffset += 8;
		//            $SideInfoOffset += 2;
		//        }
		//    }
		//
		//    if ($thisfile_mpeg_audio[&#039;version&#039;] == &#039;1&#039;) {
		//        for ($channel = 0; $channel &lt; $info[&#039;audio&#039;][&#039;channels&#039;]; $channel++) {
		//            for ($scfsi_band = 0; $scfsi_band &lt; 4; $scfsi_band++) {
		//                $thisfile_mpeg_audio[&#039;scfsi&#039;][$channel][$scfsi_band] = substr($SideInfoBitstream, $SideInfoOffset, 1);
		//                $SideInfoOffset += 2;
		//            }
		//        }
		//    }
		//    for ($granule = 0; $granule &lt; (($thisfile_mpeg_audio[&#039;version&#039;] == &#039;1&#039;) ? 2 : 1); $granule++) {
		//        for ($channel = 0; $channel &lt; $info[&#039;audio&#039;][&#039;channels&#039;]; $channel++) {
		//            $thisfile_mpeg_audio[&#039;part2_3_length&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 12);
		//            $SideInfoOffset += 12;
		//            $thisfile_mpeg_audio[&#039;big_values&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 9);
		//            $SideInfoOffset += 9;
		//            $thisfile_mpeg_audio[&#039;global_gain&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 8);
		//            $SideInfoOffset += 8;
		//            if ($thisfile_mpeg_audio[&#039;version&#039;] == &#039;1&#039;) {
		//                $thisfile_mpeg_audio[&#039;scalefac_compress&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 4);
		//                $SideInfoOffset += 4;
		//            } else {
		//                $thisfile_mpeg_audio[&#039;scalefac_compress&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 9);
		//                $SideInfoOffset += 9;
		//            }
		//            $thisfile_mpeg_audio[&#039;window_switching_flag&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 1);
		//            $SideInfoOffset += 1;
		//
		//            if ($thisfile_mpeg_audio[&#039;window_switching_flag&#039;][$granule][$channel] == &#039;1&#039;) {
		//
		//                $thisfile_mpeg_audio[&#039;block_type&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 2);
		//                $SideInfoOffset += 2;
		//                $thisfile_mpeg_audio[&#039;mixed_block_flag&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 1);
		//                $SideInfoOffset += 1;
		//
		//                for ($region = 0; $region &lt; 2; $region++) {
		//                    $thisfile_mpeg_audio[&#039;table_select&#039;][$granule][$channel][$region] = substr($SideInfoBitstream, $SideInfoOffset, 5);
		//                    $SideInfoOffset += 5;
		//                }
		//                $thisfile_mpeg_audio[&#039;table_select&#039;][$granule][$channel][2] = 0;
		//
		//                for ($window = 0; $window &lt; 3; $window++) {
		//                    $thisfile_mpeg_audio[&#039;subblock_gain&#039;][$granule][$channel][$window] = substr($SideInfoBitstream, $SideInfoOffset, 3);
		//                    $SideInfoOffset += 3;
		//                }
		//
		//            } else {
		//
		//                for ($region = 0; $region &lt; 3; $region++) {
		//                    $thisfile_mpeg_audio[&#039;table_select&#039;][$granule][$channel][$region] = substr($SideInfoBitstream, $SideInfoOffset, 5);
		//                    $SideInfoOffset += 5;
		//                }
		//
		//                $thisfile_mpeg_audio[&#039;region0_count&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 4);
		//                $SideInfoOffset += 4;
		//                $thisfile_mpeg_audio[&#039;region1_count&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 3);
		//                $SideInfoOffset += 3;
		//                $thisfile_mpeg_audio[&#039;block_type&#039;][$granule][$channel] = 0;
		//            }
		//
		//            if ($thisfile_mpeg_audio[&#039;version&#039;] == &#039;1&#039;) {
		//                $thisfile_mpeg_audio[&#039;preflag&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 1);
		//                $SideInfoOffset += 1;
		//            }
		//            $thisfile_mpeg_audio[&#039;scalefac_scale&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 1);
		//            $SideInfoOffset += 1;
		//            $thisfile_mpeg_audio[&#039;count1table_select&#039;][$granule][$channel] = substr($SideInfoBitstream, $SideInfoOffset, 1);
		//            $SideInfoOffset += 1;
		//        }
		//    }
		//}

		return true;
	}

	/**
	 * @param int $offset
	 * @param int $nextframetestoffset
	 * @param bool $ScanAsCBR
	 *
	 * @return bool
	 */
	public function RecursiveFrameScanning(&amp;$offset, &amp;$nextframetestoffset, $ScanAsCBR) {
		$info = &amp;$this-&gt;getid3-&gt;info;
		$firstframetestarray = array(&#039;error&#039; =&gt; array(), &#039;warning&#039;=&gt; array(), &#039;avdataend&#039; =&gt; $info[&#039;avdataend&#039;], &#039;avdataoffset&#039; =&gt; $info[&#039;avdataoffset&#039;]);
		$this-&gt;decodeMPEGaudioHeader($offset, $firstframetestarray, false);

		$info[&#039;mp3_validity_check_bitrates&#039;] = array();
		for ($i = 0; $i &lt; $this-&gt;mp3_valid_check_frames; $i++) {
			// check next (default: 50) frames for validity, to make sure we haven&#039;t run across a false synch
			if (($nextframetestoffset + 4) &gt;= $info[&#039;avdataend&#039;]) {
				// end of file
				return true;
			}

			$nextframetestarray = array(&#039;error&#039; =&gt; array(), &#039;warning&#039; =&gt; array(), &#039;avdataend&#039; =&gt; $info[&#039;avdataend&#039;], &#039;avdataoffset&#039;=&gt;$info[&#039;avdataoffset&#039;]);
			if ($this-&gt;decodeMPEGaudioHeader($nextframetestoffset, $nextframetestarray, false)) {
				/** @phpstan-ignore-next-line */
				getid3_lib::safe_inc($info[&#039;mp3_validity_check_bitrates&#039;][$nextframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;]]);
				if ($ScanAsCBR) {
					// force CBR mode, used for trying to pick out invalid audio streams with valid(?) VBR headers, or VBR streams with no VBR header
					if (!isset($nextframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;]) || !isset($firstframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;]) || ($nextframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;] != $firstframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;])) {
						return false;
					}
				}


				// next frame is OK, get ready to check the one after that
				if (isset($nextframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;]) &amp;&amp; ($nextframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;] &gt; 0)) {
					$nextframetestoffset += $nextframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;];
				} else {
					$this-&gt;error(&#039;Frame at offset (&#039;.$offset.&#039;) is has an invalid frame length.&#039;);
					return false;
				}

			} elseif (!empty($firstframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;]) &amp;&amp; (($nextframetestoffset + $firstframetestarray[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;]) &gt; $info[&#039;avdataend&#039;])) {

				// it&#039;s not the end of the file, but there&#039;s not enough data left for another frame, so assume it&#039;s garbage/padding and return OK
				return true;

			} else {

				// next frame is not valid, note the error and fail, so scanning can contiue for a valid frame sequence
				$this-&gt;warning(&#039;Frame at offset (&#039;.$offset.&#039;) is valid, but the next one at (&#039;.$nextframetestoffset.&#039;) is not.&#039;);

				return false;
			}
		}
		return true;
	}

	/**
	 * @param int  $offset
	 * @param bool $deepscan
	 *
	 * @return int|false
	 */
	public function FreeFormatFrameLength($offset, $deepscan=false) {
		$info = &amp;$this-&gt;getid3-&gt;info;

		$this-&gt;fseek($offset);
		$MPEGaudioData = $this-&gt;fread(32768);

		$SyncPattern1 = substr($MPEGaudioData, 0, 4);
		// may be different pattern due to padding
		$SyncPattern2 = $SyncPattern1[0].$SyncPattern1[1].chr(ord($SyncPattern1[2]) | 0x02).$SyncPattern1[3];
		if ($SyncPattern2 === $SyncPattern1) {
			$SyncPattern2 = $SyncPattern1[0].$SyncPattern1[1].chr(ord($SyncPattern1[2]) &amp; 0xFD).$SyncPattern1[3];
		}

		$framelength = false;
		$framelength1 = strpos($MPEGaudioData, $SyncPattern1, 4);
		$framelength2 = strpos($MPEGaudioData, $SyncPattern2, 4);
		if ($framelength1 &gt; 4) {
			$framelength = $framelength1;
		}
		if (($framelength2 &gt; 4) &amp;&amp; ($framelength2 &lt; $framelength1)) {
			$framelength = $framelength2;
		}
		if (!$framelength) {

			// LAME 3.88 has a different value for modeextension on the first frame vs the rest
			$framelength1 = strpos($MPEGaudioData, substr($SyncPattern1, 0, 3), 4);
			$framelength2 = strpos($MPEGaudioData, substr($SyncPattern2, 0, 3), 4);

			if ($framelength1 &gt; 4) {
				$framelength = $framelength1;
			}
			if (($framelength2 &gt; 4) &amp;&amp; ($framelength2 &lt; $framelength1)) {
				$framelength = $framelength2;
			}
			if (!$framelength) {
				$this-&gt;error(&#039;Cannot find next free-format synch pattern (&#039;.getid3_lib::PrintHexBytes($SyncPattern1).&#039; or &#039;.getid3_lib::PrintHexBytes($SyncPattern2).&#039;) after offset &#039;.$offset);
				return false;
			} else {
				$this-&gt;warning(&#039;ModeExtension varies between first frame and other frames (known free-format issue in LAME 3.88)&#039;);
				$info[&#039;audio&#039;][&#039;codec&#039;]   = &#039;LAME&#039;;
				$info[&#039;audio&#039;][&#039;encoder&#039;] = &#039;LAME3.88&#039;;
				$SyncPattern1 = substr($SyncPattern1, 0, 3);
				$SyncPattern2 = substr($SyncPattern2, 0, 3);
			}
		}

		if ($deepscan) {

			$ActualFrameLengthValues = array();
			$nextoffset = $offset + $framelength;
			while ($nextoffset &lt; ($info[&#039;avdataend&#039;] - 6)) {
				$this-&gt;fseek($nextoffset - 1);
				$NextSyncPattern = $this-&gt;fread(6);
				if ((substr($NextSyncPattern, 1, strlen($SyncPattern1)) == $SyncPattern1) || (substr($NextSyncPattern, 1, strlen($SyncPattern2)) == $SyncPattern2)) {
					// good - found where expected
					$ActualFrameLengthValues[] = $framelength;
				} elseif ((substr($NextSyncPattern, 0, strlen($SyncPattern1)) == $SyncPattern1) || (substr($NextSyncPattern, 0, strlen($SyncPattern2)) == $SyncPattern2)) {
					// ok - found one byte earlier than expected (last frame wasn&#039;t padded, first frame was)
					$ActualFrameLengthValues[] = ($framelength - 1);
					$nextoffset--;
				} elseif ((substr($NextSyncPattern, 2, strlen($SyncPattern1)) == $SyncPattern1) || (substr($NextSyncPattern, 2, strlen($SyncPattern2)) == $SyncPattern2)) {
					// ok - found one byte later than expected (last frame was padded, first frame wasn&#039;t)
					$ActualFrameLengthValues[] = ($framelength + 1);
					$nextoffset++;
				} else {
					$this-&gt;error(&#039;Did not find expected free-format sync pattern at offset &#039;.$nextoffset);
					return false;
				}
				$nextoffset += $framelength;
			}
			if (count($ActualFrameLengthValues) &gt; 0) {
				$framelength = intval(round(array_sum($ActualFrameLengthValues) / count($ActualFrameLengthValues)));
			}
		}
		return $framelength;
	}

	/**
	 * @return bool
	 */
	public function getOnlyMPEGaudioInfoBruteForce() {
		$MPEGaudioHeaderDecodeCache   = array();
		$MPEGaudioHeaderValidCache    = array();
		$MPEGaudioHeaderLengthCache   = array();
		$MPEGaudioVersionLookup       = self::MPEGaudioVersionArray();
		$MPEGaudioLayerLookup         = self::MPEGaudioLayerArray();
		$MPEGaudioBitrateLookup       = self::MPEGaudioBitrateArray();
		$MPEGaudioFrequencyLookup     = self::MPEGaudioFrequencyArray();
		$MPEGaudioChannelModeLookup   = self::MPEGaudioChannelModeArray();
		$MPEGaudioModeExtensionLookup = self::MPEGaudioModeExtensionArray();
		$MPEGaudioEmphasisLookup      = self::MPEGaudioEmphasisArray();
		$LongMPEGversionLookup        = array();
		$LongMPEGlayerLookup          = array();
		$LongMPEGbitrateLookup        = array();
		$LongMPEGpaddingLookup        = array();
		$LongMPEGfrequencyLookup      = array();
		$Distribution                 = array();
		$Distribution[&#039;bitrate&#039;]      = array();
		$Distribution[&#039;frequency&#039;]    = array();
		$Distribution[&#039;layer&#039;]        = array();
		$Distribution[&#039;version&#039;]      = array();
		$Distribution[&#039;padding&#039;]      = array();

		$info = &amp;$this-&gt;getid3-&gt;info;
		$this-&gt;fseek($info[&#039;avdataoffset&#039;]);

		$max_frames_scan = 5000;
		$frames_scanned  = 0;

		$previousvalidframe = $info[&#039;avdataoffset&#039;];
		while ($this-&gt;ftell() &lt; $info[&#039;avdataend&#039;]) {
			set_time_limit(30);
			$head4 = $this-&gt;fread(4);
			if (strlen($head4) &lt; 4) {
				break;
			}
			if ($head4[0] != &quot;\xFF&quot;) {
				for ($i = 1; $i &lt; 4; $i++) {
					if ($head4[$i] == &quot;\xFF&quot;) {
						$this-&gt;fseek($i - 4, SEEK_CUR);
						continue 2;
					}
				}
				continue;
			}
			if (!isset($MPEGaudioHeaderDecodeCache[$head4])) {
				$MPEGaudioHeaderDecodeCache[$head4] = self::MPEGaudioHeaderDecode($head4);
			}
			if (!isset($MPEGaudioHeaderValidCache[$head4])) {
				$MPEGaudioHeaderValidCache[$head4] = self::MPEGaudioHeaderValid($MPEGaudioHeaderDecodeCache[$head4], false, false);
			}
			if ($MPEGaudioHeaderValidCache[$head4]) {

				if (!isset($MPEGaudioHeaderLengthCache[$head4])) {
					$LongMPEGversionLookup[$head4]   = $MPEGaudioVersionLookup[$MPEGaudioHeaderDecodeCache[$head4][&#039;version&#039;]];
					$LongMPEGlayerLookup[$head4]     = $MPEGaudioLayerLookup[$MPEGaudioHeaderDecodeCache[$head4][&#039;layer&#039;]];
					$LongMPEGbitrateLookup[$head4]   = $MPEGaudioBitrateLookup[$LongMPEGversionLookup[$head4]][$LongMPEGlayerLookup[$head4]][$MPEGaudioHeaderDecodeCache[$head4][&#039;bitrate&#039;]];
					$LongMPEGpaddingLookup[$head4]   = (bool) $MPEGaudioHeaderDecodeCache[$head4][&#039;padding&#039;];
					$LongMPEGfrequencyLookup[$head4] = $MPEGaudioFrequencyLookup[$LongMPEGversionLookup[$head4]][$MPEGaudioHeaderDecodeCache[$head4][&#039;sample_rate&#039;]];
					$MPEGaudioHeaderLengthCache[$head4] = self::MPEGaudioFrameLength(
						$LongMPEGbitrateLookup[$head4],
						$LongMPEGversionLookup[$head4],
						$LongMPEGlayerLookup[$head4],
						$LongMPEGpaddingLookup[$head4],
						$LongMPEGfrequencyLookup[$head4]);
				}
				if ($MPEGaudioHeaderLengthCache[$head4] &gt; 4) {
					$WhereWeWere = $this-&gt;ftell();
					$this-&gt;fseek($MPEGaudioHeaderLengthCache[$head4] - 4, SEEK_CUR);
					$next4 = $this-&gt;fread(4);
					if ($next4[0] == &quot;\xFF&quot;) {
						if (!isset($MPEGaudioHeaderDecodeCache[$next4])) {
							$MPEGaudioHeaderDecodeCache[$next4] = self::MPEGaudioHeaderDecode($next4);
						}
						if (!isset($MPEGaudioHeaderValidCache[$next4])) {
							$MPEGaudioHeaderValidCache[$next4] = self::MPEGaudioHeaderValid($MPEGaudioHeaderDecodeCache[$next4], false, false);
						}
						if ($MPEGaudioHeaderValidCache[$next4]) {
							$this-&gt;fseek(-4, SEEK_CUR);

							$Distribution[&#039;bitrate&#039;][$LongMPEGbitrateLookup[$head4]] = isset($Distribution[&#039;bitrate&#039;][$LongMPEGbitrateLookup[$head4]]) ? ++$Distribution[&#039;bitrate&#039;][$LongMPEGbitrateLookup[$head4]] : 1;
							$Distribution[&#039;layer&#039;][$LongMPEGlayerLookup[$head4]] = isset($Distribution[&#039;layer&#039;][$LongMPEGlayerLookup[$head4]]) ? ++$Distribution[&#039;layer&#039;][$LongMPEGlayerLookup[$head4]] : 1;
							$Distribution[&#039;version&#039;][$LongMPEGversionLookup[$head4]] = isset($Distribution[&#039;version&#039;][$LongMPEGversionLookup[$head4]]) ? ++$Distribution[&#039;version&#039;][$LongMPEGversionLookup[$head4]] : 1;
							$Distribution[&#039;padding&#039;][intval($LongMPEGpaddingLookup[$head4])] = isset($Distribution[&#039;padding&#039;][intval($LongMPEGpaddingLookup[$head4])]) ? ++$Distribution[&#039;padding&#039;][intval($LongMPEGpaddingLookup[$head4])] : 1;
							$Distribution[&#039;frequency&#039;][$LongMPEGfrequencyLookup[$head4]] = isset($Distribution[&#039;frequency&#039;][$LongMPEGfrequencyLookup[$head4]]) ? ++$Distribution[&#039;frequency&#039;][$LongMPEGfrequencyLookup[$head4]] : 1;
							if (++$frames_scanned &gt;= $max_frames_scan) {
								$pct_data_scanned = getid3_lib::SafeDiv($this-&gt;ftell() - $info[&#039;avdataoffset&#039;], $info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]);
								$this-&gt;warning(&#039;too many MPEG audio frames to scan, only scanned first &#039;.$max_frames_scan.&#039; frames (&#039;.number_format($pct_data_scanned * 100, 1).&#039;% of file) and extrapolated distribution, playtime and bitrate may be incorrect.&#039;);
								foreach ($Distribution as $key1 =&gt; $value1) {
									foreach ($value1 as $key2 =&gt; $value2) {
										$Distribution[$key1][$key2] = $pct_data_scanned ? round($value2 / $pct_data_scanned) : 1;
									}
								}
								break;
							}
							continue;
						}
					}
					unset($next4);
					$this-&gt;fseek($WhereWeWere - 3);
				}

			}
		}
		foreach ($Distribution as $key =&gt; $value) {
			ksort($Distribution[$key], SORT_NUMERIC);
		}
		ksort($Distribution[&#039;version&#039;], SORT_STRING);
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;]   = $Distribution[&#039;bitrate&#039;];
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;frequency_distribution&#039;] = $Distribution[&#039;frequency&#039;];
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer_distribution&#039;]     = $Distribution[&#039;layer&#039;];
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;version_distribution&#039;]   = $Distribution[&#039;version&#039;];
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;padding_distribution&#039;]   = $Distribution[&#039;padding&#039;];
		if (count($Distribution[&#039;version&#039;]) &gt; 1) {
			$this-&gt;error(&#039;Corrupt file - more than one MPEG version detected&#039;);
		}
		if (count($Distribution[&#039;layer&#039;]) &gt; 1) {
			$this-&gt;error(&#039;Corrupt file - more than one MPEG layer detected&#039;);
		}
		if (count($Distribution[&#039;frequency&#039;]) &gt; 1) {
			$this-&gt;error(&#039;Corrupt file - more than one MPEG sample rate detected&#039;);
		}


		$bittotal = 0;
		foreach ($Distribution[&#039;bitrate&#039;] as $bitratevalue =&gt; $bitratecount) {
			if ($bitratevalue != &#039;free&#039;) {
				$bittotal += ($bitratevalue * $bitratecount);
			}
		}
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;frame_count&#039;]  = array_sum($Distribution[&#039;bitrate&#039;]);
		if ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;frame_count&#039;] == 0) {
			$this-&gt;error(&#039;no MPEG audio frames found&#039;);
			return false;
		}
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;]      = ($bittotal / $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;frame_count&#039;]);
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;] = ((count($Distribution[&#039;bitrate&#039;]) &gt; 0) ? &#039;vbr&#039; : &#039;cbr&#039;);
		$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;sample_rate&#039;]  = getid3_lib::array_max($Distribution[&#039;frequency&#039;], true);

		$info[&#039;audio&#039;][&#039;bitrate&#039;]      = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;];
		$info[&#039;audio&#039;][&#039;bitrate_mode&#039;] = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;];
		$info[&#039;audio&#039;][&#039;sample_rate&#039;]  = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;sample_rate&#039;];
		$info[&#039;audio&#039;][&#039;dataformat&#039;]   = &#039;mp&#039;.getid3_lib::array_max($Distribution[&#039;layer&#039;], true);
		$info[&#039;fileformat&#039;]            = $info[&#039;audio&#039;][&#039;dataformat&#039;];

		return true;
	}

	/**
	 * @param int  $avdataoffset
	 * @param bool $BitrateHistogram
	 *
	 * @return bool
	 */
	public function getOnlyMPEGaudioInfo($avdataoffset, $BitrateHistogram=false) {
		// looks for synch, decodes MPEG audio header

		$info = &amp;$this-&gt;getid3-&gt;info;

		static $MPEGaudioVersionLookup;
		static $MPEGaudioLayerLookup;
		static $MPEGaudioBitrateLookup;
		if (empty($MPEGaudioVersionLookup)) {
			$MPEGaudioVersionLookup = self::MPEGaudioVersionArray();
			$MPEGaudioLayerLookup   = self::MPEGaudioLayerArray();
			$MPEGaudioBitrateLookup = self::MPEGaudioBitrateArray();
		}

		$this-&gt;fseek($avdataoffset);
		$sync_seek_buffer_size = min(128 * 1024, $info[&#039;avdataend&#039;] - $avdataoffset);
		if ($sync_seek_buffer_size &lt;= 0) {
			$this-&gt;error(&#039;Invalid $sync_seek_buffer_size at offset &#039;.$avdataoffset);
			return false;
		}
		$header = $this-&gt;fread($sync_seek_buffer_size);
		$sync_seek_buffer_size = strlen($header);
		$SynchSeekOffset = 0;
		$SyncSeekAttempts = 0;
		$SyncSeekAttemptsMax = 1000;
		$FirstFrameThisfileInfo = null;
		while ($SynchSeekOffset &lt; $sync_seek_buffer_size) {
			if ((($avdataoffset + $SynchSeekOffset)  &lt; $info[&#039;avdataend&#039;]) &amp;&amp; !$this-&gt;feof()) {

				if ($SynchSeekOffset &gt; $sync_seek_buffer_size) {
					// if a synch&#039;s not found within the first 128k bytes, then give up
					$this-&gt;error(&#039;Could not find valid MPEG audio synch within the first &#039;.round($sync_seek_buffer_size / 1024).&#039;kB&#039;);
					if (isset($info[&#039;audio&#039;][&#039;bitrate&#039;])) {
						unset($info[&#039;audio&#039;][&#039;bitrate&#039;]);
					}
					if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
						unset($info[&#039;mpeg&#039;][&#039;audio&#039;]);
					}
					if (empty($info[&#039;mpeg&#039;])) {
						unset($info[&#039;mpeg&#039;]);
					}
					return false;
				}
			}

			if (($SynchSeekOffset + 1) &gt;= strlen($header)) {
				$this-&gt;error(&#039;Could not find valid MPEG synch before end of file&#039;);
				return false;
			}

			if (($header[$SynchSeekOffset] == &quot;\xFF&quot;) &amp;&amp; ($header[($SynchSeekOffset + 1)] &gt; &quot;\xE0&quot;)) { // possible synch detected
				if (++$SyncSeekAttempts &gt;= $SyncSeekAttemptsMax) {
					// https://github.com/JamesHeinrich/getID3/issues/286
					// corrupt files claiming to be MP3, with a large number of 0xFF bytes near the beginning, can cause this loop to take a very long time
					// should have escape condition to avoid spending too much time scanning a corrupt file
					// if a synch&#039;s not found within the first 128k bytes, then give up
					$this-&gt;error(&#039;Could not find valid MPEG audio synch after scanning &#039;.$SyncSeekAttempts.&#039; candidate offsets&#039;);
					if (isset($info[&#039;audio&#039;][&#039;bitrate&#039;])) {
						unset($info[&#039;audio&#039;][&#039;bitrate&#039;]);
					}
					if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
						unset($info[&#039;mpeg&#039;][&#039;audio&#039;]);
					}
					if (empty($info[&#039;mpeg&#039;])) {
						unset($info[&#039;mpeg&#039;]);
					}
					return false;
				}
				$FirstFrameAVDataOffset = null;
				if (!isset($FirstFrameThisfileInfo) &amp;&amp; !isset($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
					$FirstFrameThisfileInfo = $info;
					$FirstFrameAVDataOffset = $avdataoffset + $SynchSeekOffset;
					if (!$this-&gt;decodeMPEGaudioHeader($FirstFrameAVDataOffset, $FirstFrameThisfileInfo, false)) {
						// if this is the first valid MPEG-audio frame, save it in case it&#039;s a VBR header frame and there&#039;s
						// garbage between this frame and a valid sequence of MPEG-audio frames, to be restored below
						unset($FirstFrameThisfileInfo);
					}
				}

				$dummy = $info; // only overwrite real data if valid header found
				if ($this-&gt;decodeMPEGaudioHeader($avdataoffset + $SynchSeekOffset, $dummy, true)) {
					$info = $dummy;
					$info[&#039;avdataoffset&#039;] = $avdataoffset + $SynchSeekOffset;
					switch (isset($info[&#039;fileformat&#039;]) ? $info[&#039;fileformat&#039;] : &#039;&#039;) {
						case &#039;&#039;:
						case &#039;id3&#039;:
						case &#039;ape&#039;:
						case &#039;mp3&#039;:
							$info[&#039;fileformat&#039;]          = &#039;mp3&#039;;
							$info[&#039;audio&#039;][&#039;dataformat&#039;] = &#039;mp3&#039;;
							break;
					}
					if (isset($FirstFrameThisfileInfo) &amp;&amp; isset($FirstFrameThisfileInfo[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;]) &amp;&amp; ($FirstFrameThisfileInfo[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;] == &#039;vbr&#039;)) {
						if (!(abs($info[&#039;audio&#039;][&#039;bitrate&#039;] - $FirstFrameThisfileInfo[&#039;audio&#039;][&#039;bitrate&#039;]) &lt;= 1)) {
							// If there is garbage data between a valid VBR header frame and a sequence
							// of valid MPEG-audio frames the VBR data is no longer discarded.
							$info = $FirstFrameThisfileInfo;
							$info[&#039;avdataoffset&#039;]        = $FirstFrameAVDataOffset;
							$info[&#039;fileformat&#039;]          = &#039;mp3&#039;;
							$info[&#039;audio&#039;][&#039;dataformat&#039;] = &#039;mp3&#039;;
							$dummy                       = $info;
							unset($dummy[&#039;mpeg&#039;][&#039;audio&#039;]);
							$GarbageOffsetStart = $FirstFrameAVDataOffset + $FirstFrameThisfileInfo[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;];
							$GarbageOffsetEnd   = $avdataoffset + $SynchSeekOffset;
							if ($this-&gt;decodeMPEGaudioHeader($GarbageOffsetEnd, $dummy, true, true)) {
								$info = $dummy;
								$info[&#039;avdataoffset&#039;] = $GarbageOffsetEnd;
								$this-&gt;warning(&#039;apparently-valid VBR header not used because could not find &#039;.$this-&gt;mp3_valid_check_frames.&#039; consecutive MPEG-audio frames immediately after VBR header (garbage data for &#039;.($GarbageOffsetEnd - $GarbageOffsetStart).&#039; bytes between &#039;.$GarbageOffsetStart.&#039; and &#039;.$GarbageOffsetEnd.&#039;), but did find valid CBR stream starting at &#039;.$GarbageOffsetEnd);
							} else {
								$this-&gt;warning(&#039;using data from VBR header even though could not find &#039;.$this-&gt;mp3_valid_check_frames.&#039; consecutive MPEG-audio frames immediately after VBR header (garbage data for &#039;.($GarbageOffsetEnd - $GarbageOffsetStart).&#039; bytes between &#039;.$GarbageOffsetStart.&#039; and &#039;.$GarbageOffsetEnd.&#039;)&#039;);
							}
						}
					}
					if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;]) &amp;&amp; ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;] == &#039;vbr&#039;) &amp;&amp; !isset($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;VBR_method&#039;])) {
						// VBR file with no VBR header
						$BitrateHistogram = true;
					}

					if ($BitrateHistogram) {

						$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;stereo_distribution&#039;]  = array(&#039;stereo&#039;=&gt;0, &#039;joint stereo&#039;=&gt;0, &#039;dual channel&#039;=&gt;0, &#039;mono&#039;=&gt;0);
						$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;version_distribution&#039;] = array(&#039;1&#039;=&gt;0, &#039;2&#039;=&gt;0, &#039;2.5&#039;=&gt;0);

						if ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;version&#039;] == &#039;1&#039;) {
							if ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;] == 3) {
								$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] = array(&#039;free&#039;=&gt;0, 32000=&gt;0, 40000=&gt;0, 48000=&gt;0, 56000=&gt;0, 64000=&gt;0, 80000=&gt;0, 96000=&gt;0, 112000=&gt;0, 128000=&gt;0, 160000=&gt;0, 192000=&gt;0, 224000=&gt;0, 256000=&gt;0, 320000=&gt;0);
							} elseif ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;] == 2) {
								$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] = array(&#039;free&#039;=&gt;0, 32000=&gt;0, 48000=&gt;0, 56000=&gt;0, 64000=&gt;0, 80000=&gt;0, 96000=&gt;0, 112000=&gt;0, 128000=&gt;0, 160000=&gt;0, 192000=&gt;0, 224000=&gt;0, 256000=&gt;0, 320000=&gt;0, 384000=&gt;0);
							} elseif ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;] == 1) {
								$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] = array(&#039;free&#039;=&gt;0, 32000=&gt;0, 64000=&gt;0, 96000=&gt;0, 128000=&gt;0, 160000=&gt;0, 192000=&gt;0, 224000=&gt;0, 256000=&gt;0, 288000=&gt;0, 320000=&gt;0, 352000=&gt;0, 384000=&gt;0, 416000=&gt;0, 448000=&gt;0);
							}
						} elseif ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;layer&#039;] == 1) {
							$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] = array(&#039;free&#039;=&gt;0, 32000=&gt;0, 48000=&gt;0, 56000=&gt;0, 64000=&gt;0, 80000=&gt;0, 96000=&gt;0, 112000=&gt;0, 128000=&gt;0, 144000=&gt;0, 160000=&gt;0, 176000=&gt;0, 192000=&gt;0, 224000=&gt;0, 256000=&gt;0);
						} else {
							$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] = array(&#039;free&#039;=&gt;0, 8000=&gt;0, 16000=&gt;0, 24000=&gt;0, 32000=&gt;0, 40000=&gt;0, 48000=&gt;0, 56000=&gt;0, 64000=&gt;0, 80000=&gt;0, 96000=&gt;0, 112000=&gt;0, 128000=&gt;0, 144000=&gt;0, 160000=&gt;0);
						}

						$dummy = array(&#039;error&#039;=&gt;$info[&#039;error&#039;], &#039;warning&#039;=&gt;$info[&#039;warning&#039;], &#039;avdataend&#039;=&gt;$info[&#039;avdataend&#039;], &#039;avdataoffset&#039;=&gt;$info[&#039;avdataoffset&#039;]);
						$synchstartoffset = $info[&#039;avdataoffset&#039;];
						$this-&gt;fseek($info[&#039;avdataoffset&#039;]);

						// you can play with these numbers:
						$max_frames_scan  = 50000;
						$max_scan_segments = 10;

						// don&#039;t play with these numbers:
						$FastMode = false;
						$SynchErrorsFound = 0;
						$frames_scanned   = 0;
						$this_scan_segment = 0;
						$frames_scan_per_segment = ceil($max_frames_scan / $max_scan_segments);
						$pct_data_scanned = 0;
						for ($current_segment = 0; $current_segment &lt; $max_scan_segments; $current_segment++) {
							$frames_scanned_this_segment = 0;
							$scan_start_offset = array();
							if ($this-&gt;ftell() &gt;= $info[&#039;avdataend&#039;]) {
								break;
							}
							$scan_start_offset[$current_segment] = max($this-&gt;ftell(), $info[&#039;avdataoffset&#039;] + round($current_segment * (($info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]) / $max_scan_segments)));
							if ($current_segment &gt; 0) {
								$this-&gt;fseek($scan_start_offset[$current_segment]);
								$buffer_4k = $this-&gt;fread(4096);
								for ($j = 0; $j &lt; (strlen($buffer_4k) - 4); $j++) {
									if (($buffer_4k[$j] == &quot;\xFF&quot;) &amp;&amp; ($buffer_4k[($j + 1)] &gt; &quot;\xE0&quot;)) { // synch detected
										if ($this-&gt;decodeMPEGaudioHeader($scan_start_offset[$current_segment] + $j, $dummy, false, false, $FastMode)) {
											$calculated_next_offset = $scan_start_offset[$current_segment] + $j + $dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;];
											if ($this-&gt;decodeMPEGaudioHeader($calculated_next_offset, $dummy, false, false, $FastMode)) {
												$scan_start_offset[$current_segment] += $j;
												break;
											}
										}
									}
								}
							}
							$synchstartoffset = $scan_start_offset[$current_segment];
							while (($synchstartoffset &lt; $info[&#039;avdataend&#039;]) &amp;&amp; $this-&gt;decodeMPEGaudioHeader($synchstartoffset, $dummy, false, false, $FastMode)) {
								$FastMode = true;
								$thisframebitrate = $MPEGaudioBitrateLookup[$MPEGaudioVersionLookup[$dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;raw&#039;][&#039;version&#039;]]][$MPEGaudioLayerLookup[$dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;raw&#039;][&#039;layer&#039;]]][$dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;raw&#039;][&#039;bitrate&#039;]];

								if (empty($dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;])) {
									$SynchErrorsFound++;
									$synchstartoffset++;
								} else {
									getid3_lib::safe_inc($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;][$thisframebitrate]);
									getid3_lib::safe_inc($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;stereo_distribution&#039;][$dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;channelmode&#039;]]);
									getid3_lib::safe_inc($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;version_distribution&#039;][$dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;version&#039;]]);
									$synchstartoffset += $dummy[&#039;mpeg&#039;][&#039;audio&#039;][&#039;framelength&#039;];
								}
								$frames_scanned++;
								if ($frames_scan_per_segment &amp;&amp; (++$frames_scanned_this_segment &gt;= $frames_scan_per_segment)) {
									$this_pct_scanned = getid3_lib::SafeDiv($this-&gt;ftell() - $scan_start_offset[$current_segment], $info[&#039;avdataend&#039;] - $info[&#039;avdataoffset&#039;]);
									if (($current_segment == 0) &amp;&amp; (($this_pct_scanned * $max_scan_segments) &gt;= 1)) {
										// file likely contains &lt; $max_frames_scan, just scan as one segment
										$max_scan_segments = 1;
										$frames_scan_per_segment = $max_frames_scan;
									} else {
										$pct_data_scanned += $this_pct_scanned;
										break;
									}
								}
							}
						}
						if ($pct_data_scanned &gt; 0) {
							$this-&gt;warning(&#039;too many MPEG audio frames to scan, only scanned &#039;.$frames_scanned.&#039; frames in &#039;.$max_scan_segments.&#039; segments (&#039;.number_format($pct_data_scanned * 100, 1).&#039;% of file) and extrapolated distribution, playtime and bitrate may be incorrect.&#039;);
							foreach ($info[&#039;mpeg&#039;][&#039;audio&#039;] as $key1 =&gt; $value1) {
								if (!preg_match(&#039;#_distribution$#i&#039;, $key1)) {
									continue;
								}
								foreach ($value1 as $key2 =&gt; $value2) {
									$info[&#039;mpeg&#039;][&#039;audio&#039;][$key1][$key2] = round($value2 / $pct_data_scanned);
								}
							}
						}

						if ($SynchErrorsFound &gt; 0) {
							$this-&gt;warning(&#039;Found &#039;.$SynchErrorsFound.&#039; synch errors in histogram analysis&#039;);
							//return false;
						}

						$bittotal     = 0;
						$framecounter = 0;
						foreach ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] as $bitratevalue =&gt; $bitratecount) {
							$framecounter += $bitratecount;
							if ($bitratevalue != &#039;free&#039;) {
								$bittotal += ($bitratevalue * $bitratecount);
							}
						}
						if ($framecounter == 0) {
							$this-&gt;error(&#039;Corrupt MP3 file: framecounter == zero&#039;);
							return false;
						}
						$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;frame_count&#039;] = getid3_lib::CastAsInt($framecounter);
						$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;]     = ($bittotal / $framecounter);

						$info[&#039;audio&#039;][&#039;bitrate&#039;] = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate&#039;];


						// Definitively set VBR vs CBR, even if the Xing/LAME/VBRI header says differently
						$distinct_bitrates = 0;
						foreach ($info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_distribution&#039;] as $bitrate_value =&gt; $bitrate_count) {
							if ($bitrate_count &gt; 0) {
								$distinct_bitrates++;
							}
						}
						if ($distinct_bitrates &gt; 1) {
							$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;] = &#039;vbr&#039;;
						} else {
							$info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;] = &#039;cbr&#039;;
						}
						$info[&#039;audio&#039;][&#039;bitrate_mode&#039;] = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;bitrate_mode&#039;];

					}

					break; // exit while()
				}
			}

			$SynchSeekOffset++;
			if (($avdataoffset + $SynchSeekOffset) &gt;= $info[&#039;avdataend&#039;]) {
				// end of file/data

				if (empty($info[&#039;mpeg&#039;][&#039;audio&#039;])) {

					$this-&gt;error(&#039;could not find valid MPEG synch before end of file&#039;);
					if (isset($info[&#039;audio&#039;][&#039;bitrate&#039;])) {
						unset($info[&#039;audio&#039;][&#039;bitrate&#039;]);
					}
					if (isset($info[&#039;mpeg&#039;][&#039;audio&#039;])) {
						unset($info[&#039;mpeg&#039;][&#039;audio&#039;]);
					}
					if (isset($info[&#039;mpeg&#039;]) &amp;&amp; (!is_array($info[&#039;mpeg&#039;]) || empty($info[&#039;mpeg&#039;]))) {
						unset($info[&#039;mpeg&#039;]);
					}
					return false;

				}
				break;
			}

		}
		$info[&#039;audio&#039;][&#039;channels&#039;]        = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;channels&#039;];
		if ($info[&#039;audio&#039;][&#039;channels&#039;] &lt; 1) {
			$this-&gt;error(&#039;Corrupt MP3 file: no channels&#039;);
			return false;
		}
		$info[&#039;audio&#039;][&#039;channelmode&#039;]     = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;channelmode&#039;];
		$info[&#039;audio&#039;][&#039;sample_rate&#039;]     = $info[&#039;mpeg&#039;][&#039;audio&#039;][&#039;sample_rate&#039;];
		return true;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioVersionArray() {
		static $MPEGaudioVersion = array(&#039;2.5&#039;, false, &#039;2&#039;, &#039;1&#039;);
		return $MPEGaudioVersion;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioLayerArray() {
		static $MPEGaudioLayer = array(false, 3, 2, 1);
		return $MPEGaudioLayer;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioBitrateArray() {
		static $MPEGaudioBitrate;
		if (empty($MPEGaudioBitrate)) {
			$MPEGaudioBitrate = array (
				&#039;1&#039;  =&gt;  array (1 =&gt; array(&#039;free&#039;, 32000, 64000, 96000, 128000, 160000, 192000, 224000, 256000, 288000, 320000, 352000, 384000, 416000, 448000),
								2 =&gt; array(&#039;free&#039;, 32000, 48000, 56000,  64000,  80000,  96000, 112000, 128000, 160000, 192000, 224000, 256000, 320000, 384000),
								3 =&gt; array(&#039;free&#039;, 32000, 40000, 48000,  56000,  64000,  80000,  96000, 112000, 128000, 160000, 192000, 224000, 256000, 320000)
							   ),

				&#039;2&#039;  =&gt;  array (1 =&gt; array(&#039;free&#039;, 32000, 48000, 56000,  64000,  80000,  96000, 112000, 128000, 144000, 160000, 176000, 192000, 224000, 256000),
								2 =&gt; array(&#039;free&#039;,  8000, 16000, 24000,  32000,  40000,  48000,  56000,  64000,  80000,  96000, 112000, 128000, 144000, 160000),
							   )
			);
			$MPEGaudioBitrate[&#039;2&#039;][3] = $MPEGaudioBitrate[&#039;2&#039;][2];
			$MPEGaudioBitrate[&#039;2.5&#039;]  = $MPEGaudioBitrate[&#039;2&#039;];
		}
		return $MPEGaudioBitrate;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioFrequencyArray() {
		static $MPEGaudioFrequency;
		if (empty($MPEGaudioFrequency)) {
			$MPEGaudioFrequency = array (
				&#039;1&#039;   =&gt; array(44100, 48000, 32000),
				&#039;2&#039;   =&gt; array(22050, 24000, 16000),
				&#039;2.5&#039; =&gt; array(11025, 12000,  8000)
			);
		}
		return $MPEGaudioFrequency;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioChannelModeArray() {
		static $MPEGaudioChannelMode = array(&#039;stereo&#039;, &#039;joint stereo&#039;, &#039;dual channel&#039;, &#039;mono&#039;);
		return $MPEGaudioChannelMode;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioModeExtensionArray() {
		static $MPEGaudioModeExtension;
		if (empty($MPEGaudioModeExtension)) {
			$MPEGaudioModeExtension = array (
				1 =&gt; array(&#039;4-31&#039;, &#039;8-31&#039;, &#039;12-31&#039;, &#039;16-31&#039;),
				2 =&gt; array(&#039;4-31&#039;, &#039;8-31&#039;, &#039;12-31&#039;, &#039;16-31&#039;),
				3 =&gt; array(&#039;&#039;, &#039;IS&#039;, &#039;MS&#039;, &#039;IS+MS&#039;)
			);
		}
		return $MPEGaudioModeExtension;
	}

	/**
	 * @return array
	 */
	public static function MPEGaudioEmphasisArray() {
		static $MPEGaudioEmphasis = array(&#039;none&#039;, &#039;50/15ms&#039;, false, &#039;CCIT J.17&#039;);
		return $MPEGaudioEmphasis;
	}

	/**
	 * @param string $head4
	 * @param bool   $allowBitrate15
	 *
	 * @return bool
	 */
	public static function MPEGaudioHeaderBytesValid($head4, $allowBitrate15=false) {
		return self::MPEGaudioHeaderValid(self::MPEGaudioHeaderDecode($head4), false, $allowBitrate15);
	}

	/**
	 * @param array $rawarray
	 * @param bool  $echoerrors
	 * @param bool  $allowBitrate15
	 *
	 * @return bool
	 */
	public static function MPEGaudioHeaderValid($rawarray, $echoerrors=false, $allowBitrate15=false) {
		if (!isset($rawarray[&#039;synch&#039;]) || ($rawarray[&#039;synch&#039;] &amp; 0x0FFE) != 0x0FFE) {
			return false;
		}

		static $MPEGaudioVersionLookup;
		static $MPEGaudioLayerLookup;
		static $MPEGaudioBitrateLookup;
		static $MPEGaudioFrequencyLookup;
		static $MPEGaudioChannelModeLookup;
		static $MPEGaudioModeExtensionLookup;
		static $MPEGaudioEmphasisLookup;
		if (empty($MPEGaudioVersionLookup)) {
			$MPEGaudioVersionLookup       = self::MPEGaudioVersionArray();
			$MPEGaudioLayerLookup         = self::MPEGaudioLayerArray();
			$MPEGaudioBitrateLookup       = self::MPEGaudioBitrateArray();
			$MPEGaudioFrequencyLookup     = self::MPEGaudioFrequencyArray();
			$MPEGaudioChannelModeLookup   = self::MPEGaudioChannelModeArray();
			$MPEGaudioModeExtensionLookup = self::MPEGaudioModeExtensionArray();
			$MPEGaudioEmphasisLookup      = self::MPEGaudioEmphasisArray();
		}

		if (isset($MPEGaudioVersionLookup[$rawarray[&#039;version&#039;]])) {
			$decodedVersion = $MPEGaudioVersionLookup[$rawarray[&#039;version&#039;]];
		} else {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid Version (&#039;.$rawarray[&#039;version&#039;].&#039;)&#039; : &#039;&#039;);
			return false;
		}
		if (isset($MPEGaudioLayerLookup[$rawarray[&#039;layer&#039;]])) {
			$decodedLayer = $MPEGaudioLayerLookup[$rawarray[&#039;layer&#039;]];
		} else {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid Layer (&#039;.$rawarray[&#039;layer&#039;].&#039;)&#039; : &#039;&#039;);
			return false;
		}
		if (!isset($MPEGaudioBitrateLookup[$decodedVersion][$decodedLayer][$rawarray[&#039;bitrate&#039;]])) {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid Bitrate (&#039;.$rawarray[&#039;bitrate&#039;].&#039;)&#039; : &#039;&#039;);
			if ($rawarray[&#039;bitrate&#039;] == 15) {
				// known issue in LAME 3.90 - 3.93.1 where free-format has bitrate ID of 15 instead of 0
				// let it go through here otherwise file will not be identified
				if (!$allowBitrate15) {
					return false;
				}
			} else {
				return false;
			}
		}
		if (!isset($MPEGaudioFrequencyLookup[$decodedVersion][$rawarray[&#039;sample_rate&#039;]])) {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid Frequency (&#039;.$rawarray[&#039;sample_rate&#039;].&#039;)&#039; : &#039;&#039;);
			return false;
		}
		if (!isset($MPEGaudioChannelModeLookup[$rawarray[&#039;channelmode&#039;]])) {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid ChannelMode (&#039;.$rawarray[&#039;channelmode&#039;].&#039;)&#039; : &#039;&#039;);
			return false;
		}
		if (!isset($MPEGaudioModeExtensionLookup[$decodedLayer][$rawarray[&#039;modeextension&#039;]])) {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid Mode Extension (&#039;.$rawarray[&#039;modeextension&#039;].&#039;)&#039; : &#039;&#039;);
			return false;
		}
		if (!isset($MPEGaudioEmphasisLookup[$rawarray[&#039;emphasis&#039;]])) {
			echo ($echoerrors ? &quot;\n&quot;.&#039;invalid Emphasis (&#039;.$rawarray[&#039;emphasis&#039;].&#039;)&#039; : &#039;&#039;);
			return false;
		}
		// These are just either set or not set, you can&#039;t mess that up :)
		// $rawarray[&#039;protection&#039;];
		// $rawarray[&#039;padding&#039;];
		// $rawarray[&#039;private&#039;];
		// $rawarray[&#039;copyright&#039;];
		// $rawarray[&#039;original&#039;];

		return true;
	}

	/**
	 * @param string $Header4Bytes
	 *
	 * @return array|false
	 */
	public static function MPEGaudioHeaderDecode($Header4Bytes) {
		// AAAA AAAA  AAAB BCCD  EEEE FFGH  IIJJ KLMM
		// A - Frame sync (all bits set)
		// B - MPEG Audio version ID
		// C - Layer description
		// D - Protection bit
		// E - Bitrate index
		// F - Sampling rate frequency index
		// G - Padding bit
		// H - Private bit
		// I - Channel Mode
		// J - Mode extension (Only if Joint stereo)
		// K - Copyright
		// L - Original
		// M - Emphasis

		if (strlen($Header4Bytes) != 4) {
			return false;
		}

		$MPEGrawHeader = array();
		$MPEGrawHeader[&#039;synch&#039;]         = (getid3_lib::BigEndian2Int(substr($Header4Bytes, 0, 2)) &amp; 0xFFE0) &gt;&gt; 4;
		$MPEGrawHeader[&#039;version&#039;]       = (ord($Header4Bytes[1]) &amp; 0x18) &gt;&gt; 3; //    BB
		$MPEGrawHeader[&#039;layer&#039;]         = (ord($Header4Bytes[1]) &amp; 0x06) &gt;&gt; 1; //      CC
		$MPEGrawHeader[&#039;protection&#039;]    = (ord($Header4Bytes[1]) &amp; 0x01);      //        D
		$MPEGrawHeader[&#039;bitrate&#039;]       = (ord($Header4Bytes[2]) &amp; 0xF0) &gt;&gt; 4; // EEEE
		$MPEGrawHeader[&#039;sample_rate&#039;]   = (ord($Header4Bytes[2]) &amp; 0x0C) &gt;&gt; 2; //     FF
		$MPEGrawHeader[&#039;padding&#039;]       = (ord($Header4Bytes[2]) &amp; 0x02) &gt;&gt; 1; //       G
		$MPEGrawHeader[&#039;private&#039;]       = (ord($Header4Bytes[2]) &amp; 0x01);      //        H
		$MPEGrawHeader[&#039;channelmode&#039;]   = (ord($Header4Bytes[3]) &amp; 0xC0) &gt;&gt; 6; // II
		$MPEGrawHeader[&#039;modeextension&#039;] = (ord($Header4Bytes[3]) &amp; 0x30) &gt;&gt; 4; //   JJ
		$MPEGrawHeader[&#039;copyright&#039;]     = (ord($Header4Bytes[3]) &amp; 0x08) &gt;&gt; 3; //     K
		$MPEGrawHeader[&#039;original&#039;]      = (ord($Header4Bytes[3]) &amp; 0x04) &gt;&gt; 2; //      L
		$MPEGrawHeader[&#039;emphasis&#039;]      = (ord($Header4Bytes[3]) &amp; 0x03);      //       MM

		return $MPEGrawHeader;
	}

	/**
	 * @param int|string $bitrate
	 * @param string     $version
	 * @param string     $layer
	 * @param bool       $padding
	 * @param int        $samplerate
	 *
	 * @return int|false
	 */
	public static function MPEGaudioFrameLength(&amp;$bitrate, &amp;$version, &amp;$layer, $padding, &amp;$samplerate) {
		static $AudioFrameLengthCache = array();

		if (!isset($AudioFrameLengthCache[$bitrate][$version][$layer][$padding][$samplerate])) {
			$AudioFrameLengthCache[$bitrate][$version][$layer][$padding][$samplerate] = false;
			if ($bitrate != &#039;free&#039;) {

				if ($version == &#039;1&#039;) {

					if ($layer == &#039;1&#039;) {

						// For Layer I slot is 32 bits long
						$FrameLengthCoefficient = 48;
						$SlotLength = 4;

					} else { // Layer 2 / 3

						// for Layer 2 and Layer 3 slot is 8 bits long.
						$FrameLengthCoefficient = 144;
						$SlotLength = 1;

					}

				} else { // MPEG-2 / MPEG-2.5

					if ($layer == &#039;1&#039;) {

						// For Layer I slot is 32 bits long
						$FrameLengthCoefficient = 24;
						$SlotLength = 4;

					} elseif ($layer == &#039;2&#039;) {

						// for Layer 2 and Layer 3 slot is 8 bits long.
						$FrameLengthCoefficient = 144;
						$SlotLength = 1;

					} else { // layer 3

						// for Layer 2 and Layer 3 slot is 8 bits long.
						$FrameLengthCoefficient = 72;
						$SlotLength = 1;

					}

				}

				// FrameLengthInBytes = ((Coefficient * BitRate) / SampleRate) + Padding
				if ($samplerate &gt; 0) {
					$NewFramelength  = ($FrameLengthCoefficient * $bitrate) / $samplerate;
					$NewFramelength  = floor($NewFramelength / $SlotLength) * $SlotLength; // round to next-lower multiple of SlotLength (1 byte for Layer 2/3, 4 bytes for Layer I)
					if ($padding) {
						$NewFramelength += $SlotLength;
					}
					$AudioFrameLengthCache[$bitrate][$version][$layer][$padding][$samplerate] = (int) $NewFramelength;
				}
			}
		}
		return $AudioFrameLengthCache[$bitrate][$version][$layer][$padding][$samplerate];
	}

	/**
	 * @param float|int $bit_rate
	 *
	 * @return int|float|string
	 */
	public static function ClosestStandardMP3Bitrate($bit_rate) {
		static $standard_bit_rates = array (320000, 256000, 224000, 192000, 160000, 128000, 112000, 96000, 80000, 64000, 56000, 48000, 40000, 32000, 24000, 16000, 8000);
		static $bit_rate_table = array (0=&gt;&#039;-&#039;);
		$round_bit_rate = intval(round($bit_rate, -3));
		if (!isset($bit_rate_table[$round_bit_rate])) {
			if ($round_bit_rate &gt; max($standard_bit_rates)) {
				$bit_rate_table[$round_bit_rate] = round($bit_rate, 2 - strlen($bit_rate));
			} else {
				$bit_rate_table[$round_bit_rate] = max($standard_bit_rates);
				foreach ($standard_bit_rates as $standard_bit_rate) {
					if ($round_bit_rate &gt;= $standard_bit_rate + (($bit_rate_table[$round_bit_rate] - $standard_bit_rate) / 2)) {
						break;
					}
					$bit_rate_table[$round_bit_rate] = $standard_bit_rate;
				}
			}
		}
		return $bit_rate_table[$round_bit_rate];
	}

	/**
	 * @param string $version
	 * @param string $channelmode
	 *
	 * @return int
	 */
	public static function XingVBRidOffset($version, $channelmode) {
		static $XingVBRidOffsetCache = array();
		if (empty($XingVBRidOffsetCache)) {
			$XingVBRidOffsetCache = array (
				&#039;1&#039;   =&gt; array (&#039;mono&#039;          =&gt; 0x15, // 4 + 17 = 21
								&#039;stereo&#039;        =&gt; 0x24, // 4 + 32 = 36
								&#039;joint stereo&#039;  =&gt; 0x24,
								&#039;dual channel&#039;  =&gt; 0x24
							   ),

				&#039;2&#039;   =&gt; array (&#039;mono&#039;          =&gt; 0x0D, // 4 +  9 = 13
								&#039;stereo&#039;        =&gt; 0x15, // 4 + 17 = 21
								&#039;joint stereo&#039;  =&gt; 0x15,
								&#039;dual channel&#039;  =&gt; 0x15
							   ),

				&#039;2.5&#039; =&gt; array (&#039;mono&#039;          =&gt; 0x15,
								&#039;stereo&#039;        =&gt; 0x15,
								&#039;joint stereo&#039;  =&gt; 0x15,
								&#039;dual channel&#039;  =&gt; 0x15
							   )
			);
		}
		return $XingVBRidOffsetCache[$version][$channelmode];
	}

	/**
	 * @param int $VBRmethodID
	 *
	 * @return string
	 */
	public static function LAMEvbrMethodLookup($VBRmethodID) {
		static $LAMEvbrMethodLookup = array(
			0x00 =&gt; &#039;unknown&#039;,
			0x01 =&gt; &#039;cbr&#039;,
			0x02 =&gt; &#039;abr&#039;,
			0x03 =&gt; &#039;vbr-old / vbr-rh&#039;,
			0x04 =&gt; &#039;vbr-new / vbr-mtrh&#039;,
			0x05 =&gt; &#039;vbr-mt&#039;,
			0x06 =&gt; &#039;vbr (full vbr method 4)&#039;,
			0x08 =&gt; &#039;cbr (constant bitrate 2 pass)&#039;,
			0x09 =&gt; &#039;abr (2 pass)&#039;,
			0x0F =&gt; &#039;reserved&#039;
		);
		return (isset($LAMEvbrMethodLookup[$VBRmethodID]) ? $LAMEvbrMethodLookup[$VBRmethodID] : &#039;&#039;);
	}

	/**
	 * @param int $StereoModeID
	 *
	 * @return string
	 */
	public static function LAMEmiscStereoModeLookup($StereoModeID) {
		static $LAMEmiscStereoModeLookup = array(
			0 =&gt; &#039;mono&#039;,
			1 =&gt; &#039;stereo&#039;,
			2 =&gt; &#039;dual mono&#039;,
			3 =&gt; &#039;joint stereo&#039;,
			4 =&gt; &#039;forced stereo&#039;,
			5 =&gt; &#039;auto&#039;,
			6 =&gt; &#039;intensity stereo&#039;,
			7 =&gt; &#039;other&#039;
		);
		return (isset($LAMEmiscStereoModeLookup[$StereoModeID]) ? $LAMEmiscStereoModeLookup[$StereoModeID] : &#039;&#039;);
	}

	/**
	 * @param int $SourceSampleFrequencyID
	 *
	 * @return string
	 */
	public static function LAMEmiscSourceSampleFrequencyLookup($SourceSampleFrequencyID) {
		static $LAMEmiscSourceSampleFrequencyLookup = array(
			0 =&gt; &#039;&lt;= 32 kHz&#039;,
			1 =&gt; &#039;44.1 kHz&#039;,
			2 =&gt; &#039;48 kHz&#039;,
			3 =&gt; &#039;&gt; 48kHz&#039;
		);
		return (isset($LAMEmiscSourceSampleFrequencyLookup[$SourceSampleFrequencyID]) ? $LAMEmiscSourceSampleFrequencyLookup[$SourceSampleFrequencyID] : &#039;&#039;);
	}

	/**
	 * @param int $SurroundInfoID
	 *
	 * @return string
	 */
	public static function LAMEsurroundInfoLookup($SurroundInfoID) {
		static $LAMEsurroundInfoLookup = array(
			0 =&gt; &#039;no surround info&#039;,
			1 =&gt; &#039;DPL encoding&#039;,
			2 =&gt; &#039;DPL2 encoding&#039;,
			3 =&gt; &#039;Ambisonic encoding&#039;
		);
		return (isset($LAMEsurroundInfoLookup[$SurroundInfoID]) ? $LAMEsurroundInfoLookup[$SurroundInfoID] : &#039;reserved&#039;);
	}

	/**
	 * @param array $LAMEtag
	 *
	 * @return string
	 */
	public static function LAMEpresetUsedLookup($LAMEtag) {

		if ($LAMEtag[&#039;preset_used_id&#039;] == 0) {
			// no preset used (LAME &gt;=3.93)
			// no preset recorded (LAME &lt;3.93)
			return &#039;&#039;;
		}
		$LAMEpresetUsedLookup = array();

		/////  THIS PART CANNOT BE STATIC .
		for ($i = 8; $i &lt;= 320; $i++) {
			switch ($LAMEtag[&#039;vbr_method&#039;]) {
				case &#039;cbr&#039;:
					$LAMEpresetUsedLookup[$i] = &#039;--alt-preset &#039;.$LAMEtag[&#039;vbr_method&#039;].&#039; &#039;.$i;
					break;
				case &#039;abr&#039;:
				default: // other VBR modes shouldn&#039;t be here(?)
					$LAMEpresetUsedLookup[$i] = &#039;--alt-preset &#039;.$i;
					break;
			}
		}

		// named old-style presets (studio, phone, voice, etc) are handled in GuessEncoderOptions()

		// named alt-presets
		$LAMEpresetUsedLookup[1000] = &#039;--r3mix&#039;;
		$LAMEpresetUsedLookup[1001] = &#039;--alt-preset standard&#039;;
		$LAMEpresetUsedLookup[1002] = &#039;--alt-preset extreme&#039;;
		$LAMEpresetUsedLookup[1003] = &#039;--alt-preset insane&#039;;
		$LAMEpresetUsedLookup[1004] = &#039;--alt-preset fast standard&#039;;
		$LAMEpresetUsedLookup[1005] = &#039;--alt-preset fast extreme&#039;;
		$LAMEpresetUsedLookup[1006] = &#039;--alt-preset medium&#039;;
		$LAMEpresetUsedLookup[1007] = &#039;--alt-preset fast medium&#039;;

		// LAME 3.94 additions/changes
		$LAMEpresetUsedLookup[1010] = &#039;--preset portable&#039;;                                                           // 3.94a15 Oct 21 2003
		$LAMEpresetUsedLookup[1015] = &#039;--preset radio&#039;;                                                              // 3.94a15 Oct 21 2003

		$LAMEpresetUsedLookup[320]  = &#039;--preset insane&#039;;                                                             // 3.94a15 Nov 12 2003
		$LAMEpresetUsedLookup[410]  = &#039;-V9&#039;;
		$LAMEpresetUsedLookup[420]  = &#039;-V8&#039;;
		$LAMEpresetUsedLookup[440]  = &#039;-V6&#039;;
		$LAMEpresetUsedLookup[430]  = &#039;--preset radio&#039;;                                                              // 3.94a15 Nov 12 2003
		$LAMEpresetUsedLookup[450]  = &#039;--preset &#039;.(($LAMEtag[&#039;raw&#039;][&#039;vbr_method&#039;] == 4) ? &#039;fast &#039; : &#039;&#039;).&#039;portable&#039;;  // 3.94a15 Nov 12 2003
		$LAMEpresetUsedLookup[460]  = &#039;--preset &#039;.(($LAMEtag[&#039;raw&#039;][&#039;vbr_method&#039;] == 4) ? &#039;fast &#039; : &#039;&#039;).&#039;medium&#039;;    // 3.94a15 Nov 12 2003
		$LAMEpresetUsedLookup[470]  = &#039;--r3mix&#039;;                                                                     // 3.94b1  Dec 18 2003
		$LAMEpresetUsedLookup[480]  = &#039;--preset &#039;.(($LAMEtag[&#039;raw&#039;][&#039;vbr_method&#039;] == 4) ? &#039;fast &#039; : &#039;&#039;).&#039;standard&#039;;  // 3.94a15 Nov 12 2003
		$LAMEpresetUsedLookup[490]  = &#039;-V1&#039;;
		$LAMEpresetUsedLookup[500]  = &#039;--preset &#039;.(($LAMEtag[&#039;raw&#039;][&#039;vbr_method&#039;] == 4) ? &#039;fast &#039; : &#039;&#039;).&#039;extreme&#039;;   // 3.94a15 Nov 12 2003

		return (isset($LAMEpresetUsedLookup[$LAMEtag[&#039;preset_used_id&#039;]]) ? $LAMEpresetUsedLookup[$LAMEtag[&#039;preset_used_id&#039;]] : &#039;new/unknown preset: &#039;.$LAMEtag[&#039;preset_used_id&#039;].&#039; - report to info@getid3.org&#039;);
	}

}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fbansibaba.com%2Fwp-includes%2FID3'>⬅ Back to Directory</a>